2 * ntoskrnl.exe implementation
4 * Copyright (C) 2007 Alexandre Julliard
5 * Copyright (C) 2010 Damjan Jovanovic
6 * Copyright (C) 2016 Sebastian Lackner
7 * Copyright (C) 2016 CodeWeavers, Aric Stewart
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 #include "wine/port.h"
29 #define NONAMELESSUNION
30 #define NONAMELESSSTRUCT
33 #define WIN32_NO_STATUS
40 #include "ddk/ntddk.h"
41 #include "ddk/ntifs.h"
43 #include "wine/unicode.h"
44 #include "wine/server.h"
45 #include "wine/debug.h"
47 #include "wine/rbtree.h"
49 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl
);
50 WINE_DECLARE_DEBUG_CHANNEL(relay
);
51 WINE_DECLARE_DEBUG_CHANNEL(plugplay
);
53 BOOLEAN KdDebuggerEnabled
= FALSE
;
54 ULONG InitSafeBootMode
= 0;
56 extern LONG CALLBACK
vectored_handler( EXCEPTION_POINTERS
*ptrs
);
58 KSYSTEM_TIME KeTickCount
= { 0, 0, 0 };
60 typedef struct _KSERVICE_TABLE_DESCRIPTOR
66 } KSERVICE_TABLE_DESCRIPTOR
, *PKSERVICE_TABLE_DESCRIPTOR
;
68 KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable
[4] = { { 0 } };
70 typedef void (WINAPI
*PCREATE_PROCESS_NOTIFY_ROUTINE
)(HANDLE
,HANDLE
,BOOLEAN
);
71 typedef void (WINAPI
*PCREATE_THREAD_NOTIFY_ROUTINE
)(HANDLE
,HANDLE
,BOOLEAN
);
73 static const WCHAR servicesW
[] = {'\\','R','e','g','i','s','t','r','y',
74 '\\','M','a','c','h','i','n','e',
75 '\\','S','y','s','t','e','m',
76 '\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
77 '\\','S','e','r','v','i','c','e','s',
80 #define MAX_SERVICE_NAME 260
82 /* tid of the thread running client request */
83 static DWORD request_thread
;
85 /* pid/tid of the client thread */
86 static DWORD client_tid
;
87 static DWORD client_pid
;
91 struct wine_rb_entry entry
;
93 DRIVER_OBJECT driver_obj
;
94 DRIVER_EXTENSION driver_extension
;
97 static NTSTATUS
get_device_id( DEVICE_OBJECT
*device
, BUS_QUERY_ID_TYPE type
, WCHAR
**id
);
99 static int wine_drivers_rb_compare( const void *key
, const struct wine_rb_entry
*entry
)
101 const struct wine_driver
*driver
= WINE_RB_ENTRY_VALUE( entry
, const struct wine_driver
, entry
);
102 const UNICODE_STRING
*k
= key
;
104 return RtlCompareUnicodeString( k
, &driver
->driver_obj
.DriverName
, FALSE
);
107 static struct wine_rb_tree wine_drivers
= { wine_drivers_rb_compare
};
109 static CRITICAL_SECTION drivers_cs
;
110 static CRITICAL_SECTION_DEBUG critsect_debug
=
113 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
114 0, 0, { (DWORD_PTR
)(__FILE__
": drivers_cs") }
116 static CRITICAL_SECTION drivers_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
119 #define DEFINE_FASTCALL1_ENTRYPOINT( name ) \
120 __ASM_STDCALL_FUNC( name, 4, \
124 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(4))
125 #define DEFINE_FASTCALL2_ENTRYPOINT( name ) \
126 __ASM_STDCALL_FUNC( name, 8, \
131 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(8))
132 #define DEFINE_FASTCALL3_ENTRYPOINT( name ) \
133 __ASM_STDCALL_FUNC( name, 12, \
138 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(12))
141 static inline LPCSTR
debugstr_us( const UNICODE_STRING
*us
)
143 if (!us
) return "<null>";
144 return debugstr_wn( us
->Buffer
, us
->Length
/ sizeof(WCHAR
) );
147 static HANDLE
get_device_manager(void)
149 static HANDLE device_manager
;
150 HANDLE handle
= 0, ret
= device_manager
;
154 SERVER_START_REQ( create_device_manager
)
156 req
->access
= SYNCHRONIZE
;
158 if (!wine_server_call( req
)) handle
= wine_server_ptr_handle( reply
->handle
);
164 ERR( "failed to create the device manager\n" );
167 if (!(ret
= InterlockedCompareExchangePointer( &device_manager
, handle
, 0 )))
170 NtClose( handle
); /* somebody beat us to it */
175 /* transfer result of IRP back to wineserver */
176 static NTSTATUS WINAPI
dispatch_irp_completion( DEVICE_OBJECT
*device
, IRP
*irp
, void *context
)
178 FILE_OBJECT
*file
= irp
->Tail
.Overlay
.OriginalFileObject
;
179 HANDLE irp_handle
= context
;
180 void *out_buff
= irp
->UserBuffer
;
182 if (irp
->Flags
& IRP_WRITE_OPERATION
)
183 out_buff
= NULL
; /* do not transfer back input buffer */
185 SERVER_START_REQ( set_irp_result
)
187 req
->handle
= wine_server_obj_handle( irp_handle
);
188 req
->status
= irp
->IoStatus
.u
.Status
;
189 req
->file_ptr
= wine_server_client_ptr( file
);
190 if (irp
->IoStatus
.u
.Status
>= 0)
192 req
->size
= irp
->IoStatus
.Information
;
193 if (out_buff
) wine_server_add_data( req
, out_buff
, irp
->IoStatus
.Information
);
195 wine_server_call( req
);
199 if (irp
->Flags
& IRP_CLOSE_OPERATION
)
201 HeapFree( GetProcessHeap(), 0, file
);
202 irp
->Tail
.Overlay
.OriginalFileObject
= NULL
;
205 if (irp
->UserBuffer
!= irp
->AssociatedIrp
.SystemBuffer
)
207 HeapFree( GetProcessHeap(), 0, irp
->UserBuffer
);
208 irp
->UserBuffer
= NULL
;
210 return STATUS_SUCCESS
;
213 static void dispatch_irp( DEVICE_OBJECT
*device
, IRP
*irp
, HANDLE irp_handle
)
217 IoSetCompletionRoutine( irp
, dispatch_irp_completion
, irp_handle
, TRUE
, TRUE
, TRUE
);
218 KeQueryTickCount( &count
); /* update the global KeTickCount */
220 device
->CurrentIrp
= irp
;
221 IoCallDriver( device
, irp
);
222 device
->CurrentIrp
= NULL
;
225 /* process a create request for a given file */
226 static NTSTATUS
dispatch_create( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
227 ULONG out_size
, HANDLE irp_handle
)
230 IO_STACK_LOCATION
*irpsp
;
232 DEVICE_OBJECT
*device
= wine_server_get_ptr( params
->create
.device
);
234 if (!(file
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*file
) ))) return STATUS_NO_MEMORY
;
236 TRACE( "device %p -> file %p\n", device
, file
);
238 file
->Type
= 5; /* MSDN */
239 file
->Size
= sizeof(*file
);
240 file
->DeviceObject
= device
;
242 if (!(irp
= IoAllocateIrp( device
->StackSize
, FALSE
)))
244 HeapFree( GetProcessHeap(), 0, file
);
245 return STATUS_NO_MEMORY
;
248 irpsp
= IoGetNextIrpStackLocation( irp
);
249 irpsp
->MajorFunction
= IRP_MJ_CREATE
;
250 irpsp
->DeviceObject
= device
;
251 irpsp
->Parameters
.Create
.SecurityContext
= NULL
; /* FIXME */
252 irpsp
->Parameters
.Create
.Options
= params
->create
.options
;
253 irpsp
->Parameters
.Create
.ShareAccess
= params
->create
.sharing
;
254 irpsp
->Parameters
.Create
.FileAttributes
= 0;
255 irpsp
->Parameters
.Create
.EaLength
= 0;
257 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
258 irp
->RequestorMode
= UserMode
;
259 irp
->AssociatedIrp
.SystemBuffer
= NULL
;
260 irp
->UserBuffer
= NULL
;
261 irp
->UserIosb
= NULL
;
262 irp
->UserEvent
= NULL
;
264 irp
->Flags
|= IRP_CREATE_OPERATION
;
265 dispatch_irp( device
, irp
, irp_handle
);
267 HeapFree( GetProcessHeap(), 0, in_buff
);
268 return STATUS_SUCCESS
;
271 /* process a close request for a given file */
272 static NTSTATUS
dispatch_close( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
273 ULONG out_size
, HANDLE irp_handle
)
276 IO_STACK_LOCATION
*irpsp
;
277 DEVICE_OBJECT
*device
;
278 FILE_OBJECT
*file
= wine_server_get_ptr( params
->close
.file
);
280 if (!file
) return STATUS_INVALID_HANDLE
;
282 device
= file
->DeviceObject
;
284 TRACE( "device %p file %p\n", device
, file
);
286 if (!(irp
= IoAllocateIrp( device
->StackSize
, FALSE
)))
288 HeapFree( GetProcessHeap(), 0, file
);
289 return STATUS_NO_MEMORY
;
292 irpsp
= IoGetNextIrpStackLocation( irp
);
293 irpsp
->MajorFunction
= IRP_MJ_CLOSE
;
294 irpsp
->DeviceObject
= device
;
296 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
297 irp
->RequestorMode
= UserMode
;
298 irp
->AssociatedIrp
.SystemBuffer
= NULL
;
299 irp
->UserBuffer
= NULL
;
300 irp
->UserIosb
= NULL
;
301 irp
->UserEvent
= NULL
;
303 irp
->Flags
|= IRP_CLOSE_OPERATION
;
304 dispatch_irp( device
, irp
, irp_handle
);
306 HeapFree( GetProcessHeap(), 0, in_buff
);
307 return STATUS_SUCCESS
;
310 /* process a read request for a given device */
311 static NTSTATUS
dispatch_read( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
312 ULONG out_size
, HANDLE irp_handle
)
316 LARGE_INTEGER offset
;
317 IO_STACK_LOCATION
*irpsp
;
318 DEVICE_OBJECT
*device
;
319 FILE_OBJECT
*file
= wine_server_get_ptr( params
->read
.file
);
321 if (!file
) return STATUS_INVALID_HANDLE
;
323 device
= file
->DeviceObject
;
325 TRACE( "device %p file %p size %u\n", device
, file
, out_size
);
327 if (!(out_buff
= HeapAlloc( GetProcessHeap(), 0, out_size
))) return STATUS_NO_MEMORY
;
329 offset
.QuadPart
= params
->read
.pos
;
331 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_READ
, device
, out_buff
, out_size
,
332 &offset
, NULL
, NULL
)))
334 HeapFree( GetProcessHeap(), 0, out_buff
);
335 return STATUS_NO_MEMORY
;
338 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
339 irp
->RequestorMode
= UserMode
;
341 irpsp
= IoGetNextIrpStackLocation( irp
);
342 irpsp
->Parameters
.Read
.Key
= params
->read
.key
;
344 irp
->Flags
|= IRP_READ_OPERATION
;
345 irp
->Flags
|= IRP_DEALLOCATE_BUFFER
; /* deallocate out_buff */
346 dispatch_irp( device
, irp
, irp_handle
);
348 HeapFree( GetProcessHeap(), 0, in_buff
);
349 return STATUS_SUCCESS
;
352 /* process a write request for a given device */
353 static NTSTATUS
dispatch_write( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
354 ULONG out_size
, HANDLE irp_handle
)
357 LARGE_INTEGER offset
;
358 IO_STACK_LOCATION
*irpsp
;
359 DEVICE_OBJECT
*device
;
360 FILE_OBJECT
*file
= wine_server_get_ptr( params
->write
.file
);
362 if (!file
) return STATUS_INVALID_HANDLE
;
364 device
= file
->DeviceObject
;
366 TRACE( "device %p file %p size %u\n", device
, file
, in_size
);
368 offset
.QuadPart
= params
->write
.pos
;
370 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_WRITE
, device
, in_buff
, in_size
,
371 &offset
, NULL
, NULL
)))
372 return STATUS_NO_MEMORY
;
374 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
375 irp
->RequestorMode
= UserMode
;
377 irpsp
= IoGetNextIrpStackLocation( irp
);
378 irpsp
->Parameters
.Write
.Key
= params
->write
.key
;
380 irp
->Flags
|= IRP_WRITE_OPERATION
;
381 irp
->Flags
|= IRP_DEALLOCATE_BUFFER
; /* deallocate in_buff */
382 dispatch_irp( device
, irp
, irp_handle
);
384 return STATUS_SUCCESS
;
387 /* process a flush request for a given device */
388 static NTSTATUS
dispatch_flush( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
389 ULONG out_size
, HANDLE irp_handle
)
392 DEVICE_OBJECT
*device
;
393 FILE_OBJECT
*file
= wine_server_get_ptr( params
->flush
.file
);
395 if (!file
) return STATUS_INVALID_HANDLE
;
397 device
= file
->DeviceObject
;
399 TRACE( "device %p file %p\n", device
, file
);
401 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_FLUSH_BUFFERS
, device
, NULL
, 0,
403 return STATUS_NO_MEMORY
;
405 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
406 irp
->RequestorMode
= UserMode
;
408 dispatch_irp( device
, irp
, irp_handle
);
410 HeapFree( GetProcessHeap(), 0, in_buff
);
411 return STATUS_SUCCESS
;
414 /* process an ioctl request for a given device */
415 static NTSTATUS
dispatch_ioctl( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
416 ULONG out_size
, HANDLE irp_handle
)
419 void *out_buff
= NULL
;
420 void *to_free
= NULL
;
421 DEVICE_OBJECT
*device
;
422 FILE_OBJECT
*file
= wine_server_get_ptr( params
->ioctl
.file
);
424 if (!file
) return STATUS_INVALID_HANDLE
;
426 device
= file
->DeviceObject
;
428 TRACE( "ioctl %x device %p file %p in_size %u out_size %u\n",
429 params
->ioctl
.code
, device
, file
, in_size
, out_size
);
433 if ((params
->ioctl
.code
& 3) != METHOD_BUFFERED
)
435 if (in_size
< out_size
) return STATUS_INVALID_DEVICE_REQUEST
;
437 if (!(out_buff
= HeapAlloc( GetProcessHeap(), 0, out_size
))) return STATUS_NO_MEMORY
;
438 memcpy( out_buff
, (char *)in_buff
+ in_size
, out_size
);
440 else if (out_size
> in_size
)
442 if (!(out_buff
= HeapAlloc( GetProcessHeap(), 0, out_size
))) return STATUS_NO_MEMORY
;
443 memcpy( out_buff
, in_buff
, in_size
);
454 irp
= IoBuildDeviceIoControlRequest( params
->ioctl
.code
, device
, in_buff
, in_size
, out_buff
, out_size
,
458 HeapFree( GetProcessHeap(), 0, out_buff
);
459 return STATUS_NO_MEMORY
;
462 if (out_size
&& (params
->ioctl
.code
& 3) != METHOD_BUFFERED
)
463 HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY
, in_buff
, in_size
);
465 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
466 irp
->RequestorMode
= UserMode
;
467 irp
->AssociatedIrp
.SystemBuffer
= in_buff
;
469 irp
->Flags
|= IRP_DEALLOCATE_BUFFER
; /* deallocate in_buff */
470 dispatch_irp( device
, irp
, irp_handle
);
472 HeapFree( GetProcessHeap(), 0, to_free
);
473 return STATUS_SUCCESS
;
476 typedef NTSTATUS (*dispatch_func
)( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
477 ULONG out_size
, HANDLE irp_handle
);
479 static const dispatch_func dispatch_funcs
[IRP_MJ_MAXIMUM_FUNCTION
+ 1] =
481 dispatch_create
, /* IRP_MJ_CREATE */
482 NULL
, /* IRP_MJ_CREATE_NAMED_PIPE */
483 dispatch_close
, /* IRP_MJ_CLOSE */
484 dispatch_read
, /* IRP_MJ_READ */
485 dispatch_write
, /* IRP_MJ_WRITE */
486 NULL
, /* IRP_MJ_QUERY_INFORMATION */
487 NULL
, /* IRP_MJ_SET_INFORMATION */
488 NULL
, /* IRP_MJ_QUERY_EA */
489 NULL
, /* IRP_MJ_SET_EA */
490 dispatch_flush
, /* IRP_MJ_FLUSH_BUFFERS */
491 NULL
, /* IRP_MJ_QUERY_VOLUME_INFORMATION */
492 NULL
, /* IRP_MJ_SET_VOLUME_INFORMATION */
493 NULL
, /* IRP_MJ_DIRECTORY_CONTROL */
494 NULL
, /* IRP_MJ_FILE_SYSTEM_CONTROL */
495 dispatch_ioctl
, /* IRP_MJ_DEVICE_CONTROL */
496 NULL
, /* IRP_MJ_INTERNAL_DEVICE_CONTROL */
497 NULL
, /* IRP_MJ_SHUTDOWN */
498 NULL
, /* IRP_MJ_LOCK_CONTROL */
499 NULL
, /* IRP_MJ_CLEANUP */
500 NULL
, /* IRP_MJ_CREATE_MAILSLOT */
501 NULL
, /* IRP_MJ_QUERY_SECURITY */
502 NULL
, /* IRP_MJ_SET_SECURITY */
503 NULL
, /* IRP_MJ_POWER */
504 NULL
, /* IRP_MJ_SYSTEM_CONTROL */
505 NULL
, /* IRP_MJ_DEVICE_CHANGE */
506 NULL
, /* IRP_MJ_QUERY_QUOTA */
507 NULL
, /* IRP_MJ_SET_QUOTA */
508 NULL
, /* IRP_MJ_PNP */
512 /***********************************************************************
513 * wine_ntoskrnl_main_loop (Not a Windows API)
515 NTSTATUS CDECL
wine_ntoskrnl_main_loop( HANDLE stop_event
)
517 HANDLE manager
= get_device_manager();
519 NTSTATUS status
= STATUS_SUCCESS
;
520 irp_params_t irp_params
;
521 ULONG in_size
= 4096, out_size
= 0;
522 void *in_buff
= NULL
;
525 request_thread
= GetCurrentThreadId();
527 handles
[0] = stop_event
;
528 handles
[1] = manager
;
532 if (!in_buff
&& !(in_buff
= HeapAlloc( GetProcessHeap(), 0, in_size
)))
534 ERR( "failed to allocate buffer\n" );
535 return STATUS_NO_MEMORY
;
538 SERVER_START_REQ( get_next_device_request
)
540 req
->manager
= wine_server_obj_handle( manager
);
541 req
->prev
= wine_server_obj_handle( irp
);
542 req
->status
= status
;
543 wine_server_set_reply( req
, in_buff
, in_size
);
544 if (!(status
= wine_server_call( req
)))
546 irp
= wine_server_ptr_handle( reply
->next
);
547 irp_params
= reply
->params
;
548 client_tid
= reply
->client_tid
;
549 client_pid
= reply
->client_pid
;
550 in_size
= reply
->in_size
;
551 out_size
= reply
->out_size
;
555 irp
= 0; /* no previous irp */
556 if (status
== STATUS_BUFFER_OVERFLOW
)
557 in_size
= reply
->in_size
;
565 if (irp_params
.major
> IRP_MJ_MAXIMUM_FUNCTION
|| !dispatch_funcs
[irp_params
.major
])
567 WARN( "unsupported request %u\n", irp_params
.major
);
568 status
= STATUS_NOT_SUPPORTED
;
571 status
= dispatch_funcs
[irp_params
.major
]( &irp_params
, in_buff
, in_size
, out_size
, irp
);
572 if (status
== STATUS_SUCCESS
)
574 irp
= 0; /* status reported by IoCompleteRequest */
579 case STATUS_BUFFER_OVERFLOW
:
580 HeapFree( GetProcessHeap(), 0, in_buff
);
582 /* restart with larger buffer */
587 DWORD ret
= WaitForMultipleObjectsEx( 2, handles
, FALSE
, INFINITE
, TRUE
);
588 if (ret
== WAIT_OBJECT_0
)
590 HeapFree( GetProcessHeap(), 0, in_buff
);
591 return STATUS_SUCCESS
;
593 if (ret
!= WAIT_IO_COMPLETION
) break;
601 /***********************************************************************
602 * IoAcquireCancelSpinLock (NTOSKRNL.EXE.@)
604 void WINAPI
IoAcquireCancelSpinLock(PKIRQL irql
)
606 FIXME("(%p): stub\n", irql
);
610 /***********************************************************************
611 * IoReleaseCancelSpinLock (NTOSKRNL.EXE.@)
613 void WINAPI
IoReleaseCancelSpinLock(PKIRQL irql
)
615 FIXME("(%p): stub\n", irql
);
619 /***********************************************************************
620 * IoAllocateDriverObjectExtension (NTOSKRNL.EXE.@)
622 NTSTATUS WINAPI
IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject
,
623 PVOID ClientIdentificationAddress
,
624 ULONG DriverObjectExtensionSize
,
625 PVOID
*DriverObjectExtension
)
627 FIXME( "stub: %p, %p, %u, %p\n", DriverObject
, ClientIdentificationAddress
,
628 DriverObjectExtensionSize
, DriverObjectExtension
);
629 return STATUS_NOT_IMPLEMENTED
;
633 /***********************************************************************
634 * IoGetDriverObjectExtension (NTOSKRNL.EXE.@)
636 PVOID WINAPI
IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject
,
637 PVOID ClientIdentificationAddress
)
639 FIXME( "stub: %p, %p\n", DriverObject
, ClientIdentificationAddress
);
644 /***********************************************************************
645 * IoInitializeIrp (NTOSKRNL.EXE.@)
647 void WINAPI
IoInitializeIrp( IRP
*irp
, USHORT size
, CCHAR stack_size
)
649 TRACE( "%p, %u, %d\n", irp
, size
, stack_size
);
651 RtlZeroMemory( irp
, size
);
653 irp
->Type
= IO_TYPE_IRP
;
655 InitializeListHead( &irp
->ThreadListEntry
);
656 irp
->StackCount
= stack_size
;
657 irp
->CurrentLocation
= stack_size
+ 1;
658 irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
=
659 (PIO_STACK_LOCATION
)(irp
+ 1) + stack_size
;
663 /***********************************************************************
664 * IoInitializeTimer (NTOSKRNL.EXE.@)
666 NTSTATUS WINAPI
IoInitializeTimer(PDEVICE_OBJECT DeviceObject
,
667 PIO_TIMER_ROUTINE TimerRoutine
,
670 FIXME( "stub: %p, %p, %p\n", DeviceObject
, TimerRoutine
, Context
);
671 return STATUS_NOT_IMPLEMENTED
;
675 /***********************************************************************
676 * IoStartTimer (NTOSKRNL.EXE.@)
678 void WINAPI
IoStartTimer(PDEVICE_OBJECT DeviceObject
)
680 FIXME( "stub: %p\n", DeviceObject
);
684 /***********************************************************************
685 * IoStopTimer (NTOSKRNL.EXE.@)
687 void WINAPI
IoStopTimer(PDEVICE_OBJECT DeviceObject
)
689 FIXME( "stub: %p\n", DeviceObject
);
693 /***********************************************************************
694 * IoAllocateIrp (NTOSKRNL.EXE.@)
696 PIRP WINAPI
IoAllocateIrp( CCHAR stack_size
, BOOLEAN charge_quota
)
700 CCHAR loc_count
= stack_size
;
702 TRACE( "%d, %d\n", stack_size
, charge_quota
);
704 if (loc_count
< 8 && loc_count
!= 1)
707 size
= sizeof(IRP
) + loc_count
* sizeof(IO_STACK_LOCATION
);
708 irp
= ExAllocatePool( NonPagedPool
, size
);
711 IoInitializeIrp( irp
, size
, stack_size
);
712 if (stack_size
>= 1 && stack_size
<= 8)
713 irp
->AllocationFlags
= IRP_ALLOCATED_FIXED_SIZE
;
715 irp
->AllocationFlags
|= IRP_LOOKASIDE_ALLOCATION
;
720 /***********************************************************************
721 * IoFreeIrp (NTOSKRNL.EXE.@)
723 void WINAPI
IoFreeIrp( IRP
*irp
)
727 TRACE( "%p\n", irp
);
729 mdl
= irp
->MdlAddress
;
732 MDL
*next
= mdl
->Next
;
741 /***********************************************************************
742 * IoAllocateErrorLogEntry (NTOSKRNL.EXE.@)
744 PVOID WINAPI
IoAllocateErrorLogEntry( PVOID IoObject
, UCHAR EntrySize
)
746 FIXME( "stub: %p, %u\n", IoObject
, EntrySize
);
751 /***********************************************************************
752 * IoAllocateMdl (NTOSKRNL.EXE.@)
754 PMDL WINAPI
IoAllocateMdl( PVOID va
, ULONG length
, BOOLEAN secondary
, BOOLEAN charge_quota
, IRP
*irp
)
759 TRACE("(%p, %u, %i, %i, %p)\n", va
, length
, secondary
, charge_quota
, irp
);
762 FIXME("Charge quota is not yet supported\n");
764 mdl_size
= sizeof(MDL
) + sizeof(PFN_NUMBER
) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(va
, length
);
765 mdl
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, mdl_size
);
769 MmInitializeMdl( mdl
, va
, length
);
771 if (!irp
) return mdl
;
773 if (secondary
) /* add it at the end */
775 MDL
**pmdl
= &irp
->MdlAddress
;
776 while (*pmdl
) pmdl
= &(*pmdl
)->Next
;
781 mdl
->Next
= irp
->MdlAddress
;
782 irp
->MdlAddress
= mdl
;
788 /***********************************************************************
789 * IoFreeMdl (NTOSKRNL.EXE.@)
791 void WINAPI
IoFreeMdl(PMDL mdl
)
794 HeapFree(GetProcessHeap(), 0, mdl
);
798 /***********************************************************************
799 * IoAllocateWorkItem (NTOSKRNL.EXE.@)
801 PIO_WORKITEM WINAPI
IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject
)
803 FIXME( "stub: %p\n", DeviceObject
);
808 /***********************************************************************
809 * IoAttachDeviceToDeviceStack (NTOSKRNL.EXE.@)
811 PDEVICE_OBJECT WINAPI
IoAttachDeviceToDeviceStack( DEVICE_OBJECT
*source
,
812 DEVICE_OBJECT
*target
)
814 TRACE( "%p, %p\n", source
, target
);
815 target
->AttachedDevice
= source
;
816 source
->StackSize
= target
->StackSize
+ 1;
821 /***********************************************************************
822 * IoBuildDeviceIoControlRequest (NTOSKRNL.EXE.@)
824 PIRP WINAPI
IoBuildDeviceIoControlRequest( ULONG code
, PDEVICE_OBJECT device
,
825 PVOID in_buff
, ULONG in_len
,
826 PVOID out_buff
, ULONG out_len
,
827 BOOLEAN internal
, PKEVENT event
,
828 PIO_STATUS_BLOCK iosb
)
831 PIO_STACK_LOCATION irpsp
;
834 TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
835 code
, device
, in_buff
, in_len
, out_buff
, out_len
, internal
, event
, iosb
);
840 irp
= IoAllocateIrp( device
->StackSize
, FALSE
);
844 irpsp
= IoGetNextIrpStackLocation( irp
);
845 irpsp
->MajorFunction
= internal
? IRP_MJ_INTERNAL_DEVICE_CONTROL
: IRP_MJ_DEVICE_CONTROL
;
846 irpsp
->Parameters
.DeviceIoControl
.IoControlCode
= code
;
847 irpsp
->Parameters
.DeviceIoControl
.InputBufferLength
= in_len
;
848 irpsp
->Parameters
.DeviceIoControl
.OutputBufferLength
= out_len
;
849 irpsp
->DeviceObject
= device
;
850 irpsp
->CompletionRoutine
= NULL
;
854 case METHOD_BUFFERED
:
855 irp
->AssociatedIrp
.SystemBuffer
= in_buff
;
857 case METHOD_IN_DIRECT
:
858 case METHOD_OUT_DIRECT
:
859 irp
->AssociatedIrp
.SystemBuffer
= in_buff
;
861 mdl
= IoAllocateMdl( out_buff
, out_len
, FALSE
, FALSE
, irp
);
868 mdl
->MdlFlags
|= MDL_MAPPED_TO_SYSTEM_VA
;
869 mdl
->MappedSystemVa
= out_buff
;
872 irpsp
->Parameters
.DeviceIoControl
.Type3InputBuffer
= in_buff
;
876 irp
->RequestorMode
= KernelMode
;
877 irp
->UserBuffer
= out_buff
;
878 irp
->UserIosb
= iosb
;
879 irp
->UserEvent
= event
;
884 /**********************************************************
885 * IoBuildSynchronousFsdRequest (NTOSKRNL.EXE.@)
887 PIRP WINAPI
IoBuildSynchronousFsdRequest(ULONG majorfunc
, PDEVICE_OBJECT device
,
888 PVOID buffer
, ULONG length
, PLARGE_INTEGER startoffset
,
889 PKEVENT event
, PIO_STATUS_BLOCK iosb
)
892 PIO_STACK_LOCATION irpsp
;
894 TRACE("(%d %p %p %d %p %p %p)\n", majorfunc
, device
, buffer
, length
, startoffset
, event
, iosb
);
896 if (!(irp
= IoAllocateIrp( device
->StackSize
, FALSE
))) return NULL
;
898 irpsp
= IoGetNextIrpStackLocation( irp
);
899 irpsp
->MajorFunction
= majorfunc
;
900 irpsp
->DeviceObject
= device
;
901 irpsp
->CompletionRoutine
= NULL
;
903 irp
->AssociatedIrp
.SystemBuffer
= buffer
;
905 if (device
->Flags
& DO_DIRECT_IO
)
907 MDL
*mdl
= IoAllocateMdl( buffer
, length
, FALSE
, FALSE
, irp
);
914 mdl
->MdlFlags
|= MDL_MAPPED_TO_SYSTEM_VA
;
915 mdl
->MappedSystemVa
= buffer
;
921 irpsp
->Parameters
.Read
.Length
= length
;
922 irpsp
->Parameters
.Read
.ByteOffset
= *startoffset
;
925 irpsp
->Parameters
.Write
.Length
= length
;
926 irpsp
->Parameters
.Write
.ByteOffset
= *startoffset
;
929 irp
->RequestorMode
= KernelMode
;
930 irp
->UserIosb
= iosb
;
931 irp
->UserEvent
= event
;
932 irp
->UserBuffer
= buffer
;
936 static void build_driver_keypath( const WCHAR
*name
, UNICODE_STRING
*keypath
)
938 static const WCHAR driverW
[] = {'\\','D','r','i','v','e','r','\\',0};
941 /* Check what prefix is present */
942 if (strncmpW( name
, servicesW
, strlenW(servicesW
) ) == 0)
944 FIXME( "Driver name %s is malformed as the keypath\n", debugstr_w(name
) );
945 RtlCreateUnicodeString( keypath
, name
);
948 if (strncmpW( name
, driverW
, strlenW(driverW
) ) == 0)
949 name
+= strlenW(driverW
);
951 FIXME( "Driver name %s does not properly begin with \\Driver\\\n", debugstr_w(name
) );
953 str
= HeapAlloc( GetProcessHeap(), 0, sizeof(servicesW
) + strlenW(name
)*sizeof(WCHAR
));
954 lstrcpyW( str
, servicesW
);
955 lstrcatW( str
, name
);
956 RtlInitUnicodeString( keypath
, str
);
960 static NTSTATUS WINAPI
unhandled_irp( DEVICE_OBJECT
*device
, IRP
*irp
)
962 TRACE( "(%p, %p)\n", device
, irp
);
963 irp
->IoStatus
.u
.Status
= STATUS_INVALID_DEVICE_REQUEST
;
964 IoCompleteRequest( irp
, IO_NO_INCREMENT
);
965 return STATUS_INVALID_DEVICE_REQUEST
;
969 /***********************************************************************
970 * IoCreateDriver (NTOSKRNL.EXE.@)
972 NTSTATUS WINAPI
IoCreateDriver( UNICODE_STRING
*name
, PDRIVER_INITIALIZE init
)
974 struct wine_driver
*driver
;
978 TRACE("(%s, %p)\n", debugstr_us(name
), init
);
980 if (!(driver
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
,
982 return STATUS_NO_MEMORY
;
984 if ((status
= RtlDuplicateUnicodeString( 1, name
, &driver
->driver_obj
.DriverName
)))
986 RtlFreeHeap( GetProcessHeap(), 0, driver
);
990 driver
->driver_obj
.Size
= sizeof(driver
->driver_obj
);
991 driver
->driver_obj
.DriverInit
= init
;
992 driver
->driver_obj
.DriverExtension
= &driver
->driver_extension
;
993 driver
->driver_extension
.DriverObject
= &driver
->driver_obj
;
994 build_driver_keypath( driver
->driver_obj
.DriverName
.Buffer
, &driver
->driver_extension
.ServiceKeyName
);
995 for (i
= 0; i
<= IRP_MJ_MAXIMUM_FUNCTION
; i
++)
996 driver
->driver_obj
.MajorFunction
[i
] = unhandled_irp
;
998 status
= driver
->driver_obj
.DriverInit( &driver
->driver_obj
, &driver
->driver_extension
.ServiceKeyName
);
1001 RtlFreeUnicodeString( &driver
->driver_obj
.DriverName
);
1002 RtlFreeUnicodeString( &driver
->driver_extension
.ServiceKeyName
);
1003 RtlFreeHeap( GetProcessHeap(), 0, driver
);
1007 for (i
= 0; i
<= IRP_MJ_MAXIMUM_FUNCTION
; i
++)
1009 if (driver
->driver_obj
.MajorFunction
[i
]) continue;
1010 driver
->driver_obj
.MajorFunction
[i
] = unhandled_irp
;
1013 EnterCriticalSection( &drivers_cs
);
1014 if (wine_rb_put( &wine_drivers
, &driver
->driver_obj
.DriverName
, &driver
->entry
))
1015 ERR( "failed to insert driver %s in tree\n", debugstr_us(name
) );
1016 LeaveCriticalSection( &drivers_cs
);
1017 return STATUS_SUCCESS
;
1021 /***********************************************************************
1022 * IoDeleteDriver (NTOSKRNL.EXE.@)
1024 void WINAPI
IoDeleteDriver( DRIVER_OBJECT
*driver_object
)
1026 TRACE( "(%p)\n", driver_object
);
1028 EnterCriticalSection( &drivers_cs
);
1029 wine_rb_remove_key( &wine_drivers
, &driver_object
->DriverName
);
1030 LeaveCriticalSection( &drivers_cs
);
1032 RtlFreeUnicodeString( &driver_object
->DriverName
);
1033 RtlFreeUnicodeString( &driver_object
->DriverExtension
->ServiceKeyName
);
1034 RtlFreeHeap( GetProcessHeap(), 0, CONTAINING_RECORD( driver_object
, struct wine_driver
, driver_obj
) );
1038 /***********************************************************************
1039 * IoCreateDevice (NTOSKRNL.EXE.@)
1041 NTSTATUS WINAPI
IoCreateDevice( DRIVER_OBJECT
*driver
, ULONG ext_size
,
1042 UNICODE_STRING
*name
, DEVICE_TYPE type
,
1043 ULONG characteristics
, BOOLEAN exclusive
,
1044 DEVICE_OBJECT
**ret_device
)
1047 DEVICE_OBJECT
*device
;
1049 HANDLE manager
= get_device_manager();
1051 TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
1052 driver
, ext_size
, debugstr_us(name
), type
, characteristics
, exclusive
, ret_device
);
1054 if (!(device
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*device
) + ext_size
)))
1055 return STATUS_NO_MEMORY
;
1057 SERVER_START_REQ( create_device
)
1060 req
->attributes
= 0;
1062 req
->manager
= wine_server_obj_handle( manager
);
1063 req
->user_ptr
= wine_server_client_ptr( device
);
1064 if (name
) wine_server_add_data( req
, name
->Buffer
, name
->Length
);
1065 if (!(status
= wine_server_call( req
))) handle
= wine_server_ptr_handle( reply
->handle
);
1069 if (status
== STATUS_SUCCESS
)
1071 device
->DriverObject
= driver
;
1072 device
->DeviceExtension
= device
+ 1;
1073 device
->DeviceType
= type
;
1074 device
->StackSize
= 1;
1075 device
->Reserved
= handle
;
1077 device
->NextDevice
= driver
->DeviceObject
;
1078 driver
->DeviceObject
= device
;
1080 *ret_device
= device
;
1082 else HeapFree( GetProcessHeap(), 0, device
);
1088 /***********************************************************************
1089 * IoDeleteDevice (NTOSKRNL.EXE.@)
1091 void WINAPI
IoDeleteDevice( DEVICE_OBJECT
*device
)
1095 TRACE( "%p\n", device
);
1097 SERVER_START_REQ( delete_device
)
1099 req
->handle
= wine_server_obj_handle( device
->Reserved
);
1100 status
= wine_server_call( req
);
1104 if (status
== STATUS_SUCCESS
)
1106 DEVICE_OBJECT
**prev
= &device
->DriverObject
->DeviceObject
;
1107 while (*prev
&& *prev
!= device
) prev
= &(*prev
)->NextDevice
;
1108 if (*prev
) *prev
= (*prev
)->NextDevice
;
1109 NtClose( device
->Reserved
);
1110 HeapFree( GetProcessHeap(), 0, device
);
1115 /***********************************************************************
1116 * IoCreateSymbolicLink (NTOSKRNL.EXE.@)
1118 NTSTATUS WINAPI
IoCreateSymbolicLink( UNICODE_STRING
*name
, UNICODE_STRING
*target
)
1121 OBJECT_ATTRIBUTES attr
;
1123 attr
.Length
= sizeof(attr
);
1124 attr
.RootDirectory
= 0;
1125 attr
.ObjectName
= name
;
1126 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
1127 attr
.SecurityDescriptor
= NULL
;
1128 attr
.SecurityQualityOfService
= NULL
;
1130 TRACE( "%s -> %s\n", debugstr_us(name
), debugstr_us(target
) );
1131 /* FIXME: store handle somewhere */
1132 return NtCreateSymbolicLinkObject( &handle
, SYMBOLIC_LINK_ALL_ACCESS
, &attr
, target
);
1136 /***********************************************************************
1137 * IoDeleteSymbolicLink (NTOSKRNL.EXE.@)
1139 NTSTATUS WINAPI
IoDeleteSymbolicLink( UNICODE_STRING
*name
)
1142 OBJECT_ATTRIBUTES attr
;
1145 attr
.Length
= sizeof(attr
);
1146 attr
.RootDirectory
= 0;
1147 attr
.ObjectName
= name
;
1148 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1149 attr
.SecurityDescriptor
= NULL
;
1150 attr
.SecurityQualityOfService
= NULL
;
1152 if (!(status
= NtOpenSymbolicLinkObject( &handle
, 0, &attr
)))
1154 SERVER_START_REQ( unlink_object
)
1156 req
->handle
= wine_server_obj_handle( handle
);
1157 status
= wine_server_call( req
);
1166 /***********************************************************************
1167 * IoGetDeviceInterfaces (NTOSKRNL.EXE.@)
1169 NTSTATUS WINAPI
IoGetDeviceInterfaces( const GUID
*InterfaceClassGuid
,
1170 PDEVICE_OBJECT PhysicalDeviceObject
,
1171 ULONG Flags
, PWSTR
*SymbolicLinkList
)
1173 FIXME( "stub: %s %p %x %p\n", debugstr_guid(InterfaceClassGuid
),
1174 PhysicalDeviceObject
, Flags
, SymbolicLinkList
);
1175 return STATUS_NOT_IMPLEMENTED
;
1179 /***********************************************************************
1180 * IoGetDeviceObjectPointer (NTOSKRNL.EXE.@)
1182 NTSTATUS WINAPI
IoGetDeviceObjectPointer( UNICODE_STRING
*name
, ACCESS_MASK access
, PFILE_OBJECT
*file
, PDEVICE_OBJECT
*device
)
1184 static DEVICE_OBJECT stub_device
;
1185 static DRIVER_OBJECT stub_driver
;
1187 FIXME( "stub: %s %x %p %p\n", debugstr_us(name
), access
, file
, device
);
1189 stub_device
.StackSize
= 0x80; /* minimum value to appease SecuROM 5.x */
1190 stub_device
.DriverObject
= &stub_driver
;
1193 *device
= &stub_device
;
1195 return STATUS_SUCCESS
;
1198 /***********************************************************************
1199 * IoGetAttachedDevice (NTOSKRNL.EXE.@)
1201 DEVICE_OBJECT
* WINAPI
IoGetAttachedDevice( DEVICE_OBJECT
*device
)
1203 DEVICE_OBJECT
*result
= device
;
1205 TRACE( "(%p)\n", device
);
1207 while (result
->AttachedDevice
)
1208 result
= result
->AttachedDevice
;
1214 /***********************************************************************
1215 * IoGetDeviceProperty (NTOSKRNL.EXE.@)
1217 NTSTATUS WINAPI
IoGetDeviceProperty( DEVICE_OBJECT
*device
, DEVICE_REGISTRY_PROPERTY device_property
,
1218 ULONG buffer_length
, PVOID property_buffer
, PULONG result_length
)
1220 NTSTATUS status
= STATUS_NOT_IMPLEMENTED
;
1221 TRACE( "%p %d %u %p %p\n", device
, device_property
, buffer_length
,
1222 property_buffer
, result_length
);
1223 switch (device_property
)
1225 case DevicePropertyEnumeratorName
:
1229 status
= get_device_id( device
, BusQueryInstanceID
, &id
);
1230 if (status
!= STATUS_SUCCESS
)
1232 ERR( "Failed to get device id\n" );
1237 ptr
= strchrW( id
, '\\' );
1240 *result_length
= sizeof(WCHAR
) * (strlenW(id
) + 1);
1241 if (buffer_length
>= *result_length
)
1242 memcpy( property_buffer
, id
, *result_length
);
1244 status
= STATUS_BUFFER_TOO_SMALL
;
1246 HeapFree( GetProcessHeap(), 0, id
);
1249 case DevicePropertyPhysicalDeviceObjectName
:
1251 ULONG used_len
, len
= buffer_length
+ sizeof(OBJECT_NAME_INFORMATION
);
1252 OBJECT_NAME_INFORMATION
*name
= HeapAlloc(GetProcessHeap(), 0, len
);
1254 status
= NtQueryObject(device
->Reserved
, ObjectNameInformation
, name
, len
, &used_len
);
1255 if (status
== STATUS_SUCCESS
)
1257 /* Ensure room for NULL termination */
1258 if (buffer_length
>= name
->Name
.MaximumLength
)
1259 memcpy(property_buffer
, name
->Name
.Buffer
, name
->Name
.MaximumLength
);
1261 status
= STATUS_BUFFER_TOO_SMALL
;
1262 *result_length
= name
->Name
.MaximumLength
;
1266 if (status
== STATUS_INFO_LENGTH_MISMATCH
||
1267 status
== STATUS_BUFFER_OVERFLOW
)
1269 status
= STATUS_BUFFER_TOO_SMALL
;
1270 *result_length
= used_len
- sizeof(OBJECT_NAME_INFORMATION
);
1275 HeapFree(GetProcessHeap(), 0, name
);
1279 FIXME("unhandled property %d\n", device_property
);
1285 /***********************************************************************
1286 * IoCallDriver (NTOSKRNL.EXE.@)
1288 NTSTATUS WINAPI
IoCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
1290 PDRIVER_DISPATCH dispatch
;
1291 IO_STACK_LOCATION
*irpsp
;
1294 --irp
->CurrentLocation
;
1295 irpsp
= --irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1296 dispatch
= device
->DriverObject
->MajorFunction
[irpsp
->MajorFunction
];
1298 if (TRACE_ON(relay
))
1299 DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
1300 GetCurrentThreadId(), dispatch
, device
, irp
);
1302 status
= dispatch( device
, irp
);
1304 if (TRACE_ON(relay
))
1305 DPRINTF( "%04x:Ret driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
1306 GetCurrentThreadId(), dispatch
, device
, irp
, status
);
1312 /***********************************************************************
1313 * IofCallDriver (NTOSKRNL.EXE.@)
1315 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1316 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver
)
1317 NTSTATUS WINAPI
__regs_IofCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
1319 NTSTATUS WINAPI
IofCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
1322 TRACE( "%p %p\n", device
, irp
);
1323 return IoCallDriver( device
, irp
);
1327 /***********************************************************************
1328 * IoGetRelatedDeviceObject (NTOSKRNL.EXE.@)
1330 PDEVICE_OBJECT WINAPI
IoGetRelatedDeviceObject( PFILE_OBJECT obj
)
1332 FIXME( "stub: %p\n", obj
);
1336 static CONFIGURATION_INFORMATION configuration_information
;
1338 /***********************************************************************
1339 * IoGetConfigurationInformation (NTOSKRNL.EXE.@)
1341 PCONFIGURATION_INFORMATION WINAPI
IoGetConfigurationInformation(void)
1343 FIXME( "partial stub\n" );
1344 /* FIXME: return actual devices on system */
1345 return &configuration_information
;
1349 /***********************************************************************
1350 * IoIsWdmVersionAvailable (NTOSKRNL.EXE.@)
1352 NTSTATUS WINAPI
IoIsWdmVersionAvailable(UCHAR MajorVersion
, UCHAR MinorVersion
)
1358 TRACE( "%d, 0x%X\n", MajorVersion
, MinorVersion
);
1360 version
= GetVersion();
1361 major
= LOBYTE(version
);
1362 minor
= HIBYTE(LOWORD(version
));
1364 if (MajorVersion
== 6 && MinorVersion
== 0)
1366 /* Windows Vista, Windows Server 2008, Windows 7 */
1368 else if (MajorVersion
== 1)
1370 if (MinorVersion
== 0x30)
1372 /* Windows server 2003 */
1376 else if (MinorVersion
== 0x20)
1382 else if (MinorVersion
== 0x10)
1388 else if (MinorVersion
== 0x05)
1392 MinorVersion
= 0x5a;
1394 else if (MinorVersion
== 0x00)
1398 MinorVersion
= 0x0a;
1402 FIXME( "unknown major %d minor 0x%X\n", MajorVersion
, MinorVersion
);
1408 FIXME( "unknown major %d minor 0x%X\n", MajorVersion
, MinorVersion
);
1411 return major
> MajorVersion
|| (major
== MajorVersion
&& minor
>= MinorVersion
);
1415 /***********************************************************************
1416 * IoQueryDeviceDescription (NTOSKRNL.EXE.@)
1418 NTSTATUS WINAPI
IoQueryDeviceDescription(PINTERFACE_TYPE itype
, PULONG bus
, PCONFIGURATION_TYPE ctype
,
1419 PULONG cnum
, PCONFIGURATION_TYPE ptype
, PULONG pnum
,
1420 PIO_QUERY_DEVICE_ROUTINE callout
, PVOID context
)
1422 FIXME( "(%p %p %p %p %p %p %p %p)\n", itype
, bus
, ctype
, cnum
, ptype
, pnum
, callout
, context
);
1423 return STATUS_NOT_IMPLEMENTED
;
1427 /***********************************************************************
1428 * IoRegisterDriverReinitialization (NTOSKRNL.EXE.@)
1430 void WINAPI
IoRegisterDriverReinitialization( PDRIVER_OBJECT obj
, PDRIVER_REINITIALIZE reinit
, PVOID context
)
1432 FIXME( "stub: %p %p %p\n", obj
, reinit
, context
);
1436 /***********************************************************************
1437 * IoRegisterShutdownNotification (NTOSKRNL.EXE.@)
1439 NTSTATUS WINAPI
IoRegisterShutdownNotification( PDEVICE_OBJECT obj
)
1441 FIXME( "stub: %p\n", obj
);
1442 return STATUS_SUCCESS
;
1446 /***********************************************************************
1447 * IoUnregisterShutdownNotification (NTOSKRNL.EXE.@)
1449 VOID WINAPI
IoUnregisterShutdownNotification( PDEVICE_OBJECT obj
)
1451 FIXME( "stub: %p\n", obj
);
1455 /***********************************************************************
1456 * IoReportResourceForDetection (NTOSKRNL.EXE.@)
1458 NTSTATUS WINAPI
IoReportResourceForDetection( DRIVER_OBJECT
*drv_obj
, CM_RESOURCE_LIST
*drv_list
, ULONG drv_size
,
1459 DEVICE_OBJECT
*dev_obj
, CM_RESOURCE_LIST
*dev_list
, ULONG dev_size
,
1462 FIXME( "(%p, %p, %u, %p, %p, %u, %p): stub\n", drv_obj
, drv_list
, drv_size
,
1463 dev_obj
, dev_list
, dev_size
, conflict
);
1465 return STATUS_NOT_IMPLEMENTED
;
1469 /***********************************************************************
1470 * IoReportResourceUsage (NTOSKRNL.EXE.@)
1472 NTSTATUS WINAPI
IoReportResourceUsage( UNICODE_STRING
*name
, DRIVER_OBJECT
*drv_obj
, CM_RESOURCE_LIST
*drv_list
,
1473 ULONG drv_size
, DRIVER_OBJECT
*dev_obj
, CM_RESOURCE_LIST
*dev_list
,
1474 ULONG dev_size
, BOOLEAN overwrite
, BOOLEAN
*conflict
)
1476 FIXME( "(%s, %p, %p, %u, %p, %p, %u, %d, %p): stub\n", debugstr_us(name
),
1477 drv_obj
, drv_list
, drv_size
, dev_obj
, dev_list
, dev_size
, overwrite
, conflict
);
1479 return STATUS_NOT_IMPLEMENTED
;
1483 /***********************************************************************
1484 * IoCompleteRequest (NTOSKRNL.EXE.@)
1486 VOID WINAPI
IoCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1488 IO_STACK_LOCATION
*irpsp
;
1489 PIO_COMPLETION_ROUTINE routine
;
1490 NTSTATUS status
, stat
;
1493 TRACE( "%p %u\n", irp
, priority_boost
);
1495 status
= irp
->IoStatus
.u
.Status
;
1496 while (irp
->CurrentLocation
<= irp
->StackCount
)
1498 irpsp
= irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1499 routine
= irpsp
->CompletionRoutine
;
1501 /* FIXME: add SL_INVOKE_ON_CANCEL support */
1504 if ((irpsp
->Control
& SL_INVOKE_ON_SUCCESS
) && STATUS_SUCCESS
== status
)
1506 if ((irpsp
->Control
& SL_INVOKE_ON_ERROR
) && STATUS_SUCCESS
!= status
)
1509 ++irp
->CurrentLocation
;
1510 ++irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1513 TRACE( "calling %p( %p, %p, %p )\n", routine
,
1514 irpsp
->DeviceObject
, irp
, irpsp
->Context
);
1515 stat
= routine( irpsp
->DeviceObject
, irp
, irpsp
->Context
);
1516 TRACE( "CompletionRoutine returned %x\n", stat
);
1517 if (STATUS_MORE_PROCESSING_REQUIRED
== stat
)
1522 if (irp
->Flags
& IRP_DEALLOCATE_BUFFER
)
1523 HeapFree( GetProcessHeap(), 0, irp
->AssociatedIrp
.SystemBuffer
);
1529 /***********************************************************************
1530 * IofCompleteRequest (NTOSKRNL.EXE.@)
1532 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1533 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest
)
1534 void WINAPI
__regs_IofCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1536 void WINAPI
IofCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1539 TRACE( "%p %u\n", irp
, priority_boost
);
1540 IoCompleteRequest( irp
, priority_boost
);
1544 /***********************************************************************
1545 * InterlockedCompareExchange (NTOSKRNL.EXE.@)
1547 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
1548 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange
)
1549 LONG WINAPI
__regs_NTOSKRNL_InterlockedCompareExchange( LONG
volatile *dest
, LONG xchg
, LONG compare
)
1551 LONG WINAPI
NTOSKRNL_InterlockedCompareExchange( LONG
volatile *dest
, LONG xchg
, LONG compare
)
1554 return InterlockedCompareExchange( dest
, xchg
, compare
);
1558 /***********************************************************************
1559 * InterlockedDecrement (NTOSKRNL.EXE.@)
1561 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1562 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement
)
1563 LONG WINAPI
__regs_NTOSKRNL_InterlockedDecrement( LONG
volatile *dest
)
1565 LONG WINAPI
NTOSKRNL_InterlockedDecrement( LONG
volatile *dest
)
1568 return InterlockedDecrement( dest
);
1572 /***********************************************************************
1573 * InterlockedExchange (NTOSKRNL.EXE.@)
1575 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1576 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange
)
1577 LONG WINAPI
__regs_NTOSKRNL_InterlockedExchange( LONG
volatile *dest
, LONG val
)
1579 LONG WINAPI
NTOSKRNL_InterlockedExchange( LONG
volatile *dest
, LONG val
)
1582 return InterlockedExchange( dest
, val
);
1586 /***********************************************************************
1587 * InterlockedExchangeAdd (NTOSKRNL.EXE.@)
1589 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1590 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd
)
1591 LONG WINAPI
__regs_NTOSKRNL_InterlockedExchangeAdd( LONG
volatile *dest
, LONG incr
)
1593 LONG WINAPI
NTOSKRNL_InterlockedExchangeAdd( LONG
volatile *dest
, LONG incr
)
1596 return InterlockedExchangeAdd( dest
, incr
);
1600 /***********************************************************************
1601 * InterlockedIncrement (NTOSKRNL.EXE.@)
1603 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1604 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement
)
1605 LONG WINAPI
__regs_NTOSKRNL_InterlockedIncrement( LONG
volatile *dest
)
1607 LONG WINAPI
NTOSKRNL_InterlockedIncrement( LONG
volatile *dest
)
1610 return InterlockedIncrement( dest
);
1614 /***********************************************************************
1615 * InterlockedPopEntrySList (NTOSKRNL.EXE.@)
1617 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1618 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedPopEntrySList
)
1619 PSLIST_ENTRY WINAPI
__regs_NTOSKRNL_InterlockedPopEntrySList( PSLIST_HEADER list
)
1621 PSLIST_ENTRY WINAPI
NTOSKRNL_InterlockedPopEntrySList( PSLIST_HEADER list
)
1624 return InterlockedPopEntrySList( list
);
1628 /***********************************************************************
1629 * InterlockedPushEntrySList (NTOSKRNL.EXE.@)
1631 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1632 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedPushEntrySList
)
1633 PSLIST_ENTRY WINAPI
__regs_NTOSKRNL_InterlockedPushEntrySList( PSLIST_HEADER list
, PSLIST_ENTRY entry
)
1635 PSLIST_ENTRY WINAPI
NTOSKRNL_InterlockedPushEntrySList( PSLIST_HEADER list
, PSLIST_ENTRY entry
)
1638 return InterlockedPushEntrySList( list
, entry
);
1642 /***********************************************************************
1643 * ExAllocatePool (NTOSKRNL.EXE.@)
1645 PVOID WINAPI
ExAllocatePool( POOL_TYPE type
, SIZE_T size
)
1647 return ExAllocatePoolWithTag( type
, size
, 0 );
1651 /***********************************************************************
1652 * ExAllocatePoolWithQuota (NTOSKRNL.EXE.@)
1654 PVOID WINAPI
ExAllocatePoolWithQuota( POOL_TYPE type
, SIZE_T size
)
1656 return ExAllocatePoolWithTag( type
, size
, 0 );
1660 /***********************************************************************
1661 * ExAllocatePoolWithTag (NTOSKRNL.EXE.@)
1663 PVOID WINAPI
ExAllocatePoolWithTag( POOL_TYPE type
, SIZE_T size
, ULONG tag
)
1665 /* FIXME: handle page alignment constraints */
1666 void *ret
= HeapAlloc( GetProcessHeap(), 0, size
);
1667 TRACE( "%lu pool %u -> %p\n", size
, type
, ret
);
1672 /***********************************************************************
1673 * ExAllocatePoolWithQuotaTag (NTOSKRNL.EXE.@)
1675 PVOID WINAPI
ExAllocatePoolWithQuotaTag( POOL_TYPE type
, SIZE_T size
, ULONG tag
)
1677 return ExAllocatePoolWithTag( type
, size
, tag
);
1681 /***********************************************************************
1682 * ExCreateCallback (NTOSKRNL.EXE.@)
1684 NTSTATUS WINAPI
ExCreateCallback(PCALLBACK_OBJECT
*obj
, POBJECT_ATTRIBUTES attr
,
1685 BOOLEAN create
, BOOLEAN allow_multiple
)
1687 FIXME("(%p, %p, %u, %u): stub\n", obj
, attr
, create
, allow_multiple
);
1689 return STATUS_NOT_IMPLEMENTED
;
1693 /***********************************************************************
1694 * ExDeleteNPagedLookasideList (NTOSKRNL.EXE.@)
1696 void WINAPI
ExDeleteNPagedLookasideList( PNPAGED_LOOKASIDE_LIST lookaside
)
1698 FIXME("(%p) stub\n", lookaside
);
1702 /***********************************************************************
1703 * ExDeletePagedLookasideList (NTOSKRNL.EXE.@)
1705 void WINAPI
ExDeletePagedLookasideList( PPAGED_LOOKASIDE_LIST lookaside
)
1707 FIXME("(%p) stub\n", lookaside
);
1711 /***********************************************************************
1712 * ExFreePool (NTOSKRNL.EXE.@)
1714 void WINAPI
ExFreePool( void *ptr
)
1716 ExFreePoolWithTag( ptr
, 0 );
1720 /***********************************************************************
1721 * ExFreePoolWithTag (NTOSKRNL.EXE.@)
1723 void WINAPI
ExFreePoolWithTag( void *ptr
, ULONG tag
)
1725 TRACE( "%p\n", ptr
);
1726 HeapFree( GetProcessHeap(), 0, ptr
);
1730 /***********************************************************************
1731 * ExInitializeResourceLite (NTOSKRNL.EXE.@)
1733 NTSTATUS WINAPI
ExInitializeResourceLite(PERESOURCE Resource
)
1735 FIXME( "stub: %p\n", Resource
);
1736 return STATUS_NOT_IMPLEMENTED
;
1740 /***********************************************************************
1741 * ExInitializeNPagedLookasideList (NTOSKRNL.EXE.@)
1743 void WINAPI
ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside
,
1744 PALLOCATE_FUNCTION Allocate
,
1745 PFREE_FUNCTION Free
,
1751 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside
, Allocate
, Free
, Flags
, Size
, Tag
, Depth
);
1754 /***********************************************************************
1755 * ExInitializePagedLookasideList (NTOSKRNL.EXE.@)
1757 void WINAPI
ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside
,
1758 PALLOCATE_FUNCTION Allocate
,
1759 PFREE_FUNCTION Free
,
1765 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside
, Allocate
, Free
, Flags
, Size
, Tag
, Depth
);
1768 /***********************************************************************
1769 * ExInitializeZone (NTOSKRNL.EXE.@)
1771 NTSTATUS WINAPI
ExInitializeZone(PZONE_HEADER Zone
,
1773 PVOID InitialSegment
,
1774 ULONG InitialSegmentSize
)
1776 FIXME( "stub: %p, %u, %p, %u\n", Zone
, BlockSize
, InitialSegment
, InitialSegmentSize
);
1777 return STATUS_NOT_IMPLEMENTED
;
1780 /***********************************************************************
1781 * FsRtlRegisterUncProvider (NTOSKRNL.EXE.@)
1783 NTSTATUS WINAPI
FsRtlRegisterUncProvider(PHANDLE MupHandle
, PUNICODE_STRING RedirDevName
,
1784 BOOLEAN MailslotsSupported
)
1786 FIXME("(%p %p %d): stub\n", MupHandle
, RedirDevName
, MailslotsSupported
);
1787 return STATUS_NOT_IMPLEMENTED
;
1790 /***********************************************************************
1791 * IoGetCurrentProcess / PsGetCurrentProcess (NTOSKRNL.EXE.@)
1793 PEPROCESS WINAPI
IoGetCurrentProcess(void)
1799 /***********************************************************************
1800 * KeGetCurrentThread / PsGetCurrentThread (NTOSKRNL.EXE.@)
1802 PRKTHREAD WINAPI
KeGetCurrentThread(void)
1808 /***********************************************************************
1809 * KeInitializeEvent (NTOSKRNL.EXE.@)
1811 void WINAPI
KeInitializeEvent( PRKEVENT Event
, EVENT_TYPE Type
, BOOLEAN State
)
1813 FIXME( "stub: %p %d %d\n", Event
, Type
, State
);
1817 /***********************************************************************
1818 * KeInitializeMutex (NTOSKRNL.EXE.@)
1820 void WINAPI
KeInitializeMutex(PRKMUTEX Mutex
, ULONG Level
)
1822 FIXME( "stub: %p, %u\n", Mutex
, Level
);
1826 /***********************************************************************
1827 * KeWaitForMutexObject (NTOSKRNL.EXE.@)
1829 NTSTATUS WINAPI
KeWaitForMutexObject(PRKMUTEX Mutex
, KWAIT_REASON WaitReason
, KPROCESSOR_MODE WaitMode
,
1830 BOOLEAN Alertable
, PLARGE_INTEGER Timeout
)
1832 FIXME( "stub: %p, %d, %d, %d, %p\n", Mutex
, WaitReason
, WaitMode
, Alertable
, Timeout
);
1833 return STATUS_NOT_IMPLEMENTED
;
1837 /***********************************************************************
1838 * KeReleaseMutex (NTOSKRNL.EXE.@)
1840 LONG WINAPI
KeReleaseMutex(PRKMUTEX Mutex
, BOOLEAN Wait
)
1842 FIXME( "stub: %p, %d\n", Mutex
, Wait
);
1843 return STATUS_NOT_IMPLEMENTED
;
1847 /***********************************************************************
1848 * KeInitializeSemaphore (NTOSKRNL.EXE.@)
1850 void WINAPI
KeInitializeSemaphore( PRKSEMAPHORE Semaphore
, LONG Count
, LONG Limit
)
1852 FIXME( "(%p %d %d) stub\n", Semaphore
, Count
, Limit
);
1856 /***********************************************************************
1857 * KeInitializeSpinLock (NTOSKRNL.EXE.@)
1859 void WINAPI
KeInitializeSpinLock( PKSPIN_LOCK SpinLock
)
1861 FIXME( "stub: %p\n", SpinLock
);
1865 /***********************************************************************
1866 * KeInitializeTimerEx (NTOSKRNL.EXE.@)
1868 void WINAPI
KeInitializeTimerEx( PKTIMER Timer
, TIMER_TYPE Type
)
1870 FIXME( "stub: %p %d\n", Timer
, Type
);
1874 /***********************************************************************
1875 * KeInitializeTimer (NTOSKRNL.EXE.@)
1877 void WINAPI
KeInitializeTimer( PKTIMER Timer
)
1879 KeInitializeTimerEx(Timer
, NotificationTimer
);
1882 /***********************************************************************
1883 * KeInsertQueue (NTOSKRNL.EXE.@)
1885 LONG WINAPI
KeInsertQueue(PRKQUEUE Queue
, PLIST_ENTRY Entry
)
1887 FIXME( "stub: %p %p\n", Queue
, Entry
);
1891 /**********************************************************************
1892 * KeQueryActiveProcessors (NTOSKRNL.EXE.@)
1894 * Return the active Processors as bitmask
1897 * active Processors as bitmask
1900 KAFFINITY WINAPI
KeQueryActiveProcessors( void )
1902 DWORD_PTR AffinityMask
;
1904 GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask
, NULL
);
1905 return AffinityMask
;
1909 /**********************************************************************
1910 * KeQueryInterruptTime (NTOSKRNL.EXE.@)
1912 * Return the interrupt time count
1915 ULONGLONG WINAPI
KeQueryInterruptTime( void )
1917 LARGE_INTEGER totaltime
;
1919 KeQueryTickCount(&totaltime
);
1920 return totaltime
.QuadPart
;
1924 /***********************************************************************
1925 * KeQuerySystemTime (NTOSKRNL.EXE.@)
1927 void WINAPI
KeQuerySystemTime( LARGE_INTEGER
*time
)
1929 NtQuerySystemTime( time
);
1933 /***********************************************************************
1934 * KeQueryTickCount (NTOSKRNL.EXE.@)
1936 void WINAPI
KeQueryTickCount( LARGE_INTEGER
*count
)
1938 count
->QuadPart
= NtGetTickCount();
1939 /* update the global variable too */
1940 KeTickCount
.LowPart
= count
->u
.LowPart
;
1941 KeTickCount
.High1Time
= count
->u
.HighPart
;
1942 KeTickCount
.High2Time
= count
->u
.HighPart
;
1946 /***********************************************************************
1947 * KeReleaseSemaphore (NTOSKRNL.EXE.@)
1949 LONG WINAPI
KeReleaseSemaphore( PRKSEMAPHORE Semaphore
, KPRIORITY Increment
,
1950 LONG Adjustment
, BOOLEAN Wait
)
1952 FIXME("(%p %d %d %d) stub\n", Semaphore
, Increment
, Adjustment
, Wait
);
1957 /***********************************************************************
1958 * KeQueryTimeIncrement (NTOSKRNL.EXE.@)
1960 ULONG WINAPI
KeQueryTimeIncrement(void)
1966 /***********************************************************************
1967 * KeResetEvent (NTOSKRNL.EXE.@)
1969 LONG WINAPI
KeResetEvent( PRKEVENT Event
)
1971 FIXME("(%p): stub\n", Event
);
1976 /***********************************************************************
1977 * KeSetEvent (NTOSKRNL.EXE.@)
1979 LONG WINAPI
KeSetEvent( PRKEVENT Event
, KPRIORITY Increment
, BOOLEAN Wait
)
1981 FIXME("(%p, %d, %d): stub\n", Event
, Increment
, Wait
);
1986 /***********************************************************************
1987 * KeSetPriorityThread (NTOSKRNL.EXE.@)
1989 KPRIORITY WINAPI
KeSetPriorityThread( PKTHREAD Thread
, KPRIORITY Priority
)
1991 FIXME("(%p %d)\n", Thread
, Priority
);
1995 /***********************************************************************
1996 * KeSetSystemAffinityThread (NTOSKRNL.EXE.@)
1998 VOID WINAPI
KeSetSystemAffinityThread(KAFFINITY Affinity
)
2000 FIXME("(%lx) stub\n", Affinity
);
2003 /***********************************************************************
2004 * KeWaitForSingleObject (NTOSKRNL.EXE.@)
2006 NTSTATUS WINAPI
KeWaitForSingleObject(PVOID Object
,
2007 KWAIT_REASON WaitReason
,
2008 KPROCESSOR_MODE WaitMode
,
2010 PLARGE_INTEGER Timeout
)
2012 FIXME( "stub: %p, %d, %d, %d, %p\n", Object
, WaitReason
, WaitMode
, Alertable
, Timeout
);
2013 return STATUS_NOT_IMPLEMENTED
;
2016 /***********************************************************************
2017 * KeWaitForMultipleObjects (NTOSKRNL.EXE.@)
2019 NTSTATUS WINAPI
KeWaitForMultipleObjects(ULONG Count
, PVOID Object
[], WAIT_TYPE WaitType
,
2020 KWAIT_REASON WaitReason
, KPROCESSOR_MODE WaitMode
,
2021 BOOLEAN Alertable
, PLARGE_INTEGER Timeout
,
2022 PKWAIT_BLOCK WaitBlockArray
)
2024 FIXME( "stub: %u, %p, %d, %d, %d, %d, %p, %p\n", Count
, Object
, WaitType
, WaitReason
, WaitMode
,
2025 Alertable
, Timeout
, WaitBlockArray
);
2026 return STATUS_NOT_IMPLEMENTED
;
2029 /***********************************************************************
2030 * IoRegisterFileSystem (NTOSKRNL.EXE.@)
2032 VOID WINAPI
IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject
)
2034 FIXME("(%p): stub\n", DeviceObject
);
2037 /***********************************************************************
2038 * IoUnregisterFileSystem (NTOSKRNL.EXE.@)
2040 VOID WINAPI
IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject
)
2042 FIXME("(%p): stub\n", DeviceObject
);
2045 /***********************************************************************
2046 * MmAllocateNonCachedMemory (NTOSKRNL.EXE.@)
2048 PVOID WINAPI
MmAllocateNonCachedMemory( SIZE_T size
)
2050 TRACE( "%lu\n", size
);
2051 return VirtualAlloc( NULL
, size
, MEM_RESERVE
|MEM_COMMIT
, PAGE_READWRITE
|PAGE_NOCACHE
);
2054 /***********************************************************************
2055 * MmAllocateContiguousMemory (NTOSKRNL.EXE.@)
2057 PVOID WINAPI
MmAllocateContiguousMemory( SIZE_T size
, PHYSICAL_ADDRESS highest_valid_address
)
2059 FIXME( "%lu, %s stub\n", size
, wine_dbgstr_longlong(highest_valid_address
.QuadPart
) );
2063 /***********************************************************************
2064 * MmAllocateContiguousMemorySpecifyCache (NTOSKRNL.EXE.@)
2066 PVOID WINAPI
MmAllocateContiguousMemorySpecifyCache( SIZE_T size
,
2067 PHYSICAL_ADDRESS lowest_valid_address
,
2068 PHYSICAL_ADDRESS highest_valid_address
,
2069 PHYSICAL_ADDRESS BoundaryAddressMultiple
,
2070 MEMORY_CACHING_TYPE CacheType
)
2076 /***********************************************************************
2077 * MmAllocatePagesForMdl (NTOSKRNL.EXE.@)
2079 PMDL WINAPI
MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress
, PHYSICAL_ADDRESS highaddress
,
2080 PHYSICAL_ADDRESS skipbytes
, SIZE_T size
)
2082 FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress
.QuadPart
), wine_dbgstr_longlong(highaddress
.QuadPart
),
2083 wine_dbgstr_longlong(skipbytes
.QuadPart
), size
);
2087 /***********************************************************************
2088 * MmFreeNonCachedMemory (NTOSKRNL.EXE.@)
2090 void WINAPI
MmFreeNonCachedMemory( void *addr
, SIZE_T size
)
2092 TRACE( "%p %lu\n", addr
, size
);
2093 VirtualFree( addr
, 0, MEM_RELEASE
);
2096 /***********************************************************************
2097 * MmIsAddressValid (NTOSKRNL.EXE.@)
2099 * Check if the process can access the virtual address without a pagefault
2102 * VirtualAddress [I] Address to check
2106 * Success: TRUE (Accessing the Address works without a Pagefault)
2109 BOOLEAN WINAPI
MmIsAddressValid(PVOID VirtualAddress
)
2111 TRACE("(%p)\n", VirtualAddress
);
2112 return !IsBadWritePtr(VirtualAddress
, 1);
2115 /***********************************************************************
2116 * MmMapIoSpace (NTOSKRNL.EXE.@)
2118 PVOID WINAPI
MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress
, DWORD NumberOfBytes
, DWORD CacheType
)
2120 FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress
.u
.HighPart
, PhysicalAddress
.u
.LowPart
, NumberOfBytes
, CacheType
);
2125 /***********************************************************************
2126 * MmLockPagableSectionByHandle (NTOSKRNL.EXE.@)
2128 VOID WINAPI
MmLockPagableSectionByHandle(PVOID ImageSectionHandle
)
2130 FIXME("stub %p\n", ImageSectionHandle
);
2133 /***********************************************************************
2134 * MmMapLockedPagesSpecifyCache (NTOSKRNL.EXE.@)
2136 PVOID WINAPI
MmMapLockedPagesSpecifyCache(PMDLX MemoryDescriptorList
, KPROCESSOR_MODE AccessMode
, MEMORY_CACHING_TYPE CacheType
,
2137 PVOID BaseAddress
, ULONG BugCheckOnFailure
, MM_PAGE_PRIORITY Priority
)
2139 FIXME("(%p, %u, %u, %p, %u, %u): stub\n", MemoryDescriptorList
, AccessMode
, CacheType
, BaseAddress
, BugCheckOnFailure
, Priority
);
2144 /***********************************************************************
2145 * MmUnlockPagableImageSection (NTOSKRNL.EXE.@)
2147 VOID WINAPI
MmUnlockPagableImageSection(PVOID ImageSectionHandle
)
2149 FIXME("stub %p\n", ImageSectionHandle
);
2152 /***********************************************************************
2153 * MmPageEntireDriver (NTOSKRNL.EXE.@)
2155 PVOID WINAPI
MmPageEntireDriver(PVOID AddrInSection
)
2157 TRACE("%p\n", AddrInSection
);
2158 return AddrInSection
;
2162 /***********************************************************************
2163 * MmProbeAndLockPages (NTOSKRNL.EXE.@)
2165 void WINAPI
MmProbeAndLockPages(PMDLX MemoryDescriptorList
, KPROCESSOR_MODE AccessMode
, LOCK_OPERATION Operation
)
2167 FIXME("(%p, %u, %u): stub\n", MemoryDescriptorList
, AccessMode
, Operation
);
2171 /***********************************************************************
2172 * MmResetDriverPaging (NTOSKRNL.EXE.@)
2174 void WINAPI
MmResetDriverPaging(PVOID AddrInSection
)
2176 TRACE("%p\n", AddrInSection
);
2180 /***********************************************************************
2181 * MmUnlockPages (NTOSKRNL.EXE.@)
2183 void WINAPI
MmUnlockPages(PMDLX MemoryDescriptorList
)
2185 FIXME("(%p): stub\n", MemoryDescriptorList
);
2189 /***********************************************************************
2190 * MmUnmapIoSpace (NTOSKRNL.EXE.@)
2192 VOID WINAPI
MmUnmapIoSpace( PVOID BaseAddress
, SIZE_T NumberOfBytes
)
2194 FIXME( "stub: %p, %lu\n", BaseAddress
, NumberOfBytes
);
2198 /***********************************************************************
2199 * ObReferenceObjectByHandle (NTOSKRNL.EXE.@)
2201 NTSTATUS WINAPI
ObReferenceObjectByHandle( HANDLE obj
, ACCESS_MASK access
,
2203 KPROCESSOR_MODE mode
, PVOID
* ptr
,
2204 POBJECT_HANDLE_INFORMATION info
)
2206 FIXME( "stub: %p %x %p %d %p %p\n", obj
, access
, type
, mode
, ptr
, info
);
2207 return STATUS_NOT_IMPLEMENTED
;
2210 /***********************************************************************
2211 * ObReferenceObjectByName (NTOSKRNL.EXE.@)
2213 NTSTATUS WINAPI
ObReferenceObjectByName( UNICODE_STRING
*ObjectName
,
2215 ACCESS_STATE
*AccessState
,
2216 ACCESS_MASK DesiredAccess
,
2217 POBJECT_TYPE ObjectType
,
2218 KPROCESSOR_MODE AccessMode
,
2222 struct wine_driver
*driver
;
2223 struct wine_rb_entry
*entry
;
2225 TRACE("mostly-stub:%s %i %p %i %p %i %p %p\n", debugstr_us(ObjectName
),
2226 Attributes
, AccessState
, DesiredAccess
, ObjectType
, AccessMode
,
2227 ParseContext
, Object
);
2229 if (AccessState
) FIXME("Unhandled AccessState\n");
2230 if (DesiredAccess
) FIXME("Unhandled DesiredAccess\n");
2231 if (ParseContext
) FIXME("Unhandled ParseContext\n");
2232 if (ObjectType
) FIXME("Unhandled ObjectType\n");
2234 if (AccessMode
!= KernelMode
)
2236 FIXME("UserMode access not implemented\n");
2237 return STATUS_NOT_IMPLEMENTED
;
2240 EnterCriticalSection(&drivers_cs
);
2241 entry
= wine_rb_get(&wine_drivers
, ObjectName
);
2242 LeaveCriticalSection(&drivers_cs
);
2245 FIXME("Object (%s) not found, may not be tracked.\n", debugstr_us(ObjectName
));
2246 return STATUS_NOT_IMPLEMENTED
;
2249 driver
= WINE_RB_ENTRY_VALUE(entry
, struct wine_driver
, entry
);
2250 *Object
= &driver
->driver_obj
;
2251 return STATUS_SUCCESS
;
2255 static void ObReferenceObject( void *obj
)
2257 TRACE( "(%p): stub\n", obj
);
2261 /***********************************************************************
2262 * ObDereferenceObject (NTOSKRNL.EXE.@)
2264 void WINAPI
ObDereferenceObject( void *obj
)
2266 TRACE( "(%p): stub\n", obj
);
2270 /***********************************************************************
2271 * ObfReferenceObject (NTOSKRNL.EXE.@)
2273 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
2274 DEFINE_FASTCALL1_ENTRYPOINT( ObfReferenceObject
)
2275 void WINAPI
__regs_ObfReferenceObject( void *obj
)
2277 void WINAPI
ObfReferenceObject( void *obj
)
2280 ObReferenceObject( obj
);
2284 /***********************************************************************
2285 * ObfDereferenceObject (NTOSKRNL.EXE.@)
2287 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
2288 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject
)
2289 void WINAPI
__regs_ObfDereferenceObject( void *obj
)
2291 void WINAPI
ObfDereferenceObject( void *obj
)
2294 ObDereferenceObject( obj
);
2298 /***********************************************************************
2299 * IoGetAttachedDeviceReference (NTOSKRNL.EXE.@)
2301 DEVICE_OBJECT
* WINAPI
IoGetAttachedDeviceReference( DEVICE_OBJECT
*device
)
2303 DEVICE_OBJECT
*result
= IoGetAttachedDevice( device
);
2304 ObReferenceObject( result
);
2309 /***********************************************************************
2310 * PsCreateSystemThread (NTOSKRNL.EXE.@)
2312 NTSTATUS WINAPI
PsCreateSystemThread(PHANDLE ThreadHandle
, ULONG DesiredAccess
,
2313 POBJECT_ATTRIBUTES ObjectAttributes
,
2314 HANDLE ProcessHandle
, PCLIENT_ID ClientId
,
2315 PKSTART_ROUTINE StartRoutine
, PVOID StartContext
)
2317 if (!ProcessHandle
) ProcessHandle
= GetCurrentProcess();
2318 return RtlCreateUserThread(ProcessHandle
, 0, FALSE
, 0, 0,
2319 0, StartRoutine
, StartContext
,
2320 ThreadHandle
, ClientId
);
2323 /***********************************************************************
2324 * PsGetCurrentProcessId (NTOSKRNL.EXE.@)
2326 HANDLE WINAPI
PsGetCurrentProcessId(void)
2328 if (GetCurrentThreadId() == request_thread
)
2329 return UlongToHandle(client_pid
);
2330 return UlongToHandle(GetCurrentProcessId());
2334 /***********************************************************************
2335 * PsGetCurrentThreadId (NTOSKRNL.EXE.@)
2337 HANDLE WINAPI
PsGetCurrentThreadId(void)
2339 if (GetCurrentThreadId() == request_thread
)
2340 return UlongToHandle(client_tid
);
2341 return UlongToHandle(GetCurrentThreadId());
2345 /***********************************************************************
2346 * PsGetVersion (NTOSKRNL.EXE.@)
2348 BOOLEAN WINAPI
PsGetVersion(ULONG
*major
, ULONG
*minor
, ULONG
*build
, UNICODE_STRING
*version
)
2350 RTL_OSVERSIONINFOEXW info
;
2352 info
.dwOSVersionInfoSize
= sizeof(info
);
2353 RtlGetVersion( &info
);
2354 if (major
) *major
= info
.dwMajorVersion
;
2355 if (minor
) *minor
= info
.dwMinorVersion
;
2356 if (build
) *build
= info
.dwBuildNumber
;
2360 #if 0 /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
2361 size_t len
= min( strlenW(info
.szCSDVersion
)*sizeof(WCHAR
), version
->MaximumLength
);
2362 memcpy( version
->Buffer
, info
.szCSDVersion
, len
);
2363 if (len
< version
->MaximumLength
) version
->Buffer
[len
/ sizeof(WCHAR
)] = 0;
2364 version
->Length
= len
;
2371 /***********************************************************************
2372 * PsImpersonateClient (NTOSKRNL.EXE.@)
2374 NTSTATUS WINAPI
PsImpersonateClient(PETHREAD Thread
, PACCESS_TOKEN Token
, BOOLEAN CopyOnOpen
,
2375 BOOLEAN EffectiveOnly
, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
2377 FIXME("(%p, %p, %u, %u, %u): stub\n", Thread
, Token
, CopyOnOpen
, EffectiveOnly
, ImpersonationLevel
);
2379 return STATUS_NOT_IMPLEMENTED
;
2383 /***********************************************************************
2384 * PsSetCreateProcessNotifyRoutine (NTOSKRNL.EXE.@)
2386 NTSTATUS WINAPI
PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback
, BOOLEAN remove
)
2388 FIXME( "stub: %p %d\n", callback
, remove
);
2389 return STATUS_SUCCESS
;
2393 /***********************************************************************
2394 * PsSetCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
2396 NTSTATUS WINAPI
PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine
)
2398 FIXME( "stub: %p\n", NotifyRoutine
);
2399 return STATUS_SUCCESS
;
2403 /***********************************************************************
2404 * PsRemoveCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
2406 NTSTATUS WINAPI
PsRemoveCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine
)
2408 FIXME( "stub: %p\n", NotifyRoutine
);
2409 return STATUS_SUCCESS
;
2413 /***********************************************************************
2414 * PsRemoveLoadImageNotifyRoutine (NTOSKRNL.EXE.@)
2416 NTSTATUS WINAPI
PsRemoveLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE NotifyRoutine
)
2418 FIXME( "stub: %p\n", NotifyRoutine
);
2419 return STATUS_SUCCESS
;
2423 /***********************************************************************
2424 * PsTerminateSystemThread (NTOSKRNL.EXE.@)
2426 NTSTATUS WINAPI
PsTerminateSystemThread(NTSTATUS ExitStatus
)
2428 FIXME( "stub: %u\n", ExitStatus
);
2429 return STATUS_NOT_IMPLEMENTED
;
2433 /***********************************************************************
2434 * MmGetSystemRoutineAddress (NTOSKRNL.EXE.@)
2436 PVOID WINAPI
MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName
)
2439 STRING routineNameA
;
2442 static const WCHAR ntoskrnlW
[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
2443 static const WCHAR halW
[] = {'h','a','l','.','d','l','l',0};
2445 if (!SystemRoutineName
) return NULL
;
2447 if (RtlUnicodeStringToAnsiString( &routineNameA
, SystemRoutineName
, TRUE
) == STATUS_SUCCESS
)
2449 /* We only support functions exported from ntoskrnl.exe or hal.dll */
2450 hMod
= GetModuleHandleW( ntoskrnlW
);
2451 pFunc
= GetProcAddress( hMod
, routineNameA
.Buffer
);
2454 hMod
= GetModuleHandleW( halW
);
2455 if (hMod
) pFunc
= GetProcAddress( hMod
, routineNameA
.Buffer
);
2457 RtlFreeAnsiString( &routineNameA
);
2461 TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName
), pFunc
);
2463 FIXME( "%s not found\n", debugstr_us(SystemRoutineName
) );
2468 /***********************************************************************
2469 * MmQuerySystemSize (NTOSKRNL.EXE.@)
2471 MM_SYSTEMSIZE WINAPI
MmQuerySystemSize(void)
2474 return MmLargeSystem
;
2477 /***********************************************************************
2478 * KeInitializeDpc (NTOSKRNL.EXE.@)
2480 VOID WINAPI
KeInitializeDpc(PRKDPC Dpc
, PKDEFERRED_ROUTINE DeferredRoutine
, PVOID DeferredContext
)
2485 /***********************************************************************
2486 * READ_REGISTER_BUFFER_UCHAR (NTOSKRNL.EXE.@)
2488 VOID WINAPI
READ_REGISTER_BUFFER_UCHAR(PUCHAR Register
, PUCHAR Buffer
, ULONG Count
)
2493 /*****************************************************
2494 * PoSetPowerState (NTOSKRNL.EXE.@)
2496 POWER_STATE WINAPI
PoSetPowerState(PDEVICE_OBJECT DeviceObject
, POWER_STATE_TYPE Type
, POWER_STATE State
)
2498 FIXME("(%p %u %u) stub\n", DeviceObject
, Type
, State
.DeviceState
);
2502 /*****************************************************
2503 * IoWMIRegistrationControl (NTOSKRNL.EXE.@)
2505 NTSTATUS WINAPI
IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject
, ULONG Action
)
2507 FIXME("(%p %u) stub\n", DeviceObject
, Action
);
2508 return STATUS_SUCCESS
;
2511 /*****************************************************
2512 * PsSetLoadImageNotifyRoutine (NTOSKRNL.EXE.@)
2514 NTSTATUS WINAPI
PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine
)
2516 FIXME("(%p) stub\n", routine
);
2517 return STATUS_SUCCESS
;
2520 /*****************************************************
2521 * PsLookupProcessByProcessId (NTOSKRNL.EXE.@)
2523 NTSTATUS WINAPI
PsLookupProcessByProcessId(HANDLE processid
, PEPROCESS
*process
)
2526 if (!once
++) FIXME("(%p %p) stub\n", processid
, process
);
2527 return STATUS_NOT_IMPLEMENTED
;
2531 /*****************************************************
2532 * IoSetThreadHardErrorMode (NTOSKRNL.EXE.@)
2534 BOOLEAN WINAPI
IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors
)
2541 /*****************************************************
2542 * IoInitializeRemoveLockEx (NTOSKRNL.EXE.@)
2544 VOID WINAPI
IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock
, ULONG tag
,
2545 ULONG maxmin
, ULONG high
, ULONG size
)
2547 FIXME("(%p %u %u %u %u) stub\n", lock
, tag
, maxmin
, high
, size
);
2551 /*****************************************************
2552 * IoAcquireRemoveLockEx (NTOSKRNL.EXE.@)
2555 NTSTATUS WINAPI
IoAcquireRemoveLockEx(PIO_REMOVE_LOCK lock
, PVOID tag
,
2556 LPCSTR file
, ULONG line
, ULONG lock_size
)
2558 FIXME("(%p, %p, %s, %u, %u): stub\n", lock
, tag
, debugstr_a(file
), line
, lock_size
);
2560 return STATUS_NOT_IMPLEMENTED
;
2564 /*****************************************************
2567 BOOL WINAPI
DllMain( HINSTANCE inst
, DWORD reason
, LPVOID reserved
)
2569 static void *handler
;
2570 LARGE_INTEGER count
;
2574 case DLL_PROCESS_ATTACH
:
2575 DisableThreadLibraryCalls( inst
);
2576 #if defined(__i386__) || defined(__x86_64__)
2577 handler
= RtlAddVectoredExceptionHandler( TRUE
, vectored_handler
);
2579 KeQueryTickCount( &count
); /* initialize the global KeTickCount */
2581 case DLL_PROCESS_DETACH
:
2582 if (reserved
) break;
2583 RtlRemoveVectoredExceptionHandler( handler
);
2589 /*****************************************************
2590 * Ke386IoSetAccessProcess (NTOSKRNL.EXE.@)
2592 BOOLEAN WINAPI
Ke386IoSetAccessProcess(PEPROCESS
*process
, ULONG flag
)
2594 FIXME("(%p %d) stub\n", process
, flag
);
2598 /*****************************************************
2599 * Ke386SetIoAccessMap (NTOSKRNL.EXE.@)
2601 BOOLEAN WINAPI
Ke386SetIoAccessMap(ULONG flag
, PVOID buffer
)
2603 FIXME("(%d %p) stub\n", flag
, buffer
);
2607 /*****************************************************
2608 * IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
2610 PKEVENT WINAPI
IoCreateSynchronizationEvent(PUNICODE_STRING name
, PHANDLE handle
)
2612 FIXME("(%p %p) stub\n", name
, handle
);
2616 /*****************************************************
2617 * IoStartNextPacket (NTOSKRNL.EXE.@)
2619 VOID WINAPI
IoStartNextPacket(PDEVICE_OBJECT deviceobject
, BOOLEAN cancelable
)
2621 FIXME("(%p %d) stub\n", deviceobject
, cancelable
);
2624 /*****************************************************
2625 * ObQueryNameString (NTOSKRNL.EXE.@)
2627 NTSTATUS WINAPI
ObQueryNameString(PVOID object
, POBJECT_NAME_INFORMATION name
, ULONG maxlength
, PULONG returnlength
)
2629 FIXME("(%p %p %u %p) stub\n", object
, name
, maxlength
, returnlength
);
2630 return STATUS_NOT_IMPLEMENTED
;
2633 /*****************************************************
2634 * IoRegisterPlugPlayNotification (NTOSKRNL.EXE.@)
2636 NTSTATUS WINAPI
IoRegisterPlugPlayNotification(IO_NOTIFICATION_EVENT_CATEGORY category
, ULONG flags
, PVOID data
,
2637 PDRIVER_OBJECT driver
, PDRIVER_NOTIFICATION_CALLBACK_ROUTINE callback
,
2638 PVOID context
, PVOID
*notification
)
2640 FIXME("(%u %u %p %p %p %p %p) stub\n", category
, flags
, data
, driver
, callback
, context
, notification
);
2641 return STATUS_SUCCESS
;
2644 /*****************************************************
2645 * IoCsqInitialize (NTOSKRNL.EXE.@)
2647 NTSTATUS WINAPI
IoCsqInitialize(PIO_CSQ csq
, PIO_CSQ_INSERT_IRP insert_irp
, PIO_CSQ_REMOVE_IRP remove_irp
,
2648 PIO_CSQ_PEEK_NEXT_IRP peek_irp
, PIO_CSQ_ACQUIRE_LOCK acquire_lock
,
2649 PIO_CSQ_RELEASE_LOCK release_lock
, PIO_CSQ_COMPLETE_CANCELED_IRP complete_irp
)
2651 FIXME("(%p %p %p %p %p %p %p) stub\n",
2652 csq
, insert_irp
, remove_irp
, peek_irp
, acquire_lock
, release_lock
, complete_irp
);
2653 return STATUS_SUCCESS
;
2656 /***********************************************************************
2657 * ExAcquireResourceExclusiveLite (NTOSKRNL.EXE.@)
2659 BOOLEAN WINAPI
ExAcquireResourceExclusiveLite( PERESOURCE resource
, BOOLEAN wait
)
2661 FIXME( ":%p %u stub\n", resource
, wait
);
2665 /***********************************************************************
2666 * ExDeleteResourceLite (NTOSKRNL.EXE.@)
2668 NTSTATUS WINAPI
ExDeleteResourceLite(PERESOURCE resource
)
2670 FIXME("(%p): stub\n", resource
);
2671 return STATUS_NOT_IMPLEMENTED
;
2674 /*****************************************************
2675 * ExInterlockedRemoveHeadList (NTOSKRNL.EXE.@)
2677 PLIST_ENTRY WINAPI
ExInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2679 FIXME("(%p %p) stub\n", head
, lock
);
2683 /***********************************************************************
2684 * ExfInterlockedRemoveHeadList (NTOSKRNL.EXE.@)
2686 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
2687 DEFINE_FASTCALL2_ENTRYPOINT( ExfInterlockedRemoveHeadList
)
2688 PLIST_ENTRY WINAPI
__regs_ExfInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2690 PLIST_ENTRY WINAPI
ExfInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2693 FIXME("(%p %p) stub\n", head
, lock
);
2694 return ExInterlockedRemoveHeadList( head
, lock
);
2697 /***********************************************************************
2698 * ExReleaseResourceForThreadLite (NTOSKRNL.EXE.@)
2700 void WINAPI
ExReleaseResourceForThreadLite( PERESOURCE resource
, ERESOURCE_THREAD tid
)
2702 FIXME( "stub: %p %lu\n", resource
, tid
);
2705 /***********************************************************************
2706 * KeEnterCriticalRegion (NTOSKRNL.EXE.@)
2708 void WINAPI
KeEnterCriticalRegion(void)
2713 /***********************************************************************
2714 * KeLeaveCriticalRegion (NTOSKRNL.EXE.@)
2716 void WINAPI
KeLeaveCriticalRegion(void)
2721 /***********************************************************************
2722 * ProbeForRead (NTOSKRNL.EXE.@)
2724 void WINAPI
ProbeForRead(void *address
, SIZE_T length
, ULONG alignment
)
2726 FIXME("(%p %lu %u) stub\n", address
, length
, alignment
);
2729 /***********************************************************************
2730 * ProbeForWrite (NTOSKRNL.EXE.@)
2732 void WINAPI
ProbeForWrite(void *address
, SIZE_T length
, ULONG alignment
)
2734 FIXME("(%p %lu %u) stub\n", address
, length
, alignment
);
2737 /***********************************************************************
2738 * CmRegisterCallback (NTOSKRNL.EXE.@)
2740 NTSTATUS WINAPI
CmRegisterCallback(EX_CALLBACK_FUNCTION
*function
, void *context
, LARGE_INTEGER
*cookie
)
2742 FIXME("(%p %p %p): stub\n", function
, context
, cookie
);
2743 return STATUS_NOT_IMPLEMENTED
;
2746 /***********************************************************************
2747 * CmUnRegisterCallback (NTOSKRNL.EXE.@)
2749 NTSTATUS WINAPI
CmUnRegisterCallback(LARGE_INTEGER cookie
)
2751 FIXME("(%s): stub\n", wine_dbgstr_longlong(cookie
.QuadPart
));
2752 return STATUS_NOT_IMPLEMENTED
;
2755 /***********************************************************************
2756 * KeDelayExecutionThread (NTOSKRNL.EXE.@)
2758 NTSTATUS WINAPI
KeDelayExecutionThread(KPROCESSOR_MODE waitmode
, BOOLEAN alertable
, PLARGE_INTEGER interval
)
2760 FIXME("(%u, %u, %p): stub\n", waitmode
, alertable
, interval
);
2761 return STATUS_NOT_IMPLEMENTED
;
2764 /***********************************************************************
2765 * IoAttachDevice (NTOSKRNL.EXE.@)
2767 NTSTATUS WINAPI
IoAttachDevice(DEVICE_OBJECT
*source
, UNICODE_STRING
*target
, DEVICE_OBJECT
*attached
)
2769 FIXME("(%p, %s, %p): stub\n", source
, debugstr_us(target
), attached
);
2770 return STATUS_NOT_IMPLEMENTED
;
2774 static NTSTATUS
open_driver( const UNICODE_STRING
*service_name
, SC_HANDLE
*service
)
2776 QUERY_SERVICE_CONFIGW
*service_config
= NULL
;
2777 SC_HANDLE manager_handle
;
2778 DWORD config_size
= 0;
2781 if (!(name
= RtlAllocateHeap( GetProcessHeap(), 0, service_name
->Length
+ sizeof(WCHAR
) )))
2782 return STATUS_NO_MEMORY
;
2784 memcpy( name
, service_name
->Buffer
, service_name
->Length
);
2785 name
[ service_name
->Length
/ sizeof(WCHAR
) ] = 0;
2787 if (strncmpW( name
, servicesW
, strlenW(servicesW
) ))
2789 FIXME( "service name %s is not a keypath\n", debugstr_us(service_name
) );
2790 RtlFreeHeap( GetProcessHeap(), 0, name
);
2791 return STATUS_NOT_IMPLEMENTED
;
2794 if (!(manager_handle
= OpenSCManagerW( NULL
, NULL
, SC_MANAGER_CONNECT
)))
2796 WARN( "failed to connect to service manager\n" );
2797 RtlFreeHeap( GetProcessHeap(), 0, name
);
2798 return STATUS_NOT_SUPPORTED
;
2801 *service
= OpenServiceW( manager_handle
, name
+ strlenW(servicesW
), SERVICE_ALL_ACCESS
);
2802 RtlFreeHeap( GetProcessHeap(), 0, name
);
2803 CloseServiceHandle( manager_handle
);
2807 WARN( "failed to open service %s\n", debugstr_us(service_name
) );
2808 return STATUS_UNSUCCESSFUL
;
2811 QueryServiceConfigW( *service
, NULL
, 0, &config_size
);
2812 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER
)
2814 WARN( "failed to query service config\n" );
2818 if (!(service_config
= RtlAllocateHeap( GetProcessHeap(), 0, config_size
)))
2821 if (!QueryServiceConfigW( *service
, service_config
, config_size
, &config_size
))
2823 WARN( "failed to query service config\n" );
2827 if (service_config
->dwServiceType
!= SERVICE_KERNEL_DRIVER
&&
2828 service_config
->dwServiceType
!= SERVICE_FILE_SYSTEM_DRIVER
)
2830 WARN( "service %s is not a kernel driver\n", debugstr_us(service_name
) );
2834 TRACE( "opened service for driver %s\n", debugstr_us(service_name
) );
2835 RtlFreeHeap( GetProcessHeap(), 0, service_config
);
2836 return STATUS_SUCCESS
;
2839 CloseServiceHandle( *service
);
2840 RtlFreeHeap( GetProcessHeap(), 0, service_config
);
2841 return STATUS_UNSUCCESSFUL
;
2845 /***********************************************************************
2846 * ZwLoadDriver (NTOSKRNL.EXE.@)
2848 NTSTATUS WINAPI
ZwLoadDriver( const UNICODE_STRING
*service_name
)
2850 SERVICE_STATUS_PROCESS service_status
;
2851 SC_HANDLE service_handle
;
2852 ULONGLONG start_time
;
2856 TRACE( "(%s)\n", debugstr_us(service_name
) );
2858 if ((status
= open_driver( service_name
, &service_handle
)) != STATUS_SUCCESS
)
2861 TRACE( "trying to start %s\n", debugstr_us(service_name
) );
2863 start_time
= GetTickCount64();
2866 if (StartServiceW( service_handle
, 0, NULL
)) break;
2867 if (GetLastError() == ERROR_SERVICE_ALREADY_RUNNING
) break;
2868 if (GetLastError() != ERROR_SERVICE_DATABASE_LOCKED
) goto error
;
2869 if (GetTickCount64() - start_time
> 30000) goto error
;
2873 start_time
= GetTickCount64();
2876 if (!QueryServiceStatusEx( service_handle
, SC_STATUS_PROCESS_INFO
,
2877 (BYTE
*)&service_status
, sizeof(service_status
), &bytes
)) goto error
;
2878 if (service_status
.dwCurrentState
!= SERVICE_START_PENDING
) break;
2879 if (GetTickCount64() - start_time
> 30000) goto error
;
2883 if (service_status
.dwCurrentState
== SERVICE_RUNNING
)
2885 if (service_status
.dwProcessId
!= GetCurrentProcessId())
2886 FIXME( "driver %s was loaded into a different process\n", debugstr_us(service_name
) );
2888 status
= STATUS_SUCCESS
;
2893 WARN( "failed to start service %s\n", debugstr_us(service_name
) );
2894 status
= STATUS_UNSUCCESSFUL
;
2897 TRACE( "returning status %08x\n", status
);
2898 CloseServiceHandle( service_handle
);
2903 /***********************************************************************
2904 * ZwUnloadDriver (NTOSKRNL.EXE.@)
2906 NTSTATUS WINAPI
ZwUnloadDriver( const UNICODE_STRING
*service_name
)
2908 SERVICE_STATUS service_status
;
2909 SC_HANDLE service_handle
;
2910 ULONGLONG start_time
;
2913 TRACE( "(%s)\n", debugstr_us(service_name
) );
2915 if ((status
= open_driver( service_name
, &service_handle
)) != STATUS_SUCCESS
)
2918 if (!ControlService( service_handle
, SERVICE_CONTROL_STOP
, &service_status
))
2921 start_time
= GetTickCount64();
2924 if (!QueryServiceStatus( service_handle
, &service_status
)) goto error
;
2925 if (service_status
.dwCurrentState
!= SERVICE_STOP_PENDING
) break;
2926 if (GetTickCount64() - start_time
> 30000) goto error
;
2930 if (service_status
.dwCurrentState
== SERVICE_STOPPED
)
2932 status
= STATUS_SUCCESS
;
2937 WARN( "failed to stop service %s\n", debugstr_us(service_name
) );
2938 status
= STATUS_UNSUCCESSFUL
;
2941 TRACE( "returning status %08x\n", status
);
2942 CloseServiceHandle( service_handle
);
2947 static NTSTATUS WINAPI
internal_complete( DEVICE_OBJECT
*device
, IRP
*irp
, void *context
)
2949 HANDLE event
= context
;
2951 return STATUS_MORE_PROCESSING_REQUIRED
;
2955 static NTSTATUS
send_device_irp( DEVICE_OBJECT
*device
, IRP
*irp
, ULONG_PTR
*info
)
2958 HANDLE event
= CreateEventA( NULL
, FALSE
, FALSE
, NULL
);
2959 DEVICE_OBJECT
*toplevel_device
;
2961 irp
->IoStatus
.u
.Status
= STATUS_NOT_SUPPORTED
;
2962 IoSetCompletionRoutine( irp
, internal_complete
, event
, TRUE
, TRUE
, TRUE
);
2964 toplevel_device
= IoGetAttachedDeviceReference( device
);
2965 status
= IoCallDriver( toplevel_device
, irp
);
2967 if (status
== STATUS_PENDING
)
2968 WaitForSingleObject( event
, INFINITE
);
2970 status
= irp
->IoStatus
.u
.Status
;
2972 *info
= irp
->IoStatus
.Information
;
2973 IoCompleteRequest( irp
, IO_NO_INCREMENT
);
2974 ObDereferenceObject( toplevel_device
);
2975 CloseHandle( event
);
2980 static NTSTATUS
get_device_id( DEVICE_OBJECT
*device
, BUS_QUERY_ID_TYPE type
, WCHAR
**id
)
2982 IO_STACK_LOCATION
*irpsp
;
2983 IO_STATUS_BLOCK irp_status
;
2986 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_PNP
, device
, NULL
, 0, NULL
, NULL
, &irp_status
)))
2987 return STATUS_NO_MEMORY
;
2989 irpsp
= IoGetNextIrpStackLocation( irp
);
2990 irpsp
->MinorFunction
= IRP_MN_QUERY_ID
;
2991 irpsp
->Parameters
.QueryId
.IdType
= type
;
2993 return send_device_irp( device
, irp
, (ULONG_PTR
*)id
);
2997 static BOOL
get_driver_for_id( const WCHAR
*id
, WCHAR
*driver
)
2999 static const WCHAR serviceW
[] = {'S','e','r','v','i','c','e',0};
3000 static const UNICODE_STRING service_str
= { sizeof(serviceW
) - sizeof(WCHAR
), sizeof(serviceW
), (WCHAR
*)serviceW
};
3001 static const WCHAR critical_fmtW
[] =
3002 {'\\','R','e','g','i','s','t','r','y',
3003 '\\','M','a','c','h','i','n','e',
3004 '\\','S','y','s','t','e','m',
3005 '\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
3006 '\\','C','o','n','t','r','o','l',
3007 '\\','C','r','i','t','i','c','a','l','D','e','v','i','c','e','D','a','t','a','b','a','s','e',
3009 WCHAR buffer
[FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION
, Data
[MAX_SERVICE_NAME
* sizeof(WCHAR
)] )];
3010 KEY_VALUE_PARTIAL_INFORMATION
*info
= (KEY_VALUE_PARTIAL_INFORMATION
*)buffer
;
3011 OBJECT_ATTRIBUTES attr
;
3018 if (!(keyW
= RtlAllocateHeap( GetProcessHeap(), 0, sizeof(critical_fmtW
) + strlenW(id
) * sizeof(WCHAR
) )))
3019 return STATUS_NO_MEMORY
;
3021 sprintfW( keyW
, critical_fmtW
, id
);
3022 RtlInitUnicodeString( &key
, keyW
);
3023 InitializeObjectAttributes( &attr
, &key
, OBJ_CASE_INSENSITIVE
| OBJ_KERNEL_HANDLE
, NULL
, NULL
);
3025 status
= NtOpenKey( &hkey
, KEY_ALL_ACCESS
, &attr
);
3026 RtlFreeUnicodeString( &key
);
3027 if (status
!= STATUS_SUCCESS
)
3029 TRACE_(plugplay
)( "no driver found for %s\n", debugstr_w(id
) );
3033 status
= NtQueryValueKey( hkey
, &service_str
, KeyValuePartialInformation
,
3034 info
, sizeof(buffer
) - sizeof(WCHAR
), &len
);
3036 if (status
!= STATUS_SUCCESS
|| info
->Type
!= REG_SZ
)
3038 TRACE_(plugplay
)( "no driver found for %s\n", debugstr_w(id
) );
3042 memcpy( driver
, info
->Data
, info
->DataLength
);
3043 driver
[ info
->DataLength
/ sizeof(WCHAR
) ] = 0;
3044 TRACE_(plugplay
)( "found driver %s for %s\n", debugstr_w(driver
), debugstr_w(id
) );
3049 static NTSTATUS
send_pnp_irp( DEVICE_OBJECT
*device
, UCHAR minor
)
3051 IO_STACK_LOCATION
*irpsp
;
3052 IO_STATUS_BLOCK irp_status
;
3055 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_PNP
, device
, NULL
, 0, NULL
, NULL
, &irp_status
)))
3056 return STATUS_NO_MEMORY
;
3058 irpsp
= IoGetNextIrpStackLocation( irp
);
3059 irpsp
->MinorFunction
= minor
;
3061 irpsp
->Parameters
.StartDevice
.AllocatedResources
= NULL
;
3062 irpsp
->Parameters
.StartDevice
.AllocatedResourcesTranslated
= NULL
;
3064 return send_device_irp( device
, irp
, NULL
);
3068 static NTSTATUS
send_power_irp( DEVICE_OBJECT
*device
, DEVICE_POWER_STATE power
)
3070 IO_STATUS_BLOCK irp_status
;
3071 IO_STACK_LOCATION
*irpsp
;
3074 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_POWER
, device
, NULL
, 0, NULL
, NULL
, &irp_status
)))
3075 return STATUS_NO_MEMORY
;
3077 irpsp
= IoGetNextIrpStackLocation( irp
);
3078 irpsp
->MinorFunction
= IRP_MN_SET_POWER
;
3080 irpsp
->Parameters
.Power
.Type
= DevicePowerState
;
3081 irpsp
->Parameters
.Power
.State
.DeviceState
= power
;
3083 return send_device_irp( device
, irp
, NULL
);
3087 static void handle_bus_relations( DEVICE_OBJECT
*device
)
3089 static const WCHAR driverW
[] = {'\\','D','r','i','v','e','r','\\',0};
3090 WCHAR buffer
[MAX_SERVICE_NAME
+ sizeof(servicesW
)/sizeof(WCHAR
)];
3091 WCHAR driver
[MAX_SERVICE_NAME
] = {0};
3092 DRIVER_OBJECT
*driver_obj
;
3093 UNICODE_STRING string
;
3097 TRACE_(plugplay
)( "(%p)\n", device
);
3099 /* We could (should?) do a full IRP_MN_QUERY_DEVICE_RELATIONS query,
3100 * but we don't have to, we have the DEVICE_OBJECT of the new device
3101 * so we can simply handle the process here */
3103 status
= get_device_id( device
, BusQueryCompatibleIDs
, &ids
);
3104 if (status
!= STATUS_SUCCESS
|| !ids
)
3106 ERR_(plugplay
)( "Failed to get device IDs\n" );
3110 for (ptr
= ids
; *ptr
; ptr
+= strlenW(ptr
) + 1)
3112 if (get_driver_for_id( ptr
, driver
))
3115 RtlFreeHeap( GetProcessHeap(), 0, ids
);
3119 ERR_(plugplay
)( "No matching driver found for device\n" );
3123 strcpyW( buffer
, servicesW
);
3124 strcatW( buffer
, driver
);
3125 RtlInitUnicodeString( &string
, buffer
);
3126 if (ZwLoadDriver( &string
) != STATUS_SUCCESS
)
3128 ERR_(plugplay
)( "Failed to load driver %s\n", debugstr_w(driver
) );
3132 strcpyW( buffer
, driverW
);
3133 strcatW( buffer
, driver
);
3134 RtlInitUnicodeString( &string
, buffer
);
3135 if (ObReferenceObjectByName( &string
, OBJ_CASE_INSENSITIVE
, NULL
,
3136 0, NULL
, KernelMode
, NULL
, (void **)&driver_obj
) != STATUS_SUCCESS
)
3138 ERR_(plugplay
)( "Failed to locate loaded driver %s\n", debugstr_w(driver
) );
3142 if (driver_obj
->DriverExtension
->AddDevice
)
3143 status
= driver_obj
->DriverExtension
->AddDevice( driver_obj
, device
);
3145 status
= STATUS_NOT_IMPLEMENTED
;
3147 ObDereferenceObject( driver_obj
);
3149 if (status
!= STATUS_SUCCESS
)
3151 ERR_(plugplay
)( "AddDevice failed for driver %s\n", debugstr_w(driver
) );
3155 send_pnp_irp( device
, IRP_MN_START_DEVICE
);
3156 send_power_irp( device
, PowerDeviceD0
);
3160 static void handle_removal_relations( DEVICE_OBJECT
*device
)
3162 TRACE_(plugplay
)( "(%p)\n", device
);
3164 send_power_irp( device
, PowerDeviceD3
);
3165 send_pnp_irp( device
, IRP_MN_SURPRISE_REMOVAL
);
3166 send_pnp_irp( device
, IRP_MN_REMOVE_DEVICE
);
3170 /***********************************************************************
3171 * IoInvalidateDeviceRelations (NTOSKRNL.EXE.@)
3173 void WINAPI
IoInvalidateDeviceRelations( DEVICE_OBJECT
*device_object
, DEVICE_RELATION_TYPE type
)
3175 TRACE( "(%p, %i)\n", device_object
, type
);
3180 handle_bus_relations( device_object
);
3182 case RemovalRelations
:
3183 handle_removal_relations( device_object
);
3186 FIXME( "unhandled relation %i\n", type
);
3191 /***********************************************************************
3192 * KeSetTimerEx (NTOSKRNL.EXE.@)
3194 BOOL WINAPI
KeSetTimerEx( KTIMER
*timer
, LARGE_INTEGER duetime
, LONG period
, KDPC
*dpc
)
3196 FIXME("stub: %p %s %u %p\n", timer
, wine_dbgstr_longlong(duetime
.QuadPart
), period
, dpc
);
3200 /***********************************************************************
3201 * IoCreateFile (NTOSKRNL.EXE.@)
3203 NTSTATUS WINAPI
IoCreateFile(HANDLE
*handle
, ACCESS_MASK access
, OBJECT_ATTRIBUTES
*attr
,
3204 IO_STATUS_BLOCK
*io
, LARGE_INTEGER
*alloc_size
, ULONG attributes
, ULONG sharing
,
3205 ULONG disposition
, ULONG create_options
, VOID
*ea_buffer
, ULONG ea_length
,
3206 CREATE_FILE_TYPE file_type
, VOID
*parameters
, ULONG options
)
3209 return STATUS_NOT_IMPLEMENTED
;
3212 /***********************************************************************
3213 * KeClearEvent (NTOSKRNL.EXE.@)
3215 VOID WINAPI
KeClearEvent(PRKEVENT event
)
3217 FIXME("stub: %p\n", event
);
3220 /***********************************************************************
3221 * KeAcquireInStackQueuedSpinLock (NTOSKRNL.EXE.@)
3223 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
3224 DEFINE_FASTCALL2_ENTRYPOINT( KeAcquireInStackQueuedSpinLock
)
3225 void WINAPI
__regs_KeAcquireInStackQueuedSpinLock( KSPIN_LOCK
*spinlock
, KLOCK_QUEUE_HANDLE
*handle
)
3227 void WINAPI
KeAcquireInStackQueuedSpinLock( KSPIN_LOCK
*spinlock
, KLOCK_QUEUE_HANDLE
*handle
)
3230 FIXME( "stub: %p %p\n", spinlock
, handle
);
3233 /***********************************************************************
3234 * KeReleaseInStackQueuedSpinLock (NTOSKRNL.EXE.@)
3236 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
3237 DEFINE_FASTCALL1_ENTRYPOINT( KeReleaseInStackQueuedSpinLock
)
3238 void WINAPI
__regs_KeReleaseInStackQueuedSpinLock( KLOCK_QUEUE_HANDLE
*handle
)
3240 void WINAPI
KeReleaseInStackQueuedSpinLock( KLOCK_QUEUE_HANDLE
*handle
)
3243 FIXME( "stub: %p\n", handle
);