2 * ntoskrnl.exe implementation
4 * Copyright (C) 2007 Alexandre Julliard
5 * Copyright (C) 2010 Damjan Jovanovic
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 #include "wine/port.h"
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
31 #define WIN32_NO_STATUS
37 #include "ddk/ntddk.h"
38 #include "ddk/ntifs.h"
40 #include "wine/unicode.h"
41 #include "wine/server.h"
42 #include "wine/list.h"
43 #include "wine/debug.h"
45 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl
);
46 WINE_DECLARE_DEBUG_CHANNEL(relay
);
48 BOOLEAN KdDebuggerEnabled
= FALSE
;
49 ULONG InitSafeBootMode
= 0;
51 extern LONG CALLBACK
vectored_handler( EXCEPTION_POINTERS
*ptrs
);
53 KSYSTEM_TIME KeTickCount
= { 0, 0, 0 };
55 typedef struct _KSERVICE_TABLE_DESCRIPTOR
61 } KSERVICE_TABLE_DESCRIPTOR
, *PKSERVICE_TABLE_DESCRIPTOR
;
63 KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable
[4] = { { 0 } };
65 typedef void (WINAPI
*PCREATE_PROCESS_NOTIFY_ROUTINE
)(HANDLE
,HANDLE
,BOOLEAN
);
66 typedef void (WINAPI
*PCREATE_THREAD_NOTIFY_ROUTINE
)(HANDLE
,HANDLE
,BOOLEAN
);
68 /* tid of the thread running client request */
69 static DWORD request_thread
;
71 /* pid/tid of the client thread */
72 static DWORD client_tid
;
73 static DWORD client_pid
;
76 #define DEFINE_FASTCALL1_ENTRYPOINT( name ) \
77 __ASM_STDCALL_FUNC( name, 4, \
81 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(4))
82 #define DEFINE_FASTCALL2_ENTRYPOINT( name ) \
83 __ASM_STDCALL_FUNC( name, 8, \
88 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(8))
89 #define DEFINE_FASTCALL3_ENTRYPOINT( name ) \
90 __ASM_STDCALL_FUNC( name, 12, \
95 "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(12))
98 static inline LPCSTR
debugstr_us( const UNICODE_STRING
*us
)
100 if (!us
) return "<null>";
101 return debugstr_wn( us
->Buffer
, us
->Length
/ sizeof(WCHAR
) );
104 static HANDLE
get_device_manager(void)
106 static HANDLE device_manager
;
107 HANDLE handle
= 0, ret
= device_manager
;
111 SERVER_START_REQ( create_device_manager
)
113 req
->access
= SYNCHRONIZE
;
115 if (!wine_server_call( req
)) handle
= wine_server_ptr_handle( reply
->handle
);
121 ERR( "failed to create the device manager\n" );
124 if (!(ret
= InterlockedCompareExchangePointer( &device_manager
, handle
, 0 )))
127 NtClose( handle
); /* somebody beat us to it */
132 static NTSTATUS
dispatch_irp( DEVICE_OBJECT
*device
, IRP
*irp
)
136 KeQueryTickCount( &count
); /* update the global KeTickCount */
138 device
->CurrentIrp
= irp
;
140 IoCallDriver( device
, irp
);
142 device
->CurrentIrp
= NULL
;
144 return STATUS_SUCCESS
;
147 /* process a create request for a given file */
148 static NTSTATUS
dispatch_create( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
149 ULONG out_size
, HANDLE irp_handle
)
152 IO_STACK_LOCATION
*irpsp
;
154 DEVICE_OBJECT
*device
= wine_server_get_ptr( params
->create
.device
);
156 if (!(file
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*file
) ))) return STATUS_NO_MEMORY
;
158 TRACE( "device %p -> file %p\n", device
, file
);
160 file
->Type
= 5; /* MSDN */
161 file
->Size
= sizeof(*file
);
162 file
->DeviceObject
= device
;
164 if (!(irp
= IoAllocateIrp( device
->StackSize
, FALSE
)))
166 HeapFree( GetProcessHeap(), 0, file
);
167 return STATUS_NO_MEMORY
;
170 irpsp
= IoGetNextIrpStackLocation( irp
);
171 irpsp
->MajorFunction
= IRP_MJ_CREATE
;
172 irpsp
->DeviceObject
= device
;
173 irpsp
->CompletionRoutine
= NULL
;
174 irpsp
->Parameters
.Create
.SecurityContext
= NULL
; /* FIXME */
175 irpsp
->Parameters
.Create
.Options
= params
->create
.options
;
176 irpsp
->Parameters
.Create
.ShareAccess
= params
->create
.sharing
;
177 irpsp
->Parameters
.Create
.FileAttributes
= 0;
178 irpsp
->Parameters
.Create
.EaLength
= 0;
180 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
181 irp
->RequestorMode
= UserMode
;
182 irp
->AssociatedIrp
.SystemBuffer
= NULL
;
183 irp
->UserBuffer
= NULL
;
184 irp
->UserIosb
= irp_handle
; /* note: we abuse UserIosb to store the server irp handle */
185 irp
->UserEvent
= NULL
;
187 if (device
->DriverObject
->MajorFunction
[IRP_MJ_CREATE
]) return dispatch_irp( device
, irp
);
189 irp
->IoStatus
.u
.Status
= STATUS_SUCCESS
;
190 IoCompleteRequest( irp
, IO_NO_INCREMENT
);
191 return STATUS_SUCCESS
;
194 /* process a close request for a given file */
195 static NTSTATUS
dispatch_close( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
196 ULONG out_size
, HANDLE irp_handle
)
199 IO_STACK_LOCATION
*irpsp
;
200 DEVICE_OBJECT
*device
;
201 FILE_OBJECT
*file
= wine_server_get_ptr( params
->close
.file
);
203 if (!file
) return STATUS_INVALID_HANDLE
;
205 device
= file
->DeviceObject
;
207 TRACE( "device %p file %p\n", device
, file
);
209 if (!(irp
= IoAllocateIrp( device
->StackSize
, FALSE
)))
211 HeapFree( GetProcessHeap(), 0, file
);
212 return STATUS_NO_MEMORY
;
215 irpsp
= IoGetNextIrpStackLocation( irp
);
216 irpsp
->MajorFunction
= IRP_MJ_CLOSE
;
217 irpsp
->DeviceObject
= device
;
218 irpsp
->CompletionRoutine
= NULL
;
219 irpsp
->Parameters
.Create
.SecurityContext
= NULL
; /* FIXME */
220 irpsp
->Parameters
.Create
.Options
= params
->create
.options
;
221 irpsp
->Parameters
.Create
.ShareAccess
= params
->create
.sharing
;
222 irpsp
->Parameters
.Create
.FileAttributes
= 0;
223 irpsp
->Parameters
.Create
.EaLength
= 0;
225 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
226 irp
->RequestorMode
= UserMode
;
227 irp
->AssociatedIrp
.SystemBuffer
= NULL
;
228 irp
->UserBuffer
= NULL
;
229 irp
->UserIosb
= irp_handle
; /* note: we abuse UserIosb to store the server irp handle */
230 irp
->UserEvent
= NULL
;
232 if (!device
->DriverObject
->MajorFunction
[IRP_MJ_CLOSE
])
234 irp
->IoStatus
.u
.Status
= STATUS_SUCCESS
;
235 IoCompleteRequest( irp
, IO_NO_INCREMENT
);
237 else dispatch_irp( device
, irp
);
239 HeapFree( GetProcessHeap(), 0, file
); /* FIXME: async close processing not supported */
240 return STATUS_SUCCESS
;
243 /* process a read request for a given device */
244 static NTSTATUS
dispatch_read( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
245 ULONG out_size
, HANDLE irp_handle
)
249 LARGE_INTEGER offset
;
250 IO_STACK_LOCATION
*irpsp
;
251 DEVICE_OBJECT
*device
;
252 FILE_OBJECT
*file
= wine_server_get_ptr( params
->read
.file
);
254 if (!file
) return STATUS_INVALID_HANDLE
;
256 device
= file
->DeviceObject
;
257 if (!device
->DriverObject
->MajorFunction
[IRP_MJ_READ
]) return STATUS_NOT_SUPPORTED
;
259 TRACE( "device %p file %p size %u\n", device
, file
, out_size
);
261 if (!(out_buff
= HeapAlloc( GetProcessHeap(), 0, out_size
))) return STATUS_NO_MEMORY
;
263 offset
.QuadPart
= params
->read
.pos
;
265 /* note: we abuse UserIosb to store the server irp handle */
266 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_READ
, device
, out_buff
, out_size
,
267 &offset
, NULL
, irp_handle
)))
269 HeapFree( GetProcessHeap(), 0, out_buff
);
270 return STATUS_NO_MEMORY
;
273 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
274 irp
->RequestorMode
= UserMode
;
276 irpsp
= IoGetNextIrpStackLocation( irp
);
277 irpsp
->Parameters
.Read
.Key
= params
->read
.key
;
279 return dispatch_irp( device
, irp
);
282 /* process a write request for a given device */
283 static NTSTATUS
dispatch_write( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
284 ULONG out_size
, HANDLE irp_handle
)
287 LARGE_INTEGER offset
;
288 IO_STACK_LOCATION
*irpsp
;
289 DEVICE_OBJECT
*device
;
290 FILE_OBJECT
*file
= wine_server_get_ptr( params
->write
.file
);
292 if (!file
) return STATUS_INVALID_HANDLE
;
294 device
= file
->DeviceObject
;
295 if (!device
->DriverObject
->MajorFunction
[IRP_MJ_WRITE
]) return STATUS_NOT_SUPPORTED
;
297 TRACE( "device %p file %p size %u\n", device
, file
, in_size
);
299 offset
.QuadPart
= params
->write
.pos
;
301 /* note: we abuse UserIosb to store the server irp handle */
302 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_WRITE
, device
, in_buff
, in_size
,
303 &offset
, NULL
, irp_handle
)))
304 return STATUS_NO_MEMORY
;
306 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
307 irp
->RequestorMode
= UserMode
;
309 irpsp
= IoGetNextIrpStackLocation( irp
);
310 irpsp
->Parameters
.Write
.Key
= params
->write
.key
;
312 return dispatch_irp( device
, irp
);
315 /* process a flush request for a given device */
316 static NTSTATUS
dispatch_flush( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
317 ULONG out_size
, HANDLE irp_handle
)
320 DEVICE_OBJECT
*device
;
321 FILE_OBJECT
*file
= wine_server_get_ptr( params
->flush
.file
);
323 if (!file
) return STATUS_INVALID_HANDLE
;
325 device
= file
->DeviceObject
;
326 if (!device
->DriverObject
->MajorFunction
[IRP_MJ_FLUSH_BUFFERS
]) return STATUS_NOT_SUPPORTED
;
328 TRACE( "device %p file %p\n", device
, file
);
330 /* note: we abuse UserIosb to store the server irp handle */
331 if (!(irp
= IoBuildSynchronousFsdRequest( IRP_MJ_FLUSH_BUFFERS
, device
, in_buff
, in_size
,
332 NULL
, NULL
, irp_handle
)))
333 return STATUS_NO_MEMORY
;
335 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
336 irp
->RequestorMode
= UserMode
;
338 return dispatch_irp( device
, irp
);
341 /* process an ioctl request for a given device */
342 static NTSTATUS
dispatch_ioctl( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
343 ULONG out_size
, HANDLE irp_handle
)
346 void *out_buff
= NULL
;
347 DEVICE_OBJECT
*device
;
348 FILE_OBJECT
*file
= wine_server_get_ptr( params
->ioctl
.file
);
350 if (!file
) return STATUS_INVALID_HANDLE
;
352 device
= file
->DeviceObject
;
353 if (!device
->DriverObject
->MajorFunction
[IRP_MJ_DEVICE_CONTROL
]) return STATUS_NOT_SUPPORTED
;
355 TRACE( "ioctl %x device %p file %p in_size %u out_size %u\n",
356 params
->ioctl
.code
, device
, file
, in_size
, out_size
);
358 if ((params
->ioctl
.code
& 3) == METHOD_BUFFERED
) out_size
= max( in_size
, out_size
);
362 if (!(out_buff
= HeapAlloc( GetProcessHeap(), 0, out_size
))) return STATUS_NO_MEMORY
;
363 if ((params
->ioctl
.code
& 3) == METHOD_BUFFERED
)
365 memcpy( out_buff
, in_buff
, in_size
);
370 /* note: we abuse UserIosb to store the server handle to the ioctl */
371 irp
= IoBuildDeviceIoControlRequest( params
->ioctl
.code
, device
, in_buff
, in_size
, out_buff
, out_size
,
372 FALSE
, NULL
, irp_handle
);
375 HeapFree( GetProcessHeap(), 0, out_buff
);
376 return STATUS_NO_MEMORY
;
379 irp
->Tail
.Overlay
.OriginalFileObject
= file
;
380 irp
->RequestorMode
= UserMode
;
382 return dispatch_irp( device
, irp
);
385 typedef NTSTATUS (*dispatch_func
)( const irp_params_t
*params
, void *in_buff
, ULONG in_size
,
386 ULONG out_size
, HANDLE irp_handle
);
388 static const dispatch_func dispatch_funcs
[IRP_MJ_MAXIMUM_FUNCTION
+ 1] =
390 dispatch_create
, /* IRP_MJ_CREATE */
391 NULL
, /* IRP_MJ_CREATE_NAMED_PIPE */
392 dispatch_close
, /* IRP_MJ_CLOSE */
393 dispatch_read
, /* IRP_MJ_READ */
394 dispatch_write
, /* IRP_MJ_WRITE */
395 NULL
, /* IRP_MJ_QUERY_INFORMATION */
396 NULL
, /* IRP_MJ_SET_INFORMATION */
397 NULL
, /* IRP_MJ_QUERY_EA */
398 NULL
, /* IRP_MJ_SET_EA */
399 dispatch_flush
, /* IRP_MJ_FLUSH_BUFFERS */
400 NULL
, /* IRP_MJ_QUERY_VOLUME_INFORMATION */
401 NULL
, /* IRP_MJ_SET_VOLUME_INFORMATION */
402 NULL
, /* IRP_MJ_DIRECTORY_CONTROL */
403 NULL
, /* IRP_MJ_FILE_SYSTEM_CONTROL */
404 dispatch_ioctl
, /* IRP_MJ_DEVICE_CONTROL */
405 NULL
, /* IRP_MJ_INTERNAL_DEVICE_CONTROL */
406 NULL
, /* IRP_MJ_SHUTDOWN */
407 NULL
, /* IRP_MJ_LOCK_CONTROL */
408 NULL
, /* IRP_MJ_CLEANUP */
409 NULL
, /* IRP_MJ_CREATE_MAILSLOT */
410 NULL
, /* IRP_MJ_QUERY_SECURITY */
411 NULL
, /* IRP_MJ_SET_SECURITY */
412 NULL
, /* IRP_MJ_POWER */
413 NULL
, /* IRP_MJ_SYSTEM_CONTROL */
414 NULL
, /* IRP_MJ_DEVICE_CHANGE */
415 NULL
, /* IRP_MJ_QUERY_QUOTA */
416 NULL
, /* IRP_MJ_SET_QUOTA */
417 NULL
, /* IRP_MJ_PNP */
421 /***********************************************************************
422 * wine_ntoskrnl_main_loop (Not a Windows API)
424 NTSTATUS CDECL
wine_ntoskrnl_main_loop( HANDLE stop_event
)
426 HANDLE manager
= get_device_manager();
428 NTSTATUS status
= STATUS_SUCCESS
;
429 irp_params_t irp_params
;
431 ULONG in_size
= 4096, out_size
= 0;
434 request_thread
= GetCurrentThreadId();
436 if (!(in_buff
= HeapAlloc( GetProcessHeap(), 0, in_size
)))
438 ERR( "failed to allocate buffer\n" );
439 return STATUS_NO_MEMORY
;
442 handles
[0] = stop_event
;
443 handles
[1] = manager
;
447 SERVER_START_REQ( get_next_device_request
)
449 req
->manager
= wine_server_obj_handle( manager
);
450 req
->prev
= wine_server_obj_handle( irp
);
451 req
->status
= status
;
452 wine_server_set_reply( req
, in_buff
, in_size
);
453 if (!(status
= wine_server_call( req
)))
455 irp
= wine_server_ptr_handle( reply
->next
);
456 irp_params
= reply
->params
;
457 client_tid
= reply
->client_tid
;
458 client_pid
= reply
->client_pid
;
459 in_size
= reply
->in_size
;
460 out_size
= reply
->out_size
;
464 irp
= 0; /* no previous irp */
466 in_size
= reply
->in_size
;
474 if (irp_params
.major
> IRP_MJ_MAXIMUM_FUNCTION
|| !dispatch_funcs
[irp_params
.major
])
476 WARN( "unsupported request %u\n", irp_params
.major
);
477 status
= STATUS_NOT_SUPPORTED
;
480 status
= dispatch_funcs
[irp_params
.major
]( &irp_params
, in_buff
, in_size
, out_size
, irp
);
481 if (status
== STATUS_SUCCESS
) irp
= 0; /* status reported by IoCompleteRequest */
483 case STATUS_BUFFER_OVERFLOW
:
484 HeapFree( GetProcessHeap(), 0, in_buff
);
485 in_buff
= HeapAlloc( GetProcessHeap(), 0, in_size
);
486 /* restart with larger buffer */
491 DWORD ret
= WaitForMultipleObjectsEx( 2, handles
, FALSE
, INFINITE
, TRUE
);
492 if (ret
== WAIT_OBJECT_0
)
494 HeapFree( GetProcessHeap(), 0, in_buff
);
495 return STATUS_SUCCESS
;
497 if (ret
!= WAIT_IO_COMPLETION
) break;
505 /***********************************************************************
506 * IoAcquireCancelSpinLock (NTOSKRNL.EXE.@)
508 void WINAPI
IoAcquireCancelSpinLock(PKIRQL irql
)
510 FIXME("(%p): stub\n", irql
);
514 /***********************************************************************
515 * IoReleaseCancelSpinLock (NTOSKRNL.EXE.@)
517 void WINAPI
IoReleaseCancelSpinLock(PKIRQL irql
)
519 FIXME("(%p): stub\n", irql
);
523 /***********************************************************************
524 * IoAllocateDriverObjectExtension (NTOSKRNL.EXE.@)
526 NTSTATUS WINAPI
IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject
,
527 PVOID ClientIdentificationAddress
,
528 ULONG DriverObjectExtensionSize
,
529 PVOID
*DriverObjectExtension
)
531 FIXME( "stub: %p, %p, %u, %p\n", DriverObject
, ClientIdentificationAddress
,
532 DriverObjectExtensionSize
, DriverObjectExtension
);
533 return STATUS_NOT_IMPLEMENTED
;
537 /***********************************************************************
538 * IoGetDriverObjectExtension (NTOSKRNL.EXE.@)
540 PVOID WINAPI
IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject
,
541 PVOID ClientIdentificationAddress
)
543 FIXME( "stub: %p, %p\n", DriverObject
, ClientIdentificationAddress
);
548 /***********************************************************************
549 * IoInitializeIrp (NTOSKRNL.EXE.@)
551 void WINAPI
IoInitializeIrp( IRP
*irp
, USHORT size
, CCHAR stack_size
)
553 TRACE( "%p, %u, %d\n", irp
, size
, stack_size
);
555 RtlZeroMemory( irp
, size
);
557 irp
->Type
= IO_TYPE_IRP
;
559 InitializeListHead( &irp
->ThreadListEntry
);
560 irp
->StackCount
= stack_size
;
561 irp
->CurrentLocation
= stack_size
+ 1;
562 irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
=
563 (PIO_STACK_LOCATION
)(irp
+ 1) + stack_size
;
567 /***********************************************************************
568 * IoInitializeTimer (NTOSKRNL.EXE.@)
570 NTSTATUS WINAPI
IoInitializeTimer(PDEVICE_OBJECT DeviceObject
,
571 PIO_TIMER_ROUTINE TimerRoutine
,
574 FIXME( "stub: %p, %p, %p\n", DeviceObject
, TimerRoutine
, Context
);
575 return STATUS_NOT_IMPLEMENTED
;
579 /***********************************************************************
580 * IoStartTimer (NTOSKRNL.EXE.@)
582 void WINAPI
IoStartTimer(PDEVICE_OBJECT DeviceObject
)
584 FIXME( "stub: %p\n", DeviceObject
);
588 /***********************************************************************
589 * IoAllocateIrp (NTOSKRNL.EXE.@)
591 PIRP WINAPI
IoAllocateIrp( CCHAR stack_size
, BOOLEAN charge_quota
)
596 TRACE( "%d, %d\n", stack_size
, charge_quota
);
598 size
= sizeof(IRP
) + stack_size
* sizeof(IO_STACK_LOCATION
);
599 irp
= ExAllocatePool( NonPagedPool
, size
);
602 IoInitializeIrp( irp
, size
, stack_size
);
603 irp
->AllocationFlags
= IRP_ALLOCATED_FIXED_SIZE
;
605 irp
->AllocationFlags
|= IRP_LOOKASIDE_ALLOCATION
;
610 /***********************************************************************
611 * IoFreeIrp (NTOSKRNL.EXE.@)
613 void WINAPI
IoFreeIrp( IRP
*irp
)
617 TRACE( "%p\n", irp
);
619 mdl
= irp
->MdlAddress
;
622 MDL
*next
= mdl
->Next
;
631 /***********************************************************************
632 * IoAllocateErrorLogEntry (NTOSKRNL.EXE.@)
634 PVOID WINAPI
IoAllocateErrorLogEntry( PVOID IoObject
, UCHAR EntrySize
)
636 FIXME( "stub: %p, %u\n", IoObject
, EntrySize
);
641 /***********************************************************************
642 * IoAllocateMdl (NTOSKRNL.EXE.@)
644 PMDL WINAPI
IoAllocateMdl( PVOID va
, ULONG length
, BOOLEAN secondary
, BOOLEAN charge_quota
, IRP
*irp
)
647 ULONG_PTR address
= (ULONG_PTR
)va
;
648 ULONG_PTR page_address
;
649 SIZE_T nb_pages
, mdl_size
;
651 TRACE("(%p, %u, %i, %i, %p)\n", va
, length
, secondary
, charge_quota
, irp
);
654 FIXME("Charge quota is not yet supported\n");
656 /* FIXME: We suppose that page size is 4096 */
657 page_address
= address
& ~(4096 - 1);
658 nb_pages
= (((address
+ length
- 1) & ~(4096 - 1)) - page_address
) / 4096 + 1;
660 mdl_size
= sizeof(MDL
) + nb_pages
* sizeof(PVOID
);
662 mdl
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, mdl_size
);
666 mdl
->Size
= mdl_size
;
667 mdl
->Process
= NULL
; /* FIXME: IoGetCurrentProcess */
668 mdl
->StartVa
= (PVOID
)page_address
;
669 mdl
->ByteCount
= length
;
670 mdl
->ByteOffset
= address
- page_address
;
672 if (!irp
) return mdl
;
674 if (secondary
) /* add it at the end */
676 MDL
**pmdl
= &irp
->MdlAddress
;
677 while (*pmdl
) pmdl
= &(*pmdl
)->Next
;
682 mdl
->Next
= irp
->MdlAddress
;
683 irp
->MdlAddress
= mdl
;
689 /***********************************************************************
690 * IoFreeMdl (NTOSKRNL.EXE.@)
692 void WINAPI
IoFreeMdl(PMDL mdl
)
695 HeapFree(GetProcessHeap(), 0, mdl
);
699 /***********************************************************************
700 * IoAllocateWorkItem (NTOSKRNL.EXE.@)
702 PIO_WORKITEM WINAPI
IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject
)
704 FIXME( "stub: %p\n", DeviceObject
);
709 /***********************************************************************
710 * IoAttachDeviceToDeviceStack (NTOSKRNL.EXE.@)
712 PDEVICE_OBJECT WINAPI
IoAttachDeviceToDeviceStack( DEVICE_OBJECT
*source
,
713 DEVICE_OBJECT
*target
)
715 TRACE( "%p, %p\n", source
, target
);
716 target
->AttachedDevice
= source
;
717 source
->StackSize
= target
->StackSize
+ 1;
722 /***********************************************************************
723 * IoBuildDeviceIoControlRequest (NTOSKRNL.EXE.@)
725 PIRP WINAPI
IoBuildDeviceIoControlRequest( ULONG code
, PDEVICE_OBJECT device
,
726 PVOID in_buff
, ULONG in_len
,
727 PVOID out_buff
, ULONG out_len
,
728 BOOLEAN internal
, PKEVENT event
,
729 PIO_STATUS_BLOCK iosb
)
732 PIO_STACK_LOCATION irpsp
;
734 TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
735 code
, device
, in_buff
, in_len
, out_buff
, out_len
, internal
, event
, iosb
);
740 irp
= IoAllocateIrp( device
->StackSize
, FALSE
);
744 irpsp
= IoGetNextIrpStackLocation( irp
);
745 irpsp
->MajorFunction
= internal
? IRP_MJ_INTERNAL_DEVICE_CONTROL
: IRP_MJ_DEVICE_CONTROL
;
746 irpsp
->Parameters
.DeviceIoControl
.IoControlCode
= code
;
747 irpsp
->Parameters
.DeviceIoControl
.InputBufferLength
= in_len
;
748 irpsp
->Parameters
.DeviceIoControl
.OutputBufferLength
= out_len
;
749 irpsp
->DeviceObject
= device
;
750 irpsp
->CompletionRoutine
= NULL
;
754 case METHOD_BUFFERED
:
755 irp
->AssociatedIrp
.SystemBuffer
= in_buff
;
757 case METHOD_IN_DIRECT
:
758 case METHOD_OUT_DIRECT
:
759 irp
->AssociatedIrp
.SystemBuffer
= in_buff
;
760 IoAllocateMdl( out_buff
, out_len
, FALSE
, FALSE
, irp
);
763 irpsp
->Parameters
.DeviceIoControl
.Type3InputBuffer
= in_buff
;
767 irp
->RequestorMode
= KernelMode
;
768 irp
->UserBuffer
= out_buff
;
769 irp
->UserIosb
= iosb
;
770 irp
->UserEvent
= event
;
775 /**********************************************************
776 * IoBuildSynchronousFsdRequest (NTOSKRNL.EXE.@)
778 PIRP WINAPI
IoBuildSynchronousFsdRequest(ULONG majorfunc
, PDEVICE_OBJECT device
,
779 PVOID buffer
, ULONG length
, PLARGE_INTEGER startoffset
,
780 PKEVENT event
, PIO_STATUS_BLOCK iosb
)
783 PIO_STACK_LOCATION irpsp
;
785 TRACE("(%d %p %p %d %p %p %p)\n", majorfunc
, device
, buffer
, length
, startoffset
, event
, iosb
);
787 if (!(irp
= IoAllocateIrp( device
->StackSize
, FALSE
))) return NULL
;
789 irpsp
= IoGetNextIrpStackLocation( irp
);
790 irpsp
->MajorFunction
= majorfunc
;
791 irpsp
->DeviceObject
= device
;
792 irpsp
->CompletionRoutine
= NULL
;
794 irp
->AssociatedIrp
.SystemBuffer
= buffer
;
795 if (device
->Flags
& DO_DIRECT_IO
) IoAllocateMdl( buffer
, length
, FALSE
, FALSE
, irp
);
800 irpsp
->Parameters
.Read
.Length
= length
;
801 irpsp
->Parameters
.Read
.ByteOffset
= *startoffset
;
804 irpsp
->Parameters
.Write
.Length
= length
;
805 irpsp
->Parameters
.Write
.ByteOffset
= *startoffset
;
808 irp
->RequestorMode
= KernelMode
;
809 irp
->UserIosb
= iosb
;
810 irp
->UserEvent
= event
;
811 irp
->UserBuffer
= buffer
;
816 /***********************************************************************
817 * IoCreateDriver (NTOSKRNL.EXE.@)
819 NTSTATUS WINAPI
IoCreateDriver( UNICODE_STRING
*name
, PDRIVER_INITIALIZE init
)
821 DRIVER_OBJECT
*driver
;
822 DRIVER_EXTENSION
*extension
;
825 TRACE("(%s, %p)\n", debugstr_us(name
), init
);
827 if (!(driver
= RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY
,
828 sizeof(*driver
) + sizeof(*extension
) )))
829 return STATUS_NO_MEMORY
;
831 if ((status
= RtlDuplicateUnicodeString( 1, name
, &driver
->DriverName
)))
833 RtlFreeHeap( GetProcessHeap(), 0, driver
);
837 extension
= (DRIVER_EXTENSION
*)(driver
+ 1);
838 driver
->Size
= sizeof(*driver
);
839 driver
->DriverInit
= init
;
840 driver
->DriverExtension
= extension
;
841 extension
->DriverObject
= driver
;
842 extension
->ServiceKeyName
= driver
->DriverName
;
844 status
= driver
->DriverInit( driver
, name
);
848 RtlFreeUnicodeString( &driver
->DriverName
);
849 RtlFreeHeap( GetProcessHeap(), 0, driver
);
855 /***********************************************************************
856 * IoDeleteDriver (NTOSKRNL.EXE.@)
858 void WINAPI
IoDeleteDriver( DRIVER_OBJECT
*driver
)
860 TRACE("(%p)\n", driver
);
862 RtlFreeUnicodeString( &driver
->DriverName
);
863 RtlFreeHeap( GetProcessHeap(), 0, driver
);
867 /***********************************************************************
868 * IoCreateDevice (NTOSKRNL.EXE.@)
870 NTSTATUS WINAPI
IoCreateDevice( DRIVER_OBJECT
*driver
, ULONG ext_size
,
871 UNICODE_STRING
*name
, DEVICE_TYPE type
,
872 ULONG characteristics
, BOOLEAN exclusive
,
873 DEVICE_OBJECT
**ret_device
)
876 DEVICE_OBJECT
*device
;
878 HANDLE manager
= get_device_manager();
880 TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
881 driver
, ext_size
, debugstr_us(name
), type
, characteristics
, exclusive
, ret_device
);
883 if (!(device
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*device
) + ext_size
)))
884 return STATUS_NO_MEMORY
;
886 SERVER_START_REQ( create_device
)
891 req
->manager
= wine_server_obj_handle( manager
);
892 req
->user_ptr
= wine_server_client_ptr( device
);
893 if (name
) wine_server_add_data( req
, name
->Buffer
, name
->Length
);
894 if (!(status
= wine_server_call( req
))) handle
= wine_server_ptr_handle( reply
->handle
);
898 if (status
== STATUS_SUCCESS
)
900 device
->DriverObject
= driver
;
901 device
->DeviceExtension
= device
+ 1;
902 device
->DeviceType
= type
;
903 device
->StackSize
= 1;
904 device
->Reserved
= handle
;
906 device
->NextDevice
= driver
->DeviceObject
;
907 driver
->DeviceObject
= device
;
909 *ret_device
= device
;
911 else HeapFree( GetProcessHeap(), 0, device
);
917 /***********************************************************************
918 * IoDeleteDevice (NTOSKRNL.EXE.@)
920 void WINAPI
IoDeleteDevice( DEVICE_OBJECT
*device
)
924 TRACE( "%p\n", device
);
926 SERVER_START_REQ( delete_device
)
928 req
->handle
= wine_server_obj_handle( device
->Reserved
);
929 status
= wine_server_call( req
);
933 if (status
== STATUS_SUCCESS
)
935 DEVICE_OBJECT
**prev
= &device
->DriverObject
->DeviceObject
;
936 while (*prev
&& *prev
!= device
) prev
= &(*prev
)->NextDevice
;
937 if (*prev
) *prev
= (*prev
)->NextDevice
;
938 NtClose( device
->Reserved
);
939 HeapFree( GetProcessHeap(), 0, device
);
944 /***********************************************************************
945 * IoCreateSymbolicLink (NTOSKRNL.EXE.@)
947 NTSTATUS WINAPI
IoCreateSymbolicLink( UNICODE_STRING
*name
, UNICODE_STRING
*target
)
950 OBJECT_ATTRIBUTES attr
;
952 attr
.Length
= sizeof(attr
);
953 attr
.RootDirectory
= 0;
954 attr
.ObjectName
= name
;
955 attr
.Attributes
= OBJ_CASE_INSENSITIVE
| OBJ_OPENIF
;
956 attr
.SecurityDescriptor
= NULL
;
957 attr
.SecurityQualityOfService
= NULL
;
959 TRACE( "%s -> %s\n", debugstr_us(name
), debugstr_us(target
) );
960 /* FIXME: store handle somewhere */
961 return NtCreateSymbolicLinkObject( &handle
, SYMBOLIC_LINK_ALL_ACCESS
, &attr
, target
);
965 /***********************************************************************
966 * IoDeleteSymbolicLink (NTOSKRNL.EXE.@)
968 NTSTATUS WINAPI
IoDeleteSymbolicLink( UNICODE_STRING
*name
)
971 OBJECT_ATTRIBUTES attr
;
974 attr
.Length
= sizeof(attr
);
975 attr
.RootDirectory
= 0;
976 attr
.ObjectName
= name
;
977 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
978 attr
.SecurityDescriptor
= NULL
;
979 attr
.SecurityQualityOfService
= NULL
;
981 if (!(status
= NtOpenSymbolicLinkObject( &handle
, 0, &attr
)))
983 SERVER_START_REQ( unlink_object
)
985 req
->handle
= wine_server_obj_handle( handle
);
986 status
= wine_server_call( req
);
995 /***********************************************************************
996 * IoGetDeviceInterfaces (NTOSKRNL.EXE.@)
998 NTSTATUS WINAPI
IoGetDeviceInterfaces( const GUID
*InterfaceClassGuid
,
999 PDEVICE_OBJECT PhysicalDeviceObject
,
1000 ULONG Flags
, PWSTR
*SymbolicLinkList
)
1002 FIXME( "stub: %s %p %x %p\n", debugstr_guid(InterfaceClassGuid
),
1003 PhysicalDeviceObject
, Flags
, SymbolicLinkList
);
1004 return STATUS_NOT_IMPLEMENTED
;
1008 /***********************************************************************
1009 * IoGetDeviceObjectPointer (NTOSKRNL.EXE.@)
1011 NTSTATUS WINAPI
IoGetDeviceObjectPointer( UNICODE_STRING
*name
, ACCESS_MASK access
, PFILE_OBJECT
*file
, PDEVICE_OBJECT
*device
)
1013 static DEVICE_OBJECT stub_device
;
1014 static DRIVER_OBJECT stub_driver
;
1016 FIXME( "stub: %s %x %p %p\n", debugstr_us(name
), access
, file
, device
);
1018 stub_device
.StackSize
= 0x80; /* minimum value to appease SecuROM 5.x */
1019 stub_device
.DriverObject
= &stub_driver
;
1022 *device
= &stub_device
;
1024 return STATUS_SUCCESS
;
1027 /***********************************************************************
1028 * IoGetAttachedDevice (NTOSKRNL.EXE.@)
1030 PDEVICE_OBJECT WINAPI
IoGetAttachedDevice( PDEVICE_OBJECT device
)
1032 FIXME( "stub: %p\n", device
);
1037 /***********************************************************************
1038 * IoGetDeviceProperty (NTOSKRNL.EXE.@)
1040 NTSTATUS WINAPI
IoGetDeviceProperty( DEVICE_OBJECT
*device
, DEVICE_REGISTRY_PROPERTY device_property
,
1041 ULONG buffer_length
, PVOID property_buffer
, PULONG result_length
)
1043 NTSTATUS status
= STATUS_NOT_IMPLEMENTED
;
1044 TRACE( "%p %d %u %p %p\n", device
, device_property
, buffer_length
,
1045 property_buffer
, result_length
);
1046 switch (device_property
)
1048 case DevicePropertyPhysicalDeviceObjectName
:
1050 ULONG used_len
, len
= buffer_length
+ sizeof(OBJECT_NAME_INFORMATION
);
1051 OBJECT_NAME_INFORMATION
*name
= HeapAlloc(GetProcessHeap(), 0, len
);
1053 status
= NtQueryObject(device
->Reserved
, ObjectNameInformation
, name
, len
, &used_len
);
1054 if (status
== STATUS_SUCCESS
)
1056 /* Ensure room for NULL termination */
1057 if (buffer_length
>= name
->Name
.MaximumLength
)
1058 memcpy(property_buffer
, name
->Name
.Buffer
, name
->Name
.MaximumLength
);
1060 status
= STATUS_BUFFER_TOO_SMALL
;
1061 *result_length
= name
->Name
.MaximumLength
;
1065 if (status
== STATUS_INFO_LENGTH_MISMATCH
||
1066 status
== STATUS_BUFFER_OVERFLOW
)
1068 status
= STATUS_BUFFER_TOO_SMALL
;
1069 *result_length
= used_len
- sizeof(OBJECT_NAME_INFORMATION
);
1074 HeapFree(GetProcessHeap(), 0, name
);
1078 FIXME("unhandled property %d\n", device_property
);
1084 /***********************************************************************
1085 * IoCallDriver (NTOSKRNL.EXE.@)
1087 NTSTATUS WINAPI
IoCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
1089 PDRIVER_DISPATCH dispatch
;
1090 IO_STACK_LOCATION
*irpsp
;
1093 --irp
->CurrentLocation
;
1094 irpsp
= --irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1095 dispatch
= device
->DriverObject
->MajorFunction
[irpsp
->MajorFunction
];
1097 if (TRACE_ON(relay
))
1098 DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
1099 GetCurrentThreadId(), dispatch
, device
, irp
);
1101 status
= dispatch( device
, irp
);
1103 if (TRACE_ON(relay
))
1104 DPRINTF( "%04x:Ret driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
1105 GetCurrentThreadId(), dispatch
, device
, irp
, status
);
1111 /***********************************************************************
1112 * IofCallDriver (NTOSKRNL.EXE.@)
1114 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1115 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver
)
1116 NTSTATUS WINAPI
__regs_IofCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
1118 NTSTATUS WINAPI
IofCallDriver( DEVICE_OBJECT
*device
, IRP
*irp
)
1121 TRACE( "%p %p\n", device
, irp
);
1122 return IoCallDriver( device
, irp
);
1126 /***********************************************************************
1127 * IoGetRelatedDeviceObject (NTOSKRNL.EXE.@)
1129 PDEVICE_OBJECT WINAPI
IoGetRelatedDeviceObject( PFILE_OBJECT obj
)
1131 FIXME( "stub: %p\n", obj
);
1135 static CONFIGURATION_INFORMATION configuration_information
;
1137 /***********************************************************************
1138 * IoGetConfigurationInformation (NTOSKRNL.EXE.@)
1140 PCONFIGURATION_INFORMATION WINAPI
IoGetConfigurationInformation(void)
1142 FIXME( "partial stub\n" );
1143 /* FIXME: return actual devices on system */
1144 return &configuration_information
;
1148 /***********************************************************************
1149 * IoIsWdmVersionAvailable (NTOSKRNL.EXE.@)
1151 NTSTATUS WINAPI
IoIsWdmVersionAvailable(UCHAR MajorVersion
, UCHAR MinorVersion
)
1157 TRACE( "%d, 0x%X\n", MajorVersion
, MinorVersion
);
1159 version
= GetVersion();
1160 major
= LOBYTE(version
);
1161 minor
= HIBYTE(LOWORD(version
));
1163 if (MajorVersion
== 6 && MinorVersion
== 0)
1165 /* Windows Vista, Windows Server 2008, Windows 7 */
1167 else if (MajorVersion
== 1)
1169 if (MinorVersion
== 0x30)
1171 /* Windows server 2003 */
1175 else if (MinorVersion
== 0x20)
1181 else if (MinorVersion
== 0x10)
1187 else if (MinorVersion
== 0x05)
1191 MinorVersion
= 0x5a;
1193 else if (MinorVersion
== 0x00)
1197 MinorVersion
= 0x0a;
1201 FIXME( "unknown major %d minor 0x%X\n", MajorVersion
, MinorVersion
);
1207 FIXME( "unknown major %d minor 0x%X\n", MajorVersion
, MinorVersion
);
1210 return major
> MajorVersion
|| (major
== MajorVersion
&& minor
>= MinorVersion
);
1214 /***********************************************************************
1215 * IoQueryDeviceDescription (NTOSKRNL.EXE.@)
1217 NTSTATUS WINAPI
IoQueryDeviceDescription(PINTERFACE_TYPE itype
, PULONG bus
, PCONFIGURATION_TYPE ctype
,
1218 PULONG cnum
, PCONFIGURATION_TYPE ptype
, PULONG pnum
,
1219 PIO_QUERY_DEVICE_ROUTINE callout
, PVOID context
)
1221 FIXME( "(%p %p %p %p %p %p %p %p)\n", itype
, bus
, ctype
, cnum
, ptype
, pnum
, callout
, context
);
1222 return STATUS_NOT_IMPLEMENTED
;
1226 /***********************************************************************
1227 * IoRegisterDriverReinitialization (NTOSKRNL.EXE.@)
1229 void WINAPI
IoRegisterDriverReinitialization( PDRIVER_OBJECT obj
, PDRIVER_REINITIALIZE reinit
, PVOID context
)
1231 FIXME( "stub: %p %p %p\n", obj
, reinit
, context
);
1235 /***********************************************************************
1236 * IoRegisterShutdownNotification (NTOSKRNL.EXE.@)
1238 NTSTATUS WINAPI
IoRegisterShutdownNotification( PDEVICE_OBJECT obj
)
1240 FIXME( "stub: %p\n", obj
);
1241 return STATUS_SUCCESS
;
1245 /***********************************************************************
1246 * IoUnregisterShutdownNotification (NTOSKRNL.EXE.@)
1248 VOID WINAPI
IoUnregisterShutdownNotification( PDEVICE_OBJECT obj
)
1250 FIXME( "stub: %p\n", obj
);
1254 /***********************************************************************
1255 * IoReportResourceUsage (NTOSKRNL.EXE.@)
1257 NTSTATUS WINAPI
IoReportResourceUsage(PUNICODE_STRING name
, PDRIVER_OBJECT drv_obj
, PCM_RESOURCE_LIST drv_list
,
1258 ULONG drv_size
, PDRIVER_OBJECT dev_obj
, PCM_RESOURCE_LIST dev_list
,
1259 ULONG dev_size
, BOOLEAN overwrite
, PBOOLEAN detected
)
1261 FIXME("(%s %p %p %u %p %p %u %d %p) stub\n", debugstr_w(name
? name
->Buffer
: NULL
),
1262 drv_obj
, drv_list
, drv_size
, dev_obj
, dev_list
, dev_size
, overwrite
, detected
);
1263 return STATUS_NOT_IMPLEMENTED
;
1267 /***********************************************************************
1268 * IoCompleteRequest (NTOSKRNL.EXE.@)
1270 VOID WINAPI
IoCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1272 IO_STACK_LOCATION
*irpsp
;
1273 PIO_COMPLETION_ROUTINE routine
;
1274 NTSTATUS status
, stat
;
1278 TRACE( "%p %u\n", irp
, priority_boost
);
1280 status
= irp
->IoStatus
.u
.Status
;
1281 while (irp
->CurrentLocation
<= irp
->StackCount
)
1283 irpsp
= irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1284 routine
= irpsp
->CompletionRoutine
;
1286 /* FIXME: add SL_INVOKE_ON_CANCEL support */
1289 if ((irpsp
->Control
& SL_INVOKE_ON_SUCCESS
) && STATUS_SUCCESS
== status
)
1291 if ((irpsp
->Control
& SL_INVOKE_ON_ERROR
) && STATUS_SUCCESS
!= status
)
1294 ++irp
->CurrentLocation
;
1295 ++irp
->Tail
.Overlay
.s
.u2
.CurrentStackLocation
;
1298 TRACE( "calling %p( %p, %p, %p )\n", routine
,
1299 irpsp
->DeviceObject
, irp
, irpsp
->Context
);
1300 stat
= routine( irpsp
->DeviceObject
, irp
, irpsp
->Context
);
1301 TRACE( "CompletionRoutine returned %x\n", stat
);
1302 if (STATUS_MORE_PROCESSING_REQUIRED
== stat
)
1307 handle
= (HANDLE
)irp
->UserIosb
;
1310 void *out_buff
= irp
->UserBuffer
;
1311 FILE_OBJECT
*file
= irp
->Tail
.Overlay
.OriginalFileObject
;
1313 SERVER_START_REQ( set_irp_result
)
1315 req
->handle
= wine_server_obj_handle( handle
);
1316 req
->status
= irp
->IoStatus
.u
.Status
;
1317 req
->file_ptr
= wine_server_client_ptr( file
);
1318 if (irp
->IoStatus
.u
.Status
>= 0)
1320 req
->size
= irp
->IoStatus
.Information
;
1321 if (out_buff
) wine_server_add_data( req
, out_buff
, irp
->IoStatus
.Information
);
1323 wine_server_call( req
);
1326 HeapFree( GetProcessHeap(), 0, out_buff
);
1333 /***********************************************************************
1334 * IofCompleteRequest (NTOSKRNL.EXE.@)
1336 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1337 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest
)
1338 void WINAPI
__regs_IofCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1340 void WINAPI
IofCompleteRequest( IRP
*irp
, UCHAR priority_boost
)
1343 TRACE( "%p %u\n", irp
, priority_boost
);
1344 IoCompleteRequest( irp
, priority_boost
);
1348 /***********************************************************************
1349 * InterlockedCompareExchange (NTOSKRNL.EXE.@)
1351 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
1352 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange
)
1353 LONG WINAPI
__regs_NTOSKRNL_InterlockedCompareExchange( LONG
volatile *dest
, LONG xchg
, LONG compare
)
1355 LONG WINAPI
NTOSKRNL_InterlockedCompareExchange( LONG
volatile *dest
, LONG xchg
, LONG compare
)
1358 return InterlockedCompareExchange( dest
, xchg
, compare
);
1362 /***********************************************************************
1363 * InterlockedDecrement (NTOSKRNL.EXE.@)
1365 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1366 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement
)
1367 LONG WINAPI
__regs_NTOSKRNL_InterlockedDecrement( LONG
volatile *dest
)
1369 LONG WINAPI
NTOSKRNL_InterlockedDecrement( LONG
volatile *dest
)
1372 return InterlockedDecrement( dest
);
1376 /***********************************************************************
1377 * InterlockedExchange (NTOSKRNL.EXE.@)
1379 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1380 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange
)
1381 LONG WINAPI
__regs_NTOSKRNL_InterlockedExchange( LONG
volatile *dest
, LONG val
)
1383 LONG WINAPI
NTOSKRNL_InterlockedExchange( LONG
volatile *dest
, LONG val
)
1386 return InterlockedExchange( dest
, val
);
1390 /***********************************************************************
1391 * InterlockedExchangeAdd (NTOSKRNL.EXE.@)
1393 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1394 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd
)
1395 LONG WINAPI
__regs_NTOSKRNL_InterlockedExchangeAdd( LONG
volatile *dest
, LONG incr
)
1397 LONG WINAPI
NTOSKRNL_InterlockedExchangeAdd( LONG
volatile *dest
, LONG incr
)
1400 return InterlockedExchangeAdd( dest
, incr
);
1404 /***********************************************************************
1405 * InterlockedIncrement (NTOSKRNL.EXE.@)
1407 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1408 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement
)
1409 LONG WINAPI
__regs_NTOSKRNL_InterlockedIncrement( LONG
volatile *dest
)
1411 LONG WINAPI
NTOSKRNL_InterlockedIncrement( LONG
volatile *dest
)
1414 return InterlockedIncrement( dest
);
1418 /***********************************************************************
1419 * ExAllocatePool (NTOSKRNL.EXE.@)
1421 PVOID WINAPI
ExAllocatePool( POOL_TYPE type
, SIZE_T size
)
1423 return ExAllocatePoolWithTag( type
, size
, 0 );
1427 /***********************************************************************
1428 * ExAllocatePoolWithQuota (NTOSKRNL.EXE.@)
1430 PVOID WINAPI
ExAllocatePoolWithQuota( POOL_TYPE type
, SIZE_T size
)
1432 return ExAllocatePoolWithTag( type
, size
, 0 );
1436 /***********************************************************************
1437 * ExAllocatePoolWithTag (NTOSKRNL.EXE.@)
1439 PVOID WINAPI
ExAllocatePoolWithTag( POOL_TYPE type
, SIZE_T size
, ULONG tag
)
1441 /* FIXME: handle page alignment constraints */
1442 void *ret
= HeapAlloc( GetProcessHeap(), 0, size
);
1443 TRACE( "%lu pool %u -> %p\n", size
, type
, ret
);
1448 /***********************************************************************
1449 * ExAllocatePoolWithQuotaTag (NTOSKRNL.EXE.@)
1451 PVOID WINAPI
ExAllocatePoolWithQuotaTag( POOL_TYPE type
, SIZE_T size
, ULONG tag
)
1453 return ExAllocatePoolWithTag( type
, size
, tag
);
1457 /***********************************************************************
1458 * ExCreateCallback (NTOSKRNL.EXE.@)
1460 NTSTATUS WINAPI
ExCreateCallback(PCALLBACK_OBJECT
*obj
, POBJECT_ATTRIBUTES attr
,
1461 BOOLEAN create
, BOOLEAN allow_multiple
)
1463 FIXME("(%p, %p, %u, %u): stub\n", obj
, attr
, create
, allow_multiple
);
1465 return STATUS_NOT_IMPLEMENTED
;
1469 /***********************************************************************
1470 * ExDeleteNPagedLookasideList (NTOSKRNL.EXE.@)
1472 void WINAPI
ExDeleteNPagedLookasideList( PNPAGED_LOOKASIDE_LIST lookaside
)
1474 FIXME("(%p) stub\n", lookaside
);
1478 /***********************************************************************
1479 * ExDeletePagedLookasideList (NTOSKRNL.EXE.@)
1481 void WINAPI
ExDeletePagedLookasideList( PPAGED_LOOKASIDE_LIST lookaside
)
1483 FIXME("(%p) stub\n", lookaside
);
1487 /***********************************************************************
1488 * ExFreePool (NTOSKRNL.EXE.@)
1490 void WINAPI
ExFreePool( void *ptr
)
1492 ExFreePoolWithTag( ptr
, 0 );
1496 /***********************************************************************
1497 * ExFreePoolWithTag (NTOSKRNL.EXE.@)
1499 void WINAPI
ExFreePoolWithTag( void *ptr
, ULONG tag
)
1501 TRACE( "%p\n", ptr
);
1502 HeapFree( GetProcessHeap(), 0, ptr
);
1506 /***********************************************************************
1507 * ExInitializeResourceLite (NTOSKRNL.EXE.@)
1509 NTSTATUS WINAPI
ExInitializeResourceLite(PERESOURCE Resource
)
1511 FIXME( "stub: %p\n", Resource
);
1512 return STATUS_NOT_IMPLEMENTED
;
1516 /***********************************************************************
1517 * ExInitializeNPagedLookasideList (NTOSKRNL.EXE.@)
1519 void WINAPI
ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside
,
1520 PALLOCATE_FUNCTION Allocate
,
1521 PFREE_FUNCTION Free
,
1527 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside
, Allocate
, Free
, Flags
, Size
, Tag
, Depth
);
1530 /***********************************************************************
1531 * ExInitializePagedLookasideList (NTOSKRNL.EXE.@)
1533 void WINAPI
ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside
,
1534 PALLOCATE_FUNCTION Allocate
,
1535 PFREE_FUNCTION Free
,
1541 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside
, Allocate
, Free
, Flags
, Size
, Tag
, Depth
);
1544 /***********************************************************************
1545 * ExInitializeZone (NTOSKRNL.EXE.@)
1547 NTSTATUS WINAPI
ExInitializeZone(PZONE_HEADER Zone
,
1549 PVOID InitialSegment
,
1550 ULONG InitialSegmentSize
)
1552 FIXME( "stub: %p, %u, %p, %u\n", Zone
, BlockSize
, InitialSegment
, InitialSegmentSize
);
1553 return STATUS_NOT_IMPLEMENTED
;
1556 /***********************************************************************
1557 * FsRtlRegisterUncProvider (NTOSKRNL.EXE.@)
1559 NTSTATUS WINAPI
FsRtlRegisterUncProvider(PHANDLE MupHandle
, PUNICODE_STRING RedirDevName
,
1560 BOOLEAN MailslotsSupported
)
1562 FIXME("(%p %p %d): stub\n", MupHandle
, RedirDevName
, MailslotsSupported
);
1563 return STATUS_NOT_IMPLEMENTED
;
1566 /***********************************************************************
1567 * IoGetCurrentProcess / PsGetCurrentProcess (NTOSKRNL.EXE.@)
1569 PEPROCESS WINAPI
IoGetCurrentProcess(void)
1575 /***********************************************************************
1576 * KeGetCurrentThread / PsGetCurrentThread (NTOSKRNL.EXE.@)
1578 PRKTHREAD WINAPI
KeGetCurrentThread(void)
1584 /***********************************************************************
1585 * KeInitializeEvent (NTOSKRNL.EXE.@)
1587 void WINAPI
KeInitializeEvent( PRKEVENT Event
, EVENT_TYPE Type
, BOOLEAN State
)
1589 FIXME( "stub: %p %d %d\n", Event
, Type
, State
);
1593 /***********************************************************************
1594 * KeInitializeMutex (NTOSKRNL.EXE.@)
1596 void WINAPI
KeInitializeMutex(PRKMUTEX Mutex
, ULONG Level
)
1598 FIXME( "stub: %p, %u\n", Mutex
, Level
);
1602 /***********************************************************************
1603 * KeWaitForMutexObject (NTOSKRNL.EXE.@)
1605 NTSTATUS WINAPI
KeWaitForMutexObject(PRKMUTEX Mutex
, KWAIT_REASON WaitReason
, KPROCESSOR_MODE WaitMode
,
1606 BOOLEAN Alertable
, PLARGE_INTEGER Timeout
)
1608 FIXME( "stub: %p, %d, %d, %d, %p\n", Mutex
, WaitReason
, WaitMode
, Alertable
, Timeout
);
1609 return STATUS_NOT_IMPLEMENTED
;
1613 /***********************************************************************
1614 * KeReleaseMutex (NTOSKRNL.EXE.@)
1616 LONG WINAPI
KeReleaseMutex(PRKMUTEX Mutex
, BOOLEAN Wait
)
1618 FIXME( "stub: %p, %d\n", Mutex
, Wait
);
1619 return STATUS_NOT_IMPLEMENTED
;
1623 /***********************************************************************
1624 * KeInitializeSemaphore (NTOSKRNL.EXE.@)
1626 void WINAPI
KeInitializeSemaphore( PRKSEMAPHORE Semaphore
, LONG Count
, LONG Limit
)
1628 FIXME( "(%p %d %d) stub\n", Semaphore
, Count
, Limit
);
1632 /***********************************************************************
1633 * KeInitializeSpinLock (NTOSKRNL.EXE.@)
1635 void WINAPI
KeInitializeSpinLock( PKSPIN_LOCK SpinLock
)
1637 FIXME( "stub: %p\n", SpinLock
);
1641 /***********************************************************************
1642 * KeInitializeTimerEx (NTOSKRNL.EXE.@)
1644 void WINAPI
KeInitializeTimerEx( PKTIMER Timer
, TIMER_TYPE Type
)
1646 FIXME( "stub: %p %d\n", Timer
, Type
);
1650 /***********************************************************************
1651 * KeInitializeTimer (NTOSKRNL.EXE.@)
1653 void WINAPI
KeInitializeTimer( PKTIMER Timer
)
1655 KeInitializeTimerEx(Timer
, NotificationTimer
);
1658 /***********************************************************************
1659 * KeInsertQueue (NTOSKRNL.EXE.@)
1661 LONG WINAPI
KeInsertQueue(PRKQUEUE Queue
, PLIST_ENTRY Entry
)
1663 FIXME( "stub: %p %p\n", Queue
, Entry
);
1667 /**********************************************************************
1668 * KeQueryActiveProcessors (NTOSKRNL.EXE.@)
1670 * Return the active Processors as bitmask
1673 * active Processors as bitmask
1676 KAFFINITY WINAPI
KeQueryActiveProcessors( void )
1678 DWORD_PTR AffinityMask
;
1680 GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask
, NULL
);
1681 return AffinityMask
;
1685 /**********************************************************************
1686 * KeQueryInterruptTime (NTOSKRNL.EXE.@)
1688 * Return the interrupt time count
1691 ULONGLONG WINAPI
KeQueryInterruptTime( void )
1693 LARGE_INTEGER totaltime
;
1695 KeQueryTickCount(&totaltime
);
1696 return totaltime
.QuadPart
;
1700 /***********************************************************************
1701 * KeQuerySystemTime (NTOSKRNL.EXE.@)
1703 void WINAPI
KeQuerySystemTime( LARGE_INTEGER
*time
)
1705 NtQuerySystemTime( time
);
1709 /***********************************************************************
1710 * KeQueryTickCount (NTOSKRNL.EXE.@)
1712 void WINAPI
KeQueryTickCount( LARGE_INTEGER
*count
)
1714 count
->QuadPart
= NtGetTickCount();
1715 /* update the global variable too */
1716 KeTickCount
.LowPart
= count
->u
.LowPart
;
1717 KeTickCount
.High1Time
= count
->u
.HighPart
;
1718 KeTickCount
.High2Time
= count
->u
.HighPart
;
1722 /***********************************************************************
1723 * KeReleaseSemaphore (NTOSKRNL.EXE.@)
1725 LONG WINAPI
KeReleaseSemaphore( PRKSEMAPHORE Semaphore
, KPRIORITY Increment
,
1726 LONG Adjustment
, BOOLEAN Wait
)
1728 FIXME("(%p %d %d %d) stub\n", Semaphore
, Increment
, Adjustment
, Wait
);
1733 /***********************************************************************
1734 * KeQueryTimeIncrement (NTOSKRNL.EXE.@)
1736 ULONG WINAPI
KeQueryTimeIncrement(void)
1742 /***********************************************************************
1743 * KeResetEvent (NTOSKRNL.EXE.@)
1745 LONG WINAPI
KeResetEvent( PRKEVENT Event
)
1747 FIXME("(%p): stub\n", Event
);
1752 /***********************************************************************
1753 * KeSetEvent (NTOSKRNL.EXE.@)
1755 LONG WINAPI
KeSetEvent( PRKEVENT Event
, KPRIORITY Increment
, BOOLEAN Wait
)
1757 FIXME("(%p, %d, %d): stub\n", Event
, Increment
, Wait
);
1762 /***********************************************************************
1763 * KeSetPriorityThread (NTOSKRNL.EXE.@)
1765 KPRIORITY WINAPI
KeSetPriorityThread( PKTHREAD Thread
, KPRIORITY Priority
)
1767 FIXME("(%p %d)\n", Thread
, Priority
);
1771 /***********************************************************************
1772 * KeSetSystemAffinityThread (NTOSKRNL.EXE.@)
1774 VOID WINAPI
KeSetSystemAffinityThread(KAFFINITY Affinity
)
1776 FIXME("(%lx) stub\n", Affinity
);
1779 /***********************************************************************
1780 * KeWaitForSingleObject (NTOSKRNL.EXE.@)
1782 NTSTATUS WINAPI
KeWaitForSingleObject(PVOID Object
,
1783 KWAIT_REASON WaitReason
,
1784 KPROCESSOR_MODE WaitMode
,
1786 PLARGE_INTEGER Timeout
)
1788 FIXME( "stub: %p, %d, %d, %d, %p\n", Object
, WaitReason
, WaitMode
, Alertable
, Timeout
);
1789 return STATUS_NOT_IMPLEMENTED
;
1792 /***********************************************************************
1793 * IoRegisterFileSystem (NTOSKRNL.EXE.@)
1795 VOID WINAPI
IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject
)
1797 FIXME("(%p): stub\n", DeviceObject
);
1800 /***********************************************************************
1801 * IoUnregisterFileSystem (NTOSKRNL.EXE.@)
1803 VOID WINAPI
IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject
)
1805 FIXME("(%p): stub\n", DeviceObject
);
1808 /***********************************************************************
1809 * MmAllocateNonCachedMemory (NTOSKRNL.EXE.@)
1811 PVOID WINAPI
MmAllocateNonCachedMemory( SIZE_T size
)
1813 TRACE( "%lu\n", size
);
1814 return VirtualAlloc( NULL
, size
, MEM_RESERVE
|MEM_COMMIT
, PAGE_READWRITE
|PAGE_NOCACHE
);
1817 /***********************************************************************
1818 * MmAllocateContiguousMemory (NTOSKRNL.EXE.@)
1820 PVOID WINAPI
MmAllocateContiguousMemory( SIZE_T size
, PHYSICAL_ADDRESS highest_valid_address
)
1822 FIXME( "%lu, %s stub\n", size
, wine_dbgstr_longlong(highest_valid_address
.QuadPart
) );
1826 /***********************************************************************
1827 * MmAllocateContiguousMemorySpecifyCache (NTOSKRNL.EXE.@)
1829 PVOID WINAPI
MmAllocateContiguousMemorySpecifyCache( SIZE_T size
,
1830 PHYSICAL_ADDRESS lowest_valid_address
,
1831 PHYSICAL_ADDRESS highest_valid_address
,
1832 PHYSICAL_ADDRESS BoundaryAddressMultiple
,
1833 MEMORY_CACHING_TYPE CacheType
)
1839 /***********************************************************************
1840 * MmAllocatePagesForMdl (NTOSKRNL.EXE.@)
1842 PMDL WINAPI
MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress
, PHYSICAL_ADDRESS highaddress
,
1843 PHYSICAL_ADDRESS skipbytes
, SIZE_T size
)
1845 FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress
.QuadPart
), wine_dbgstr_longlong(highaddress
.QuadPart
),
1846 wine_dbgstr_longlong(skipbytes
.QuadPart
), size
);
1850 /***********************************************************************
1851 * MmFreeNonCachedMemory (NTOSKRNL.EXE.@)
1853 void WINAPI
MmFreeNonCachedMemory( void *addr
, SIZE_T size
)
1855 TRACE( "%p %lu\n", addr
, size
);
1856 VirtualFree( addr
, 0, MEM_RELEASE
);
1859 /***********************************************************************
1860 * MmIsAddressValid (NTOSKRNL.EXE.@)
1862 * Check if the process can access the virtual address without a pagefault
1865 * VirtualAddress [I] Address to check
1869 * Success: TRUE (Accessing the Address works without a Pagefault)
1872 BOOLEAN WINAPI
MmIsAddressValid(PVOID VirtualAddress
)
1874 TRACE("(%p)\n", VirtualAddress
);
1875 return !IsBadWritePtr(VirtualAddress
, 1);
1878 /***********************************************************************
1879 * MmMapIoSpace (NTOSKRNL.EXE.@)
1881 PVOID WINAPI
MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress
, DWORD NumberOfBytes
, DWORD CacheType
)
1883 FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress
.u
.HighPart
, PhysicalAddress
.u
.LowPart
, NumberOfBytes
, CacheType
);
1888 /***********************************************************************
1889 * MmLockPagableSectionByHandle (NTOSKRNL.EXE.@)
1891 VOID WINAPI
MmLockPagableSectionByHandle(PVOID ImageSectionHandle
)
1893 FIXME("stub %p\n", ImageSectionHandle
);
1896 /***********************************************************************
1897 * MmMapLockedPagesSpecifyCache (NTOSKRNL.EXE.@)
1899 PVOID WINAPI
MmMapLockedPagesSpecifyCache(PMDLX MemoryDescriptorList
, KPROCESSOR_MODE AccessMode
, MEMORY_CACHING_TYPE CacheType
,
1900 PVOID BaseAddress
, ULONG BugCheckOnFailure
, MM_PAGE_PRIORITY Priority
)
1902 FIXME("(%p, %u, %u, %p, %u, %u): stub\n", MemoryDescriptorList
, AccessMode
, CacheType
, BaseAddress
, BugCheckOnFailure
, Priority
);
1907 /***********************************************************************
1908 * MmUnlockPagableImageSection (NTOSKRNL.EXE.@)
1910 VOID WINAPI
MmUnlockPagableImageSection(PVOID ImageSectionHandle
)
1912 FIXME("stub %p\n", ImageSectionHandle
);
1915 /***********************************************************************
1916 * MmPageEntireDriver (NTOSKRNL.EXE.@)
1918 PVOID WINAPI
MmPageEntireDriver(PVOID AddrInSection
)
1920 TRACE("%p\n", AddrInSection
);
1921 return AddrInSection
;
1925 /***********************************************************************
1926 * MmProbeAndLockPages (NTOSKRNL.EXE.@)
1928 void WINAPI
MmProbeAndLockPages(PMDLX MemoryDescriptorList
, KPROCESSOR_MODE AccessMode
, LOCK_OPERATION Operation
)
1930 FIXME("(%p, %u, %u): stub\n", MemoryDescriptorList
, AccessMode
, Operation
);
1934 /***********************************************************************
1935 * MmResetDriverPaging (NTOSKRNL.EXE.@)
1937 void WINAPI
MmResetDriverPaging(PVOID AddrInSection
)
1939 TRACE("%p\n", AddrInSection
);
1943 /***********************************************************************
1944 * MmUnlockPages (NTOSKRNL.EXE.@)
1946 void WINAPI
MmUnlockPages(PMDLX MemoryDescriptorList
)
1948 FIXME("(%p): stub\n", MemoryDescriptorList
);
1952 /***********************************************************************
1953 * MmUnmapIoSpace (NTOSKRNL.EXE.@)
1955 VOID WINAPI
MmUnmapIoSpace( PVOID BaseAddress
, SIZE_T NumberOfBytes
)
1957 FIXME( "stub: %p, %lu\n", BaseAddress
, NumberOfBytes
);
1960 /***********************************************************************
1961 * ObfReferenceObject (NTOSKRNL.EXE.@)
1963 VOID WINAPI
ObfReferenceObject(PVOID Object
)
1965 FIXME("(%p): stub\n", Object
);
1968 /***********************************************************************
1969 * ObReferenceObjectByHandle (NTOSKRNL.EXE.@)
1971 NTSTATUS WINAPI
ObReferenceObjectByHandle( HANDLE obj
, ACCESS_MASK access
,
1973 KPROCESSOR_MODE mode
, PVOID
* ptr
,
1974 POBJECT_HANDLE_INFORMATION info
)
1976 FIXME( "stub: %p %x %p %d %p %p\n", obj
, access
, type
, mode
, ptr
, info
);
1977 return STATUS_NOT_IMPLEMENTED
;
1980 /***********************************************************************
1981 * ObReferenceObjectByName (NTOSKRNL.EXE.@)
1983 NTSTATUS WINAPI
ObReferenceObjectByName( UNICODE_STRING
*ObjectName
,
1985 ACCESS_STATE
*AccessState
,
1986 ACCESS_MASK DesiredAccess
,
1987 POBJECT_TYPE ObjectType
,
1988 KPROCESSOR_MODE AccessMode
,
1993 return STATUS_NOT_IMPLEMENTED
;
1996 /***********************************************************************
1997 * ObfDereferenceObject (NTOSKRNL.EXE.@)
1999 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
2000 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject
)
2001 void WINAPI
__regs_ObfDereferenceObject( VOID
*obj
)
2003 void WINAPI
ObfDereferenceObject( VOID
*obj
)
2006 FIXME( "stub: %p\n", obj
);
2010 /***********************************************************************
2011 * PsCreateSystemThread (NTOSKRNL.EXE.@)
2013 NTSTATUS WINAPI
PsCreateSystemThread(PHANDLE ThreadHandle
, ULONG DesiredAccess
,
2014 POBJECT_ATTRIBUTES ObjectAttributes
,
2015 HANDLE ProcessHandle
, PCLIENT_ID ClientId
,
2016 PKSTART_ROUTINE StartRoutine
, PVOID StartContext
)
2018 if (!ProcessHandle
) ProcessHandle
= GetCurrentProcess();
2019 return RtlCreateUserThread(ProcessHandle
, 0, FALSE
, 0, 0,
2020 0, StartRoutine
, StartContext
,
2021 ThreadHandle
, ClientId
);
2024 /***********************************************************************
2025 * PsGetCurrentProcessId (NTOSKRNL.EXE.@)
2027 HANDLE WINAPI
PsGetCurrentProcessId(void)
2029 if (GetCurrentThreadId() == request_thread
)
2030 return UlongToHandle(client_pid
);
2031 return UlongToHandle(GetCurrentProcessId());
2035 /***********************************************************************
2036 * PsGetCurrentThreadId (NTOSKRNL.EXE.@)
2038 HANDLE WINAPI
PsGetCurrentThreadId(void)
2040 if (GetCurrentThreadId() == request_thread
)
2041 return UlongToHandle(client_tid
);
2042 return UlongToHandle(GetCurrentThreadId());
2046 /***********************************************************************
2047 * PsGetVersion (NTOSKRNL.EXE.@)
2049 BOOLEAN WINAPI
PsGetVersion(ULONG
*major
, ULONG
*minor
, ULONG
*build
, UNICODE_STRING
*version
)
2051 RTL_OSVERSIONINFOEXW info
;
2053 info
.dwOSVersionInfoSize
= sizeof(info
);
2054 RtlGetVersion( &info
);
2055 if (major
) *major
= info
.dwMajorVersion
;
2056 if (minor
) *minor
= info
.dwMinorVersion
;
2057 if (build
) *build
= info
.dwBuildNumber
;
2061 #if 0 /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
2062 size_t len
= min( strlenW(info
.szCSDVersion
)*sizeof(WCHAR
), version
->MaximumLength
);
2063 memcpy( version
->Buffer
, info
.szCSDVersion
, len
);
2064 if (len
< version
->MaximumLength
) version
->Buffer
[len
/ sizeof(WCHAR
)] = 0;
2065 version
->Length
= len
;
2072 /***********************************************************************
2073 * PsImpersonateClient (NTOSKRNL.EXE.@)
2075 NTSTATUS WINAPI
PsImpersonateClient(PETHREAD Thread
, PACCESS_TOKEN Token
, BOOLEAN CopyOnOpen
,
2076 BOOLEAN EffectiveOnly
, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel
)
2078 FIXME("(%p, %p, %u, %u, %u): stub\n", Thread
, Token
, CopyOnOpen
, EffectiveOnly
, ImpersonationLevel
);
2080 return STATUS_NOT_IMPLEMENTED
;
2084 /***********************************************************************
2085 * PsSetCreateProcessNotifyRoutine (NTOSKRNL.EXE.@)
2087 NTSTATUS WINAPI
PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback
, BOOLEAN remove
)
2089 FIXME( "stub: %p %d\n", callback
, remove
);
2090 return STATUS_SUCCESS
;
2094 /***********************************************************************
2095 * PsSetCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
2097 NTSTATUS WINAPI
PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine
)
2099 FIXME( "stub: %p\n", NotifyRoutine
);
2100 return STATUS_SUCCESS
;
2104 /***********************************************************************
2105 * PsRemoveCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
2107 NTSTATUS WINAPI
PsRemoveCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine
)
2109 FIXME( "stub: %p\n", NotifyRoutine
);
2110 return STATUS_SUCCESS
;
2114 /***********************************************************************
2115 * PsTerminateSystemThread (NTOSKRNL.EXE.@)
2117 NTSTATUS WINAPI
PsTerminateSystemThread(NTSTATUS ExitStatus
)
2119 FIXME( "stub: %u\n", ExitStatus
);
2120 return STATUS_NOT_IMPLEMENTED
;
2124 /***********************************************************************
2125 * MmGetSystemRoutineAddress (NTOSKRNL.EXE.@)
2127 PVOID WINAPI
MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName
)
2130 STRING routineNameA
;
2133 static const WCHAR ntoskrnlW
[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
2134 static const WCHAR halW
[] = {'h','a','l','.','d','l','l',0};
2136 if (!SystemRoutineName
) return NULL
;
2138 if (RtlUnicodeStringToAnsiString( &routineNameA
, SystemRoutineName
, TRUE
) == STATUS_SUCCESS
)
2140 /* We only support functions exported from ntoskrnl.exe or hal.dll */
2141 hMod
= GetModuleHandleW( ntoskrnlW
);
2142 pFunc
= GetProcAddress( hMod
, routineNameA
.Buffer
);
2145 hMod
= GetModuleHandleW( halW
);
2146 if (hMod
) pFunc
= GetProcAddress( hMod
, routineNameA
.Buffer
);
2148 RtlFreeAnsiString( &routineNameA
);
2152 TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName
), pFunc
);
2154 FIXME( "%s not found\n", debugstr_us(SystemRoutineName
) );
2159 /***********************************************************************
2160 * MmQuerySystemSize (NTOSKRNL.EXE.@)
2162 MM_SYSTEMSIZE WINAPI
MmQuerySystemSize(void)
2165 return MmLargeSystem
;
2168 /***********************************************************************
2169 * KeInitializeDpc (NTOSKRNL.EXE.@)
2171 VOID WINAPI
KeInitializeDpc(PRKDPC Dpc
, PKDEFERRED_ROUTINE DeferredRoutine
, PVOID DeferredContext
)
2176 /***********************************************************************
2177 * READ_REGISTER_BUFFER_UCHAR (NTOSKRNL.EXE.@)
2179 VOID WINAPI
READ_REGISTER_BUFFER_UCHAR(PUCHAR Register
, PUCHAR Buffer
, ULONG Count
)
2184 /*****************************************************
2185 * PoSetPowerState (NTOSKRNL.EXE.@)
2187 POWER_STATE WINAPI
PoSetPowerState(PDEVICE_OBJECT DeviceObject
, POWER_STATE_TYPE Type
, POWER_STATE State
)
2189 FIXME("(%p %u %u) stub\n", DeviceObject
, Type
, State
.DeviceState
);
2193 /*****************************************************
2194 * IoWMIRegistrationControl (NTOSKRNL.EXE.@)
2196 NTSTATUS WINAPI
IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject
, ULONG Action
)
2198 FIXME("(%p %u) stub\n", DeviceObject
, Action
);
2199 return STATUS_SUCCESS
;
2202 /*****************************************************
2203 * PsSetLoadImageNotifyRoutine (NTOSKRNL.EXE.@)
2205 NTSTATUS WINAPI
PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine
)
2207 FIXME("(%p) stub\n", routine
);
2208 return STATUS_SUCCESS
;
2211 /*****************************************************
2212 * PsLookupProcessByProcessId (NTOSKRNL.EXE.@)
2214 NTSTATUS WINAPI
PsLookupProcessByProcessId(HANDLE processid
, PEPROCESS
*process
)
2217 if (!once
++) FIXME("(%p %p) stub\n", processid
, process
);
2218 return STATUS_NOT_IMPLEMENTED
;
2222 /*****************************************************
2223 * IoSetThreadHardErrorMode (NTOSKRNL.EXE.@)
2225 BOOLEAN WINAPI
IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors
)
2232 /*****************************************************
2233 * IoInitializeRemoveLockEx (NTOSKRNL.EXE.@)
2235 VOID WINAPI
IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock
, ULONG tag
,
2236 ULONG maxmin
, ULONG high
, ULONG size
)
2238 FIXME("(%p %u %u %u %u) stub\n", lock
, tag
, maxmin
, high
, size
);
2242 /*****************************************************
2243 * IoAcquireRemoveLockEx (NTOSKRNL.EXE.@)
2246 NTSTATUS WINAPI
IoAcquireRemoveLockEx(PIO_REMOVE_LOCK lock
, PVOID tag
,
2247 LPCSTR file
, ULONG line
, ULONG lock_size
)
2249 FIXME("(%p, %p, %s, %u, %u): stub\n", lock
, tag
, debugstr_a(file
), line
, lock_size
);
2251 return STATUS_NOT_IMPLEMENTED
;
2255 /*****************************************************
2258 BOOL WINAPI
DllMain( HINSTANCE inst
, DWORD reason
, LPVOID reserved
)
2260 static void *handler
;
2261 LARGE_INTEGER count
;
2265 case DLL_PROCESS_ATTACH
:
2266 DisableThreadLibraryCalls( inst
);
2267 #if defined(__i386__) || defined(__x86_64__)
2268 handler
= RtlAddVectoredExceptionHandler( TRUE
, vectored_handler
);
2270 KeQueryTickCount( &count
); /* initialize the global KeTickCount */
2272 case DLL_PROCESS_DETACH
:
2273 if (reserved
) break;
2274 RtlRemoveVectoredExceptionHandler( handler
);
2280 /*****************************************************
2281 * Ke386IoSetAccessProcess (NTOSKRNL.EXE.@)
2283 BOOLEAN WINAPI
Ke386IoSetAccessProcess(PEPROCESS
*process
, ULONG flag
)
2285 FIXME("(%p %d) stub\n", process
, flag
);
2289 /*****************************************************
2290 * Ke386SetIoAccessMap (NTOSKRNL.EXE.@)
2292 BOOLEAN WINAPI
Ke386SetIoAccessMap(ULONG flag
, PVOID buffer
)
2294 FIXME("(%d %p) stub\n", flag
, buffer
);
2298 /*****************************************************
2299 * IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
2301 PKEVENT WINAPI
IoCreateSynchronizationEvent(PUNICODE_STRING name
, PHANDLE handle
)
2303 FIXME("(%p %p) stub\n", name
, handle
);
2307 /*****************************************************
2308 * IoStartNextPacket (NTOSKRNL.EXE.@)
2310 VOID WINAPI
IoStartNextPacket(PDEVICE_OBJECT deviceobject
, BOOLEAN cancelable
)
2312 FIXME("(%p %d) stub\n", deviceobject
, cancelable
);
2315 /*****************************************************
2316 * ObQueryNameString (NTOSKRNL.EXE.@)
2318 NTSTATUS WINAPI
ObQueryNameString(PVOID object
, POBJECT_NAME_INFORMATION name
, ULONG maxlength
, PULONG returnlength
)
2320 FIXME("(%p %p %u %p) stub\n", object
, name
, maxlength
, returnlength
);
2321 return STATUS_NOT_IMPLEMENTED
;
2324 /*****************************************************
2325 * IoRegisterPlugPlayNotification (NTOSKRNL.EXE.@)
2327 NTSTATUS WINAPI
IoRegisterPlugPlayNotification(IO_NOTIFICATION_EVENT_CATEGORY category
, ULONG flags
, PVOID data
,
2328 PDRIVER_OBJECT driver
, PDRIVER_NOTIFICATION_CALLBACK_ROUTINE callback
,
2329 PVOID context
, PVOID
*notification
)
2331 FIXME("(%u %u %p %p %p %p %p) stub\n", category
, flags
, data
, driver
, callback
, context
, notification
);
2332 return STATUS_SUCCESS
;
2335 /*****************************************************
2336 * IoCsqInitialize (NTOSKRNL.EXE.@)
2338 NTSTATUS WINAPI
IoCsqInitialize(PIO_CSQ csq
, PIO_CSQ_INSERT_IRP insert_irp
, PIO_CSQ_REMOVE_IRP remove_irp
,
2339 PIO_CSQ_PEEK_NEXT_IRP peek_irp
, PIO_CSQ_ACQUIRE_LOCK acquire_lock
,
2340 PIO_CSQ_RELEASE_LOCK release_lock
, PIO_CSQ_COMPLETE_CANCELED_IRP complete_irp
)
2342 FIXME("(%p %p %p %p %p %p %p) stub\n",
2343 csq
, insert_irp
, remove_irp
, peek_irp
, acquire_lock
, release_lock
, complete_irp
);
2344 return STATUS_SUCCESS
;
2347 /***********************************************************************
2348 * ExAcquireResourceExclusiveLite (NTOSKRNL.EXE.@)
2350 BOOLEAN WINAPI
ExAcquireResourceExclusiveLite( PERESOURCE resource
, BOOLEAN wait
)
2352 FIXME( ":%p %u stub\n", resource
, wait
);
2356 /***********************************************************************
2357 * ExDeleteResourceLite (NTOSKRNL.EXE.@)
2359 NTSTATUS WINAPI
ExDeleteResourceLite(PERESOURCE resource
)
2361 FIXME("(%p): stub\n", resource
);
2362 return STATUS_NOT_IMPLEMENTED
;
2365 /*****************************************************
2366 * ExInterlockedRemoveHeadList (NTOSKRNL.EXE.@)
2368 PLIST_ENTRY WINAPI
ExInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2370 FIXME("(%p %p) stub\n", head
, lock
);
2374 /***********************************************************************
2375 * ExfInterlockedRemoveHeadList (NTOSKRNL.EXE.@)
2377 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
2378 DEFINE_FASTCALL2_ENTRYPOINT( ExfInterlockedRemoveHeadList
)
2379 PLIST_ENTRY WINAPI
__regs_ExfInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2381 PLIST_ENTRY WINAPI
ExfInterlockedRemoveHeadList(PLIST_ENTRY head
, PKSPIN_LOCK lock
)
2384 FIXME("(%p %p) stub\n", head
, lock
);
2385 return ExInterlockedRemoveHeadList( head
, lock
);
2388 /***********************************************************************
2389 * ExReleaseResourceForThreadLite (NTOSKRNL.EXE.@)
2391 void WINAPI
ExReleaseResourceForThreadLite( PERESOURCE resource
, ERESOURCE_THREAD tid
)
2393 FIXME( "stub: %p %lu\n", resource
, tid
);
2396 /***********************************************************************
2397 * KeEnterCriticalRegion (NTOSKRNL.EXE.@)
2399 void WINAPI
KeEnterCriticalRegion(void)
2404 /***********************************************************************
2405 * KeLeaveCriticalRegion (NTOSKRNL.EXE.@)
2407 void WINAPI
KeLeaveCriticalRegion(void)
2412 /***********************************************************************
2413 * ProbeForRead (NTOSKRNL.EXE.@)
2415 void WINAPI
ProbeForRead(void *address
, SIZE_T length
, ULONG alignment
)
2417 FIXME("(%p %lu %u) stub\n", address
, length
, alignment
);
2420 /***********************************************************************
2421 * ProbeForWrite (NTOSKRNL.EXE.@)
2423 void WINAPI
ProbeForWrite(void *address
, SIZE_T length
, ULONG alignment
)
2425 FIXME("(%p %lu %u) stub\n", address
, length
, alignment
);
2428 /***********************************************************************
2429 * CmRegisterCallback (NTOSKRNL.EXE.@)
2431 NTSTATUS WINAPI
CmRegisterCallback(EX_CALLBACK_FUNCTION
*function
, void *context
, LARGE_INTEGER
*cookie
)
2433 FIXME("(%p %p %p): stub\n", function
, context
, cookie
);
2434 return STATUS_NOT_IMPLEMENTED
;
2437 /***********************************************************************
2438 * CmUnRegisterCallback (NTOSKRNL.EXE.@)
2440 NTSTATUS WINAPI
CmUnRegisterCallback(LARGE_INTEGER cookie
)
2442 FIXME("(%s): stub\n", wine_dbgstr_longlong(cookie
.QuadPart
));
2443 return STATUS_NOT_IMPLEMENTED
;