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