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