text: /*
   * ntoskrnl.exe implementation
   *
   * Copyright (C) 2007 Alexandre Julliard
   * Copyright (C) 2010 Damjan Jovanovic
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
   */
  
  #include "config.h"
  #include "wine/port.h"
  
  #include <stdarg.h>
  
  #define NONAMELESSUNION
  #define NONAMELESSSTRUCT
  
  #include "ntstatus.h"
  #define WIN32_NO_STATUS
  #include "windef.h"
  #include "winternl.h"
  #include "excpt.h"
  #include "winioctl.h"
  #include "ddk/csq.h"
  #include "ddk/ntddk.h"
  #include "ddk/ntifs.h"
  #include "wine/unicode.h"
  #include "wine/server.h"
  #include "wine/list.h"
  #include "wine/debug.h"
  
  WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl);
  WINE_DECLARE_DEBUG_CHANNEL(relay);
  
  BOOLEAN KdDebuggerEnabled = FALSE;
  ULONG InitSafeBootMode = 0;
  
  extern LONG CALLBACK vectored_handler( EXCEPTION_POINTERS *ptrs );
  
  KSYSTEM_TIME KeTickCount = { 0, 0, 0 };
  
  typedef struct _KSERVICE_TABLE_DESCRIPTOR
  {
      PULONG_PTR Base;
      PULONG Count;
      ULONG Limit;
      PUCHAR Number;
  } KSERVICE_TABLE_DESCRIPTOR, *PKSERVICE_TABLE_DESCRIPTOR;
  
  KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable[4] = { { 0 } };
  
  typedef void (WINAPI *PCREATE_PROCESS_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
  typedef void (WINAPI *PCREATE_THREAD_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
  
  static struct list Irps = LIST_INIT(Irps);
  
  struct IrpInstance
  {
      struct list entry;
      IRP *irp;
  };
  
  /* tid of the thread running client request */
  static DWORD request_thread;
  
  /* pid/tid of the client thread */
  static DWORD client_tid;
  static DWORD client_pid;
  
  #ifdef __i386__
  #define DEFINE_FASTCALL1_ENTRYPOINT( name ) \
      __ASM_STDCALL_FUNC( name, 4, \
                         "popl %eax\n\t" \
                         "pushl %ecx\n\t" \
                         "pushl %eax\n\t" \
                         "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(4))
  #define DEFINE_FASTCALL2_ENTRYPOINT( name ) \
      __ASM_STDCALL_FUNC( name, 8, \
                         "popl %eax\n\t" \
                         "pushl %edx\n\t" \
                         "pushl %ecx\n\t" \
                         "pushl %eax\n\t" \
                         "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(8))
  #define DEFINE_FASTCALL3_ENTRYPOINT( name ) \
      __ASM_STDCALL_FUNC( name, 12, \
                         "popl %eax\n\t" \
                         "pushl %edx\n\t" \
                         "pushl %ecx\n\t" \
                         "pushl %eax\n\t" \
                         "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(12))
  #endif
  
  static inline LPCSTR debugstr_us( const UNICODE_STRING *us )
  {
      if (!us) return "<null>";
      return debugstr_wn( us->Buffer, us->Length / sizeof(WCHAR) );
  }
  
  static HANDLE get_device_manager(void)
  {
      static HANDLE device_manager;
      HANDLE handle = 0, ret = device_manager;
  
      if (!ret)
      {
          SERVER_START_REQ( create_device_manager )
          {
              req->access     = SYNCHRONIZE;
              req->attributes = 0;
              if (!wine_server_call( req )) handle = wine_server_ptr_handle( reply->handle );
          }
          SERVER_END_REQ;
  
          if (!handle)
          {
              ERR( "failed to create the device manager\n" );
              return 0;
          }
          if (!(ret = InterlockedCompareExchangePointer( &device_manager, handle, 0 )))
              ret = handle;
          else
              NtClose( handle );  /* somebody beat us to it */
      }
      return ret;
  }
  
  /* process an ioctl request for a given device */
  static NTSTATUS process_ioctl( DEVICE_OBJECT *device, ULONG code, void *in_buff, ULONG in_size,
                                 void *out_buff, ULONG *out_size )
  {
      IRP irp;
      MDL mdl;
      IO_STACK_LOCATION irpsp;
      FILE_OBJECT file;
      PDRIVER_DISPATCH dispatch = device->DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL];
      NTSTATUS status;
      LARGE_INTEGER count;
  
      TRACE( "ioctl %x device %p in_size %u out_size %u\n", code, device, in_size, *out_size );
  
      /* so we can spot things that we should initialize */
      memset( &irp, 0x55, sizeof(irp) );
      memset( &irpsp, 0x66, sizeof(irpsp) );
      memset( &mdl, 0x77, sizeof(mdl) );
      memset( &file, 0x88, sizeof(file) );
  
      irp.RequestorMode = UserMode;
      if ((code & 3) == METHOD_BUFFERED)
      {
          irp.AssociatedIrp.SystemBuffer = HeapAlloc( GetProcessHeap(), 0, max( in_size, *out_size ) );
          if (!irp.AssociatedIrp.SystemBuffer)
              return STATUS_NO_MEMORY;
          memcpy( irp.AssociatedIrp.SystemBuffer, in_buff, in_size );
      }
      else
          irp.AssociatedIrp.SystemBuffer = in_buff;
      irp.UserBuffer = out_buff;
      irp.MdlAddress = &mdl;
      irp.Tail.Overlay.s.u2.CurrentStackLocation = &irpsp;
      irp.Tail.Overlay.OriginalFileObject = &file;
      irp.UserIosb = NULL;
  
      irpsp.MajorFunction = IRP_MJ_DEVICE_CONTROL;
      irpsp.Parameters.DeviceIoControl.OutputBufferLength = *out_size;
      irpsp.Parameters.DeviceIoControl.InputBufferLength = in_size;
      irpsp.Parameters.DeviceIoControl.IoControlCode = code;
      irpsp.Parameters.DeviceIoControl.Type3InputBuffer = in_buff;
      irpsp.DeviceObject = device;
      irpsp.CompletionRoutine = NULL;
  
      mdl.Next = NULL;
      mdl.Size = 0;
      mdl.StartVa = out_buff;
      mdl.ByteCount = *out_size;
      mdl.ByteOffset = 0;
  
      file.FsContext = NULL;
      file.FsContext2 = NULL;
  
      device->CurrentIrp = &irp;
  
      KeQueryTickCount( &count );  /* update the global KeTickCount */
  
      if (TRACE_ON(relay))
          DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
                   GetCurrentThreadId(), dispatch, device, &irp );
  
      status = dispatch( device, &irp );
  
      if (TRACE_ON(relay))
          DPRINTF( "%04x:Ret  driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
                   GetCurrentThreadId(), dispatch, device, &irp, status );
  
      *out_size = (irp.IoStatus.u.Status >= 0) ? irp.IoStatus.Information : 0;
      if ((code & 3) == METHOD_BUFFERED)
      {
          if (out_buff) memcpy( out_buff, irp.AssociatedIrp.SystemBuffer, *out_size );
          HeapFree( GetProcessHeap(), 0, irp.AssociatedIrp.SystemBuffer );
      }
      return irp.IoStatus.u.Status;
  }
  
  
  /***********************************************************************
   *           wine_ntoskrnl_main_loop   (Not a Windows API)
   */
  NTSTATUS CDECL wine_ntoskrnl_main_loop( HANDLE stop_event )
  {
      HANDLE manager = get_device_manager();
      obj_handle_t ioctl = 0;
      NTSTATUS status = STATUS_SUCCESS;
      ULONG code = 0;
      void *in_buff, *out_buff = NULL;
      DEVICE_OBJECT *device = NULL;
      ULONG in_size = 4096, out_size = 0;
      HANDLE handles[2];
  
      request_thread = GetCurrentThreadId();
  
      if (!(in_buff = HeapAlloc( GetProcessHeap(), 0, in_size )))
      {
          ERR( "failed to allocate buffer\n" );
          return STATUS_NO_MEMORY;
      }
  
      handles[0] = stop_event;
      handles[1] = manager;
  
      for (;;)
      {
          SERVER_START_REQ( get_next_device_request )
          {
              req->manager = wine_server_obj_handle( manager );
              req->prev = ioctl;
              req->status = status;
              wine_server_add_data( req, out_buff, out_size );
              wine_server_set_reply( req, in_buff, in_size );
              if (!(status = wine_server_call( req )))
              {
                  code       = reply->code;
                  ioctl      = reply->next;
                  device     = wine_server_get_ptr( reply->user_ptr );
                  client_tid = reply->client_tid;
                  client_pid = reply->client_pid;
                  in_size    = reply->in_size;
                  out_size   = reply->out_size;
              }
              else
              {
                  ioctl = 0; /* no previous ioctl */
                  out_size = 0;
                  in_size = reply->in_size;
              }
          }
          SERVER_END_REQ;
  
          switch(status)
          {
          case STATUS_SUCCESS:
              HeapFree( GetProcessHeap(), 0, out_buff );
              if (out_size) out_buff = HeapAlloc( GetProcessHeap(), 0, out_size );
              else out_buff = NULL;
              status = process_ioctl( device, code, in_buff, in_size, out_buff, &out_size );
              break;
          case STATUS_BUFFER_OVERFLOW:
              HeapFree( GetProcessHeap(), 0, in_buff );
              in_buff = HeapAlloc( GetProcessHeap(), 0, in_size );
              /* restart with larger buffer */
              break;
          case STATUS_PENDING:
              if (WaitForMultipleObjects( 2, handles, FALSE, INFINITE ) == WAIT_OBJECT_0)
              {
                  HeapFree( GetProcessHeap(), 0, in_buff );
                  HeapFree( GetProcessHeap(), 0, out_buff );
                  return STATUS_SUCCESS;
              }
              break;
          }
      }
  }
  
  
  /***********************************************************************
   *           IoAcquireCancelSpinLock  (NTOSKRNL.EXE.@)
   */
  void WINAPI IoAcquireCancelSpinLock(PKIRQL irql)
  {
      FIXME("(%p): stub\n", irql);
  }
  
  
  /***********************************************************************
   *           IoReleaseCancelSpinLock  (NTOSKRNL.EXE.@)
   */
  void WINAPI IoReleaseCancelSpinLock(PKIRQL irql)
  {
      FIXME("(%p): stub\n", irql);
  }
  
  
  /***********************************************************************
   *           IoAllocateDriverObjectExtension  (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject,
                                                   PVOID ClientIdentificationAddress,
                                                   ULONG DriverObjectExtensionSize,
                                                   PVOID *DriverObjectExtension )
  {
      FIXME( "stub: %p, %p, %u, %p\n", DriverObject, ClientIdentificationAddress,
              DriverObjectExtensionSize, DriverObjectExtension );
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           IoGetDriverObjectExtension  (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject,
                                           PVOID ClientIdentificationAddress )
  {
      FIXME( "stub: %p, %p\n", DriverObject, ClientIdentificationAddress );
      return NULL;
  }
  
  
  /***********************************************************************
   *           IoInitializeIrp  (NTOSKRNL.EXE.@)
   */
  void WINAPI IoInitializeIrp( IRP *irp, USHORT size, CCHAR stack_size )
  {
      TRACE( "%p, %u, %d\n", irp, size, stack_size );
  
      RtlZeroMemory( irp, size );
  
      irp->Type = IO_TYPE_IRP;
      irp->Size = size;
      InitializeListHead( &irp->ThreadListEntry );
      irp->StackCount = stack_size;
      irp->CurrentLocation = stack_size + 1;
      irp->Tail.Overlay.s.u2.CurrentStackLocation =
              (PIO_STACK_LOCATION)(irp + 1) + stack_size;
  }
  
  
  /***********************************************************************
   *           IoInitializeTimer   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoInitializeTimer(PDEVICE_OBJECT DeviceObject,
                                    PIO_TIMER_ROUTINE TimerRoutine,
                                    PVOID Context)
  {
      FIXME( "stub: %p, %p, %p\n", DeviceObject, TimerRoutine, Context );
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           IoStartTimer   (NTOSKRNL.EXE.@)
   */
  void WINAPI IoStartTimer(PDEVICE_OBJECT DeviceObject)
  {
      FIXME( "stub: %p\n", DeviceObject );
  }
  
  
  /***********************************************************************
   *           IoAllocateIrp  (NTOSKRNL.EXE.@)
   */
  PIRP WINAPI IoAllocateIrp( CCHAR stack_size, BOOLEAN charge_quota )
  {
      SIZE_T size;
      PIRP irp;
  
      TRACE( "%d, %d\n", stack_size, charge_quota );
  
      size = sizeof(IRP) + stack_size * sizeof(IO_STACK_LOCATION);
      irp = ExAllocatePool( NonPagedPool, size );
      if (irp == NULL)
          return NULL;
      IoInitializeIrp( irp, size, stack_size );
      irp->AllocationFlags = IRP_ALLOCATED_FIXED_SIZE;
      if (charge_quota)
          irp->AllocationFlags |= IRP_LOOKASIDE_ALLOCATION;
      return irp;
  }
  
  
  /***********************************************************************
   *           IoFreeIrp  (NTOSKRNL.EXE.@)
   */
  void WINAPI IoFreeIrp( IRP *irp )
  {
      TRACE( "%p\n", irp );
  
      ExFreePool( irp );
  }
  
  
  /***********************************************************************
   *           IoAllocateErrorLogEntry  (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI IoAllocateErrorLogEntry( PVOID IoObject, UCHAR EntrySize )
  {
      FIXME( "stub: %p, %u\n", IoObject, EntrySize );
      return NULL;
  }
  
  
  /***********************************************************************
   *           IoAllocateMdl  (NTOSKRNL.EXE.@)
   */
  PMDL WINAPI IoAllocateMdl( PVOID VirtualAddress, ULONG Length, BOOLEAN SecondaryBuffer, BOOLEAN ChargeQuota, PIRP Irp )
  {
      PMDL mdl;
      ULONG_PTR address = (ULONG_PTR)VirtualAddress;
      ULONG_PTR page_address;
      SIZE_T nb_pages, mdl_size;
  
      TRACE("(%p, %u, %i, %i, %p)\n", VirtualAddress, Length, SecondaryBuffer, ChargeQuota, Irp);
  
      if (Irp)
          FIXME("Attaching the MDL to an IRP is not yet supported\n");
  
      if (ChargeQuota)
          FIXME("Charge quota is not yet supported\n");
  
      /* FIXME: We suppose that page size is 4096 */
      page_address = address & ~(4096 - 1);
      nb_pages = (((address + Length - 1) & ~(4096 - 1)) - page_address) / 4096 + 1;
  
      mdl_size = sizeof(MDL) + nb_pages * sizeof(PVOID);
  
      mdl = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mdl_size);
      if (!mdl)
          return NULL;
  
      mdl->Size = mdl_size;
      mdl->Process = IoGetCurrentProcess();
      mdl->StartVa = (PVOID)page_address;
      mdl->ByteCount = Length;
      mdl->ByteOffset = address - page_address;
  
      return mdl;
  }
  
  
  /***********************************************************************
   *           IoFreeMdl  (NTOSKRNL.EXE.@)
   */
  VOID WINAPI IoFreeMdl(PMDL mdl)
  {
      FIXME("partial stub: %p\n", mdl);
  
      HeapFree(GetProcessHeap(), 0, mdl);
  }
  
  
  /***********************************************************************
   *           IoAllocateWorkItem  (NTOSKRNL.EXE.@)
   */
  PIO_WORKITEM WINAPI IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject )
  {
      FIXME( "stub: %p\n", DeviceObject );
      return NULL;
  }
  
  
  /***********************************************************************
   *           IoAttachDeviceToDeviceStack  (NTOSKRNL.EXE.@)
   */
  PDEVICE_OBJECT WINAPI IoAttachDeviceToDeviceStack( DEVICE_OBJECT *source,
                                                     DEVICE_OBJECT *target )
  {
      TRACE( "%p, %p\n", source, target );
      target->AttachedDevice = source;
      source->StackSize = target->StackSize + 1;
      return target;
  }
  
  
  /***********************************************************************
   *           IoBuildDeviceIoControlRequest  (NTOSKRNL.EXE.@)
   */
  PIRP WINAPI IoBuildDeviceIoControlRequest( ULONG IoControlCode,
                                             PDEVICE_OBJECT DeviceObject,
                                             PVOID InputBuffer,
                                             ULONG InputBufferLength,
                                             PVOID OutputBuffer,
                                             ULONG OutputBufferLength,
                                             BOOLEAN InternalDeviceIoControl,
                                             PKEVENT Event,
                                             PIO_STATUS_BLOCK IoStatusBlock )
  {
      PIRP irp;
      PIO_STACK_LOCATION irpsp;
      struct IrpInstance *instance;
  
      TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
             IoControlCode, DeviceObject, InputBuffer, InputBufferLength,
             OutputBuffer, OutputBufferLength, InternalDeviceIoControl,
             Event, IoStatusBlock );
  
      if (DeviceObject == NULL)
          return NULL;
  
      irp = IoAllocateIrp( DeviceObject->StackSize, FALSE );
      if (irp == NULL)
          return NULL;
  
      instance = HeapAlloc( GetProcessHeap(), 0, sizeof(struct IrpInstance) );
      if (instance == NULL)
      {
          IoFreeIrp( irp );
          return NULL;
      }
      instance->irp = irp;
      list_add_tail( &Irps, &instance->entry );
  
      irpsp = IoGetNextIrpStackLocation( irp );
      irpsp->MajorFunction = InternalDeviceIoControl ?
              IRP_MJ_INTERNAL_DEVICE_CONTROL : IRP_MJ_DEVICE_CONTROL;
      irpsp->Parameters.DeviceIoControl.IoControlCode = IoControlCode;
      irp->UserIosb = IoStatusBlock;
      irp->UserEvent = Event;
  
      return irp;
  }
  
  
  /**********************************************************
   *           IoBuildSynchronousFsdRequest  (NTOSKRNL.EXE.@)
   */
  PIRP WINAPI IoBuildSynchronousFsdRequest(ULONG majorfunc, PDEVICE_OBJECT device,
                                           PVOID buffer, ULONG length, PLARGE_INTEGER startoffset,
                                           PKEVENT event, PIO_STATUS_BLOCK iosb)
  {
      PIRP irp;
      struct IrpInstance *instance;
      PIO_STACK_LOCATION irpsp;
  
      FIXME("(%d %p %p %d %p %p %p) stub\n", majorfunc, device, buffer, length, startoffset, event, iosb);
  
      irp = IoAllocateIrp( device->StackSize, FALSE );
      if (irp == NULL)
          return NULL;
  
      instance = HeapAlloc( GetProcessHeap(), 0, sizeof(struct IrpInstance) );
      if (instance == NULL)
      {
          IoFreeIrp( irp );
          return NULL;
      }
      instance->irp = irp;
      list_add_tail( &Irps, &instance->entry );
  
      irpsp = IoGetNextIrpStackLocation( irp );
      irpsp->MajorFunction = majorfunc;
      /*irpsp->Parameters.DeviceIoControl.IoControlCode = IoControlCode;*/
  
      irp->UserIosb = iosb;
      irp->UserEvent = event;
      irp->UserBuffer = buffer;
      return irp;
  }
  
  
  /***********************************************************************
   *           IoCreateDriver   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoCreateDriver( UNICODE_STRING *name, PDRIVER_INITIALIZE init )
  {
      DRIVER_OBJECT *driver;
      DRIVER_EXTENSION *extension;
      NTSTATUS status;
  
      TRACE("(%s, %p)\n", debugstr_us(name), init);
  
      if (!(driver = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
                                      sizeof(*driver) + sizeof(*extension) )))
          return STATUS_NO_MEMORY;
  
      if ((status = RtlDuplicateUnicodeString( 1, name, &driver->DriverName )))
      {
          RtlFreeHeap( GetProcessHeap(), 0, driver );
          return status;
      }
  
      extension = (DRIVER_EXTENSION *)(driver + 1);
      driver->Size            = sizeof(*driver);
      driver->DriverInit      = init;
      driver->DriverExtension = extension;
      extension->DriverObject   = driver;
      extension->ServiceKeyName = driver->DriverName;
  
      status = driver->DriverInit( driver, name );
  
      if (status)
      {
          RtlFreeUnicodeString( &driver->DriverName );
          RtlFreeHeap( GetProcessHeap(), 0, driver );
      }
      return status;
  }
  
  
  /***********************************************************************
   *           IoDeleteDriver   (NTOSKRNL.EXE.@)
   */
  void WINAPI IoDeleteDriver( DRIVER_OBJECT *driver )
  {
      TRACE("(%p)\n", driver);
  
      RtlFreeUnicodeString( &driver->DriverName );
      RtlFreeHeap( GetProcessHeap(), 0, driver );
  }
  
  
  /***********************************************************************
   *           IoCreateDevice   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoCreateDevice( DRIVER_OBJECT *driver, ULONG ext_size,
                                  UNICODE_STRING *name, DEVICE_TYPE type,
                                  ULONG characteristics, BOOLEAN exclusive,
                                  DEVICE_OBJECT **ret_device )
  {
      NTSTATUS status;
      DEVICE_OBJECT *device;
      HANDLE handle = 0;
      HANDLE manager = get_device_manager();
  
      TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
             driver, ext_size, debugstr_us(name), type, characteristics, exclusive, ret_device );
  
      if (!(device = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*device) + ext_size )))
          return STATUS_NO_MEMORY;
  
      SERVER_START_REQ( create_device )
      {
          req->access     = 0;
          req->attributes = 0;
          req->rootdir    = 0;
          req->manager    = wine_server_obj_handle( manager );
          req->user_ptr   = wine_server_client_ptr( device );
          if (name) wine_server_add_data( req, name->Buffer, name->Length );
          if (!(status = wine_server_call( req ))) handle = wine_server_ptr_handle( reply->handle );
      }
      SERVER_END_REQ;
  
      if (status == STATUS_SUCCESS)
      {
          device->DriverObject    = driver;
          device->DeviceExtension = device + 1;
          device->DeviceType      = type;
          device->StackSize       = 1;
          device->Reserved        = handle;
  
          device->NextDevice   = driver->DeviceObject;
          driver->DeviceObject = device;
  
          *ret_device = device;
      }
      else HeapFree( GetProcessHeap(), 0, device );
  
      return status;
  }
  
  
  /***********************************************************************
   *           IoDeleteDevice   (NTOSKRNL.EXE.@)
   */
  void WINAPI IoDeleteDevice( DEVICE_OBJECT *device )
  {
      NTSTATUS status;
  
      TRACE( "%p\n", device );
  
      SERVER_START_REQ( delete_device )
      {
          req->handle = wine_server_obj_handle( device->Reserved );
          status = wine_server_call( req );
      }
      SERVER_END_REQ;
  
      if (status == STATUS_SUCCESS)
      {
          DEVICE_OBJECT **prev = &device->DriverObject->DeviceObject;
          while (*prev && *prev != device) prev = &(*prev)->NextDevice;
          if (*prev) *prev = (*prev)->NextDevice;
          NtClose( device->Reserved );
          HeapFree( GetProcessHeap(), 0, device );
      }
  }
  
  
  /***********************************************************************
   *           IoCreateSymbolicLink   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoCreateSymbolicLink( UNICODE_STRING *name, UNICODE_STRING *target )
  {
      HANDLE handle;
      OBJECT_ATTRIBUTES attr;
  
      attr.Length                   = sizeof(attr);
      attr.RootDirectory            = 0;
      attr.ObjectName               = name;
      attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
      attr.SecurityDescriptor       = NULL;
      attr.SecurityQualityOfService = NULL;
  
      TRACE( "%s -> %s\n", debugstr_us(name), debugstr_us(target) );
      /* FIXME: store handle somewhere */
      return NtCreateSymbolicLinkObject( &handle, SYMBOLIC_LINK_ALL_ACCESS, &attr, target );
  }
  
  
  /***********************************************************************
   *           IoDeleteSymbolicLink   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoDeleteSymbolicLink( UNICODE_STRING *name )
  {
      HANDLE handle;
      OBJECT_ATTRIBUTES attr;
      NTSTATUS status;
  
      attr.Length                   = sizeof(attr);
      attr.RootDirectory            = 0;
      attr.ObjectName               = name;
      attr.Attributes               = OBJ_CASE_INSENSITIVE;
      attr.SecurityDescriptor       = NULL;
      attr.SecurityQualityOfService = NULL;
  
      if (!(status = NtOpenSymbolicLinkObject( &handle, 0, &attr )))
      {
          SERVER_START_REQ( unlink_object )
          {
              req->handle = wine_server_obj_handle( handle );
              status = wine_server_call( req );
          }
          SERVER_END_REQ;
          NtClose( handle );
      }
      return status;
  }
  
  
  /***********************************************************************
   *           IoGetDeviceInterfaces   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoGetDeviceInterfaces( const GUID *InterfaceClassGuid,
                                         PDEVICE_OBJECT PhysicalDeviceObject,
                                         ULONG Flags, PWSTR *SymbolicLinkList )
  {
      FIXME( "stub: %s %p %x %p\n", debugstr_guid(InterfaceClassGuid),
             PhysicalDeviceObject, Flags, SymbolicLinkList );
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           IoGetDeviceObjectPointer   (NTOSKRNL.EXE.@)
   */
  NTSTATUS  WINAPI IoGetDeviceObjectPointer( UNICODE_STRING *name, ACCESS_MASK access, PFILE_OBJECT *file, PDEVICE_OBJECT *device )
  {
      FIXME( "stub: %s %x %p %p\n", debugstr_us(name), access, file, device );
  
      *file  = NULL;
      *device  = NULL;
  
      return STATUS_SUCCESS;
  }
  
  /***********************************************************************
   *           IoGetAttachedDevice   (NTOSKRNL.EXE.@)
   */
  PDEVICE_OBJECT WINAPI IoGetAttachedDevice( PDEVICE_OBJECT device )
  {
      FIXME( "stub: %p\n", device );
  
      return device;
  }
  
  /***********************************************************************
   *           IoGetDeviceProperty   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoGetDeviceProperty( DEVICE_OBJECT *device, DEVICE_REGISTRY_PROPERTY device_property,
                                       ULONG buffer_length, PVOID property_buffer, PULONG result_length )
  {
      FIXME( "%p %d %u %p %p: stub\n", device, device_property, buffer_length,
             property_buffer, result_length );
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           IoCallDriver   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoCallDriver( DEVICE_OBJECT *device, IRP *irp )
  {
      PDRIVER_DISPATCH dispatch;
      IO_STACK_LOCATION *irpsp;
      NTSTATUS status;
  
      TRACE( "%p %p\n", device, irp );
  
      --irp->CurrentLocation;
      irpsp = --irp->Tail.Overlay.s.u2.CurrentStackLocation;
      dispatch = device->DriverObject->MajorFunction[irpsp->MajorFunction];
      status = dispatch( device, irp );
  
      return status;
  }
  
  
  /***********************************************************************
   *           IofCallDriver   (NTOSKRNL.EXE.@)
   */
  #ifdef DEFINE_FASTCALL2_ENTRYPOINT
  DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver )
  NTSTATUS WINAPI __regs_IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
  #else
  NTSTATUS WINAPI IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
  #endif
  {
      TRACE( "%p %p\n", device, irp );
      return IoCallDriver( device, irp );
  }
  
  
  /***********************************************************************
   *           IoGetRelatedDeviceObject    (NTOSKRNL.EXE.@)
   */
  PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject( PFILE_OBJECT obj )
  {
      FIXME( "stub: %p\n", obj );
      return NULL;
  }
  
  static CONFIGURATION_INFORMATION configuration_information;
  
  /***********************************************************************
   *           IoGetConfigurationInformation    (NTOSKRNL.EXE.@)
   */
  PCONFIGURATION_INFORMATION WINAPI IoGetConfigurationInformation(void)
  {
      FIXME( "partial stub\n" );
      /* FIXME: return actual devices on system */
      return &configuration_information;
  }
  
  
  /***********************************************************************
   *           IoIsWdmVersionAvailable     (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoIsWdmVersionAvailable(UCHAR MajorVersion, UCHAR MinorVersion)
  {
      DWORD version;
      DWORD major;
      DWORD minor;
  
      TRACE( "%d, 0x%X\n", MajorVersion, MinorVersion );
  
      version = GetVersion();
      major = LOBYTE(version);
      minor = HIBYTE(LOWORD(version));
  
      if (MajorVersion == 6 && MinorVersion == 0)
      {
          /* Windows Vista, Windows Server 2008, Windows 7 */
      }
      else if (MajorVersion == 1)
      {
          if (MinorVersion == 0x30)
          {
              /* Windows server 2003 */
              MajorVersion = 6;
              MinorVersion = 0;
          }
          else if (MinorVersion == 0x20)
          {
              /* Windows XP */
              MajorVersion = 5;
              MinorVersion = 1;
          }
          else if (MinorVersion == 0x10)
          {
              /* Windows 2000 */
              MajorVersion = 5;
              MinorVersion = 0;
          }
          else if (MinorVersion == 0x05)
          {
              /* Windows ME */
              MajorVersion = 4;
              MinorVersion = 0x5a;
          }
          else if (MinorVersion == 0x00)
          {
              /* Windows 98 */
              MajorVersion = 4;
              MinorVersion = 0x0a;
          }
          else
          {
              FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
              return FALSE;
          }
      }
      else
      {
          FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
          return FALSE;
      }
      return major > MajorVersion || (major == MajorVersion && minor >= MinorVersion);
  }
  
  
  /***********************************************************************
   *           IoQueryDeviceDescription    (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoQueryDeviceDescription(PINTERFACE_TYPE itype, PULONG bus, PCONFIGURATION_TYPE ctype,
                                       PULONG cnum, PCONFIGURATION_TYPE ptype, PULONG pnum,
                                       PIO_QUERY_DEVICE_ROUTINE callout, PVOID context)
  {
      FIXME( "(%p %p %p %p %p %p %p %p)\n", itype, bus, ctype, cnum, ptype, pnum, callout, context);
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           IoRegisterDriverReinitialization    (NTOSKRNL.EXE.@)
   */
  void WINAPI IoRegisterDriverReinitialization( PDRIVER_OBJECT obj, PDRIVER_REINITIALIZE reinit, PVOID context )
  {
      FIXME( "stub: %p %p %p\n", obj, reinit, context );
  }
  
  
  /***********************************************************************
   *           IoRegisterShutdownNotification    (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoRegisterShutdownNotification( PDEVICE_OBJECT obj )
  {
      FIXME( "stub: %p\n", obj );
      return STATUS_SUCCESS;
  }
  
  
  /***********************************************************************
   *           IoUnregisterShutdownNotification    (NTOSKRNL.EXE.@)
   */
  VOID WINAPI IoUnregisterShutdownNotification( PDEVICE_OBJECT obj )
  {
      FIXME( "stub: %p\n", obj );
  }
  
  
  /***********************************************************************
   *           IoReportResourceUsage    (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoReportResourceUsage(PUNICODE_STRING name, PDRIVER_OBJECT drv_obj, PCM_RESOURCE_LIST drv_list,
                                        ULONG drv_size, PDRIVER_OBJECT dev_obj, PCM_RESOURCE_LIST dev_list,
                                        ULONG dev_size, BOOLEAN overwrite, PBOOLEAN detected)
  {
      FIXME("(%s %p %p %u %p %p %u %d %p) stub\n", debugstr_w(name? name->Buffer : NULL),
            drv_obj, drv_list, drv_size, dev_obj, dev_list, dev_size, overwrite, detected);
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           IoCompleteRequest   (NTOSKRNL.EXE.@)
   */
  VOID WINAPI IoCompleteRequest( IRP *irp, UCHAR priority_boost )
  {
      IO_STACK_LOCATION *irpsp;
      PIO_COMPLETION_ROUTINE routine;
      IO_STATUS_BLOCK *iosb;
      struct IrpInstance *instance;
      NTSTATUS status, stat;
      int call_flag = 0;
  
      TRACE( "%p %u\n", irp, priority_boost );
  
      iosb = irp->UserIosb;
      status = irp->IoStatus.u.Status;
      while (irp->CurrentLocation <= irp->StackCount)
      {
          irpsp = irp->Tail.Overlay.s.u2.CurrentStackLocation;
          routine = irpsp->CompletionRoutine;
          call_flag = 0;
          /* FIXME: add SL_INVOKE_ON_CANCEL support */
          if (routine)
          {
              if ((irpsp->Control & SL_INVOKE_ON_SUCCESS) && STATUS_SUCCESS == status)
                  call_flag = 1;
              if ((irpsp->Control & SL_INVOKE_ON_ERROR) && STATUS_SUCCESS != status)
                  call_flag = 1;
          }
          ++irp->CurrentLocation;
          ++irp->Tail.Overlay.s.u2.CurrentStackLocation;
          if (call_flag)
          {
              TRACE( "calling %p( %p, %p, %p )\n", routine,
                      irpsp->DeviceObject, irp, irpsp->Context );
              stat = routine( irpsp->DeviceObject, irp, irpsp->Context );
              TRACE( "CompletionRoutine returned %x\n", stat );
              if (STATUS_MORE_PROCESSING_REQUIRED == stat)
                  return;
          }
      }
      if (iosb && STATUS_SUCCESS == status)
      {
          iosb->u.Status = irp->IoStatus.u.Status;
          iosb->Information = irp->IoStatus.Information;
      }
      LIST_FOR_EACH_ENTRY( instance, &Irps, struct IrpInstance, entry )
      {
          if (instance->irp == irp)
          {
              list_remove( &instance->entry );
              HeapFree( GetProcessHeap(), 0, instance );
              IoFreeIrp( irp );
              break;
          }
      }
  }
  
  
  /***********************************************************************
   *           IofCompleteRequest   (NTOSKRNL.EXE.@)
   */
  #ifdef DEFINE_FASTCALL2_ENTRYPOINT
  DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest )
  void WINAPI __regs_IofCompleteRequest( IRP *irp, UCHAR priority_boost )
  #else
  void WINAPI IofCompleteRequest( IRP *irp, UCHAR priority_boost )
  #endif
  {
      TRACE( "%p %u\n", irp, priority_boost );
      IoCompleteRequest( irp, priority_boost );
  }
  
  
  /***********************************************************************
   *           InterlockedCompareExchange   (NTOSKRNL.EXE.@)
   */
  #ifdef DEFINE_FASTCALL3_ENTRYPOINT
  DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange )
  LONG WINAPI __regs_NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
  #else
  LONG WINAPI NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
  #endif
  {
      return InterlockedCompareExchange( dest, xchg, compare );
  }
  
  
  /***********************************************************************
   *           InterlockedDecrement   (NTOSKRNL.EXE.@)
   */
  #ifdef DEFINE_FASTCALL1_ENTRYPOINT
  DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement )
  LONG WINAPI __regs_NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
  #else
  LONG WINAPI NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
  #endif
  {
      return InterlockedDecrement( dest );
  }
  
  
  /***********************************************************************
   *           InterlockedExchange   (NTOSKRNL.EXE.@)
   */
  #ifdef DEFINE_FASTCALL2_ENTRYPOINT
  DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange )
  LONG WINAPI __regs_NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
  #else
  LONG WINAPI NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
  #endif
  {
      return InterlockedExchange( dest, val );
  }
  
  
  /***********************************************************************
   *           InterlockedExchangeAdd   (NTOSKRNL.EXE.@)
   */
  #ifdef DEFINE_FASTCALL2_ENTRYPOINT
  DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd )
  LONG WINAPI __regs_NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
  #else
  LONG WINAPI NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
  #endif
  {
      return InterlockedExchangeAdd( dest, incr );
  }
  
  
  /***********************************************************************
   *           InterlockedIncrement   (NTOSKRNL.EXE.@)
   */
  #ifdef DEFINE_FASTCALL1_ENTRYPOINT
  DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement )
  LONG WINAPI __regs_NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
  #else
  LONG WINAPI NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
  #endif
  {
      return InterlockedIncrement( dest );
  }
  
  
  /***********************************************************************
   *           ExAllocatePool   (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI ExAllocatePool( POOL_TYPE type, SIZE_T size )
  {
      return ExAllocatePoolWithTag( type, size, 0 );
  }
  
  
  /***********************************************************************
   *           ExAllocatePoolWithQuota   (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI ExAllocatePoolWithQuota( POOL_TYPE type, SIZE_T size )
  {
      return ExAllocatePoolWithTag( type, size, 0 );
  }
  
  
  /***********************************************************************
   *           ExAllocatePoolWithTag   (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI ExAllocatePoolWithTag( POOL_TYPE type, SIZE_T size, ULONG tag )
  {
      /* FIXME: handle page alignment constraints */
      void *ret = HeapAlloc( GetProcessHeap(), 0, size );
      TRACE( "%lu pool %u -> %p\n", size, type, ret );
      return ret;
  }
  
  
  /***********************************************************************
   *           ExAllocatePoolWithQuotaTag   (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI ExAllocatePoolWithQuotaTag( POOL_TYPE type, SIZE_T size, ULONG tag )
  {
      return ExAllocatePoolWithTag( type, size, tag );
  }
  
  
  /***********************************************************************
   *           ExCreateCallback   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI ExCreateCallback(PCALLBACK_OBJECT *obj, POBJECT_ATTRIBUTES attr,
                                   BOOLEAN create, BOOLEAN allow_multiple)
  {
      FIXME("(%p, %p, %u, %u): stub\n", obj, attr, create, allow_multiple);
  
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           ExFreePool   (NTOSKRNL.EXE.@)
   */
  void WINAPI ExFreePool( void *ptr )
  {
      ExFreePoolWithTag( ptr, 0 );
  }
  
  
  /***********************************************************************
   *           ExFreePoolWithTag   (NTOSKRNL.EXE.@)
   */
  void WINAPI ExFreePoolWithTag( void *ptr, ULONG tag )
  {
      TRACE( "%p\n", ptr );
      HeapFree( GetProcessHeap(), 0, ptr );
  }
  
  
  /***********************************************************************
   *           ExInitializeResourceLite   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI ExInitializeResourceLite(PERESOURCE Resource)
  {
      FIXME( "stub: %p\n", Resource );
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           ExInitializeNPagedLookasideList   (NTOSKRNL.EXE.@)
   */
  void WINAPI ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
                                              PALLOCATE_FUNCTION Allocate,
                                              PFREE_FUNCTION Free,
                                              ULONG Flags,
                                              SIZE_T Size,
                                              ULONG Tag,
                                              USHORT Depth)
  {
      FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
  }
  
  /***********************************************************************
   *           ExInitializePagedLookasideList   (NTOSKRNL.EXE.@)
   */
  void WINAPI ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside,
                                             PALLOCATE_FUNCTION Allocate,
                                             PFREE_FUNCTION Free,
                                             ULONG Flags,
                                             SIZE_T Size,
                                             ULONG Tag,
                                             USHORT Depth)
  {
      FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
  }
  
  /***********************************************************************
   *           ExInitializeZone   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI ExInitializeZone(PZONE_HEADER Zone,
                                   ULONG BlockSize,
                                   PVOID InitialSegment,
                                   ULONG InitialSegmentSize)
  {
      FIXME( "stub: %p, %u, %p, %u\n", Zone, BlockSize, InitialSegment, InitialSegmentSize );
      return STATUS_NOT_IMPLEMENTED;
  }
  
  /***********************************************************************
  *           FsRtlRegisterUncProvider   (NTOSKRNL.EXE.@)
  */
  NTSTATUS WINAPI FsRtlRegisterUncProvider(PHANDLE MupHandle, PUNICODE_STRING RedirDevName,
                                           BOOLEAN MailslotsSupported)
  {
      FIXME("(%p %p %d): stub\n", MupHandle, RedirDevName, MailslotsSupported);
      return STATUS_NOT_IMPLEMENTED;
  }
  
  /***********************************************************************
   *           IoGetCurrentProcess / PsGetCurrentProcess   (NTOSKRNL.EXE.@)
   */
  PEPROCESS WINAPI IoGetCurrentProcess(void)
  {
      FIXME("() stub\n");
      return NULL;
  }
  
  /***********************************************************************
   *           KeGetCurrentThread / PsGetCurrentThread   (NTOSKRNL.EXE.@)
   */
  PRKTHREAD WINAPI KeGetCurrentThread(void)
  {
      FIXME("() stub\n");
      return NULL;
  }
  
  /***********************************************************************
   *           KeInitializeEvent   (NTOSKRNL.EXE.@)
   */
  void WINAPI KeInitializeEvent( PRKEVENT Event, EVENT_TYPE Type, BOOLEAN State )
  {
      FIXME( "stub: %p %d %d\n", Event, Type, State );
  }
  
  
   /***********************************************************************
   *           KeInitializeMutex   (NTOSKRNL.EXE.@)
   */
  void WINAPI KeInitializeMutex(PRKMUTEX Mutex, ULONG Level)
  {
      FIXME( "stub: %p, %u\n", Mutex, Level );
  }
  
  
   /***********************************************************************
   *           KeWaitForMutexObject   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI KeWaitForMutexObject(PRKMUTEX Mutex, KWAIT_REASON WaitReason, KPROCESSOR_MODE WaitMode,
                                       BOOLEAN Alertable, PLARGE_INTEGER Timeout)
  {
      FIXME( "stub: %p, %d, %d, %d, %p\n", Mutex, WaitReason, WaitMode, Alertable, Timeout );
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
   /***********************************************************************
   *           KeReleaseMutex   (NTOSKRNL.EXE.@)
   */
  LONG WINAPI KeReleaseMutex(PRKMUTEX Mutex, BOOLEAN Wait)
  {
      FIXME( "stub: %p, %d\n", Mutex, Wait );
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           KeInitializeSemaphore   (NTOSKRNL.EXE.@)
   */
  void WINAPI KeInitializeSemaphore( PRKSEMAPHORE Semaphore, LONG Count, LONG Limit )
  {
      FIXME( "(%p %d %d) stub\n", Semaphore , Count, Limit );
  }
  
  
  /***********************************************************************
   *           KeInitializeSpinLock   (NTOSKRNL.EXE.@)
   */
  void WINAPI KeInitializeSpinLock( PKSPIN_LOCK SpinLock )
  {
      FIXME( "stub: %p\n", SpinLock );
  }
  
  
  /***********************************************************************
   *           KeInitializeTimerEx   (NTOSKRNL.EXE.@)
   */
  void WINAPI KeInitializeTimerEx( PKTIMER Timer, TIMER_TYPE Type )
  {
      FIXME( "stub: %p %d\n", Timer, Type );
  }
  
  
  /***********************************************************************
   *           KeInitializeTimer   (NTOSKRNL.EXE.@)
   */
  void WINAPI KeInitializeTimer( PKTIMER Timer )
  {
      KeInitializeTimerEx(Timer, NotificationTimer);
  }
  
  /***********************************************************************
   *           KeInsertQueue   (NTOSKRNL.EXE.@)
   */
  LONG WINAPI KeInsertQueue(PRKQUEUE Queue, PLIST_ENTRY Entry)
  {
      FIXME( "stub: %p %p\n", Queue, Entry );
      return 0;
  }
  
  /**********************************************************************
   *           KeQueryActiveProcessors   (NTOSKRNL.EXE.@)
   *
   * Return the active Processors as bitmask
   *
   * RETURNS
   *   active Processors as bitmask
   *
   */
  KAFFINITY WINAPI KeQueryActiveProcessors( void )
  {
      DWORD_PTR AffinityMask;
  
      GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask, NULL);
      return AffinityMask;
  }
  
  
  /**********************************************************************
   *           KeQueryInterruptTime   (NTOSKRNL.EXE.@)
   *
   * Return the interrupt time count
   *
   */
  ULONGLONG WINAPI KeQueryInterruptTime( void )
  {
      LARGE_INTEGER totaltime;
  
      KeQueryTickCount(&totaltime);
      return totaltime.QuadPart;
  }
  
  
  /***********************************************************************
   *           KeQuerySystemTime   (NTOSKRNL.EXE.@)
   */
  void WINAPI KeQuerySystemTime( LARGE_INTEGER *time )
  {
      NtQuerySystemTime( time );
  }
  
  
  /***********************************************************************
   *           KeQueryTickCount   (NTOSKRNL.EXE.@)
   */
  void WINAPI KeQueryTickCount( LARGE_INTEGER *count )
  {
      count->QuadPart = NtGetTickCount();
      /* update the global variable too */
      KeTickCount.LowPart   = count->u.LowPart;
      KeTickCount.High1Time = count->u.HighPart;
      KeTickCount.High2Time = count->u.HighPart;
  }
  
  
  /***********************************************************************
   *           KeReleaseSemaphore   (NTOSKRNL.EXE.@)
   */
  LONG WINAPI KeReleaseSemaphore( PRKSEMAPHORE Semaphore, KPRIORITY Increment,
                                  LONG Adjustment, BOOLEAN Wait )
  {
      FIXME("(%p %d %d %d) stub\n", Semaphore, Increment, Adjustment, Wait );
      return 0;
  }
  
  
  /***********************************************************************
   *           KeQueryTimeIncrement   (NTOSKRNL.EXE.@)
   */
  ULONG WINAPI KeQueryTimeIncrement(void)
  {
      return 10000;
  }
  
  
  /***********************************************************************
   *           KeResetEvent   (NTOSKRNL.EXE.@)
   */
  LONG WINAPI KeResetEvent( PRKEVENT Event )
  {
      FIXME("(%p): stub\n", Event);
      return 0;
  }
  
  
  /***********************************************************************
   *           KeSetEvent   (NTOSKRNL.EXE.@)
   */
  LONG WINAPI KeSetEvent( PRKEVENT Event, KPRIORITY Increment, BOOLEAN Wait )
  {
      FIXME("(%p, %d, %d): stub\n", Event, Increment, Wait);
      return 0;
  }
  
  
  /***********************************************************************
   *           KeSetPriorityThread   (NTOSKRNL.EXE.@)
   */
  KPRIORITY WINAPI KeSetPriorityThread( PKTHREAD Thread, KPRIORITY Priority )
  {
      FIXME("(%p %d)\n", Thread, Priority);
      return Priority;
  }
  
  /***********************************************************************
   *           KeSetSystemAffinityThread   (NTOSKRNL.EXE.@)
   */
  VOID WINAPI KeSetSystemAffinityThread(KAFFINITY Affinity)
  {
      FIXME("(%lx) stub\n", Affinity);
  }
  
  /***********************************************************************
   *           KeWaitForSingleObject   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI KeWaitForSingleObject(PVOID Object,
                                        KWAIT_REASON WaitReason,
                                        KPROCESSOR_MODE WaitMode,
                                        BOOLEAN Alertable,
                                        PLARGE_INTEGER Timeout)
  {
      FIXME( "stub: %p, %d, %d, %d, %p\n", Object, WaitReason, WaitMode, Alertable, Timeout );
      return STATUS_NOT_IMPLEMENTED;
  }
  
  /***********************************************************************
   *           IoRegisterFileSystem   (NTOSKRNL.EXE.@)
   */
  VOID WINAPI IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject)
  {
      FIXME("(%p): stub\n", DeviceObject);
  }
  
  /***********************************************************************
  *           IoUnregisterFileSystem   (NTOSKRNL.EXE.@)
  */
  VOID WINAPI IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject)
  {
      FIXME("(%p): stub\n", DeviceObject);
  }
  
  /***********************************************************************
   *           MmAllocateNonCachedMemory   (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI MmAllocateNonCachedMemory( SIZE_T size )
  {
      TRACE( "%lu\n", size );
      return VirtualAlloc( NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE|PAGE_NOCACHE );
  }
  
  /***********************************************************************
   *           MmAllocateContiguousMemory   (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI MmAllocateContiguousMemory( SIZE_T size, PHYSICAL_ADDRESS highest_valid_address )
  {
      FIXME( "%lu, %s stub\n", size, wine_dbgstr_longlong(highest_valid_address.QuadPart) );
      return NULL;
  }
  
  /***********************************************************************
   *           MmAllocateContiguousMemorySpecifyCache   (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI MmAllocateContiguousMemorySpecifyCache( SIZE_T size,
                                                       PHYSICAL_ADDRESS lowest_valid_address,
                                                       PHYSICAL_ADDRESS highest_valid_address,
                                                       PHYSICAL_ADDRESS BoundaryAddressMultiple,
                                                       MEMORY_CACHING_TYPE CacheType )
  {
      FIXME(": stub\n");
      return NULL;
  }
  
  /***********************************************************************
   *           MmAllocatePagesForMdl   (NTOSKRNL.EXE.@)
   */
  PMDL WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress, PHYSICAL_ADDRESS highaddress,
                                    PHYSICAL_ADDRESS skipbytes, SIZE_T size)
  {
      FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress.QuadPart), wine_dbgstr_longlong(highaddress.QuadPart),
                                    wine_dbgstr_longlong(skipbytes.QuadPart), size);
      return NULL;
  }
  
  /***********************************************************************
   *           MmFreeNonCachedMemory   (NTOSKRNL.EXE.@)
   */
  void WINAPI MmFreeNonCachedMemory( void *addr, SIZE_T size )
  {
      TRACE( "%p %lu\n", addr, size );
      VirtualFree( addr, 0, MEM_RELEASE );
  }
  
  /***********************************************************************
   *           MmIsAddressValid   (NTOSKRNL.EXE.@)
   *
   * Check if the process can access the virtual address without a pagefault
   *
   * PARAMS
   *  VirtualAddress [I] Address to check
   *
   * RETURNS
   *  Failure: FALSE
   *  Success: TRUE  (Accessing the Address works without a Pagefault)
   *
   */
  BOOLEAN WINAPI MmIsAddressValid(PVOID VirtualAddress)
  {
      TRACE("(%p)\n", VirtualAddress);
      return !IsBadWritePtr(VirtualAddress, 1);
  }
  
  /***********************************************************************
   *           MmMapIoSpace   (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress, DWORD NumberOfBytes, DWORD CacheType )
  {
      FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress.u.HighPart, PhysicalAddress.u.LowPart, NumberOfBytes, CacheType );
      return NULL;
  }
  
  
  /***********************************************************************
   *           MmLockPagableSectionByHandle  (NTOSKRNL.EXE.@)
   */
  VOID WINAPI MmLockPagableSectionByHandle(PVOID ImageSectionHandle)
  {
      FIXME("stub %p\n", ImageSectionHandle);
  }
  
  /***********************************************************************
   *           MmMapLockedPagesSpecifyCache  (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI  MmMapLockedPagesSpecifyCache(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, MEMORY_CACHING_TYPE CacheType,
                                             PVOID BaseAddress, ULONG BugCheckOnFailure, MM_PAGE_PRIORITY Priority)
  {
      FIXME("(%p, %u, %u, %p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, CacheType, BaseAddress, BugCheckOnFailure, Priority);
  
      return NULL;
  }
  
  /***********************************************************************
   *           MmUnlockPagableImageSection  (NTOSKRNL.EXE.@)
   */
  VOID WINAPI MmUnlockPagableImageSection(PVOID ImageSectionHandle)
  {
      FIXME("stub %p\n", ImageSectionHandle);
  }
  
  /***********************************************************************
   *           MmPageEntireDriver   (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI MmPageEntireDriver(PVOID AddrInSection)
  {
      TRACE("%p\n", AddrInSection);
      return AddrInSection;
  }
  
  
  /***********************************************************************
   *           MmProbeAndLockPages  (NTOSKRNL.EXE.@)
   */
  void WINAPI MmProbeAndLockPages(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, LOCK_OPERATION Operation)
  {
      FIXME("(%p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, Operation);
  }
  
  
  /***********************************************************************
   *           MmResetDriverPaging   (NTOSKRNL.EXE.@)
   */
  void WINAPI MmResetDriverPaging(PVOID AddrInSection)
  {
      TRACE("%p\n", AddrInSection);
  }
  
  
  /***********************************************************************
   *           MmUnlockPages  (NTOSKRNL.EXE.@)
   */
  void WINAPI  MmUnlockPages(PMDLX MemoryDescriptorList)
  {
      FIXME("(%p): stub\n", MemoryDescriptorList);
  }
  
  
  /***********************************************************************
   *           MmUnmapIoSpace   (NTOSKRNL.EXE.@)
   */
  VOID WINAPI MmUnmapIoSpace( PVOID BaseAddress, SIZE_T NumberOfBytes )
  {
      FIXME( "stub: %p, %lu\n", BaseAddress, NumberOfBytes );
  }
  
  /***********************************************************************
   *           ObfReferenceObject   (NTOSKRNL.EXE.@)
   */
  VOID WINAPI ObfReferenceObject(PVOID Object)
  {
      FIXME("(%p): stub\n", Object);
  }
  
   /***********************************************************************
   *           ObReferenceObjectByHandle    (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI ObReferenceObjectByHandle( HANDLE obj, ACCESS_MASK access,
                                             POBJECT_TYPE type,
                                             KPROCESSOR_MODE mode, PVOID* ptr,
                                             POBJECT_HANDLE_INFORMATION info)
  {
      FIXME( "stub: %p %x %p %d %p %p\n", obj, access, type, mode, ptr, info);
      return STATUS_NOT_IMPLEMENTED;
  }
  
   /***********************************************************************
   *           ObReferenceObjectByName    (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI ObReferenceObjectByName( UNICODE_STRING *ObjectName,
                                           ULONG Attributes,
                                           ACCESS_STATE *AccessState,
                                           ACCESS_MASK DesiredAccess,
                                           POBJECT_TYPE ObjectType,
                                           KPROCESSOR_MODE AccessMode,
                                           void *ParseContext,
                                           void **Object)
  {
      FIXME("stub\n");
      return STATUS_NOT_IMPLEMENTED;
  }
  
  /***********************************************************************
   *           ObfDereferenceObject   (NTOSKRNL.EXE.@)
   */
  #ifdef DEFINE_FASTCALL1_ENTRYPOINT
  DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject )
  void WINAPI __regs_ObfDereferenceObject( VOID *obj )
  #else
  void WINAPI ObfDereferenceObject( VOID *obj )
  #endif
  {
      FIXME( "stub: %p\n", obj );
  }
  
  
  /***********************************************************************
   *           PsCreateSystemThread   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI PsCreateSystemThread(PHANDLE ThreadHandle, ULONG DesiredAccess,
  				     POBJECT_ATTRIBUTES ObjectAttributes,
  			             HANDLE ProcessHandle, PCLIENT_ID ClientId,
                                       PKSTART_ROUTINE StartRoutine, PVOID StartContext)
  {
      if (!ProcessHandle) ProcessHandle = GetCurrentProcess();
      return RtlCreateUserThread(ProcessHandle, 0, FALSE, 0, 0,
                                 0, StartRoutine, StartContext,
                                 ThreadHandle, ClientId);
  }
  
  /***********************************************************************
   *           PsGetCurrentProcessId   (NTOSKRNL.EXE.@)
   */
  HANDLE WINAPI PsGetCurrentProcessId(void)
  {
      if (GetCurrentThreadId() == request_thread)
          return UlongToHandle(client_pid);
      return UlongToHandle(GetCurrentProcessId());
  }
  
  
  /***********************************************************************
   *           PsGetCurrentThreadId   (NTOSKRNL.EXE.@)
   */
  HANDLE WINAPI PsGetCurrentThreadId(void)
  {
      if (GetCurrentThreadId() == request_thread)
          return UlongToHandle(client_tid);
      return UlongToHandle(GetCurrentThreadId());
  }
  
  
  /***********************************************************************
   *           PsGetVersion   (NTOSKRNL.EXE.@)
   */
  BOOLEAN WINAPI PsGetVersion(ULONG *major, ULONG *minor, ULONG *build, UNICODE_STRING *version )
  {
      RTL_OSVERSIONINFOEXW info;
  
      info.dwOSVersionInfoSize = sizeof(info);
      RtlGetVersion( &info );
      if (major) *major = info.dwMajorVersion;
      if (minor) *minor = info.dwMinorVersion;
      if (build) *build = info.dwBuildNumber;
  
      if (version)
      {
  #if 0  /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
          size_t len = min( strlenW(info.szCSDVersion)*sizeof(WCHAR), version->MaximumLength );
          memcpy( version->Buffer, info.szCSDVersion, len );
          if (len < version->MaximumLength) version->Buffer[len / sizeof(WCHAR)] = 0;
          version->Length = len;
  #endif
      }
      return TRUE;
  }
  
  
  /***********************************************************************
   *           PsImpersonateClient   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI PsImpersonateClient(PETHREAD Thread, PACCESS_TOKEN Token, BOOLEAN CopyOnOpen,
                                      BOOLEAN EffectiveOnly, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
  {
      FIXME("(%p, %p, %u, %u, %u): stub\n", Thread, Token, CopyOnOpen, EffectiveOnly, ImpersonationLevel);
  
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           PsSetCreateProcessNotifyRoutine   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback, BOOLEAN remove )
  {
      FIXME( "stub: %p %d\n", callback, remove );
      return STATUS_SUCCESS;
  }
  
  
  /***********************************************************************
   *           PsSetCreateThreadNotifyRoutine   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
  {
      FIXME( "stub: %p\n", NotifyRoutine );
      return STATUS_SUCCESS;
  }
  
  
  /***********************************************************************
   *           PsTerminateSystemThread   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI PsTerminateSystemThread(NTSTATUS ExitStatus)
  {
      FIXME( "stub: %u\n", ExitStatus );
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /***********************************************************************
   *           MmGetSystemRoutineAddress   (NTOSKRNL.EXE.@)
   */
  PVOID WINAPI MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName)
  {
      HMODULE hMod;
      STRING routineNameA;
      PVOID pFunc = NULL;
  
      static const WCHAR ntoskrnlW[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
      static const WCHAR halW[] = {'h','a','l','.','d','l','l',0};
  
      if (!SystemRoutineName) return NULL;
  
      if (RtlUnicodeStringToAnsiString( &routineNameA, SystemRoutineName, TRUE ) == STATUS_SUCCESS)
      {
          /* We only support functions exported from ntoskrnl.exe or hal.dll */
          hMod = GetModuleHandleW( ntoskrnlW );
          pFunc = GetProcAddress( hMod, routineNameA.Buffer );
          if (!pFunc)
          {
             hMod = GetModuleHandleW( halW );
             if (hMod) pFunc = GetProcAddress( hMod, routineNameA.Buffer );
          }
          RtlFreeAnsiString( &routineNameA );
      }
  
      if (pFunc)
          TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName), pFunc );
      else
          FIXME( "%s not found\n", debugstr_us(SystemRoutineName) );
      return pFunc;
  }
  
  
  /***********************************************************************
   *           MmQuerySystemSize   (NTOSKRNL.EXE.@)
   */
  MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void)
  {
      FIXME("stub\n");
      return MmLargeSystem;
  }
  
  /***********************************************************************
   *           KeInitializeDpc   (NTOSKRNL.EXE.@)
   */
  VOID WINAPI KeInitializeDpc(PRKDPC Dpc, PKDEFERRED_ROUTINE DeferredRoutine, PVOID DeferredContext)
  {
      FIXME("stub\n");
  }
  
  /***********************************************************************
   *           READ_REGISTER_BUFFER_UCHAR   (NTOSKRNL.EXE.@)
   */
  VOID WINAPI READ_REGISTER_BUFFER_UCHAR(PUCHAR Register, PUCHAR Buffer, ULONG Count)
  {
      FIXME("stub\n");
  }
  
  /*****************************************************
   *           PoSetPowerState   (NTOSKRNL.EXE.@)
   */
  POWER_STATE WINAPI PoSetPowerState(PDEVICE_OBJECT DeviceObject, POWER_STATE_TYPE Type, POWER_STATE State)
  {
      FIXME("(%p %u %u) stub\n", DeviceObject, Type, State.DeviceState);
      return State;
  }
  
  /*****************************************************
   *           IoWMIRegistrationControl   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject, ULONG Action)
  {
      FIXME("(%p %u) stub\n", DeviceObject, Action);
      return STATUS_SUCCESS;
  }
  
  /*****************************************************
   *           PsSetLoadImageNotifyRoutine   (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine)
  {
      FIXME("(%p) stub\n", routine);
      return STATUS_SUCCESS;
  }
  
  /*****************************************************
   *           PsLookupProcessByProcessId  (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI PsLookupProcessByProcessId(HANDLE processid, PEPROCESS *process)
  {
      FIXME("(%p %p) stub\n", processid, process);
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /*****************************************************
   *           IoSetThreadHardErrorMode  (NTOSKRNL.EXE.@)
   */
  BOOLEAN WINAPI IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors)
  {
      FIXME("stub\n");
      return FALSE;
  }
  
  
  /*****************************************************
   *           IoInitializeRemoveLockEx  (NTOSKRNL.EXE.@)
   */
  VOID WINAPI IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock, ULONG tag,
                                       ULONG maxmin, ULONG high, ULONG size)
  {
      FIXME("(%p %u %u %u %u) stub\n", lock, tag, maxmin, high, size);
  }
  
  
  /*****************************************************
   *           IoAcquireRemoveLockEx  (NTOSKRNL.EXE.@)
   */
  
  NTSTATUS WINAPI IoAcquireRemoveLockEx(PIO_REMOVE_LOCK lock, PVOID tag,
                                        LPCSTR file, ULONG line, ULONG lock_size)
  {
      FIXME("(%p, %p, %s, %u, %u): stub\n", lock, tag, debugstr_a(file), line, lock_size);
  
      return STATUS_NOT_IMPLEMENTED;
  }
  
  
  /*****************************************************
   *           DllMain
   */
  BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
  {
      static void *handler;
      LARGE_INTEGER count;
  
      switch(reason)
      {
      case DLL_PROCESS_ATTACH:
          DisableThreadLibraryCalls( inst );
  #ifdef __i386__
          handler = RtlAddVectoredExceptionHandler( TRUE, vectored_handler );
  #endif
          KeQueryTickCount( &count );  /* initialize the global KeTickCount */
          break;
      case DLL_PROCESS_DETACH:
          if (reserved) break;
          RtlRemoveVectoredExceptionHandler( handler );
          break;
      }
      return TRUE;
  }
  
  /*****************************************************
   *           Ke386IoSetAccessProcess  (NTOSKRNL.EXE.@)
   */
  BOOLEAN WINAPI Ke386IoSetAccessProcess(PEPROCESS *process, ULONG flag)
  {
      FIXME("(%p %d) stub\n", process, flag);
      return FALSE;
  }
  
  /*****************************************************
   *           Ke386SetIoAccessMap  (NTOSKRNL.EXE.@)
   */
  BOOLEAN WINAPI Ke386SetIoAccessMap(ULONG flag, PVOID buffer)
  {
      FIXME("(%d %p) stub\n", flag, buffer);
      return FALSE;
  }
  
  /*****************************************************
   *           IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
   */
  PKEVENT WINAPI IoCreateSynchronizationEvent(PUNICODE_STRING name, PHANDLE handle)
  {
      FIXME("(%p %p) stub\n", name, handle);
      return NULL;
  }
  
  /*****************************************************
   *           IoStartNextPacket  (NTOSKRNL.EXE.@)
   */
  VOID WINAPI IoStartNextPacket(PDEVICE_OBJECT deviceobject, BOOLEAN cancelable)
  {
      FIXME("(%p %d) stub\n", deviceobject, cancelable);
  }
  
  /*****************************************************
   *           ObQueryNameString  (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI ObQueryNameString(PVOID object, POBJECT_NAME_INFORMATION name, ULONG maxlength, PULONG returnlength)
  {
      FIXME("(%p %p %u %p) stub\n", object, name, maxlength, returnlength);
      return STATUS_NOT_IMPLEMENTED;
  }
  
  /*****************************************************
   *           IoRegisterPlugPlayNotification  (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoRegisterPlugPlayNotification(IO_NOTIFICATION_EVENT_CATEGORY category, ULONG flags, PVOID data,
                                                 PDRIVER_OBJECT driver, PDRIVER_NOTIFICATION_CALLBACK_ROUTINE callback,
                                                 PVOID context, PVOID *notification)
  {
      FIXME("(%u %u %p %p %p %p %p) stub\n", category, flags, data, driver, callback, context, notification);
      return STATUS_SUCCESS;
  }
  
  /*****************************************************
   *           IoCsqInitialize  (NTOSKRNL.EXE.@)
   */
  NTSTATUS WINAPI IoCsqInitialize(PIO_CSQ csq, PIO_CSQ_INSERT_IRP insert_irp, PIO_CSQ_REMOVE_IRP remove_irp,
                                  PIO_CSQ_PEEK_NEXT_IRP peek_irp, PIO_CSQ_ACQUIRE_LOCK acquire_lock,
                                  PIO_CSQ_RELEASE_LOCK release_lock, PIO_CSQ_COMPLETE_CANCELED_IRP complete_irp)
  {
      FIXME("(%p %p %p %p %p %p %p) stub\n",
            csq, insert_irp, remove_irp, peek_irp, acquire_lock, release_lock, complete_irp);
      return STATUS_SUCCESS;
  }
  
  /*****************************************************
   *           ExInterlockedRemoveHeadList  (NTOSKRNL.EXE.@)
   */
  PLIST_ENTRY WINAPI ExInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
  {
      FIXME("(%p %p) stub\n", head, lock);
      return NULL;
  }
  
  /***********************************************************************
   *           ExfInterlockedRemoveHeadList   (NTOSKRNL.EXE.@)
   */
  #ifdef DEFINE_FASTCALL2_ENTRYPOINT
  DEFINE_FASTCALL2_ENTRYPOINT( ExfInterlockedRemoveHeadList )
  PLIST_ENTRY WINAPI __regs_ExfInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
  #else
  PLIST_ENTRY WINAPI ExfInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
  #endif
  {
      FIXME("(%p %p) stub\n", head, lock);
      return ExInterlockedRemoveHeadList( head, lock );
  }
  