oleaut32: Partially implement UnRegisterTypeLibForUser.
[wine] / dlls / ntoskrnl.exe / ntoskrnl.c
1 /*
2  * ntoskrnl.exe implementation
3  *
4  * Copyright (C) 2007 Alexandre Julliard
5  * Copyright (C) 2010 Damjan Jovanovic
6  *
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.
11  *
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.
16  *
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
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdarg.h>
26
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
29
30 #include "ntstatus.h"
31 #define WIN32_NO_STATUS
32 #include "windef.h"
33 #include "winternl.h"
34 #include "excpt.h"
35 #include "ddk/ntddk.h"
36 #include "wine/unicode.h"
37 #include "wine/server.h"
38 #include "wine/list.h"
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl);
42 WINE_DECLARE_DEBUG_CHANNEL(relay);
43
44 extern LONG CALLBACK vectored_handler( EXCEPTION_POINTERS *ptrs );
45
46 KSYSTEM_TIME KeTickCount = { 0, 0, 0 };
47
48 typedef struct _KSERVICE_TABLE_DESCRIPTOR
49 {
50     PULONG_PTR Base;
51     PULONG Count;
52     ULONG Limit;
53     PUCHAR Number;
54 } KSERVICE_TABLE_DESCRIPTOR, *PKSERVICE_TABLE_DESCRIPTOR;
55
56 KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable[4] = { { 0 } };
57
58 typedef void (WINAPI *PCREATE_PROCESS_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
59 typedef void (WINAPI *PCREATE_THREAD_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
60
61 static struct list Irps = LIST_INIT(Irps);
62
63 struct IrpInstance
64 {
65     struct list entry;
66     IRP *irp;
67 };
68
69 #ifdef __i386__
70 #define DEFINE_FASTCALL1_ENTRYPOINT( name ) \
71     __ASM_STDCALL_FUNC( name, 4, \
72                        "popl %eax\n\t" \
73                        "pushl %ecx\n\t" \
74                        "pushl %eax\n\t" \
75                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(4))
76 #define DEFINE_FASTCALL2_ENTRYPOINT( name ) \
77     __ASM_STDCALL_FUNC( name, 8, \
78                        "popl %eax\n\t" \
79                        "pushl %edx\n\t" \
80                        "pushl %ecx\n\t" \
81                        "pushl %eax\n\t" \
82                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(8))
83 #define DEFINE_FASTCALL3_ENTRYPOINT( name ) \
84     __ASM_STDCALL_FUNC( name, 12, \
85                        "popl %eax\n\t" \
86                        "pushl %edx\n\t" \
87                        "pushl %ecx\n\t" \
88                        "pushl %eax\n\t" \
89                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(12))
90 #endif
91
92 static inline LPCSTR debugstr_us( const UNICODE_STRING *us )
93 {
94     if (!us) return "<null>";
95     return debugstr_wn( us->Buffer, us->Length / sizeof(WCHAR) );
96 }
97
98 static HANDLE get_device_manager(void)
99 {
100     static HANDLE device_manager;
101     HANDLE handle = 0, ret = device_manager;
102
103     if (!ret)
104     {
105         SERVER_START_REQ( create_device_manager )
106         {
107             req->access     = SYNCHRONIZE;
108             req->attributes = 0;
109             if (!wine_server_call( req )) handle = wine_server_ptr_handle( reply->handle );
110         }
111         SERVER_END_REQ;
112
113         if (!handle)
114         {
115             ERR( "failed to create the device manager\n" );
116             return 0;
117         }
118         if (!(ret = InterlockedCompareExchangePointer( &device_manager, handle, 0 )))
119             ret = handle;
120         else
121             NtClose( handle );  /* somebody beat us to it */
122     }
123     return ret;
124 }
125
126 /* process an ioctl request for a given device */
127 static NTSTATUS process_ioctl( DEVICE_OBJECT *device, ULONG code, void *in_buff, ULONG in_size,
128                                void *out_buff, ULONG *out_size )
129 {
130     IRP irp;
131     MDL mdl;
132     IO_STACK_LOCATION irpsp;
133     PDRIVER_DISPATCH dispatch = device->DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL];
134     NTSTATUS status;
135     LARGE_INTEGER count;
136
137     TRACE( "ioctl %x device %p in_size %u out_size %u\n", code, device, in_size, *out_size );
138
139     /* so we can spot things that we should initialize */
140     memset( &irp, 0x55, sizeof(irp) );
141     memset( &irpsp, 0x66, sizeof(irpsp) );
142     memset( &mdl, 0x77, sizeof(mdl) );
143
144     irp.RequestorMode = UserMode;
145     irp.AssociatedIrp.SystemBuffer = in_buff;
146     irp.UserBuffer = out_buff;
147     irp.MdlAddress = &mdl;
148     irp.Tail.Overlay.s.u2.CurrentStackLocation = &irpsp;
149     irp.UserIosb = NULL;
150
151     irpsp.MajorFunction = IRP_MJ_DEVICE_CONTROL;
152     irpsp.Parameters.DeviceIoControl.OutputBufferLength = *out_size;
153     irpsp.Parameters.DeviceIoControl.InputBufferLength = in_size;
154     irpsp.Parameters.DeviceIoControl.IoControlCode = code;
155     irpsp.Parameters.DeviceIoControl.Type3InputBuffer = in_buff;
156     irpsp.DeviceObject = device;
157     irpsp.CompletionRoutine = NULL;
158
159     mdl.Next = NULL;
160     mdl.Size = 0;
161     mdl.StartVa = out_buff;
162     mdl.ByteCount = *out_size;
163     mdl.ByteOffset = 0;
164
165     device->CurrentIrp = &irp;
166
167     KeQueryTickCount( &count );  /* update the global KeTickCount */
168
169     if (TRACE_ON(relay))
170         DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
171                  GetCurrentThreadId(), dispatch, device, &irp );
172
173     status = dispatch( device, &irp );
174
175     if (TRACE_ON(relay))
176         DPRINTF( "%04x:Ret  driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
177                  GetCurrentThreadId(), dispatch, device, &irp, status );
178
179     *out_size = (irp.IoStatus.u.Status >= 0) ? irp.IoStatus.Information : 0;
180     return irp.IoStatus.u.Status;
181 }
182
183
184 /***********************************************************************
185  *           wine_ntoskrnl_main_loop   (Not a Windows API)
186  */
187 NTSTATUS CDECL wine_ntoskrnl_main_loop( HANDLE stop_event )
188 {
189     HANDLE manager = get_device_manager();
190     obj_handle_t ioctl = 0;
191     NTSTATUS status = STATUS_SUCCESS;
192     ULONG code = 0;
193     void *in_buff, *out_buff = NULL;
194     DEVICE_OBJECT *device = NULL;
195     ULONG in_size = 4096, out_size = 0;
196     HANDLE handles[2];
197
198     if (!(in_buff = HeapAlloc( GetProcessHeap(), 0, in_size )))
199     {
200         ERR( "failed to allocate buffer\n" );
201         return STATUS_NO_MEMORY;
202     }
203
204     handles[0] = stop_event;
205     handles[1] = manager;
206
207     for (;;)
208     {
209         SERVER_START_REQ( get_next_device_request )
210         {
211             req->manager = wine_server_obj_handle( manager );
212             req->prev = ioctl;
213             req->status = status;
214             wine_server_add_data( req, out_buff, out_size );
215             wine_server_set_reply( req, in_buff, in_size );
216             if (!(status = wine_server_call( req )))
217             {
218                 code     = reply->code;
219                 ioctl    = reply->next;
220                 device   = wine_server_get_ptr( reply->user_ptr );
221                 in_size  = reply->in_size;
222                 out_size = reply->out_size;
223             }
224             else
225             {
226                 ioctl = 0; /* no previous ioctl */
227                 out_size = 0;
228                 in_size = reply->in_size;
229             }
230         }
231         SERVER_END_REQ;
232
233         switch(status)
234         {
235         case STATUS_SUCCESS:
236             HeapFree( GetProcessHeap(), 0, out_buff );
237             if (out_size) out_buff = HeapAlloc( GetProcessHeap(), 0, out_size );
238             else out_buff = NULL;
239             status = process_ioctl( device, code, in_buff, in_size, out_buff, &out_size );
240             break;
241         case STATUS_BUFFER_OVERFLOW:
242             HeapFree( GetProcessHeap(), 0, in_buff );
243             in_buff = HeapAlloc( GetProcessHeap(), 0, in_size );
244             /* restart with larger buffer */
245             break;
246         case STATUS_PENDING:
247             if (WaitForMultipleObjects( 2, handles, FALSE, INFINITE ) == WAIT_OBJECT_0)
248             {
249                 HeapFree( GetProcessHeap(), 0, in_buff );
250                 HeapFree( GetProcessHeap(), 0, out_buff );
251                 return STATUS_SUCCESS;
252             }
253             break;
254         }
255     }
256 }
257
258
259 /***********************************************************************
260  *           IoAllocateDriverObjectExtension  (NTOSKRNL.EXE.@)
261  */
262 NTSTATUS WINAPI IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject,
263                                                  PVOID ClientIdentificationAddress,
264                                                  ULONG DriverObjectExtensionSize,
265                                                  PVOID *DriverObjectExtension )
266 {
267     FIXME( "stub: %p, %p, %u, %p\n", DriverObject, ClientIdentificationAddress,
268             DriverObjectExtensionSize, DriverObjectExtension );
269     return STATUS_NOT_IMPLEMENTED;
270 }
271
272
273 /***********************************************************************
274  *           IoGetDriverObjectExtension  (NTOSKRNL.EXE.@)
275  */
276 PVOID WINAPI IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject,
277                                          PVOID ClientIdentificationAddress )
278 {
279     FIXME( "stub: %p, %p\n", DriverObject, ClientIdentificationAddress );
280     return NULL;
281 }
282
283
284 /***********************************************************************
285  *           IoInitializeIrp  (NTOSKRNL.EXE.@)
286  */
287 void WINAPI IoInitializeIrp( IRP *irp, USHORT size, CCHAR stack_size )
288 {
289     TRACE( "%p, %u, %d\n", irp, size, stack_size );
290
291     RtlZeroMemory( irp, size );
292
293     irp->Type = IO_TYPE_IRP;
294     irp->Size = size;
295     InitializeListHead( &irp->ThreadListEntry );
296     irp->StackCount = stack_size;
297     irp->CurrentLocation = stack_size + 1;
298     irp->Tail.Overlay.s.u2.CurrentStackLocation =
299             (PIO_STACK_LOCATION)(irp + 1) + stack_size;
300 }
301
302
303 /***********************************************************************
304  *           IoInitializeTimer   (NTOSKRNL.EXE.@)
305  */
306 NTSTATUS WINAPI IoInitializeTimer(PDEVICE_OBJECT DeviceObject,
307                                   PIO_TIMER_ROUTINE TimerRoutine,
308                                   PVOID Context)
309 {
310     FIXME( "stub: %p, %p, %p\n", DeviceObject, TimerRoutine, Context );
311     return STATUS_NOT_IMPLEMENTED;
312 }
313
314
315 /***********************************************************************
316  *           IoStartTimer   (NTOSKRNL.EXE.@)
317  */
318 void WINAPI IoStartTimer(PDEVICE_OBJECT DeviceObject)
319 {
320     FIXME( "stub: %p\n", DeviceObject );
321 }
322
323
324 /***********************************************************************
325  *           IoAllocateIrp  (NTOSKRNL.EXE.@)
326  */
327 PIRP WINAPI IoAllocateIrp( CCHAR stack_size, BOOLEAN charge_quota )
328 {
329     SIZE_T size;
330     PIRP irp;
331
332     TRACE( "%d, %d\n", stack_size, charge_quota );
333
334     size = sizeof(IRP) + stack_size * sizeof(IO_STACK_LOCATION);
335     irp = ExAllocatePool( NonPagedPool, size );
336     if (irp == NULL)
337         return NULL;
338     IoInitializeIrp( irp, size, stack_size );
339     irp->AllocationFlags = IRP_ALLOCATED_FIXED_SIZE;
340     if (charge_quota)
341         irp->AllocationFlags |= IRP_LOOKASIDE_ALLOCATION;
342     return irp;
343 }
344
345
346 /***********************************************************************
347  *           IoFreeIrp  (NTOSKRNL.EXE.@)
348  */
349 void WINAPI IoFreeIrp( IRP *irp )
350 {
351     TRACE( "%p\n", irp );
352
353     ExFreePool( irp );
354 }
355
356
357 /***********************************************************************
358  *           IoAllocateErrorLogEntry  (NTOSKRNL.EXE.@)
359  */
360 PVOID WINAPI IoAllocateErrorLogEntry( PVOID IoObject, UCHAR EntrySize )
361 {
362     FIXME( "stub: %p, %u\n", IoObject, EntrySize );
363     return NULL;
364 }
365
366
367 /***********************************************************************
368  *           IoAllocateMdl  (NTOSKRNL.EXE.@)
369  */
370 PMDL WINAPI IoAllocateMdl( PVOID VirtualAddress, ULONG Length, BOOLEAN SecondaryBuffer, BOOLEAN ChargeQuota, PIRP Irp )
371 {
372     FIXME( "stub: %p, %u, %i, %i, %p\n", VirtualAddress, Length, SecondaryBuffer, ChargeQuota, Irp );
373     return NULL;
374 }
375
376
377 /***********************************************************************
378  *           IoAllocateWorkItem  (NTOSKRNL.EXE.@)
379  */
380 PIO_WORKITEM WINAPI IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject )
381 {
382     FIXME( "stub: %p\n", DeviceObject );
383     return NULL;
384 }
385
386
387 /***********************************************************************
388  *           IoAttachDeviceToDeviceStack  (NTOSKRNL.EXE.@)
389  */
390 PDEVICE_OBJECT WINAPI IoAttachDeviceToDeviceStack( DEVICE_OBJECT *source,
391                                                    DEVICE_OBJECT *target )
392 {
393     TRACE( "%p, %p\n", source, target );
394     target->AttachedDevice = source;
395     source->StackSize = target->StackSize + 1;
396     return target;
397 }
398
399
400 /***********************************************************************
401  *           IoBuildDeviceIoControlRequest  (NTOSKRNL.EXE.@)
402  */
403 PIRP WINAPI IoBuildDeviceIoControlRequest( ULONG IoControlCode,
404                                            PDEVICE_OBJECT DeviceObject,
405                                            PVOID InputBuffer,
406                                            ULONG InputBufferLength,
407                                            PVOID OutputBuffer,
408                                            ULONG OutputBufferLength,
409                                            BOOLEAN InternalDeviceIoControl,
410                                            PKEVENT Event,
411                                            PIO_STATUS_BLOCK IoStatusBlock )
412 {
413     PIRP irp;
414     PIO_STACK_LOCATION irpsp;
415     struct IrpInstance *instance;
416
417     TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
418            IoControlCode, DeviceObject, InputBuffer, InputBufferLength,
419            OutputBuffer, OutputBufferLength, InternalDeviceIoControl,
420            Event, IoStatusBlock );
421
422     if (DeviceObject == NULL)
423         return NULL;
424
425     irp = IoAllocateIrp( DeviceObject->StackSize, FALSE );
426     if (irp == NULL)
427         return NULL;
428
429     instance = HeapAlloc( GetProcessHeap(), 0, sizeof(struct IrpInstance) );
430     if (instance == NULL)
431     {
432         IoFreeIrp( irp );
433         return NULL;
434     }
435     instance->irp = irp;
436     list_add_tail( &Irps, &instance->entry );
437
438     irpsp = IoGetNextIrpStackLocation( irp );
439     irpsp->MajorFunction = InternalDeviceIoControl ?
440             IRP_MJ_INTERNAL_DEVICE_CONTROL : IRP_MJ_DEVICE_CONTROL;
441     irpsp->Parameters.DeviceIoControl.IoControlCode = IoControlCode;
442     irp->UserIosb = IoStatusBlock;
443     irp->UserEvent = Event;
444
445     return irp;
446 }
447
448
449 /***********************************************************************
450  *           IoCreateDriver   (NTOSKRNL.EXE.@)
451  */
452 NTSTATUS WINAPI IoCreateDriver( UNICODE_STRING *name, PDRIVER_INITIALIZE init )
453 {
454     DRIVER_OBJECT *driver;
455     DRIVER_EXTENSION *extension;
456     NTSTATUS status;
457
458     if (!(driver = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
459                                     sizeof(*driver) + sizeof(*extension) )))
460         return STATUS_NO_MEMORY;
461
462     if ((status = RtlDuplicateUnicodeString( 1, name, &driver->DriverName )))
463     {
464         RtlFreeHeap( GetProcessHeap(), 0, driver );
465         return status;
466     }
467
468     extension = (DRIVER_EXTENSION *)(driver + 1);
469     driver->Size            = sizeof(*driver);
470     driver->DriverInit      = init;
471     driver->DriverExtension = extension;
472     extension->DriverObject   = driver;
473     extension->ServiceKeyName = driver->DriverName;
474
475     status = driver->DriverInit( driver, name );
476
477     if (status)
478     {
479         RtlFreeUnicodeString( &driver->DriverName );
480         RtlFreeHeap( GetProcessHeap(), 0, driver );
481     }
482     return status;
483 }
484
485
486 /***********************************************************************
487  *           IoDeleteDriver   (NTOSKRNL.EXE.@)
488  */
489 void WINAPI IoDeleteDriver( DRIVER_OBJECT *driver )
490 {
491     RtlFreeUnicodeString( &driver->DriverName );
492     RtlFreeHeap( GetProcessHeap(), 0, driver );
493 }
494
495
496 /***********************************************************************
497  *           IoCreateDevice   (NTOSKRNL.EXE.@)
498  */
499 NTSTATUS WINAPI IoCreateDevice( DRIVER_OBJECT *driver, ULONG ext_size,
500                                 UNICODE_STRING *name, DEVICE_TYPE type,
501                                 ULONG characteristics, BOOLEAN exclusive,
502                                 DEVICE_OBJECT **ret_device )
503 {
504     NTSTATUS status;
505     DEVICE_OBJECT *device;
506     HANDLE handle = 0;
507     HANDLE manager = get_device_manager();
508
509     TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
510            driver, ext_size, debugstr_us(name), type, characteristics, exclusive, ret_device );
511
512     if (!(device = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*device) + ext_size )))
513         return STATUS_NO_MEMORY;
514
515     SERVER_START_REQ( create_device )
516     {
517         req->access     = 0;
518         req->attributes = 0;
519         req->rootdir    = 0;
520         req->manager    = wine_server_obj_handle( manager );
521         req->user_ptr   = wine_server_client_ptr( device );
522         if (name) wine_server_add_data( req, name->Buffer, name->Length );
523         if (!(status = wine_server_call( req ))) handle = wine_server_ptr_handle( reply->handle );
524     }
525     SERVER_END_REQ;
526
527     if (status == STATUS_SUCCESS)
528     {
529         device->DriverObject    = driver;
530         device->DeviceExtension = device + 1;
531         device->DeviceType      = type;
532         device->StackSize       = 1;
533         device->Reserved        = handle;
534
535         device->NextDevice   = driver->DeviceObject;
536         driver->DeviceObject = device;
537
538         *ret_device = device;
539     }
540     else HeapFree( GetProcessHeap(), 0, device );
541
542     return status;
543 }
544
545
546 /***********************************************************************
547  *           IoDeleteDevice   (NTOSKRNL.EXE.@)
548  */
549 void WINAPI IoDeleteDevice( DEVICE_OBJECT *device )
550 {
551     NTSTATUS status;
552
553     TRACE( "%p\n", device );
554
555     SERVER_START_REQ( delete_device )
556     {
557         req->handle = wine_server_obj_handle( device->Reserved );
558         status = wine_server_call( req );
559     }
560     SERVER_END_REQ;
561
562     if (status == STATUS_SUCCESS)
563     {
564         DEVICE_OBJECT **prev = &device->DriverObject->DeviceObject;
565         while (*prev && *prev != device) prev = &(*prev)->NextDevice;
566         if (*prev) *prev = (*prev)->NextDevice;
567         NtClose( device->Reserved );
568         HeapFree( GetProcessHeap(), 0, device );
569     }
570 }
571
572
573 /***********************************************************************
574  *           IoCreateSymbolicLink   (NTOSKRNL.EXE.@)
575  */
576 NTSTATUS WINAPI IoCreateSymbolicLink( UNICODE_STRING *name, UNICODE_STRING *target )
577 {
578     HANDLE handle;
579     OBJECT_ATTRIBUTES attr;
580
581     attr.Length                   = sizeof(attr);
582     attr.RootDirectory            = 0;
583     attr.ObjectName               = name;
584     attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
585     attr.SecurityDescriptor       = NULL;
586     attr.SecurityQualityOfService = NULL;
587
588     TRACE( "%s -> %s\n", debugstr_us(name), debugstr_us(target) );
589     /* FIXME: store handle somewhere */
590     return NtCreateSymbolicLinkObject( &handle, SYMBOLIC_LINK_ALL_ACCESS, &attr, target );
591 }
592
593
594 /***********************************************************************
595  *           IoDeleteSymbolicLink   (NTOSKRNL.EXE.@)
596  */
597 NTSTATUS WINAPI IoDeleteSymbolicLink( UNICODE_STRING *name )
598 {
599     HANDLE handle;
600     OBJECT_ATTRIBUTES attr;
601     NTSTATUS status;
602
603     attr.Length                   = sizeof(attr);
604     attr.RootDirectory            = 0;
605     attr.ObjectName               = name;
606     attr.Attributes               = OBJ_CASE_INSENSITIVE;
607     attr.SecurityDescriptor       = NULL;
608     attr.SecurityQualityOfService = NULL;
609
610     if (!(status = NtOpenSymbolicLinkObject( &handle, 0, &attr )))
611     {
612         SERVER_START_REQ( unlink_object )
613         {
614             req->handle = wine_server_obj_handle( handle );
615             status = wine_server_call( req );
616         }
617         SERVER_END_REQ;
618         NtClose( handle );
619     }
620     return status;
621 }
622
623
624 /***********************************************************************
625  *           IoGetDeviceObjectPointer   (NTOSKRNL.EXE.@)
626  */
627 NTSTATUS  WINAPI IoGetDeviceObjectPointer( UNICODE_STRING *name, ACCESS_MASK access, PFILE_OBJECT *file, PDEVICE_OBJECT *device )
628 {
629     FIXME( "stub: %s %x %p %p\n", debugstr_us(name), access, file, device );
630     return STATUS_NOT_IMPLEMENTED;
631 }
632
633
634 /***********************************************************************
635  *           IoGetDeviceProperty   (NTOSKRNL.EXE.@)
636  */
637 NTSTATUS WINAPI IoGetDeviceProperty( DEVICE_OBJECT *device, DEVICE_REGISTRY_PROPERTY device_property,
638                                      ULONG buffer_length, PVOID property_buffer, PULONG result_length )
639 {
640     FIXME( "%p %d %u %p %p: stub\n", device, device_property, buffer_length,
641            property_buffer, result_length );
642     return STATUS_NOT_IMPLEMENTED;
643 }
644
645
646 /***********************************************************************
647  *           IoCallDriver   (NTOSKRNL.EXE.@)
648  */
649 NTSTATUS WINAPI IoCallDriver( DEVICE_OBJECT *device, IRP *irp )
650 {
651     PDRIVER_DISPATCH dispatch;
652     IO_STACK_LOCATION *irpsp;
653     NTSTATUS status;
654
655     TRACE( "%p %p\n", device, irp );
656
657     --irp->CurrentLocation;
658     irpsp = --irp->Tail.Overlay.s.u2.CurrentStackLocation;
659     dispatch = device->DriverObject->MajorFunction[irpsp->MajorFunction];
660     status = dispatch( device, irp );
661
662     return status;
663 }
664
665
666 /***********************************************************************
667  *           IofCallDriver   (NTOSKRNL.EXE.@)
668  */
669 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
670 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver )
671 NTSTATUS WINAPI __regs_IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
672 #else
673 NTSTATUS WINAPI IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
674 #endif
675 {
676     TRACE( "%p %p\n", device, irp );
677     return IoCallDriver( device, irp );
678 }
679
680
681 /***********************************************************************
682  *           IoGetRelatedDeviceObject    (NTOSKRNL.EXE.@)
683  */
684 PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject( PFILE_OBJECT obj )
685 {
686     FIXME( "stub: %p\n", obj );
687     return NULL;
688 }
689
690 static CONFIGURATION_INFORMATION configuration_information;
691
692 /***********************************************************************
693  *           IoGetConfigurationInformation    (NTOSKRNL.EXE.@)
694  */
695 PCONFIGURATION_INFORMATION WINAPI IoGetConfigurationInformation(void)
696 {
697     FIXME( "partial stub\n" );
698     /* FIXME: return actual devices on system */
699     return &configuration_information;
700 }
701
702
703 /***********************************************************************
704  *           IoIsWdmVersionAvailable     (NTOSKRNL.EXE.@)
705  */
706 NTSTATUS WINAPI IoIsWdmVersionAvailable(UCHAR MajorVersion, UCHAR MinorVersion)
707 {
708     DWORD version;
709     DWORD major;
710     DWORD minor;
711
712     TRACE( "%d, 0x%X\n", MajorVersion, MinorVersion );
713
714     version = GetVersion();
715     major = LOBYTE(version);
716     minor = HIBYTE(LOWORD(version));
717
718     if (MajorVersion == 6 && MinorVersion == 0)
719     {
720         /* Windows Vista, Windows Server 2008, Windows 7 */
721     }
722     else if (MajorVersion == 1)
723     {
724         if (MinorVersion == 0x30)
725         {
726             /* Windows server 2003 */
727             MajorVersion = 6;
728             MinorVersion = 0;
729         }
730         else if (MinorVersion == 0x20)
731         {
732             /* Windows XP */
733             MajorVersion = 5;
734             MinorVersion = 1;
735         }
736         else if (MinorVersion == 0x10)
737         {
738             /* Windows 2000 */
739             MajorVersion = 5;
740             MinorVersion = 0;
741         }
742         else if (MinorVersion == 0x05)
743         {
744             /* Windows ME */
745             MajorVersion = 4;
746             MinorVersion = 0x5a;
747         }
748         else if (MinorVersion == 0x00)
749         {
750             /* Windows 98 */
751             MajorVersion = 4;
752             MinorVersion = 0x0a;
753         }
754         else
755         {
756             FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
757             return FALSE;
758         }
759     }
760     else
761     {
762         FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
763         return FALSE;
764     }
765     return major > MajorVersion || (major == MajorVersion && minor >= MinorVersion);
766 }
767
768
769 /***********************************************************************
770  *           IoQueryDeviceDescription    (NTOSKRNL.EXE.@)
771  */
772 NTSTATUS WINAPI IoQueryDeviceDescription(PINTERFACE_TYPE itype, PULONG bus, PCONFIGURATION_TYPE ctype,
773                                      PULONG cnum, PCONFIGURATION_TYPE ptype, PULONG pnum,
774                                      PIO_QUERY_DEVICE_ROUTINE callout, PVOID context)
775 {
776     FIXME( "(%p %p %p %p %p %p %p %p)\n", itype, bus, ctype, cnum, ptype, pnum, callout, context);
777     return STATUS_NOT_IMPLEMENTED;
778 }
779
780
781 /***********************************************************************
782  *           IoRegisterDriverReinitialization    (NTOSKRNL.EXE.@)
783  */
784 void WINAPI IoRegisterDriverReinitialization( PDRIVER_OBJECT obj, PDRIVER_REINITIALIZE reinit, PVOID context )
785 {
786     FIXME( "stub: %p %p %p\n", obj, reinit, context );
787 }
788
789
790 /***********************************************************************
791  *           IoRegisterShutdownNotification    (NTOSKRNL.EXE.@)
792  */
793 NTSTATUS WINAPI IoRegisterShutdownNotification( PDEVICE_OBJECT obj )
794 {
795     FIXME( "stub: %p\n", obj );
796     return STATUS_SUCCESS;
797 }
798
799
800 /***********************************************************************
801  *           IoReportResourceUsage    (NTOSKRNL.EXE.@)
802  */
803 NTSTATUS WINAPI IoReportResourceUsage(PUNICODE_STRING name, PDRIVER_OBJECT drv_obj, PCM_RESOURCE_LIST drv_list,
804                                       ULONG drv_size, PDRIVER_OBJECT dev_obj, PCM_RESOURCE_LIST dev_list,
805                                       ULONG dev_size, BOOLEAN overwrite, PBOOLEAN detected)
806 {
807     FIXME("(%s %p %p %u %p %p %u %d %p) stub\n", debugstr_w(name? name->Buffer : NULL),
808           drv_obj, drv_list, drv_size, dev_obj, dev_list, dev_size, overwrite, detected);
809     return STATUS_NOT_IMPLEMENTED;
810 }
811
812
813 /***********************************************************************
814  *           IoCompleteRequest   (NTOSKRNL.EXE.@)
815  */
816 VOID WINAPI IoCompleteRequest( IRP *irp, UCHAR priority_boost )
817 {
818     IO_STACK_LOCATION *irpsp;
819     PIO_COMPLETION_ROUTINE routine;
820     IO_STATUS_BLOCK *iosb;
821     struct IrpInstance *instance;
822     NTSTATUS status, stat;
823     int call_flag = 0;
824
825     TRACE( "%p %u\n", irp, priority_boost );
826
827     iosb = irp->UserIosb;
828     status = irp->IoStatus.u.Status;
829     while (irp->CurrentLocation <= irp->StackCount)
830     {
831         irpsp = irp->Tail.Overlay.s.u2.CurrentStackLocation;
832         routine = irpsp->CompletionRoutine;
833         call_flag = 0;
834         /* FIXME: add SL_INVOKE_ON_CANCEL support */
835         if (routine)
836         {
837             if ((irpsp->Control & SL_INVOKE_ON_SUCCESS) && STATUS_SUCCESS == status)
838                 call_flag = 1;
839             if ((irpsp->Control & SL_INVOKE_ON_ERROR) && STATUS_SUCCESS != status)
840                 call_flag = 1;
841         }
842         ++irp->CurrentLocation;
843         ++irp->Tail.Overlay.s.u2.CurrentStackLocation;
844         if (call_flag)
845         {
846             TRACE( "calling %p( %p, %p, %p )\n", routine,
847                     irpsp->DeviceObject, irp, irpsp->Context );
848             stat = routine( irpsp->DeviceObject, irp, irpsp->Context );
849             TRACE( "CompletionRoutine returned %x\n", stat );
850             if (STATUS_MORE_PROCESSING_REQUIRED == stat)
851                 return;
852         }
853     }
854     if (iosb && STATUS_SUCCESS == status)
855     {
856         iosb->u.Status = irp->IoStatus.u.Status;
857         iosb->Information = irp->IoStatus.Information;
858     }
859     LIST_FOR_EACH_ENTRY( instance, &Irps, struct IrpInstance, entry )
860     {
861         if (instance->irp == irp)
862         {
863             list_remove( &instance->entry );
864             HeapFree( GetProcessHeap(), 0, instance );
865             IoFreeIrp( irp );
866             break;
867         }
868     }
869 }
870
871
872 /***********************************************************************
873  *           IofCompleteRequest   (NTOSKRNL.EXE.@)
874  */
875 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
876 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest )
877 void WINAPI __regs_IofCompleteRequest( IRP *irp, UCHAR priority_boost )
878 #else
879 void WINAPI IofCompleteRequest( IRP *irp, UCHAR priority_boost )
880 #endif
881 {
882     TRACE( "%p %u\n", irp, priority_boost );
883     IoCompleteRequest( irp, priority_boost );
884 }
885
886
887 /***********************************************************************
888  *           InterlockedCompareExchange   (NTOSKRNL.EXE.@)
889  */
890 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
891 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange )
892 LONG WINAPI __regs_NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
893 #else
894 LONG WINAPI NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
895 #endif
896 {
897     return InterlockedCompareExchange( dest, xchg, compare );
898 }
899
900
901 /***********************************************************************
902  *           InterlockedDecrement   (NTOSKRNL.EXE.@)
903  */
904 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
905 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement )
906 LONG WINAPI __regs_NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
907 #else
908 LONG WINAPI NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
909 #endif
910 {
911     return InterlockedDecrement( dest );
912 }
913
914
915 /***********************************************************************
916  *           InterlockedExchange   (NTOSKRNL.EXE.@)
917  */
918 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
919 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange )
920 LONG WINAPI __regs_NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
921 #else
922 LONG WINAPI NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
923 #endif
924 {
925     return InterlockedExchange( dest, val );
926 }
927
928
929 /***********************************************************************
930  *           InterlockedExchangeAdd   (NTOSKRNL.EXE.@)
931  */
932 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
933 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd )
934 LONG WINAPI __regs_NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
935 #else
936 LONG WINAPI NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
937 #endif
938 {
939     return InterlockedExchangeAdd( dest, incr );
940 }
941
942
943 /***********************************************************************
944  *           InterlockedIncrement   (NTOSKRNL.EXE.@)
945  */
946 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
947 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement )
948 LONG WINAPI __regs_NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
949 #else
950 LONG WINAPI NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
951 #endif
952 {
953     return InterlockedIncrement( dest );
954 }
955
956
957 /***********************************************************************
958  *           ExAllocatePool   (NTOSKRNL.EXE.@)
959  */
960 PVOID WINAPI ExAllocatePool( POOL_TYPE type, SIZE_T size )
961 {
962     return ExAllocatePoolWithTag( type, size, 0 );
963 }
964
965
966 /***********************************************************************
967  *           ExAllocatePoolWithQuota   (NTOSKRNL.EXE.@)
968  */
969 PVOID WINAPI ExAllocatePoolWithQuota( POOL_TYPE type, SIZE_T size )
970 {
971     return ExAllocatePoolWithTag( type, size, 0 );
972 }
973
974
975 /***********************************************************************
976  *           ExAllocatePoolWithTag   (NTOSKRNL.EXE.@)
977  */
978 PVOID WINAPI ExAllocatePoolWithTag( POOL_TYPE type, SIZE_T size, ULONG tag )
979 {
980     /* FIXME: handle page alignment constraints */
981     void *ret = HeapAlloc( GetProcessHeap(), 0, size );
982     TRACE( "%lu pool %u -> %p\n", size, type, ret );
983     return ret;
984 }
985
986
987 /***********************************************************************
988  *           ExAllocatePoolWithQuotaTag   (NTOSKRNL.EXE.@)
989  */
990 PVOID WINAPI ExAllocatePoolWithQuotaTag( POOL_TYPE type, SIZE_T size, ULONG tag )
991 {
992     return ExAllocatePoolWithTag( type, size, tag );
993 }
994
995
996 /***********************************************************************
997  *           ExFreePool   (NTOSKRNL.EXE.@)
998  */
999 void WINAPI ExFreePool( void *ptr )
1000 {
1001     ExFreePoolWithTag( ptr, 0 );
1002 }
1003
1004
1005 /***********************************************************************
1006  *           ExFreePoolWithTag   (NTOSKRNL.EXE.@)
1007  */
1008 void WINAPI ExFreePoolWithTag( void *ptr, ULONG tag )
1009 {
1010     TRACE( "%p\n", ptr );
1011     HeapFree( GetProcessHeap(), 0, ptr );
1012 }
1013
1014
1015 /***********************************************************************
1016  *           ExInitializeResourceLite   (NTOSKRNL.EXE.@)
1017  */
1018 NTSTATUS WINAPI ExInitializeResourceLite(PERESOURCE Resource)
1019 {
1020     FIXME( "stub: %p\n", Resource );
1021     return STATUS_NOT_IMPLEMENTED;
1022 }
1023
1024
1025 /***********************************************************************
1026  *           ExInitializeNPagedLookasideList   (NTOSKRNL.EXE.@)
1027  */
1028 void WINAPI ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
1029                                             PALLOCATE_FUNCTION Allocate,
1030                                             PFREE_FUNCTION Free,
1031                                             ULONG Flags,
1032                                             SIZE_T Size,
1033                                             ULONG Tag,
1034                                             USHORT Depth)
1035 {
1036     FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1037 }
1038
1039
1040 /***********************************************************************
1041  *           ExInitializeZone   (NTOSKRNL.EXE.@)
1042  */
1043 NTSTATUS WINAPI ExInitializeZone(PZONE_HEADER Zone,
1044                                  ULONG BlockSize,
1045                                  PVOID InitialSegment,
1046                                  ULONG InitialSegmentSize)
1047 {
1048     FIXME( "stub: %p, %u, %p, %u\n", Zone, BlockSize, InitialSegment, InitialSegmentSize );
1049     return STATUS_NOT_IMPLEMENTED;
1050 }
1051
1052 /***********************************************************************
1053 *           FsRtlRegisterUncProvider   (NTOSKRNL.EXE.@)
1054 */
1055 NTSTATUS WINAPI FsRtlRegisterUncProvider(PHANDLE MupHandle, PUNICODE_STRING RedirDevName,
1056                                          BOOLEAN MailslotsSupported)
1057 {
1058     FIXME("(%p %p %d): stub\n", MupHandle, RedirDevName, MailslotsSupported);
1059     return STATUS_NOT_IMPLEMENTED;
1060 }
1061
1062 /***********************************************************************
1063  *           KeGetCurrentThread / PsGetCurrentThread   (NTOSKRNL.EXE.@)
1064  */
1065 PRKTHREAD WINAPI KeGetCurrentThread(void)
1066 {
1067     FIXME("() stub\n");
1068     return NULL;
1069 }
1070
1071 /***********************************************************************
1072  *           KeInitializeEvent   (NTOSKRNL.EXE.@)
1073  */
1074 void WINAPI KeInitializeEvent( PRKEVENT Event, EVENT_TYPE Type, BOOLEAN State )
1075 {
1076     FIXME( "stub: %p %d %d\n", Event, Type, State );
1077 }
1078
1079
1080  /***********************************************************************
1081  *           KeInitializeMutex   (NTOSKRNL.EXE.@)
1082  */
1083 void WINAPI KeInitializeMutex(PRKMUTEX Mutex, ULONG Level)
1084 {
1085     FIXME( "stub: %p, %u\n", Mutex, Level );
1086 }
1087
1088
1089 /***********************************************************************
1090  *           KeInitializeSemaphore   (NTOSKRNL.EXE.@)
1091  */
1092 void WINAPI KeInitializeSemaphore( PRKSEMAPHORE Semaphore, LONG Count, LONG Limit )
1093 {
1094     FIXME( "(%p %d %d) stub\n", Semaphore , Count, Limit );
1095 }
1096
1097
1098 /***********************************************************************
1099  *           KeInitializeSpinLock   (NTOSKRNL.EXE.@)
1100  */
1101 void WINAPI KeInitializeSpinLock( PKSPIN_LOCK SpinLock )
1102 {
1103     FIXME( "stub: %p\n", SpinLock );
1104 }
1105
1106
1107 /***********************************************************************
1108  *           KeInitializeTimerEx   (NTOSKRNL.EXE.@)
1109  */
1110 void WINAPI KeInitializeTimerEx( PKTIMER Timer, TIMER_TYPE Type )
1111 {
1112     FIXME( "stub: %p %d\n", Timer, Type );
1113 }
1114
1115
1116 /***********************************************************************
1117  *           KeInitializeTimer   (NTOSKRNL.EXE.@)
1118  */
1119 void WINAPI KeInitializeTimer( PKTIMER Timer )
1120 {
1121     KeInitializeTimerEx(Timer, NotificationTimer);
1122 }
1123
1124
1125 /**********************************************************************
1126  *           KeQueryActiveProcessors   (NTOSKRNL.EXE.@)
1127  *
1128  * Return the active Processors as bitmask
1129  *
1130  * RETURNS
1131  *   active Processors as bitmask
1132  *
1133  */
1134 KAFFINITY WINAPI KeQueryActiveProcessors( void )
1135 {
1136     DWORD_PTR AffinityMask;
1137
1138     GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask, NULL);
1139     return AffinityMask;
1140 }
1141
1142
1143 /**********************************************************************
1144  *           KeQueryInterruptTime   (NTOSKRNL.EXE.@)
1145  *
1146  * Return the interrupt time count
1147  *
1148  */
1149 ULONGLONG WINAPI KeQueryInterruptTime( void )
1150 {
1151     LARGE_INTEGER totaltime;
1152
1153     KeQueryTickCount(&totaltime);
1154     return totaltime.QuadPart;
1155 }
1156
1157
1158 /***********************************************************************
1159  *           KeQuerySystemTime   (NTOSKRNL.EXE.@)
1160  */
1161 void WINAPI KeQuerySystemTime( LARGE_INTEGER *time )
1162 {
1163     NtQuerySystemTime( time );
1164 }
1165
1166
1167 /***********************************************************************
1168  *           KeQueryTickCount   (NTOSKRNL.EXE.@)
1169  */
1170 void WINAPI KeQueryTickCount( LARGE_INTEGER *count )
1171 {
1172     count->QuadPart = NtGetTickCount();
1173     /* update the global variable too */
1174     KeTickCount.LowPart   = count->u.LowPart;
1175     KeTickCount.High1Time = count->u.HighPart;
1176     KeTickCount.High2Time = count->u.HighPart;
1177 }
1178
1179
1180 /***********************************************************************
1181  *           KeReleaseSemaphore   (NTOSKRNL.EXE.@)
1182  */
1183 LONG WINAPI KeReleaseSemaphore( PRKSEMAPHORE Semaphore, KPRIORITY Increment,
1184                                 LONG Adjustment, BOOLEAN Wait )
1185 {
1186     FIXME("(%p %d %d %d) stub\n", Semaphore, Increment, Adjustment, Wait );
1187     return 0;
1188 }
1189
1190
1191 /***********************************************************************
1192  *           KeQueryTimeIncrement   (NTOSKRNL.EXE.@)
1193  */
1194 ULONG WINAPI KeQueryTimeIncrement(void)
1195 {
1196     return 10000;
1197 }
1198
1199
1200 /***********************************************************************
1201  *           KeResetEvent   (NTOSKRNL.EXE.@)
1202  */
1203 LONG WINAPI KeResetEvent( PRKEVENT Event )
1204 {
1205     FIXME("(%p): stub\n", Event);
1206     return 0;
1207 }
1208
1209
1210 /***********************************************************************
1211  *           KeSetEvent   (NTOSKRNL.EXE.@)
1212  */
1213 LONG WINAPI KeSetEvent( PRKEVENT Event, KPRIORITY Increment, BOOLEAN Wait )
1214 {
1215     FIXME("(%p, %d, %d): stub\n", Event, Increment, Wait);
1216     return 0;
1217 }
1218
1219
1220 /***********************************************************************
1221  *           KeSetPriorityThread   (NTOSKRNL.EXE.@)
1222  */
1223 KPRIORITY WINAPI KeSetPriorityThread( PKTHREAD Thread, KPRIORITY Priority )
1224 {
1225     FIXME("(%p %d)\n", Thread, Priority);
1226     return Priority;
1227 }
1228
1229
1230 /***********************************************************************
1231  *           KeWaitForSingleObject   (NTOSKRNL.EXE.@)
1232  */
1233 NTSTATUS WINAPI KeWaitForSingleObject(PVOID Object,
1234                                       KWAIT_REASON WaitReason,
1235                                       KPROCESSOR_MODE WaitMode,
1236                                       BOOLEAN Alertable,
1237                                       PLARGE_INTEGER Timeout)
1238 {
1239     FIXME( "stub: %p, %d, %d, %d, %p\n", Object, WaitReason, WaitMode, Alertable, Timeout );
1240     return STATUS_NOT_IMPLEMENTED;
1241 }
1242
1243 /***********************************************************************
1244  *           IoRegisterFileSystem   (NTOSKRNL.EXE.@)
1245  */
1246 VOID WINAPI IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject)
1247 {
1248     FIXME("(%p): stub\n", DeviceObject);
1249 }
1250
1251 /***********************************************************************
1252 *           IoUnregisterFileSystem   (NTOSKRNL.EXE.@)
1253 */
1254 VOID WINAPI IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject)
1255 {
1256     FIXME("(%p): stub\n", DeviceObject);
1257 }
1258
1259 /***********************************************************************
1260  *           MmAllocateNonCachedMemory   (NTOSKRNL.EXE.@)
1261  */
1262 PVOID WINAPI MmAllocateNonCachedMemory( SIZE_T size )
1263 {
1264     TRACE( "%lu\n", size );
1265     return VirtualAlloc( NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE|PAGE_NOCACHE );
1266 }
1267
1268 /***********************************************************************
1269  *           MmAllocateContiguousMemory   (NTOSKRNL.EXE.@)
1270  */
1271 PVOID WINAPI MmAllocateContiguousMemory( SIZE_T size, PHYSICAL_ADDRESS highest_valid_address )
1272 {
1273     FIXME( "%lu, %s stub\n", size, wine_dbgstr_longlong(highest_valid_address.QuadPart) );
1274     return NULL;
1275 }
1276
1277 /***********************************************************************
1278  *           MmAllocateContiguousMemorySpecifyCache   (NTOSKRNL.EXE.@)
1279  */
1280 PVOID WINAPI MmAllocateContiguousMemorySpecifyCache( SIZE_T size,
1281                                                      PHYSICAL_ADDRESS lowest_valid_address,
1282                                                      PHYSICAL_ADDRESS highest_valid_address,
1283                                                      PHYSICAL_ADDRESS BoundaryAddressMultiple,
1284                                                      MEMORY_CACHING_TYPE CacheType )
1285 {
1286     FIXME(": stub\n");
1287     return NULL;
1288 }
1289
1290 /***********************************************************************
1291  *           MmAllocatePagesForMdl   (NTOSKRNL.EXE.@)
1292  */
1293 PMDL WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress, PHYSICAL_ADDRESS highaddress,
1294                                   PHYSICAL_ADDRESS skipbytes, SIZE_T size)
1295 {
1296     FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress.QuadPart), wine_dbgstr_longlong(highaddress.QuadPart),
1297                                   wine_dbgstr_longlong(skipbytes.QuadPart), size);
1298     return NULL;
1299 }
1300
1301 /***********************************************************************
1302  *           MmFreeNonCachedMemory   (NTOSKRNL.EXE.@)
1303  */
1304 void WINAPI MmFreeNonCachedMemory( void *addr, SIZE_T size )
1305 {
1306     TRACE( "%p %lu\n", addr, size );
1307     VirtualFree( addr, 0, MEM_RELEASE );
1308 }
1309
1310 /***********************************************************************
1311  *           MmIsAddressValid   (NTOSKRNL.EXE.@)
1312  *
1313  * Check if the process can access the virtual address without a pagefault
1314  *
1315  * PARAMS
1316  *  VirtualAddress [I] Address to check
1317  *
1318  * RETURNS
1319  *  Failure: FALSE
1320  *  Success: TRUE  (Accessing the Address works without a Pagefault)
1321  *
1322  */
1323 BOOLEAN WINAPI MmIsAddressValid(PVOID VirtualAddress)
1324 {
1325     TRACE("(%p)\n", VirtualAddress);
1326     return !IsBadWritePtr(VirtualAddress, 1);
1327 }
1328
1329 /***********************************************************************
1330  *           MmMapIoSpace   (NTOSKRNL.EXE.@)
1331  */
1332 PVOID WINAPI MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress, DWORD NumberOfBytes, DWORD CacheType )
1333 {
1334     FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress.u.HighPart, PhysicalAddress.u.LowPart, NumberOfBytes, CacheType );
1335     return NULL;
1336 }
1337
1338 /***********************************************************************
1339  *           MmPageEntireDriver   (NTOSKRNL.EXE.@)
1340  */
1341 PVOID WINAPI MmPageEntireDriver(PVOID AddrInSection)
1342 {
1343     TRACE("%p\n", AddrInSection);
1344     return AddrInSection;
1345 }
1346
1347 /***********************************************************************
1348  *           MmResetDriverPaging   (NTOSKRNL.EXE.@)
1349  */
1350 void WINAPI MmResetDriverPaging(PVOID AddrInSection)
1351 {
1352     TRACE("%p\n", AddrInSection);
1353 }
1354
1355 /***********************************************************************
1356  *           MmUnmapIoSpace   (NTOSKRNL.EXE.@)
1357  */
1358 VOID WINAPI MmUnmapIoSpace( PVOID BaseAddress, SIZE_T NumberOfBytes )
1359 {
1360     FIXME( "stub: %p, %lu\n", BaseAddress, NumberOfBytes );
1361 }
1362
1363 /***********************************************************************
1364  *           ObfReferenceObject   (NTOSKRNL.EXE.@)
1365  */
1366 VOID WINAPI ObfReferenceObject(PVOID Object)
1367 {
1368     FIXME("(%p): stub\n", Object);
1369 }
1370
1371  /***********************************************************************
1372  *           ObReferenceObjectByHandle    (NTOSKRNL.EXE.@)
1373  */
1374 NTSTATUS WINAPI ObReferenceObjectByHandle( HANDLE obj, ACCESS_MASK access,
1375                                            POBJECT_TYPE type,
1376                                            KPROCESSOR_MODE mode, PVOID* ptr,
1377                                            POBJECT_HANDLE_INFORMATION info)
1378 {
1379     FIXME( "stub: %p %x %p %d %p %p\n", obj, access, type, mode, ptr, info);
1380     return STATUS_NOT_IMPLEMENTED;
1381 }
1382
1383
1384 /***********************************************************************
1385  *           ObfDereferenceObject   (NTOSKRNL.EXE.@)
1386  */
1387 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1388 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject )
1389 void WINAPI __regs_ObfDereferenceObject( VOID *obj )
1390 #else
1391 void WINAPI ObfDereferenceObject( VOID *obj )
1392 #endif
1393 {
1394     FIXME( "stub: %p\n", obj );
1395 }
1396
1397
1398 /***********************************************************************
1399  *           PsCreateSystemThread   (NTOSKRNL.EXE.@)
1400  */
1401 NTSTATUS WINAPI PsCreateSystemThread(PHANDLE ThreadHandle, ULONG DesiredAccess,
1402                                      POBJECT_ATTRIBUTES ObjectAttributes,
1403                                      HANDLE ProcessHandle, PCLIENT_ID ClientId,
1404                                      PKSTART_ROUTINE StartRoutine, PVOID StartContext)
1405 {
1406     if (!ProcessHandle) ProcessHandle = GetCurrentProcess();
1407     return RtlCreateUserThread(ProcessHandle, 0, FALSE, 0, 0,
1408                                0, StartRoutine, StartContext,
1409                                ThreadHandle, ClientId);
1410 }
1411
1412 /***********************************************************************
1413  *           PsGetCurrentProcessId   (NTOSKRNL.EXE.@)
1414  */
1415 HANDLE WINAPI PsGetCurrentProcessId(void)
1416 {
1417     return UlongToHandle(GetCurrentProcessId());  /* FIXME: not quite right... */
1418 }
1419
1420
1421 /***********************************************************************
1422  *           PsGetCurrentThreadId   (NTOSKRNL.EXE.@)
1423  */
1424 HANDLE WINAPI PsGetCurrentThreadId(void)
1425 {
1426     return UlongToHandle(GetCurrentThreadId());  /* FIXME: not quite right... */
1427 }
1428
1429
1430 /***********************************************************************
1431  *           PsGetVersion   (NTOSKRNL.EXE.@)
1432  */
1433 BOOLEAN WINAPI PsGetVersion(ULONG *major, ULONG *minor, ULONG *build, UNICODE_STRING *version )
1434 {
1435     RTL_OSVERSIONINFOEXW info;
1436
1437     info.dwOSVersionInfoSize = sizeof(info);
1438     RtlGetVersion( &info );
1439     if (major) *major = info.dwMajorVersion;
1440     if (minor) *minor = info.dwMinorVersion;
1441     if (build) *build = info.dwBuildNumber;
1442
1443     if (version)
1444     {
1445 #if 0  /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
1446         size_t len = min( strlenW(info.szCSDVersion)*sizeof(WCHAR), version->MaximumLength );
1447         memcpy( version->Buffer, info.szCSDVersion, len );
1448         if (len < version->MaximumLength) version->Buffer[len / sizeof(WCHAR)] = 0;
1449         version->Length = len;
1450 #endif
1451     }
1452     return TRUE;
1453 }
1454
1455
1456 /***********************************************************************
1457  *           PsSetCreateProcessNotifyRoutine   (NTOSKRNL.EXE.@)
1458  */
1459 NTSTATUS WINAPI PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback, BOOLEAN remove )
1460 {
1461     FIXME( "stub: %p %d\n", callback, remove );
1462     return STATUS_SUCCESS;
1463 }
1464
1465
1466 /***********************************************************************
1467  *           PsSetCreateThreadNotifyRoutine   (NTOSKRNL.EXE.@)
1468  */
1469 NTSTATUS WINAPI PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
1470 {
1471     FIXME( "stub: %p\n", NotifyRoutine );
1472     return STATUS_SUCCESS;
1473 }
1474
1475
1476 /***********************************************************************
1477  *           PsTerminateSystemThread   (NTOSKRNL.EXE.@)
1478  */
1479 NTSTATUS WINAPI PsTerminateSystemThread(NTSTATUS ExitStatus)
1480 {
1481     FIXME( "stub: %u\n", ExitStatus );
1482     return STATUS_NOT_IMPLEMENTED;
1483 }
1484
1485
1486 /***********************************************************************
1487  *           MmGetSystemRoutineAddress   (NTOSKRNL.EXE.@)
1488  */
1489 PVOID WINAPI MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName)
1490 {
1491     HMODULE hMod;
1492     STRING routineNameA;
1493     PVOID pFunc = NULL;
1494
1495     static const WCHAR ntoskrnlW[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
1496     static const WCHAR halW[] = {'h','a','l','.','d','l','l',0};
1497
1498     if (!SystemRoutineName) return NULL;
1499
1500     if (RtlUnicodeStringToAnsiString( &routineNameA, SystemRoutineName, TRUE ) == STATUS_SUCCESS)
1501     {
1502         /* We only support functions exported from ntoskrnl.exe or hal.dll */
1503         hMod = GetModuleHandleW( ntoskrnlW );
1504         pFunc = GetProcAddress( hMod, routineNameA.Buffer );
1505         if (!pFunc)
1506         {
1507            hMod = GetModuleHandleW( halW );
1508            if (hMod) pFunc = GetProcAddress( hMod, routineNameA.Buffer );
1509         }
1510         RtlFreeAnsiString( &routineNameA );
1511     }
1512
1513     TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName), pFunc );
1514     return pFunc;
1515 }
1516
1517
1518 /***********************************************************************
1519  *           MmQuerySystemSize   (NTOSKRNL.EXE.@)
1520  */
1521 MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void)
1522 {
1523     FIXME("stub\n");
1524     return MmLargeSystem;
1525 }
1526
1527
1528 /*****************************************************
1529  *           DllMain
1530  */
1531 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
1532 {
1533     static void *handler;
1534     LARGE_INTEGER count;
1535
1536     switch(reason)
1537     {
1538     case DLL_PROCESS_ATTACH:
1539         DisableThreadLibraryCalls( inst );
1540 #ifdef __i386__
1541         handler = RtlAddVectoredExceptionHandler( TRUE, vectored_handler );
1542 #endif
1543         KeQueryTickCount( &count );  /* initialize the global KeTickCount */
1544         break;
1545     case DLL_PROCESS_DETACH:
1546         RtlRemoveVectoredExceptionHandler( handler );
1547         break;
1548     }
1549     return TRUE;
1550 }