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