dlls/ntoskrnl.exe/ntoskrnl.c

   1 /*
   2  * ntoskrnl.exe implementation
   3  *
   4  * Copyright (C) 2007 Alexandre Julliard
   5  * Copyright (C) 2010 Damjan Jovanovic
   6  * Copyright (C) 2016 Sebastian Lackner
   7  * Copyright (C) 2016 CodeWeavers, Aric Stewart
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <stdarg.h>
  28
  29 #define NONAMELESSUNION
  30 #define NONAMELESSSTRUCT
  31
  32 #include "ntstatus.h"
  33 #define WIN32_NO_STATUS
  34 #include "windef.h"
  35 #include "winsvc.h"
  36 #include "winternl.h"
  37 #include "excpt.h"
  38 #include "winioctl.h"
  39 #include "ddk/csq.h"
  40 #include "ddk/ntddk.h"
  41 #include "ddk/ntifs.h"
  42 #include "ddk/wdm.h"
  43 #include "wine/unicode.h"
  44 #include "wine/server.h"
  45 #include "wine/debug.h"
  46
  47 #include "wine/rbtree.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl);
  50 WINE_DECLARE_DEBUG_CHANNEL(relay);
  51 WINE_DECLARE_DEBUG_CHANNEL(plugplay);
  52
  53 BOOLEAN KdDebuggerEnabled = FALSE;
  54 ULONG InitSafeBootMode = 0;
  55
  56 extern LONG CALLBACK vectored_handler( EXCEPTION_POINTERS *ptrs );
  57
  58 KSYSTEM_TIME KeTickCount = { 0, 0, 0 };
  59
  60 typedef struct _KSERVICE_TABLE_DESCRIPTOR
  61 {
  62     PULONG_PTR Base;
  63     PULONG Count;
  64     ULONG Limit;
  65     PUCHAR Number;
  66 } KSERVICE_TABLE_DESCRIPTOR, *PKSERVICE_TABLE_DESCRIPTOR;
  67
  68 KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable[4] = { { 0 } };
  69
  70 typedef void (WINAPI *PCREATE_PROCESS_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
  71 typedef void (WINAPI *PCREATE_PROCESS_NOTIFY_ROUTINE_EX)(PEPROCESS,HANDLE,PPS_CREATE_NOTIFY_INFO);
  72 typedef void (WINAPI *PCREATE_THREAD_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
  73
  74 static const WCHAR servicesW[] = {'\\','R','e','g','i','s','t','r','y',
  75                                   '\\','M','a','c','h','i','n','e',
  76                                   '\\','S','y','s','t','e','m',
  77                                   '\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
  78                                   '\\','S','e','r','v','i','c','e','s',
  79                                   '\\',0};
  80
  81 #define MAX_SERVICE_NAME 260
  82
  83 /* tid of the thread running client request */
  84 static DWORD request_thread;
  85
  86 /* pid/tid of the client thread */
  87 static DWORD client_tid;
  88 static DWORD client_pid;
  89
  90 struct wine_driver
  91 {
  92     struct wine_rb_entry entry;
  93
  94     DRIVER_OBJECT driver_obj;
  95     DRIVER_EXTENSION driver_extension;
  96 };
  97
  98 static NTSTATUS get_device_id( DEVICE_OBJECT *device, BUS_QUERY_ID_TYPE type, WCHAR **id );
  99
 100 static int wine_drivers_rb_compare( const void *key, const struct wine_rb_entry *entry )
 101 {
 102     const struct wine_driver *driver = WINE_RB_ENTRY_VALUE( entry, const struct wine_driver, entry );
 103     const UNICODE_STRING *k = key;
 104
 105     return RtlCompareUnicodeString( k, &driver->driver_obj.DriverName, FALSE );
 106 }
 107
 108 static struct wine_rb_tree wine_drivers = { wine_drivers_rb_compare };
 109
 110 static CRITICAL_SECTION drivers_cs;
 111 static CRITICAL_SECTION_DEBUG critsect_debug =
 112 {
 113     0, 0, &drivers_cs,
 114     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 115       0, 0, { (DWORD_PTR)(__FILE__ ": drivers_cs") }
 116 };
 117 static CRITICAL_SECTION drivers_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
 118
 119 #ifdef __i386__
 120 #define DEFINE_FASTCALL1_ENTRYPOINT( name ) \
 121     __ASM_STDCALL_FUNC( name, 4, \
 122                        "popl %eax\n\t" \
 123                        "pushl %ecx\n\t" \
 124                        "pushl %eax\n\t" \
 125                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(4))
 126 #define DEFINE_FASTCALL2_ENTRYPOINT( name ) \
 127     __ASM_STDCALL_FUNC( name, 8, \
 128                        "popl %eax\n\t" \
 129                        "pushl %edx\n\t" \
 130                        "pushl %ecx\n\t" \
 131                        "pushl %eax\n\t" \
 132                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(8))
 133 #define DEFINE_FASTCALL3_ENTRYPOINT( name ) \
 134     __ASM_STDCALL_FUNC( name, 12, \
 135                        "popl %eax\n\t" \
 136                        "pushl %edx\n\t" \
 137                        "pushl %ecx\n\t" \
 138                        "pushl %eax\n\t" \
 139                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(12))
 140 #endif
 141
 142 static inline LPCSTR debugstr_us( const UNICODE_STRING *us )
 143 {
 144     if (!us) return "<null>";
 145     return debugstr_wn( us->Buffer, us->Length / sizeof(WCHAR) );
 146 }
 147
 148 static HANDLE get_device_manager(void)
 149 {
 150     static HANDLE device_manager;
 151     HANDLE handle = 0, ret = device_manager;
 152
 153     if (!ret)
 154     {
 155         SERVER_START_REQ( create_device_manager )
 156         {
 157             req->access     = SYNCHRONIZE;
 158             req->attributes = 0;
 159             if (!wine_server_call( req )) handle = wine_server_ptr_handle( reply->handle );
 160         }
 161         SERVER_END_REQ;
 162
 163         if (!handle)
 164         {
 165             ERR( "failed to create the device manager\n" );
 166             return 0;
 167         }
 168         if (!(ret = InterlockedCompareExchangePointer( &device_manager, handle, 0 )))
 169             ret = handle;
 170         else
 171             NtClose( handle );  /* somebody beat us to it */
 172     }
 173     return ret;
 174 }
 175
 176 /* transfer result of IRP back to wineserver */
 177 static NTSTATUS WINAPI dispatch_irp_completion( DEVICE_OBJECT *device, IRP *irp, void *context )
 178 {
 179     FILE_OBJECT *file = irp->Tail.Overlay.OriginalFileObject;
 180     HANDLE irp_handle = context;
 181     void *out_buff = irp->UserBuffer;
 182
 183     if (irp->Flags & IRP_WRITE_OPERATION)
 184         out_buff = NULL;  /* do not transfer back input buffer */
 185
 186     SERVER_START_REQ( set_irp_result )
 187     {
 188         req->handle   = wine_server_obj_handle( irp_handle );
 189         req->status   = irp->IoStatus.u.Status;
 190         req->file_ptr = wine_server_client_ptr( file );
 191         if (irp->IoStatus.u.Status >= 0)
 192         {
 193             req->size = irp->IoStatus.Information;
 194             if (out_buff) wine_server_add_data( req, out_buff, irp->IoStatus.Information );
 195         }
 196         wine_server_call( req );
 197     }
 198     SERVER_END_REQ;
 199
 200     if (irp->Flags & IRP_CLOSE_OPERATION)
 201     {
 202         HeapFree( GetProcessHeap(), 0, file );
 203         irp->Tail.Overlay.OriginalFileObject = NULL;
 204     }
 205
 206     if (irp->UserBuffer != irp->AssociatedIrp.SystemBuffer)
 207     {
 208         HeapFree( GetProcessHeap(), 0, irp->UserBuffer );
 209         irp->UserBuffer = NULL;
 210     }
 211     return STATUS_SUCCESS;
 212 }
 213
 214 static void dispatch_irp( DEVICE_OBJECT *device, IRP *irp, HANDLE irp_handle )
 215 {
 216     LARGE_INTEGER count;
 217
 218     IoSetCompletionRoutine( irp, dispatch_irp_completion, irp_handle, TRUE, TRUE, TRUE );
 219     KeQueryTickCount( &count );  /* update the global KeTickCount */
 220
 221     device->CurrentIrp = irp;
 222     IoCallDriver( device, irp );
 223     device->CurrentIrp = NULL;
 224 }
 225
 226 /* process a create request for a given file */
 227 static NTSTATUS dispatch_create( const irp_params_t *params, void *in_buff, ULONG in_size,
 228                                  ULONG out_size, HANDLE irp_handle )
 229 {
 230     IRP *irp;
 231     IO_STACK_LOCATION *irpsp;
 232     FILE_OBJECT *file;
 233     DEVICE_OBJECT *device = wine_server_get_ptr( params->create.device );
 234
 235     if (!(file = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*file) ))) return STATUS_NO_MEMORY;
 236
 237     TRACE( "device %p -> file %p\n", device, file );
 238
 239     file->Type = 5;  /* MSDN */
 240     file->Size = sizeof(*file);
 241     file->DeviceObject = device;
 242
 243     if (!(irp = IoAllocateIrp( device->StackSize, FALSE )))
 244     {
 245         HeapFree( GetProcessHeap(), 0, file );
 246         return STATUS_NO_MEMORY;
 247     }
 248
 249     irpsp = IoGetNextIrpStackLocation( irp );
 250     irpsp->MajorFunction = IRP_MJ_CREATE;
 251     irpsp->DeviceObject = device;
 252     irpsp->Parameters.Create.SecurityContext = NULL;  /* FIXME */
 253     irpsp->Parameters.Create.Options = params->create.options;
 254     irpsp->Parameters.Create.ShareAccess = params->create.sharing;
 255     irpsp->Parameters.Create.FileAttributes = 0;
 256     irpsp->Parameters.Create.EaLength = 0;
 257
 258     irp->Tail.Overlay.OriginalFileObject = file;
 259     irp->RequestorMode = UserMode;
 260     irp->AssociatedIrp.SystemBuffer = NULL;
 261     irp->UserBuffer = NULL;
 262     irp->UserIosb = NULL;
 263     irp->UserEvent = NULL;
 264
 265     irp->Flags |= IRP_CREATE_OPERATION;
 266     dispatch_irp( device, irp, irp_handle );
 267
 268     HeapFree( GetProcessHeap(), 0, in_buff );
 269     return STATUS_SUCCESS;
 270 }
 271
 272 /* process a close request for a given file */
 273 static NTSTATUS dispatch_close( const irp_params_t *params, void *in_buff, ULONG in_size,
 274                                  ULONG out_size, HANDLE irp_handle )
 275 {
 276     IRP *irp;
 277     IO_STACK_LOCATION *irpsp;
 278     DEVICE_OBJECT *device;
 279     FILE_OBJECT *file = wine_server_get_ptr( params->close.file );
 280
 281     if (!file) return STATUS_INVALID_HANDLE;
 282
 283     device = file->DeviceObject;
 284
 285     TRACE( "device %p file %p\n", device, file );
 286
 287     if (!(irp = IoAllocateIrp( device->StackSize, FALSE )))
 288     {
 289         HeapFree( GetProcessHeap(), 0, file );
 290         return STATUS_NO_MEMORY;
 291     }
 292
 293     irpsp = IoGetNextIrpStackLocation( irp );
 294     irpsp->MajorFunction = IRP_MJ_CLOSE;
 295     irpsp->DeviceObject = device;
 296
 297     irp->Tail.Overlay.OriginalFileObject = file;
 298     irp->RequestorMode = UserMode;
 299     irp->AssociatedIrp.SystemBuffer = NULL;
 300     irp->UserBuffer = NULL;
 301     irp->UserIosb = NULL;
 302     irp->UserEvent = NULL;
 303
 304     irp->Flags |= IRP_CLOSE_OPERATION;
 305     dispatch_irp( device, irp, irp_handle );
 306
 307     HeapFree( GetProcessHeap(), 0, in_buff );
 308     return STATUS_SUCCESS;
 309 }
 310
 311 /* process a read request for a given device */
 312 static NTSTATUS dispatch_read( const irp_params_t *params, void *in_buff, ULONG in_size,
 313                                ULONG out_size, HANDLE irp_handle )
 314 {
 315     IRP *irp;
 316     void *out_buff;
 317     LARGE_INTEGER offset;
 318     IO_STACK_LOCATION *irpsp;
 319     DEVICE_OBJECT *device;
 320     FILE_OBJECT *file = wine_server_get_ptr( params->read.file );
 321
 322     if (!file) return STATUS_INVALID_HANDLE;
 323
 324     device = file->DeviceObject;
 325
 326     TRACE( "device %p file %p size %u\n", device, file, out_size );
 327
 328     if (!(out_buff = HeapAlloc( GetProcessHeap(), 0, out_size ))) return STATUS_NO_MEMORY;
 329
 330     offset.QuadPart = params->read.pos;
 331
 332     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ, device, out_buff, out_size,
 333                                               &offset, NULL, NULL )))
 334     {
 335         HeapFree( GetProcessHeap(), 0, out_buff );
 336         return STATUS_NO_MEMORY;
 337     }
 338
 339     irp->Tail.Overlay.OriginalFileObject = file;
 340     irp->RequestorMode = UserMode;
 341
 342     irpsp = IoGetNextIrpStackLocation( irp );
 343     irpsp->Parameters.Read.Key = params->read.key;
 344
 345     irp->Flags |= IRP_READ_OPERATION;
 346     irp->Flags |= IRP_DEALLOCATE_BUFFER;  /* deallocate out_buff */
 347     dispatch_irp( device, irp, irp_handle );
 348
 349     HeapFree( GetProcessHeap(), 0, in_buff );
 350     return STATUS_SUCCESS;
 351 }
 352
 353 /* process a write request for a given device */
 354 static NTSTATUS dispatch_write( const irp_params_t *params, void *in_buff, ULONG in_size,
 355                                 ULONG out_size, HANDLE irp_handle )
 356 {
 357     IRP *irp;
 358     LARGE_INTEGER offset;
 359     IO_STACK_LOCATION *irpsp;
 360     DEVICE_OBJECT *device;
 361     FILE_OBJECT *file = wine_server_get_ptr( params->write.file );
 362
 363     if (!file) return STATUS_INVALID_HANDLE;
 364
 365     device = file->DeviceObject;
 366
 367     TRACE( "device %p file %p size %u\n", device, file, in_size );
 368
 369     offset.QuadPart = params->write.pos;
 370
 371     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_WRITE, device, in_buff, in_size,
 372                                               &offset, NULL, NULL )))
 373         return STATUS_NO_MEMORY;
 374
 375     irp->Tail.Overlay.OriginalFileObject = file;
 376     irp->RequestorMode = UserMode;
 377
 378     irpsp = IoGetNextIrpStackLocation( irp );
 379     irpsp->Parameters.Write.Key = params->write.key;
 380
 381     irp->Flags |= IRP_WRITE_OPERATION;
 382     irp->Flags |= IRP_DEALLOCATE_BUFFER;  /* deallocate in_buff */
 383     dispatch_irp( device, irp, irp_handle );
 384
 385     return STATUS_SUCCESS;
 386 }
 387
 388 /* process a flush request for a given device */
 389 static NTSTATUS dispatch_flush( const irp_params_t *params, void *in_buff, ULONG in_size,
 390                                 ULONG out_size, HANDLE irp_handle )
 391 {
 392     IRP *irp;
 393     DEVICE_OBJECT *device;
 394     FILE_OBJECT *file = wine_server_get_ptr( params->flush.file );
 395
 396     if (!file) return STATUS_INVALID_HANDLE;
 397
 398     device = file->DeviceObject;
 399
 400     TRACE( "device %p file %p\n", device, file );
 401
 402     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_FLUSH_BUFFERS, device, NULL, 0,
 403                                               NULL, NULL, NULL )))
 404         return STATUS_NO_MEMORY;
 405
 406     irp->Tail.Overlay.OriginalFileObject = file;
 407     irp->RequestorMode = UserMode;
 408
 409     dispatch_irp( device, irp, irp_handle );
 410
 411     HeapFree( GetProcessHeap(), 0, in_buff );
 412     return STATUS_SUCCESS;
 413 }
 414
 415 /* process an ioctl request for a given device */
 416 static NTSTATUS dispatch_ioctl( const irp_params_t *params, void *in_buff, ULONG in_size,
 417                                 ULONG out_size, HANDLE irp_handle )
 418 {
 419     IRP *irp;
 420     void *out_buff = NULL;
 421     void *to_free = NULL;
 422     DEVICE_OBJECT *device;
 423     FILE_OBJECT *file = wine_server_get_ptr( params->ioctl.file );
 424
 425     if (!file) return STATUS_INVALID_HANDLE;
 426
 427     device = file->DeviceObject;
 428
 429     TRACE( "ioctl %x device %p file %p in_size %u out_size %u\n",
 430            params->ioctl.code, device, file, in_size, out_size );
 431
 432     if (out_size)
 433     {
 434         if ((params->ioctl.code & 3) != METHOD_BUFFERED)
 435         {
 436             if (in_size < out_size) return STATUS_INVALID_DEVICE_REQUEST;
 437             in_size -= out_size;
 438             if (!(out_buff = HeapAlloc( GetProcessHeap(), 0, out_size ))) return STATUS_NO_MEMORY;
 439             memcpy( out_buff, (char *)in_buff + in_size, out_size );
 440         }
 441         else if (out_size > in_size)
 442         {
 443             if (!(out_buff = HeapAlloc( GetProcessHeap(), 0, out_size ))) return STATUS_NO_MEMORY;
 444             memcpy( out_buff, in_buff, in_size );
 445             to_free = in_buff;
 446             in_buff = out_buff;
 447         }
 448         else
 449         {
 450             out_buff = in_buff;
 451             out_size = in_size;
 452         }
 453     }
 454
 455     irp = IoBuildDeviceIoControlRequest( params->ioctl.code, device, in_buff, in_size, out_buff, out_size,
 456                                          FALSE, NULL, NULL );
 457     if (!irp)
 458     {
 459         HeapFree( GetProcessHeap(), 0, out_buff );
 460         return STATUS_NO_MEMORY;
 461     }
 462
 463     if (out_size && (params->ioctl.code & 3) != METHOD_BUFFERED)
 464         HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, in_buff, in_size );
 465
 466     irp->Tail.Overlay.OriginalFileObject = file;
 467     irp->RequestorMode = UserMode;
 468     irp->AssociatedIrp.SystemBuffer = in_buff;
 469
 470     irp->Flags |= IRP_DEALLOCATE_BUFFER;  /* deallocate in_buff */
 471     dispatch_irp( device, irp, irp_handle );
 472
 473     HeapFree( GetProcessHeap(), 0, to_free );
 474     return STATUS_SUCCESS;
 475 }
 476
 477 typedef NTSTATUS (*dispatch_func)( const irp_params_t *params, void *in_buff, ULONG in_size,
 478                                    ULONG out_size, HANDLE irp_handle );
 479
 480 static const dispatch_func dispatch_funcs[IRP_MJ_MAXIMUM_FUNCTION + 1] =
 481 {
 482     dispatch_create,   /* IRP_MJ_CREATE */
 483     NULL,              /* IRP_MJ_CREATE_NAMED_PIPE */
 484     dispatch_close,    /* IRP_MJ_CLOSE */
 485     dispatch_read,     /* IRP_MJ_READ */
 486     dispatch_write,    /* IRP_MJ_WRITE */
 487     NULL,              /* IRP_MJ_QUERY_INFORMATION */
 488     NULL,              /* IRP_MJ_SET_INFORMATION */
 489     NULL,              /* IRP_MJ_QUERY_EA */
 490     NULL,              /* IRP_MJ_SET_EA */
 491     dispatch_flush,    /* IRP_MJ_FLUSH_BUFFERS */
 492     NULL,              /* IRP_MJ_QUERY_VOLUME_INFORMATION */
 493     NULL,              /* IRP_MJ_SET_VOLUME_INFORMATION */
 494     NULL,              /* IRP_MJ_DIRECTORY_CONTROL */
 495     NULL,              /* IRP_MJ_FILE_SYSTEM_CONTROL */
 496     dispatch_ioctl,    /* IRP_MJ_DEVICE_CONTROL */
 497     NULL,              /* IRP_MJ_INTERNAL_DEVICE_CONTROL */
 498     NULL,              /* IRP_MJ_SHUTDOWN */
 499     NULL,              /* IRP_MJ_LOCK_CONTROL */
 500     NULL,              /* IRP_MJ_CLEANUP */
 501     NULL,              /* IRP_MJ_CREATE_MAILSLOT */
 502     NULL,              /* IRP_MJ_QUERY_SECURITY */
 503     NULL,              /* IRP_MJ_SET_SECURITY */
 504     NULL,              /* IRP_MJ_POWER */
 505     NULL,              /* IRP_MJ_SYSTEM_CONTROL */
 506     NULL,              /* IRP_MJ_DEVICE_CHANGE */
 507     NULL,              /* IRP_MJ_QUERY_QUOTA */
 508     NULL,              /* IRP_MJ_SET_QUOTA */
 509     NULL,              /* IRP_MJ_PNP */
 510 };
 511
 512
 513 /***********************************************************************
 514  *           wine_ntoskrnl_main_loop   (Not a Windows API)
 515  */
 516 NTSTATUS CDECL wine_ntoskrnl_main_loop( HANDLE stop_event )
 517 {
 518     HANDLE manager = get_device_manager();
 519     HANDLE irp = 0;
 520     NTSTATUS status = STATUS_SUCCESS;
 521     irp_params_t irp_params;
 522     ULONG in_size = 4096, out_size = 0;
 523     void *in_buff = NULL;
 524     HANDLE handles[2];
 525
 526     request_thread = GetCurrentThreadId();
 527
 528     handles[0] = stop_event;
 529     handles[1] = manager;
 530
 531     for (;;)
 532     {
 533         if (!in_buff && !(in_buff = HeapAlloc( GetProcessHeap(), 0, in_size )))
 534         {
 535             ERR( "failed to allocate buffer\n" );
 536             return STATUS_NO_MEMORY;
 537         }
 538
 539         SERVER_START_REQ( get_next_device_request )
 540         {
 541             req->manager = wine_server_obj_handle( manager );
 542             req->prev = wine_server_obj_handle( irp );
 543             req->status = status;
 544             wine_server_set_reply( req, in_buff, in_size );
 545             if (!(status = wine_server_call( req )))
 546             {
 547                 irp        = wine_server_ptr_handle( reply->next );
 548                 irp_params = reply->params;
 549                 client_tid = reply->client_tid;
 550                 client_pid = reply->client_pid;
 551                 in_size    = reply->in_size;
 552                 out_size   = reply->out_size;
 553             }
 554             else
 555             {
 556                 irp = 0; /* no previous irp */
 557                 if (status == STATUS_BUFFER_OVERFLOW)
 558                     in_size = reply->in_size;
 559             }
 560         }
 561         SERVER_END_REQ;
 562
 563         switch (status)
 564         {
 565         case STATUS_SUCCESS:
 566             if (irp_params.major > IRP_MJ_MAXIMUM_FUNCTION || !dispatch_funcs[irp_params.major])
 567             {
 568                 WARN( "unsupported request %u\n", irp_params.major );
 569                 status = STATUS_NOT_SUPPORTED;
 570                 break;
 571             }
 572             status = dispatch_funcs[irp_params.major]( &irp_params, in_buff, in_size, out_size, irp );
 573             if (status == STATUS_SUCCESS)
 574             {
 575                 irp = 0;  /* status reported by IoCompleteRequest */
 576                 in_size = 4096;
 577                 in_buff = NULL;
 578             }
 579             break;
 580         case STATUS_BUFFER_OVERFLOW:
 581             HeapFree( GetProcessHeap(), 0, in_buff );
 582             in_buff = NULL;
 583             /* restart with larger buffer */
 584             break;
 585         case STATUS_PENDING:
 586             for (;;)
 587             {
 588                 DWORD ret = WaitForMultipleObjectsEx( 2, handles, FALSE, INFINITE, TRUE );
 589                 if (ret == WAIT_OBJECT_0)
 590                 {
 591                     HeapFree( GetProcessHeap(), 0, in_buff );
 592                     return STATUS_SUCCESS;
 593                 }
 594                 if (ret != WAIT_IO_COMPLETION) break;
 595             }
 596             break;
 597         }
 598     }
 599 }
 600
 601
 602 /***********************************************************************
 603  *           IoAcquireCancelSpinLock  (NTOSKRNL.EXE.@)
 604  */
 605 void WINAPI IoAcquireCancelSpinLock(PKIRQL irql)
 606 {
 607     FIXME("(%p): stub\n", irql);
 608 }
 609
 610
 611 /***********************************************************************
 612  *           IoReleaseCancelSpinLock  (NTOSKRNL.EXE.@)
 613  */
 614 void WINAPI IoReleaseCancelSpinLock(PKIRQL irql)
 615 {
 616     FIXME("(%p): stub\n", irql);
 617 }
 618
 619
 620 /***********************************************************************
 621  *           IoAllocateDriverObjectExtension  (NTOSKRNL.EXE.@)
 622  */
 623 NTSTATUS WINAPI IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject,
 624                                                  PVOID ClientIdentificationAddress,
 625                                                  ULONG DriverObjectExtensionSize,
 626                                                  PVOID *DriverObjectExtension )
 627 {
 628     FIXME( "stub: %p, %p, %u, %p\n", DriverObject, ClientIdentificationAddress,
 629             DriverObjectExtensionSize, DriverObjectExtension );
 630     return STATUS_NOT_IMPLEMENTED;
 631 }
 632
 633
 634 /***********************************************************************
 635  *           IoGetDriverObjectExtension  (NTOSKRNL.EXE.@)
 636  */
 637 PVOID WINAPI IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject,
 638                                          PVOID ClientIdentificationAddress )
 639 {
 640     FIXME( "stub: %p, %p\n", DriverObject, ClientIdentificationAddress );
 641     return NULL;
 642 }
 643
 644
 645 /***********************************************************************
 646  *           IoInitializeIrp  (NTOSKRNL.EXE.@)
 647  */
 648 void WINAPI IoInitializeIrp( IRP *irp, USHORT size, CCHAR stack_size )
 649 {
 650     TRACE( "%p, %u, %d\n", irp, size, stack_size );
 651
 652     RtlZeroMemory( irp, size );
 653
 654     irp->Type = IO_TYPE_IRP;
 655     irp->Size = size;
 656     InitializeListHead( &irp->ThreadListEntry );
 657     irp->StackCount = stack_size;
 658     irp->CurrentLocation = stack_size + 1;
 659     irp->Tail.Overlay.s.u2.CurrentStackLocation =
 660             (PIO_STACK_LOCATION)(irp + 1) + stack_size;
 661 }
 662
 663
 664 /***********************************************************************
 665  *           IoInitializeTimer   (NTOSKRNL.EXE.@)
 666  */
 667 NTSTATUS WINAPI IoInitializeTimer(PDEVICE_OBJECT DeviceObject,
 668                                   PIO_TIMER_ROUTINE TimerRoutine,
 669                                   PVOID Context)
 670 {
 671     FIXME( "stub: %p, %p, %p\n", DeviceObject, TimerRoutine, Context );
 672     return STATUS_NOT_IMPLEMENTED;
 673 }
 674
 675
 676 /***********************************************************************
 677  *           IoStartTimer   (NTOSKRNL.EXE.@)
 678  */
 679 void WINAPI IoStartTimer(PDEVICE_OBJECT DeviceObject)
 680 {
 681     FIXME( "stub: %p\n", DeviceObject );
 682 }
 683
 684
 685 /***********************************************************************
 686  *           IoStopTimer   (NTOSKRNL.EXE.@)
 687  */
 688 void WINAPI IoStopTimer(PDEVICE_OBJECT DeviceObject)
 689 {
 690     FIXME( "stub: %p\n", DeviceObject );
 691 }
 692
 693
 694 /***********************************************************************
 695  *           IoAllocateIrp  (NTOSKRNL.EXE.@)
 696  */
 697 PIRP WINAPI IoAllocateIrp( CCHAR stack_size, BOOLEAN charge_quota )
 698 {
 699     SIZE_T size;
 700     PIRP irp;
 701     CCHAR loc_count = stack_size;
 702
 703     TRACE( "%d, %d\n", stack_size, charge_quota );
 704
 705     if (loc_count < 8 && loc_count != 1)
 706         loc_count = 8;
 707
 708     size = sizeof(IRP) + loc_count * sizeof(IO_STACK_LOCATION);
 709     irp = ExAllocatePool( NonPagedPool, size );
 710     if (irp == NULL)
 711         return NULL;
 712     IoInitializeIrp( irp, size, stack_size );
 713     if (stack_size >= 1 && stack_size <= 8)
 714         irp->AllocationFlags = IRP_ALLOCATED_FIXED_SIZE;
 715     if (charge_quota)
 716         irp->AllocationFlags |= IRP_LOOKASIDE_ALLOCATION;
 717     return irp;
 718 }
 719
 720
 721 /***********************************************************************
 722  *           IoFreeIrp  (NTOSKRNL.EXE.@)
 723  */
 724 void WINAPI IoFreeIrp( IRP *irp )
 725 {
 726     MDL *mdl;
 727
 728     TRACE( "%p\n", irp );
 729
 730     mdl = irp->MdlAddress;
 731     while (mdl)
 732     {
 733         MDL *next = mdl->Next;
 734         IoFreeMdl( mdl );
 735         mdl = next;
 736     }
 737
 738     ExFreePool( irp );
 739 }
 740
 741
 742 /***********************************************************************
 743  *           IoAllocateErrorLogEntry  (NTOSKRNL.EXE.@)
 744  */
 745 PVOID WINAPI IoAllocateErrorLogEntry( PVOID IoObject, UCHAR EntrySize )
 746 {
 747     FIXME( "stub: %p, %u\n", IoObject, EntrySize );
 748     return NULL;
 749 }
 750
 751
 752 /***********************************************************************
 753  *           IoAllocateMdl  (NTOSKRNL.EXE.@)
 754  */
 755 PMDL WINAPI IoAllocateMdl( PVOID va, ULONG length, BOOLEAN secondary, BOOLEAN charge_quota, IRP *irp )
 756 {
 757     SIZE_T mdl_size;
 758     PMDL mdl;
 759
 760     TRACE("(%p, %u, %i, %i, %p)\n", va, length, secondary, charge_quota, irp);
 761
 762     if (charge_quota)
 763         FIXME("Charge quota is not yet supported\n");
 764
 765     mdl_size = sizeof(MDL) + sizeof(PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(va, length);
 766     mdl = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, mdl_size );
 767     if (!mdl)
 768         return NULL;
 769
 770     MmInitializeMdl( mdl, va, length );
 771
 772     if (!irp) return mdl;
 773
 774     if (secondary)  /* add it at the end */
 775     {
 776         MDL **pmdl = &irp->MdlAddress;
 777         while (*pmdl) pmdl = &(*pmdl)->Next;
 778         *pmdl = mdl;
 779     }
 780     else
 781     {
 782         mdl->Next = irp->MdlAddress;
 783         irp->MdlAddress = mdl;
 784     }
 785     return mdl;
 786 }
 787
 788
 789 /***********************************************************************
 790  *           IoFreeMdl  (NTOSKRNL.EXE.@)
 791  */
 792 void WINAPI IoFreeMdl(PMDL mdl)
 793 {
 794     TRACE("%p\n", mdl);
 795     HeapFree(GetProcessHeap(), 0, mdl);
 796 }
 797
 798
 799 /***********************************************************************
 800  *           IoAllocateWorkItem  (NTOSKRNL.EXE.@)
 801  */
 802 PIO_WORKITEM WINAPI IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject )
 803 {
 804     FIXME( "stub: %p\n", DeviceObject );
 805     return NULL;
 806 }
 807
 808
 809 /***********************************************************************
 810  *           IoAttachDeviceToDeviceStack  (NTOSKRNL.EXE.@)
 811  */
 812 PDEVICE_OBJECT WINAPI IoAttachDeviceToDeviceStack( DEVICE_OBJECT *source,
 813                                                    DEVICE_OBJECT *target )
 814 {
 815     TRACE( "%p, %p\n", source, target );
 816     target->AttachedDevice = source;
 817     source->StackSize = target->StackSize + 1;
 818     return target;
 819 }
 820
 821
 822 /***********************************************************************
 823  *           IoBuildDeviceIoControlRequest  (NTOSKRNL.EXE.@)
 824  */
 825 PIRP WINAPI IoBuildDeviceIoControlRequest( ULONG code, PDEVICE_OBJECT device,
 826                                            PVOID in_buff, ULONG in_len,
 827                                            PVOID out_buff, ULONG out_len,
 828                                            BOOLEAN internal, PKEVENT event,
 829                                            PIO_STATUS_BLOCK iosb )
 830 {
 831     PIRP irp;
 832     PIO_STACK_LOCATION irpsp;
 833     MDL *mdl;
 834
 835     TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
 836            code, device, in_buff, in_len, out_buff, out_len, internal, event, iosb );
 837
 838     if (device == NULL)
 839         return NULL;
 840
 841     irp = IoAllocateIrp( device->StackSize, FALSE );
 842     if (irp == NULL)
 843         return NULL;
 844
 845     irpsp = IoGetNextIrpStackLocation( irp );
 846     irpsp->MajorFunction = internal ? IRP_MJ_INTERNAL_DEVICE_CONTROL : IRP_MJ_DEVICE_CONTROL;
 847     irpsp->Parameters.DeviceIoControl.IoControlCode = code;
 848     irpsp->Parameters.DeviceIoControl.InputBufferLength = in_len;
 849     irpsp->Parameters.DeviceIoControl.OutputBufferLength = out_len;
 850     irpsp->DeviceObject = device;
 851     irpsp->CompletionRoutine = NULL;
 852
 853     switch (code & 3)
 854     {
 855     case METHOD_BUFFERED:
 856         irp->AssociatedIrp.SystemBuffer = in_buff;
 857         break;
 858     case METHOD_IN_DIRECT:
 859     case METHOD_OUT_DIRECT:
 860         irp->AssociatedIrp.SystemBuffer = in_buff;
 861
 862         mdl = IoAllocateMdl( out_buff, out_len, FALSE, FALSE, irp );
 863         if (!mdl)
 864         {
 865             IoFreeIrp( irp );
 866             return NULL;
 867         }
 868
 869         mdl->MdlFlags |= MDL_MAPPED_TO_SYSTEM_VA;
 870         mdl->MappedSystemVa = out_buff;
 871         break;
 872     case METHOD_NEITHER:
 873         irpsp->Parameters.DeviceIoControl.Type3InputBuffer = in_buff;
 874         break;
 875     }
 876
 877     irp->RequestorMode = KernelMode;
 878     irp->UserBuffer = out_buff;
 879     irp->UserIosb = iosb;
 880     irp->UserEvent = event;
 881     return irp;
 882 }
 883
 884
 885 /**********************************************************
 886  *           IoBuildSynchronousFsdRequest  (NTOSKRNL.EXE.@)
 887  */
 888 PIRP WINAPI IoBuildSynchronousFsdRequest(ULONG majorfunc, PDEVICE_OBJECT device,
 889                                          PVOID buffer, ULONG length, PLARGE_INTEGER startoffset,
 890                                          PKEVENT event, PIO_STATUS_BLOCK iosb)
 891 {
 892     PIRP irp;
 893     PIO_STACK_LOCATION irpsp;
 894
 895     TRACE("(%d %p %p %d %p %p %p)\n", majorfunc, device, buffer, length, startoffset, event, iosb);
 896
 897     if (!(irp = IoAllocateIrp( device->StackSize, FALSE ))) return NULL;
 898
 899     irpsp = IoGetNextIrpStackLocation( irp );
 900     irpsp->MajorFunction = majorfunc;
 901     irpsp->DeviceObject = device;
 902     irpsp->CompletionRoutine = NULL;
 903
 904     irp->AssociatedIrp.SystemBuffer = buffer;
 905
 906     if (device->Flags & DO_DIRECT_IO)
 907     {
 908         MDL *mdl = IoAllocateMdl( buffer, length, FALSE, FALSE, irp );
 909         if (!mdl)
 910         {
 911             IoFreeIrp( irp );
 912             return NULL;
 913         }
 914
 915         mdl->MdlFlags |= MDL_MAPPED_TO_SYSTEM_VA;
 916         mdl->MappedSystemVa = buffer;
 917     }
 918
 919     switch (majorfunc)
 920     {
 921     case IRP_MJ_READ:
 922         irpsp->Parameters.Read.Length = length;
 923         irpsp->Parameters.Read.ByteOffset = *startoffset;
 924         break;
 925     case IRP_MJ_WRITE:
 926         irpsp->Parameters.Write.Length = length;
 927         irpsp->Parameters.Write.ByteOffset = *startoffset;
 928         break;
 929     }
 930     irp->RequestorMode = KernelMode;
 931     irp->UserIosb = iosb;
 932     irp->UserEvent = event;
 933     irp->UserBuffer = buffer;
 934     return irp;
 935 }
 936
 937 static void build_driver_keypath( const WCHAR *name, UNICODE_STRING *keypath )
 938 {
 939     static const WCHAR driverW[] = {'\\','D','r','i','v','e','r','\\',0};
 940     WCHAR *str;
 941
 942     /* Check what prefix is present */
 943     if (strncmpW( name, servicesW, strlenW(servicesW) ) == 0)
 944     {
 945         FIXME( "Driver name %s is malformed as the keypath\n", debugstr_w(name) );
 946         RtlCreateUnicodeString( keypath, name );
 947         return;
 948     }
 949     if (strncmpW( name, driverW, strlenW(driverW) ) == 0)
 950         name += strlenW(driverW);
 951     else
 952         FIXME( "Driver name %s does not properly begin with \\Driver\\\n", debugstr_w(name) );
 953
 954     str = HeapAlloc( GetProcessHeap(), 0, sizeof(servicesW) + strlenW(name)*sizeof(WCHAR));
 955     lstrcpyW( str, servicesW );
 956     lstrcatW( str, name );
 957     RtlInitUnicodeString( keypath, str );
 958 }
 959
 960
 961 static NTSTATUS WINAPI unhandled_irp( DEVICE_OBJECT *device, IRP *irp )
 962 {
 963     TRACE( "(%p, %p)\n", device, irp );
 964     irp->IoStatus.u.Status = STATUS_INVALID_DEVICE_REQUEST;
 965     IoCompleteRequest( irp, IO_NO_INCREMENT );
 966     return STATUS_INVALID_DEVICE_REQUEST;
 967 }
 968
 969
 970 /***********************************************************************
 971  *           IoCreateDriver   (NTOSKRNL.EXE.@)
 972  */
 973 NTSTATUS WINAPI IoCreateDriver( UNICODE_STRING *name, PDRIVER_INITIALIZE init )
 974 {
 975     struct wine_driver *driver;
 976     NTSTATUS status;
 977     unsigned int i;
 978
 979     TRACE("(%s, %p)\n", debugstr_us(name), init);
 980
 981     if (!(driver = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
 982                                     sizeof(*driver) )))
 983         return STATUS_NO_MEMORY;
 984
 985     if ((status = RtlDuplicateUnicodeString( 1, name, &driver->driver_obj.DriverName )))
 986     {
 987         RtlFreeHeap( GetProcessHeap(), 0, driver );
 988         return status;
 989     }
 990
 991     driver->driver_obj.Size            = sizeof(driver->driver_obj);
 992     driver->driver_obj.DriverInit      = init;
 993     driver->driver_obj.DriverExtension = &driver->driver_extension;
 994     driver->driver_extension.DriverObject   = &driver->driver_obj;
 995     build_driver_keypath( driver->driver_obj.DriverName.Buffer, &driver->driver_extension.ServiceKeyName );
 996     for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
 997         driver->driver_obj.MajorFunction[i] = unhandled_irp;
 998
 999     status = driver->driver_obj.DriverInit( &driver->driver_obj, &driver->driver_extension.ServiceKeyName );
1000     if (status)
1001     {
1002         RtlFreeUnicodeString( &driver->driver_obj.DriverName );
1003         RtlFreeUnicodeString( &driver->driver_extension.ServiceKeyName );
1004         RtlFreeHeap( GetProcessHeap(), 0, driver );
1005         return status;
1006     }
1007
1008     for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
1009     {
1010         if (driver->driver_obj.MajorFunction[i]) continue;
1011         driver->driver_obj.MajorFunction[i] = unhandled_irp;
1012     }
1013
1014     EnterCriticalSection( &drivers_cs );
1015     if (wine_rb_put( &wine_drivers, &driver->driver_obj.DriverName, &driver->entry ))
1016         ERR( "failed to insert driver %s in tree\n", debugstr_us(name) );
1017     LeaveCriticalSection( &drivers_cs );
1018     return STATUS_SUCCESS;
1019 }
1020
1021
1022 /***********************************************************************
1023  *           IoDeleteDriver   (NTOSKRNL.EXE.@)
1024  */
1025 void WINAPI IoDeleteDriver( DRIVER_OBJECT *driver_object )
1026 {
1027     TRACE( "(%p)\n", driver_object );
1028
1029     EnterCriticalSection( &drivers_cs );
1030     wine_rb_remove_key( &wine_drivers, &driver_object->DriverName );
1031     LeaveCriticalSection( &drivers_cs );
1032
1033     RtlFreeUnicodeString( &driver_object->DriverName );
1034     RtlFreeUnicodeString( &driver_object->DriverExtension->ServiceKeyName );
1035     RtlFreeHeap( GetProcessHeap(), 0, CONTAINING_RECORD( driver_object, struct wine_driver, driver_obj ) );
1036 }
1037
1038
1039 /***********************************************************************
1040  *           IoCreateDevice   (NTOSKRNL.EXE.@)
1041  */
1042 NTSTATUS WINAPI IoCreateDevice( DRIVER_OBJECT *driver, ULONG ext_size,
1043                                 UNICODE_STRING *name, DEVICE_TYPE type,
1044                                 ULONG characteristics, BOOLEAN exclusive,
1045                                 DEVICE_OBJECT **ret_device )
1046 {
1047     NTSTATUS status;
1048     DEVICE_OBJECT *device;
1049     HANDLE handle = 0;
1050     HANDLE manager = get_device_manager();
1051
1052     TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
1053            driver, ext_size, debugstr_us(name), type, characteristics, exclusive, ret_device );
1054
1055     if (!(device = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*device) + ext_size )))
1056         return STATUS_NO_MEMORY;
1057
1058     SERVER_START_REQ( create_device )
1059     {
1060         req->access     = 0;
1061         req->attributes = 0;
1062         req->rootdir    = 0;
1063         req->manager    = wine_server_obj_handle( manager );
1064         req->user_ptr   = wine_server_client_ptr( device );
1065         if (name) wine_server_add_data( req, name->Buffer, name->Length );
1066         if (!(status = wine_server_call( req ))) handle = wine_server_ptr_handle( reply->handle );
1067     }
1068     SERVER_END_REQ;
1069
1070     if (status == STATUS_SUCCESS)
1071     {
1072         device->DriverObject    = driver;
1073         device->DeviceExtension = device + 1;
1074         device->DeviceType      = type;
1075         device->StackSize       = 1;
1076         device->Reserved        = handle;
1077
1078         device->NextDevice   = driver->DeviceObject;
1079         driver->DeviceObject = device;
1080
1081         *ret_device = device;
1082     }
1083     else HeapFree( GetProcessHeap(), 0, device );
1084
1085     return status;
1086 }
1087
1088
1089 /***********************************************************************
1090  *           IoDeleteDevice   (NTOSKRNL.EXE.@)
1091  */
1092 void WINAPI IoDeleteDevice( DEVICE_OBJECT *device )
1093 {
1094     NTSTATUS status;
1095
1096     TRACE( "%p\n", device );
1097
1098     SERVER_START_REQ( delete_device )
1099     {
1100         req->handle = wine_server_obj_handle( device->Reserved );
1101         status = wine_server_call( req );
1102     }
1103     SERVER_END_REQ;
1104
1105     if (status == STATUS_SUCCESS)
1106     {
1107         DEVICE_OBJECT **prev = &device->DriverObject->DeviceObject;
1108         while (*prev && *prev != device) prev = &(*prev)->NextDevice;
1109         if (*prev) *prev = (*prev)->NextDevice;
1110         NtClose( device->Reserved );
1111         HeapFree( GetProcessHeap(), 0, device );
1112     }
1113 }
1114
1115
1116 /***********************************************************************
1117  *           IoCreateSymbolicLink   (NTOSKRNL.EXE.@)
1118  */
1119 NTSTATUS WINAPI IoCreateSymbolicLink( UNICODE_STRING *name, UNICODE_STRING *target )
1120 {
1121     HANDLE handle;
1122     OBJECT_ATTRIBUTES attr;
1123
1124     attr.Length                   = sizeof(attr);
1125     attr.RootDirectory            = 0;
1126     attr.ObjectName               = name;
1127     attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
1128     attr.SecurityDescriptor       = NULL;
1129     attr.SecurityQualityOfService = NULL;
1130
1131     TRACE( "%s -> %s\n", debugstr_us(name), debugstr_us(target) );
1132     /* FIXME: store handle somewhere */
1133     return NtCreateSymbolicLinkObject( &handle, SYMBOLIC_LINK_ALL_ACCESS, &attr, target );
1134 }
1135
1136
1137 /***********************************************************************
1138  *           IoDeleteSymbolicLink   (NTOSKRNL.EXE.@)
1139  */
1140 NTSTATUS WINAPI IoDeleteSymbolicLink( UNICODE_STRING *name )
1141 {
1142     HANDLE handle;
1143     OBJECT_ATTRIBUTES attr;
1144     NTSTATUS status;
1145
1146     attr.Length                   = sizeof(attr);
1147     attr.RootDirectory            = 0;
1148     attr.ObjectName               = name;
1149     attr.Attributes               = OBJ_CASE_INSENSITIVE;
1150     attr.SecurityDescriptor       = NULL;
1151     attr.SecurityQualityOfService = NULL;
1152
1153     if (!(status = NtOpenSymbolicLinkObject( &handle, 0, &attr )))
1154     {
1155         SERVER_START_REQ( unlink_object )
1156         {
1157             req->handle = wine_server_obj_handle( handle );
1158             status = wine_server_call( req );
1159         }
1160         SERVER_END_REQ;
1161         NtClose( handle );
1162     }
1163     return status;
1164 }
1165
1166
1167 /***********************************************************************
1168  *           IoGetDeviceInterfaces   (NTOSKRNL.EXE.@)
1169  */
1170 NTSTATUS WINAPI IoGetDeviceInterfaces( const GUID *InterfaceClassGuid,
1171                                        PDEVICE_OBJECT PhysicalDeviceObject,
1172                                        ULONG Flags, PWSTR *SymbolicLinkList )
1173 {
1174     FIXME( "stub: %s %p %x %p\n", debugstr_guid(InterfaceClassGuid),
1175            PhysicalDeviceObject, Flags, SymbolicLinkList );
1176     return STATUS_NOT_IMPLEMENTED;
1177 }
1178
1179
1180 /***********************************************************************
1181  *           IoGetDeviceObjectPointer   (NTOSKRNL.EXE.@)
1182  */
1183 NTSTATUS  WINAPI IoGetDeviceObjectPointer( UNICODE_STRING *name, ACCESS_MASK access, PFILE_OBJECT *file, PDEVICE_OBJECT *device )
1184 {
1185     static DEVICE_OBJECT stub_device;
1186     static DRIVER_OBJECT stub_driver;
1187
1188     FIXME( "stub: %s %x %p %p\n", debugstr_us(name), access, file, device );
1189
1190     stub_device.StackSize = 0x80; /* minimum value to appease SecuROM 5.x */
1191     stub_device.DriverObject = &stub_driver;
1192
1193     *file  = NULL;
1194     *device = &stub_device;
1195
1196     return STATUS_SUCCESS;
1197 }
1198
1199 /***********************************************************************
1200  *           IoGetAttachedDevice   (NTOSKRNL.EXE.@)
1201  */
1202 DEVICE_OBJECT* WINAPI IoGetAttachedDevice( DEVICE_OBJECT *device )
1203 {
1204     DEVICE_OBJECT *result = device;
1205
1206     TRACE( "(%p)\n", device );
1207
1208     while (result->AttachedDevice)
1209         result = result->AttachedDevice;
1210
1211     return result;
1212 }
1213
1214
1215 /***********************************************************************
1216  *           IoGetDeviceProperty   (NTOSKRNL.EXE.@)
1217  */
1218 NTSTATUS WINAPI IoGetDeviceProperty( DEVICE_OBJECT *device, DEVICE_REGISTRY_PROPERTY device_property,
1219                                      ULONG buffer_length, PVOID property_buffer, PULONG result_length )
1220 {
1221     NTSTATUS status = STATUS_NOT_IMPLEMENTED;
1222     TRACE( "%p %d %u %p %p\n", device, device_property, buffer_length,
1223            property_buffer, result_length );
1224     switch (device_property)
1225     {
1226         case DevicePropertyEnumeratorName:
1227         {
1228             WCHAR *id, *ptr;
1229
1230             status = get_device_id( device, BusQueryInstanceID, &id );
1231             if (status != STATUS_SUCCESS)
1232             {
1233                 ERR( "Failed to get device id\n" );
1234                 break;
1235             }
1236
1237             struprW( id );
1238             ptr = strchrW( id, '\\' );
1239             if (ptr) *ptr = 0;
1240
1241             *result_length = sizeof(WCHAR) * (strlenW(id) + 1);
1242             if (buffer_length >= *result_length)
1243                 memcpy( property_buffer, id, *result_length );
1244             else
1245                 status = STATUS_BUFFER_TOO_SMALL;
1246
1247             HeapFree( GetProcessHeap(), 0, id );
1248             break;
1249         }
1250         case DevicePropertyPhysicalDeviceObjectName:
1251         {
1252             ULONG used_len, len = buffer_length + sizeof(OBJECT_NAME_INFORMATION);
1253             OBJECT_NAME_INFORMATION *name = HeapAlloc(GetProcessHeap(), 0, len);
1254
1255             status = NtQueryObject(device->Reserved, ObjectNameInformation, name, len, &used_len);
1256             if (status == STATUS_SUCCESS)
1257             {
1258                 /* Ensure room for NULL termination */
1259                 if (buffer_length >= name->Name.MaximumLength)
1260                     memcpy(property_buffer, name->Name.Buffer, name->Name.MaximumLength);
1261                 else
1262                     status = STATUS_BUFFER_TOO_SMALL;
1263                 *result_length = name->Name.MaximumLength;
1264             }
1265             else
1266             {
1267                 if (status == STATUS_INFO_LENGTH_MISMATCH ||
1268                     status == STATUS_BUFFER_OVERFLOW)
1269                 {
1270                     status = STATUS_BUFFER_TOO_SMALL;
1271                     *result_length = used_len - sizeof(OBJECT_NAME_INFORMATION);
1272                 }
1273                 else
1274                     *result_length = 0;
1275             }
1276             HeapFree(GetProcessHeap(), 0, name);
1277             break;
1278         }
1279         default:
1280             FIXME("unhandled property %d\n", device_property);
1281     }
1282     return status;
1283 }
1284
1285
1286 /***********************************************************************
1287  *           IoCallDriver   (NTOSKRNL.EXE.@)
1288  */
1289 NTSTATUS WINAPI IoCallDriver( DEVICE_OBJECT *device, IRP *irp )
1290 {
1291     PDRIVER_DISPATCH dispatch;
1292     IO_STACK_LOCATION *irpsp;
1293     NTSTATUS status;
1294
1295     --irp->CurrentLocation;
1296     irpsp = --irp->Tail.Overlay.s.u2.CurrentStackLocation;
1297     dispatch = device->DriverObject->MajorFunction[irpsp->MajorFunction];
1298
1299     TRACE_(relay)( "\1Call driver dispatch %p (device=%p,irp=%p)\n", dispatch, device, irp );
1300
1301     status = dispatch( device, irp );
1302
1303     TRACE_(relay)( "\1Ret  driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
1304                    dispatch, device, irp, status );
1305
1306     return status;
1307 }
1308
1309
1310 /***********************************************************************
1311  *           IofCallDriver   (NTOSKRNL.EXE.@)
1312  */
1313 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1314 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver )
1315 NTSTATUS WINAPI DECLSPEC_HIDDEN __regs_IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
1316 #else
1317 NTSTATUS WINAPI IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
1318 #endif
1319 {
1320     TRACE( "%p %p\n", device, irp );
1321     return IoCallDriver( device, irp );
1322 }
1323
1324
1325 /***********************************************************************
1326  *           IoGetRelatedDeviceObject    (NTOSKRNL.EXE.@)
1327  */
1328 PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject( PFILE_OBJECT obj )
1329 {
1330     FIXME( "stub: %p\n", obj );
1331     return NULL;
1332 }
1333
1334 static CONFIGURATION_INFORMATION configuration_information;
1335
1336 /***********************************************************************
1337  *           IoGetConfigurationInformation    (NTOSKRNL.EXE.@)
1338  */
1339 PCONFIGURATION_INFORMATION WINAPI IoGetConfigurationInformation(void)
1340 {
1341     FIXME( "partial stub\n" );
1342     /* FIXME: return actual devices on system */
1343     return &configuration_information;
1344 }
1345
1346
1347 /***********************************************************************
1348  *           IoIsWdmVersionAvailable     (NTOSKRNL.EXE.@)
1349  */
1350 NTSTATUS WINAPI IoIsWdmVersionAvailable(UCHAR MajorVersion, UCHAR MinorVersion)
1351 {
1352     DWORD version;
1353     DWORD major;
1354     DWORD minor;
1355
1356     TRACE( "%d, 0x%X\n", MajorVersion, MinorVersion );
1357
1358     version = GetVersion();
1359     major = LOBYTE(version);
1360     minor = HIBYTE(LOWORD(version));
1361
1362     if (MajorVersion == 6 && MinorVersion == 0)
1363     {
1364         /* Windows Vista, Windows Server 2008, Windows 7 */
1365     }
1366     else if (MajorVersion == 1)
1367     {
1368         if (MinorVersion == 0x30)
1369         {
1370             /* Windows server 2003 */
1371             MajorVersion = 6;
1372             MinorVersion = 0;
1373         }
1374         else if (MinorVersion == 0x20)
1375         {
1376             /* Windows XP */
1377             MajorVersion = 5;
1378             MinorVersion = 1;
1379         }
1380         else if (MinorVersion == 0x10)
1381         {
1382             /* Windows 2000 */
1383             MajorVersion = 5;
1384             MinorVersion = 0;
1385         }
1386         else if (MinorVersion == 0x05)
1387         {
1388             /* Windows ME */
1389             MajorVersion = 4;
1390             MinorVersion = 0x5a;
1391         }
1392         else if (MinorVersion == 0x00)
1393         {
1394             /* Windows 98 */
1395             MajorVersion = 4;
1396             MinorVersion = 0x0a;
1397         }
1398         else
1399         {
1400             FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
1401             return FALSE;
1402         }
1403     }
1404     else
1405     {
1406         FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
1407         return FALSE;
1408     }
1409     return major > MajorVersion || (major == MajorVersion && minor >= MinorVersion);
1410 }
1411
1412
1413 /***********************************************************************
1414  *           IoQueryDeviceDescription    (NTOSKRNL.EXE.@)
1415  */
1416 NTSTATUS WINAPI IoQueryDeviceDescription(PINTERFACE_TYPE itype, PULONG bus, PCONFIGURATION_TYPE ctype,
1417                                      PULONG cnum, PCONFIGURATION_TYPE ptype, PULONG pnum,
1418                                      PIO_QUERY_DEVICE_ROUTINE callout, PVOID context)
1419 {
1420     FIXME( "(%p %p %p %p %p %p %p %p)\n", itype, bus, ctype, cnum, ptype, pnum, callout, context);
1421     return STATUS_NOT_IMPLEMENTED;
1422 }
1423
1424
1425 /***********************************************************************
1426  *           IoRegisterDriverReinitialization    (NTOSKRNL.EXE.@)
1427  */
1428 void WINAPI IoRegisterDriverReinitialization( PDRIVER_OBJECT obj, PDRIVER_REINITIALIZE reinit, PVOID context )
1429 {
1430     FIXME( "stub: %p %p %p\n", obj, reinit, context );
1431 }
1432
1433
1434 /***********************************************************************
1435  *           IoRegisterShutdownNotification    (NTOSKRNL.EXE.@)
1436  */
1437 NTSTATUS WINAPI IoRegisterShutdownNotification( PDEVICE_OBJECT obj )
1438 {
1439     FIXME( "stub: %p\n", obj );
1440     return STATUS_SUCCESS;
1441 }
1442
1443
1444 /***********************************************************************
1445  *           IoUnregisterShutdownNotification    (NTOSKRNL.EXE.@)
1446  */
1447 VOID WINAPI IoUnregisterShutdownNotification( PDEVICE_OBJECT obj )
1448 {
1449     FIXME( "stub: %p\n", obj );
1450 }
1451
1452
1453 /***********************************************************************
1454  *           IoReportResourceForDetection   (NTOSKRNL.EXE.@)
1455  */
1456 NTSTATUS WINAPI IoReportResourceForDetection( DRIVER_OBJECT *drv_obj, CM_RESOURCE_LIST *drv_list, ULONG drv_size,
1457                                               DEVICE_OBJECT *dev_obj, CM_RESOURCE_LIST *dev_list, ULONG dev_size,
1458                                               BOOLEAN *conflict )
1459 {
1460     FIXME( "(%p, %p, %u, %p, %p, %u, %p): stub\n", drv_obj, drv_list, drv_size,
1461            dev_obj, dev_list, dev_size, conflict );
1462
1463     return STATUS_NOT_IMPLEMENTED;
1464 }
1465
1466
1467 /***********************************************************************
1468  *           IoReportResourceUsage    (NTOSKRNL.EXE.@)
1469  */
1470 NTSTATUS WINAPI IoReportResourceUsage( UNICODE_STRING *name, DRIVER_OBJECT *drv_obj, CM_RESOURCE_LIST *drv_list,
1471                                        ULONG drv_size, DRIVER_OBJECT *dev_obj, CM_RESOURCE_LIST *dev_list,
1472                                        ULONG dev_size, BOOLEAN overwrite, BOOLEAN *conflict )
1473 {
1474     FIXME( "(%s, %p, %p, %u, %p, %p, %u, %d, %p): stub\n", debugstr_us(name),
1475            drv_obj, drv_list, drv_size, dev_obj, dev_list, dev_size, overwrite, conflict );
1476
1477     return STATUS_NOT_IMPLEMENTED;
1478 }
1479
1480
1481 /***********************************************************************
1482  *           IoCompleteRequest   (NTOSKRNL.EXE.@)
1483  */
1484 VOID WINAPI IoCompleteRequest( IRP *irp, UCHAR priority_boost )
1485 {
1486     IO_STACK_LOCATION *irpsp;
1487     PIO_COMPLETION_ROUTINE routine;
1488     NTSTATUS status, stat;
1489     int call_flag = 0;
1490
1491     TRACE( "%p %u\n", irp, priority_boost );
1492
1493     status = irp->IoStatus.u.Status;
1494     while (irp->CurrentLocation <= irp->StackCount)
1495     {
1496         irpsp = irp->Tail.Overlay.s.u2.CurrentStackLocation;
1497         routine = irpsp->CompletionRoutine;
1498         call_flag = 0;
1499         /* FIXME: add SL_INVOKE_ON_CANCEL support */
1500         if (routine)
1501         {
1502             if ((irpsp->Control & SL_INVOKE_ON_SUCCESS) && STATUS_SUCCESS == status)
1503                 call_flag = 1;
1504             if ((irpsp->Control & SL_INVOKE_ON_ERROR) && STATUS_SUCCESS != status)
1505                 call_flag = 1;
1506         }
1507         ++irp->CurrentLocation;
1508         ++irp->Tail.Overlay.s.u2.CurrentStackLocation;
1509         if (call_flag)
1510         {
1511             TRACE( "calling %p( %p, %p, %p )\n", routine,
1512                     irpsp->DeviceObject, irp, irpsp->Context );
1513             stat = routine( irpsp->DeviceObject, irp, irpsp->Context );
1514             TRACE( "CompletionRoutine returned %x\n", stat );
1515             if (STATUS_MORE_PROCESSING_REQUIRED == stat)
1516                 return;
1517         }
1518     }
1519
1520     if (irp->Flags & IRP_DEALLOCATE_BUFFER)
1521         HeapFree( GetProcessHeap(), 0, irp->AssociatedIrp.SystemBuffer );
1522
1523     IoFreeIrp( irp );
1524 }
1525
1526
1527 /***********************************************************************
1528  *           IofCompleteRequest   (NTOSKRNL.EXE.@)
1529  */
1530 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1531 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest )
1532 void WINAPI DECLSPEC_HIDDEN __regs_IofCompleteRequest( IRP *irp, UCHAR priority_boost )
1533 #else
1534 void WINAPI IofCompleteRequest( IRP *irp, UCHAR priority_boost )
1535 #endif
1536 {
1537     TRACE( "%p %u\n", irp, priority_boost );
1538     IoCompleteRequest( irp, priority_boost );
1539 }
1540
1541
1542 /***********************************************************************
1543  *           InterlockedCompareExchange   (NTOSKRNL.EXE.@)
1544  */
1545 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
1546 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange )
1547 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
1548 #else
1549 LONG WINAPI NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
1550 #endif
1551 {
1552     return InterlockedCompareExchange( dest, xchg, compare );
1553 }
1554
1555
1556 /***********************************************************************
1557  *           InterlockedDecrement   (NTOSKRNL.EXE.@)
1558  */
1559 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1560 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement )
1561 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
1562 #else
1563 LONG WINAPI NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
1564 #endif
1565 {
1566     return InterlockedDecrement( dest );
1567 }
1568
1569
1570 /***********************************************************************
1571  *           InterlockedExchange   (NTOSKRNL.EXE.@)
1572  */
1573 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1574 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange )
1575 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
1576 #else
1577 LONG WINAPI NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
1578 #endif
1579 {
1580     return InterlockedExchange( dest, val );
1581 }
1582
1583
1584 /***********************************************************************
1585  *           InterlockedExchangeAdd   (NTOSKRNL.EXE.@)
1586  */
1587 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1588 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd )
1589 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
1590 #else
1591 LONG WINAPI NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
1592 #endif
1593 {
1594     return InterlockedExchangeAdd( dest, incr );
1595 }
1596
1597
1598 /***********************************************************************
1599  *           InterlockedIncrement   (NTOSKRNL.EXE.@)
1600  */
1601 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1602 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement )
1603 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1604 #else
1605 LONG WINAPI NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1606 #endif
1607 {
1608     return InterlockedIncrement( dest );
1609 }
1610
1611
1612 /***********************************************************************
1613  *           InterlockedPopEntrySList   (NTOSKRNL.EXE.@)
1614  */
1615 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1616 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedPopEntrySList )
1617 PSLIST_ENTRY WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedPopEntrySList( PSLIST_HEADER list )
1618 #else
1619 PSLIST_ENTRY WINAPI NTOSKRNL_InterlockedPopEntrySList( PSLIST_HEADER list )
1620 #endif
1621 {
1622     return InterlockedPopEntrySList( list );
1623 }
1624
1625
1626 /***********************************************************************
1627  *           InterlockedPushEntrySList   (NTOSKRNL.EXE.@)
1628  */
1629 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1630 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedPushEntrySList )
1631 PSLIST_ENTRY WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedPushEntrySList( PSLIST_HEADER list,
1632                                                                                PSLIST_ENTRY entry )
1633 #else
1634 PSLIST_ENTRY WINAPI NTOSKRNL_InterlockedPushEntrySList( PSLIST_HEADER list, PSLIST_ENTRY entry )
1635 #endif
1636 {
1637     return InterlockedPushEntrySList( list, entry );
1638 }
1639
1640
1641 /***********************************************************************
1642  *           ExAllocatePool   (NTOSKRNL.EXE.@)
1643  */
1644 PVOID WINAPI ExAllocatePool( POOL_TYPE type, SIZE_T size )
1645 {
1646     return ExAllocatePoolWithTag( type, size, 0 );
1647 }
1648
1649
1650 /***********************************************************************
1651  *           ExAllocatePoolWithQuota   (NTOSKRNL.EXE.@)
1652  */
1653 PVOID WINAPI ExAllocatePoolWithQuota( POOL_TYPE type, SIZE_T size )
1654 {
1655     return ExAllocatePoolWithTag( type, size, 0 );
1656 }
1657
1658
1659 /***********************************************************************
1660  *           ExAllocatePoolWithTag   (NTOSKRNL.EXE.@)
1661  */
1662 PVOID WINAPI ExAllocatePoolWithTag( POOL_TYPE type, SIZE_T size, ULONG tag )
1663 {
1664     /* FIXME: handle page alignment constraints */
1665     void *ret = HeapAlloc( GetProcessHeap(), 0, size );
1666     TRACE( "%lu pool %u -> %p\n", size, type, ret );
1667     return ret;
1668 }
1669
1670
1671 /***********************************************************************
1672  *           ExAllocatePoolWithQuotaTag   (NTOSKRNL.EXE.@)
1673  */
1674 PVOID WINAPI ExAllocatePoolWithQuotaTag( POOL_TYPE type, SIZE_T size, ULONG tag )
1675 {
1676     return ExAllocatePoolWithTag( type, size, tag );
1677 }
1678
1679
1680 /***********************************************************************
1681  *           ExCreateCallback   (NTOSKRNL.EXE.@)
1682  */
1683 NTSTATUS WINAPI ExCreateCallback(PCALLBACK_OBJECT *obj, POBJECT_ATTRIBUTES attr,
1684                                  BOOLEAN create, BOOLEAN allow_multiple)
1685 {
1686     FIXME("(%p, %p, %u, %u): stub\n", obj, attr, create, allow_multiple);
1687
1688     return STATUS_NOT_IMPLEMENTED;
1689 }
1690
1691
1692 /***********************************************************************
1693  *           ExDeleteNPagedLookasideList   (NTOSKRNL.EXE.@)
1694  */
1695 void WINAPI ExDeleteNPagedLookasideList( PNPAGED_LOOKASIDE_LIST lookaside )
1696 {
1697     FIXME("(%p) stub\n", lookaside);
1698 }
1699
1700
1701 /***********************************************************************
1702  *           ExDeletePagedLookasideList  (NTOSKRNL.EXE.@)
1703  */
1704 void WINAPI ExDeletePagedLookasideList( PPAGED_LOOKASIDE_LIST lookaside )
1705 {
1706     FIXME("(%p) stub\n", lookaside);
1707 }
1708
1709
1710 /***********************************************************************
1711  *           ExFreePool   (NTOSKRNL.EXE.@)
1712  */
1713 void WINAPI ExFreePool( void *ptr )
1714 {
1715     ExFreePoolWithTag( ptr, 0 );
1716 }
1717
1718
1719 /***********************************************************************
1720  *           ExFreePoolWithTag   (NTOSKRNL.EXE.@)
1721  */
1722 void WINAPI ExFreePoolWithTag( void *ptr, ULONG tag )
1723 {
1724     TRACE( "%p\n", ptr );
1725     HeapFree( GetProcessHeap(), 0, ptr );
1726 }
1727
1728
1729 /***********************************************************************
1730  *           ExInitializeResourceLite   (NTOSKRNL.EXE.@)
1731  */
1732 NTSTATUS WINAPI ExInitializeResourceLite(PERESOURCE Resource)
1733 {
1734     FIXME( "stub: %p\n", Resource );
1735     return STATUS_NOT_IMPLEMENTED;
1736 }
1737
1738
1739 /***********************************************************************
1740  *           ExInitializeNPagedLookasideList   (NTOSKRNL.EXE.@)
1741  */
1742 void WINAPI ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
1743                                             PALLOCATE_FUNCTION Allocate,
1744                                             PFREE_FUNCTION Free,
1745                                             ULONG Flags,
1746                                             SIZE_T Size,
1747                                             ULONG Tag,
1748                                             USHORT Depth)
1749 {
1750     FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1751 }
1752
1753 /***********************************************************************
1754  *           ExInitializePagedLookasideList   (NTOSKRNL.EXE.@)
1755  */
1756 void WINAPI ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside,
1757                                            PALLOCATE_FUNCTION Allocate,
1758                                            PFREE_FUNCTION Free,
1759                                            ULONG Flags,
1760                                            SIZE_T Size,
1761                                            ULONG Tag,
1762                                            USHORT Depth)
1763 {
1764     FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1765 }
1766
1767 /***********************************************************************
1768  *           ExInitializeZone   (NTOSKRNL.EXE.@)
1769  */
1770 NTSTATUS WINAPI ExInitializeZone(PZONE_HEADER Zone,
1771                                  ULONG BlockSize,
1772                                  PVOID InitialSegment,
1773                                  ULONG InitialSegmentSize)
1774 {
1775     FIXME( "stub: %p, %u, %p, %u\n", Zone, BlockSize, InitialSegment, InitialSegmentSize );
1776     return STATUS_NOT_IMPLEMENTED;
1777 }
1778
1779 /***********************************************************************
1780 *           FsRtlRegisterUncProvider   (NTOSKRNL.EXE.@)
1781 */
1782 NTSTATUS WINAPI FsRtlRegisterUncProvider(PHANDLE MupHandle, PUNICODE_STRING RedirDevName,
1783                                          BOOLEAN MailslotsSupported)
1784 {
1785     FIXME("(%p %p %d): stub\n", MupHandle, RedirDevName, MailslotsSupported);
1786     return STATUS_NOT_IMPLEMENTED;
1787 }
1788
1789 /***********************************************************************
1790  *           IoGetCurrentProcess / PsGetCurrentProcess   (NTOSKRNL.EXE.@)
1791  */
1792 PEPROCESS WINAPI IoGetCurrentProcess(void)
1793 {
1794     FIXME("() stub\n");
1795     return NULL;
1796 }
1797
1798 /***********************************************************************
1799  *           KeGetCurrentThread / PsGetCurrentThread   (NTOSKRNL.EXE.@)
1800  */
1801 PRKTHREAD WINAPI KeGetCurrentThread(void)
1802 {
1803     FIXME("() stub\n");
1804     return NULL;
1805 }
1806
1807 /***********************************************************************
1808  *           KeInitializeEvent   (NTOSKRNL.EXE.@)
1809  */
1810 void WINAPI KeInitializeEvent( PRKEVENT Event, EVENT_TYPE Type, BOOLEAN State )
1811 {
1812     FIXME( "stub: %p %d %d\n", Event, Type, State );
1813 }
1814
1815
1816  /***********************************************************************
1817  *           KeInitializeMutex   (NTOSKRNL.EXE.@)
1818  */
1819 void WINAPI KeInitializeMutex(PRKMUTEX Mutex, ULONG Level)
1820 {
1821     FIXME( "stub: %p, %u\n", Mutex, Level );
1822 }
1823
1824
1825  /***********************************************************************
1826  *           KeWaitForMutexObject   (NTOSKRNL.EXE.@)
1827  */
1828 NTSTATUS WINAPI KeWaitForMutexObject(PRKMUTEX Mutex, KWAIT_REASON WaitReason, KPROCESSOR_MODE WaitMode,
1829                                      BOOLEAN Alertable, PLARGE_INTEGER Timeout)
1830 {
1831     FIXME( "stub: %p, %d, %d, %d, %p\n", Mutex, WaitReason, WaitMode, Alertable, Timeout );
1832     return STATUS_NOT_IMPLEMENTED;
1833 }
1834
1835
1836  /***********************************************************************
1837  *           KeReleaseMutex   (NTOSKRNL.EXE.@)
1838  */
1839 LONG WINAPI KeReleaseMutex(PRKMUTEX Mutex, BOOLEAN Wait)
1840 {
1841     FIXME( "stub: %p, %d\n", Mutex, Wait );
1842     return STATUS_NOT_IMPLEMENTED;
1843 }
1844
1845
1846 /***********************************************************************
1847  *           KeInitializeSemaphore   (NTOSKRNL.EXE.@)
1848  */
1849 void WINAPI KeInitializeSemaphore( PRKSEMAPHORE Semaphore, LONG Count, LONG Limit )
1850 {
1851     FIXME( "(%p %d %d) stub\n", Semaphore , Count, Limit );
1852 }
1853
1854
1855 /***********************************************************************
1856  *           KeInitializeSpinLock   (NTOSKRNL.EXE.@)
1857  */
1858 void WINAPI KeInitializeSpinLock( PKSPIN_LOCK SpinLock )
1859 {
1860     FIXME( "stub: %p\n", SpinLock );
1861 }
1862
1863
1864 /***********************************************************************
1865  *           KeInitializeTimerEx   (NTOSKRNL.EXE.@)
1866  */
1867 void WINAPI KeInitializeTimerEx( PKTIMER Timer, TIMER_TYPE Type )
1868 {
1869     FIXME( "stub: %p %d\n", Timer, Type );
1870 }
1871
1872
1873 /***********************************************************************
1874  *           KeInitializeTimer   (NTOSKRNL.EXE.@)
1875  */
1876 void WINAPI KeInitializeTimer( PKTIMER Timer )
1877 {
1878     KeInitializeTimerEx(Timer, NotificationTimer);
1879 }
1880
1881 /***********************************************************************
1882  *           KeInsertQueue   (NTOSKRNL.EXE.@)
1883  */
1884 LONG WINAPI KeInsertQueue(PRKQUEUE Queue, PLIST_ENTRY Entry)
1885 {
1886     FIXME( "stub: %p %p\n", Queue, Entry );
1887     return 0;
1888 }
1889
1890 /**********************************************************************
1891  *           KeQueryActiveProcessors   (NTOSKRNL.EXE.@)
1892  *
1893  * Return the active Processors as bitmask
1894  *
1895  * RETURNS
1896  *   active Processors as bitmask
1897  *
1898  */
1899 KAFFINITY WINAPI KeQueryActiveProcessors( void )
1900 {
1901     DWORD_PTR AffinityMask;
1902
1903     GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask, NULL);
1904     return AffinityMask;
1905 }
1906
1907
1908 /**********************************************************************
1909  *           KeQueryInterruptTime   (NTOSKRNL.EXE.@)
1910  *
1911  * Return the interrupt time count
1912  *
1913  */
1914 ULONGLONG WINAPI KeQueryInterruptTime( void )
1915 {
1916     LARGE_INTEGER totaltime;
1917
1918     KeQueryTickCount(&totaltime);
1919     return totaltime.QuadPart;
1920 }
1921
1922
1923 /***********************************************************************
1924  *           KeQuerySystemTime   (NTOSKRNL.EXE.@)
1925  */
1926 void WINAPI KeQuerySystemTime( LARGE_INTEGER *time )
1927 {
1928     NtQuerySystemTime( time );
1929 }
1930
1931
1932 /***********************************************************************
1933  *           KeQueryTickCount   (NTOSKRNL.EXE.@)
1934  */
1935 void WINAPI KeQueryTickCount( LARGE_INTEGER *count )
1936 {
1937     count->QuadPart = NtGetTickCount();
1938     /* update the global variable too */
1939     KeTickCount.LowPart   = count->u.LowPart;
1940     KeTickCount.High1Time = count->u.HighPart;
1941     KeTickCount.High2Time = count->u.HighPart;
1942 }
1943
1944
1945 /***********************************************************************
1946  *           KeReleaseSemaphore   (NTOSKRNL.EXE.@)
1947  */
1948 LONG WINAPI KeReleaseSemaphore( PRKSEMAPHORE Semaphore, KPRIORITY Increment,
1949                                 LONG Adjustment, BOOLEAN Wait )
1950 {
1951     FIXME("(%p %d %d %d) stub\n", Semaphore, Increment, Adjustment, Wait );
1952     return 0;
1953 }
1954
1955
1956 /***********************************************************************
1957  *           KeQueryTimeIncrement   (NTOSKRNL.EXE.@)
1958  */
1959 ULONG WINAPI KeQueryTimeIncrement(void)
1960 {
1961     return 10000;
1962 }
1963
1964
1965 /***********************************************************************
1966  *           KeResetEvent   (NTOSKRNL.EXE.@)
1967  */
1968 LONG WINAPI KeResetEvent( PRKEVENT Event )
1969 {
1970     FIXME("(%p): stub\n", Event);
1971     return 0;
1972 }
1973
1974
1975 /***********************************************************************
1976  *           KeSetEvent   (NTOSKRNL.EXE.@)
1977  */
1978 LONG WINAPI KeSetEvent( PRKEVENT Event, KPRIORITY Increment, BOOLEAN Wait )
1979 {
1980     FIXME("(%p, %d, %d): stub\n", Event, Increment, Wait);
1981     return 0;
1982 }
1983
1984
1985 /***********************************************************************
1986  *           KeSetPriorityThread   (NTOSKRNL.EXE.@)
1987  */
1988 KPRIORITY WINAPI KeSetPriorityThread( PKTHREAD Thread, KPRIORITY Priority )
1989 {
1990     FIXME("(%p %d)\n", Thread, Priority);
1991     return Priority;
1992 }
1993
1994 /***********************************************************************
1995  *           KeSetSystemAffinityThread   (NTOSKRNL.EXE.@)
1996  */
1997 VOID WINAPI KeSetSystemAffinityThread(KAFFINITY Affinity)
1998 {
1999     FIXME("(%lx) stub\n", Affinity);
2000 }
2001
2002 /***********************************************************************
2003  *           KeWaitForSingleObject   (NTOSKRNL.EXE.@)
2004  */
2005 NTSTATUS WINAPI KeWaitForSingleObject(PVOID Object,
2006                                       KWAIT_REASON WaitReason,
2007                                       KPROCESSOR_MODE WaitMode,
2008                                       BOOLEAN Alertable,
2009                                       PLARGE_INTEGER Timeout)
2010 {
2011     FIXME( "stub: %p, %d, %d, %d, %p\n", Object, WaitReason, WaitMode, Alertable, Timeout );
2012     return STATUS_NOT_IMPLEMENTED;
2013 }
2014
2015 /***********************************************************************
2016  *           KeWaitForMultipleObjects   (NTOSKRNL.EXE.@)
2017  */
2018 NTSTATUS WINAPI KeWaitForMultipleObjects(ULONG Count, PVOID Object[], WAIT_TYPE WaitType,
2019                                          KWAIT_REASON WaitReason, KPROCESSOR_MODE WaitMode,
2020                                          BOOLEAN Alertable, PLARGE_INTEGER Timeout,
2021                                          PKWAIT_BLOCK WaitBlockArray)
2022 {
2023     FIXME( "stub: %u, %p, %d, %d, %d, %d, %p, %p\n", Count, Object, WaitType, WaitReason, WaitMode,
2024            Alertable, Timeout, WaitBlockArray );
2025     return STATUS_NOT_IMPLEMENTED;
2026 }
2027
2028 /***********************************************************************
2029  *           IoRegisterFileSystem   (NTOSKRNL.EXE.@)
2030  */
2031 VOID WINAPI IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject)
2032 {
2033     FIXME("(%p): stub\n", DeviceObject);
2034 }
2035
2036 /***********************************************************************
2037 *           IoUnregisterFileSystem   (NTOSKRNL.EXE.@)
2038 */
2039 VOID WINAPI IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject)
2040 {
2041     FIXME("(%p): stub\n", DeviceObject);
2042 }
2043
2044 /***********************************************************************
2045  *           MmAllocateNonCachedMemory   (NTOSKRNL.EXE.@)
2046  */
2047 PVOID WINAPI MmAllocateNonCachedMemory( SIZE_T size )
2048 {
2049     TRACE( "%lu\n", size );
2050     return VirtualAlloc( NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE|PAGE_NOCACHE );
2051 }
2052
2053 /***********************************************************************
2054  *           MmAllocateContiguousMemory   (NTOSKRNL.EXE.@)
2055  */
2056 PVOID WINAPI MmAllocateContiguousMemory( SIZE_T size, PHYSICAL_ADDRESS highest_valid_address )
2057 {
2058     FIXME( "%lu, %s stub\n", size, wine_dbgstr_longlong(highest_valid_address.QuadPart) );
2059     return NULL;
2060 }
2061
2062 /***********************************************************************
2063  *           MmAllocateContiguousMemorySpecifyCache   (NTOSKRNL.EXE.@)
2064  */
2065 PVOID WINAPI MmAllocateContiguousMemorySpecifyCache( SIZE_T size,
2066                                                      PHYSICAL_ADDRESS lowest_valid_address,
2067                                                      PHYSICAL_ADDRESS highest_valid_address,
2068                                                      PHYSICAL_ADDRESS BoundaryAddressMultiple,
2069                                                      MEMORY_CACHING_TYPE CacheType )
2070 {
2071     FIXME(": stub\n");
2072     return NULL;
2073 }
2074
2075 /***********************************************************************
2076  *           MmAllocatePagesForMdl   (NTOSKRNL.EXE.@)
2077  */
2078 PMDL WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress, PHYSICAL_ADDRESS highaddress,
2079                                   PHYSICAL_ADDRESS skipbytes, SIZE_T size)
2080 {
2081     FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress.QuadPart), wine_dbgstr_longlong(highaddress.QuadPart),
2082                                   wine_dbgstr_longlong(skipbytes.QuadPart), size);
2083     return NULL;
2084 }
2085
2086 /***********************************************************************
2087  *           MmFreeNonCachedMemory   (NTOSKRNL.EXE.@)
2088  */
2089 void WINAPI MmFreeNonCachedMemory( void *addr, SIZE_T size )
2090 {
2091     TRACE( "%p %lu\n", addr, size );
2092     VirtualFree( addr, 0, MEM_RELEASE );
2093 }
2094
2095 /***********************************************************************
2096  *           MmIsAddressValid   (NTOSKRNL.EXE.@)
2097  *
2098  * Check if the process can access the virtual address without a pagefault
2099  *
2100  * PARAMS
2101  *  VirtualAddress [I] Address to check
2102  *
2103  * RETURNS
2104  *  Failure: FALSE
2105  *  Success: TRUE  (Accessing the Address works without a Pagefault)
2106  *
2107  */
2108 BOOLEAN WINAPI MmIsAddressValid(PVOID VirtualAddress)
2109 {
2110     TRACE("(%p)\n", VirtualAddress);
2111     return !IsBadWritePtr(VirtualAddress, 1);
2112 }
2113
2114 /***********************************************************************
2115  *           MmMapIoSpace   (NTOSKRNL.EXE.@)
2116  */
2117 PVOID WINAPI MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress, DWORD NumberOfBytes, DWORD CacheType )
2118 {
2119     FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress.u.HighPart, PhysicalAddress.u.LowPart, NumberOfBytes, CacheType );
2120     return NULL;
2121 }
2122
2123
2124 /***********************************************************************
2125  *           MmLockPagableSectionByHandle  (NTOSKRNL.EXE.@)
2126  */
2127 VOID WINAPI MmLockPagableSectionByHandle(PVOID ImageSectionHandle)
2128 {
2129     FIXME("stub %p\n", ImageSectionHandle);
2130 }
2131
2132 /***********************************************************************
2133  *           MmMapLockedPagesSpecifyCache  (NTOSKRNL.EXE.@)
2134  */
2135 PVOID WINAPI  MmMapLockedPagesSpecifyCache(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, MEMORY_CACHING_TYPE CacheType,
2136                                            PVOID BaseAddress, ULONG BugCheckOnFailure, MM_PAGE_PRIORITY Priority)
2137 {
2138     FIXME("(%p, %u, %u, %p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, CacheType, BaseAddress, BugCheckOnFailure, Priority);
2139
2140     return NULL;
2141 }
2142
2143 /***********************************************************************
2144  *           MmUnlockPagableImageSection  (NTOSKRNL.EXE.@)
2145  */
2146 VOID WINAPI MmUnlockPagableImageSection(PVOID ImageSectionHandle)
2147 {
2148     FIXME("stub %p\n", ImageSectionHandle);
2149 }
2150
2151 /***********************************************************************
2152  *           MmPageEntireDriver   (NTOSKRNL.EXE.@)
2153  */
2154 PVOID WINAPI MmPageEntireDriver(PVOID AddrInSection)
2155 {
2156     TRACE("%p\n", AddrInSection);
2157     return AddrInSection;
2158 }
2159
2160
2161 /***********************************************************************
2162  *           MmProbeAndLockPages  (NTOSKRNL.EXE.@)
2163  */
2164 void WINAPI MmProbeAndLockPages(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, LOCK_OPERATION Operation)
2165 {
2166     FIXME("(%p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, Operation);
2167 }
2168
2169
2170 /***********************************************************************
2171  *           MmResetDriverPaging   (NTOSKRNL.EXE.@)
2172  */
2173 void WINAPI MmResetDriverPaging(PVOID AddrInSection)
2174 {
2175     TRACE("%p\n", AddrInSection);
2176 }
2177
2178
2179 /***********************************************************************
2180  *           MmUnlockPages  (NTOSKRNL.EXE.@)
2181  */
2182 void WINAPI  MmUnlockPages(PMDLX MemoryDescriptorList)
2183 {
2184     FIXME("(%p): stub\n", MemoryDescriptorList);
2185 }
2186
2187
2188 /***********************************************************************
2189  *           MmUnmapIoSpace   (NTOSKRNL.EXE.@)
2190  */
2191 VOID WINAPI MmUnmapIoSpace( PVOID BaseAddress, SIZE_T NumberOfBytes )
2192 {
2193     FIXME( "stub: %p, %lu\n", BaseAddress, NumberOfBytes );
2194 }
2195
2196
2197  /***********************************************************************
2198  *           ObReferenceObjectByHandle    (NTOSKRNL.EXE.@)
2199  */
2200 NTSTATUS WINAPI ObReferenceObjectByHandle( HANDLE obj, ACCESS_MASK access,
2201                                            POBJECT_TYPE type,
2202                                            KPROCESSOR_MODE mode, PVOID* ptr,
2203                                            POBJECT_HANDLE_INFORMATION info)
2204 {
2205     FIXME( "stub: %p %x %p %d %p %p\n", obj, access, type, mode, ptr, info);
2206     return STATUS_NOT_IMPLEMENTED;
2207 }
2208
2209  /***********************************************************************
2210  *           ObReferenceObjectByName    (NTOSKRNL.EXE.@)
2211  */
2212 NTSTATUS WINAPI ObReferenceObjectByName( UNICODE_STRING *ObjectName,
2213                                          ULONG Attributes,
2214                                          ACCESS_STATE *AccessState,
2215                                          ACCESS_MASK DesiredAccess,
2216                                          POBJECT_TYPE ObjectType,
2217                                          KPROCESSOR_MODE AccessMode,
2218                                          void *ParseContext,
2219                                          void **Object)
2220 {
2221     struct wine_driver *driver;
2222     struct wine_rb_entry *entry;
2223
2224     TRACE("mostly-stub:%s %i %p %i %p %i %p %p\n", debugstr_us(ObjectName),
2225         Attributes, AccessState, DesiredAccess, ObjectType, AccessMode,
2226         ParseContext, Object);
2227
2228     if (AccessState) FIXME("Unhandled AccessState\n");
2229     if (DesiredAccess) FIXME("Unhandled DesiredAccess\n");
2230     if (ParseContext) FIXME("Unhandled ParseContext\n");
2231     if (ObjectType) FIXME("Unhandled ObjectType\n");
2232
2233     if (AccessMode != KernelMode)
2234     {
2235         FIXME("UserMode access not implemented\n");
2236         return STATUS_NOT_IMPLEMENTED;
2237     }
2238
2239     EnterCriticalSection(&drivers_cs);
2240     entry = wine_rb_get(&wine_drivers, ObjectName);
2241     LeaveCriticalSection(&drivers_cs);
2242     if (!entry)
2243     {
2244         FIXME("Object (%s) not found, may not be tracked.\n", debugstr_us(ObjectName));
2245         return STATUS_NOT_IMPLEMENTED;
2246     }
2247
2248     driver = WINE_RB_ENTRY_VALUE(entry, struct wine_driver, entry);
2249     *Object = &driver->driver_obj;
2250     return STATUS_SUCCESS;
2251 }
2252
2253
2254 static void ObReferenceObject( void *obj )
2255 {
2256     TRACE( "(%p): stub\n", obj );
2257 }
2258
2259
2260 /***********************************************************************
2261  *           ObReferenceObjectByPointer   (NTOSKRNL.EXE.@)
2262  */
2263 NTSTATUS WINAPI ObReferenceObjectByPointer(void *obj, ACCESS_MASK access,
2264                                            POBJECT_TYPE type,
2265                                            KPROCESSOR_MODE mode)
2266 {
2267     FIXME("(%p, %x, %p, %d): stub\n", obj, access, type, mode);
2268
2269     return STATUS_NOT_IMPLEMENTED;
2270 }
2271
2272
2273 /***********************************************************************
2274  *           ObDereferenceObject   (NTOSKRNL.EXE.@)
2275  */
2276 void WINAPI ObDereferenceObject( void *obj )
2277 {
2278     TRACE( "(%p): stub\n", obj );
2279 }
2280
2281
2282 /***********************************************************************
2283  *           ObfReferenceObject   (NTOSKRNL.EXE.@)
2284  */
2285 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
2286 DEFINE_FASTCALL1_ENTRYPOINT( ObfReferenceObject )
2287 void WINAPI DECLSPEC_HIDDEN __regs_ObfReferenceObject( void *obj )
2288 #else
2289 void WINAPI ObfReferenceObject( void *obj )
2290 #endif
2291 {
2292     ObReferenceObject( obj );
2293 }
2294
2295
2296 /***********************************************************************
2297  *           ObfDereferenceObject   (NTOSKRNL.EXE.@)
2298  */
2299 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
2300 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject )
2301 void WINAPI DECLSPEC_HIDDEN __regs_ObfDereferenceObject( void *obj )
2302 #else
2303 void WINAPI ObfDereferenceObject( void *obj )
2304 #endif
2305 {
2306     ObDereferenceObject( obj );
2307 }
2308
2309
2310 /***********************************************************************
2311  *           IoGetAttachedDeviceReference   (NTOSKRNL.EXE.@)
2312  */
2313 DEVICE_OBJECT* WINAPI IoGetAttachedDeviceReference( DEVICE_OBJECT *device )
2314 {
2315     DEVICE_OBJECT *result = IoGetAttachedDevice( device );
2316     ObReferenceObject( result );
2317     return result;
2318 }
2319
2320
2321 /***********************************************************************
2322  *           PsCreateSystemThread   (NTOSKRNL.EXE.@)
2323  */
2324 NTSTATUS WINAPI PsCreateSystemThread(PHANDLE ThreadHandle, ULONG DesiredAccess,
2325                                      POBJECT_ATTRIBUTES ObjectAttributes,
2326                                      HANDLE ProcessHandle, PCLIENT_ID ClientId,
2327                                      PKSTART_ROUTINE StartRoutine, PVOID StartContext)
2328 {
2329     if (!ProcessHandle) ProcessHandle = GetCurrentProcess();
2330     return RtlCreateUserThread(ProcessHandle, 0, FALSE, 0, 0,
2331                                0, StartRoutine, StartContext,
2332                                ThreadHandle, ClientId);
2333 }
2334
2335 /***********************************************************************
2336  *           PsGetCurrentProcessId   (NTOSKRNL.EXE.@)
2337  */
2338 HANDLE WINAPI PsGetCurrentProcessId(void)
2339 {
2340     if (GetCurrentThreadId() == request_thread)
2341         return UlongToHandle(client_pid);
2342     return UlongToHandle(GetCurrentProcessId());
2343 }
2344
2345
2346 /***********************************************************************
2347  *           PsGetCurrentThreadId   (NTOSKRNL.EXE.@)
2348  */
2349 HANDLE WINAPI PsGetCurrentThreadId(void)
2350 {
2351     if (GetCurrentThreadId() == request_thread)
2352         return UlongToHandle(client_tid);
2353     return UlongToHandle(GetCurrentThreadId());
2354 }
2355
2356
2357 /***********************************************************************
2358  *           PsGetVersion   (NTOSKRNL.EXE.@)
2359  */
2360 BOOLEAN WINAPI PsGetVersion(ULONG *major, ULONG *minor, ULONG *build, UNICODE_STRING *version )
2361 {
2362     RTL_OSVERSIONINFOEXW info;
2363
2364     info.dwOSVersionInfoSize = sizeof(info);
2365     RtlGetVersion( &info );
2366     if (major) *major = info.dwMajorVersion;
2367     if (minor) *minor = info.dwMinorVersion;
2368     if (build) *build = info.dwBuildNumber;
2369
2370     if (version)
2371     {
2372 #if 0  /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
2373         size_t len = min( strlenW(info.szCSDVersion)*sizeof(WCHAR), version->MaximumLength );
2374         memcpy( version->Buffer, info.szCSDVersion, len );
2375         if (len < version->MaximumLength) version->Buffer[len / sizeof(WCHAR)] = 0;
2376         version->Length = len;
2377 #endif
2378     }
2379     return TRUE;
2380 }
2381
2382
2383 /***********************************************************************
2384  *           PsImpersonateClient   (NTOSKRNL.EXE.@)
2385  */
2386 NTSTATUS WINAPI PsImpersonateClient(PETHREAD Thread, PACCESS_TOKEN Token, BOOLEAN CopyOnOpen,
2387                                     BOOLEAN EffectiveOnly, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
2388 {
2389     FIXME("(%p, %p, %u, %u, %u): stub\n", Thread, Token, CopyOnOpen, EffectiveOnly, ImpersonationLevel);
2390
2391     return STATUS_NOT_IMPLEMENTED;
2392 }
2393
2394
2395 /***********************************************************************
2396  *           PsSetCreateProcessNotifyRoutine   (NTOSKRNL.EXE.@)
2397  */
2398 NTSTATUS WINAPI PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback, BOOLEAN remove )
2399 {
2400     FIXME( "stub: %p %d\n", callback, remove );
2401     return STATUS_SUCCESS;
2402 }
2403
2404
2405 /***********************************************************************
2406  *           PsSetCreateProcessNotifyRoutineEx   (NTOSKRNL.EXE.@)
2407  */
2408 NTSTATUS WINAPI PsSetCreateProcessNotifyRoutineEx( PCREATE_PROCESS_NOTIFY_ROUTINE_EX callback, BOOLEAN remove )
2409 {
2410     FIXME( "stub: %p %d\n", callback, remove );
2411     return STATUS_SUCCESS;
2412 }
2413
2414
2415 /***********************************************************************
2416  *           PsSetCreateThreadNotifyRoutine   (NTOSKRNL.EXE.@)
2417  */
2418 NTSTATUS WINAPI PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
2419 {
2420     FIXME( "stub: %p\n", NotifyRoutine );
2421     return STATUS_SUCCESS;
2422 }
2423
2424
2425 /***********************************************************************
2426  *           PsRemoveCreateThreadNotifyRoutine  (NTOSKRNL.EXE.@)
2427  */
2428 NTSTATUS WINAPI PsRemoveCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
2429 {
2430     FIXME( "stub: %p\n", NotifyRoutine );
2431     return STATUS_SUCCESS;
2432 }
2433
2434
2435 /***********************************************************************
2436  *           PsRemoveLoadImageNotifyRoutine  (NTOSKRNL.EXE.@)
2437  */
2438  NTSTATUS WINAPI PsRemoveLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE NotifyRoutine)
2439  {
2440     FIXME( "stub: %p\n", NotifyRoutine );
2441     return STATUS_SUCCESS;
2442  }
2443
2444
2445 /***********************************************************************
2446  *           PsTerminateSystemThread   (NTOSKRNL.EXE.@)
2447  */
2448 NTSTATUS WINAPI PsTerminateSystemThread(NTSTATUS ExitStatus)
2449 {
2450     FIXME( "stub: %u\n", ExitStatus );
2451     return STATUS_NOT_IMPLEMENTED;
2452 }
2453
2454
2455 /***********************************************************************
2456  *           MmGetSystemRoutineAddress   (NTOSKRNL.EXE.@)
2457  */
2458 PVOID WINAPI MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName)
2459 {
2460     HMODULE hMod;
2461     STRING routineNameA;
2462     PVOID pFunc = NULL;
2463
2464     static const WCHAR ntoskrnlW[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
2465     static const WCHAR halW[] = {'h','a','l','.','d','l','l',0};
2466
2467     if (!SystemRoutineName) return NULL;
2468
2469     if (RtlUnicodeStringToAnsiString( &routineNameA, SystemRoutineName, TRUE ) == STATUS_SUCCESS)
2470     {
2471         /* We only support functions exported from ntoskrnl.exe or hal.dll */
2472         hMod = GetModuleHandleW( ntoskrnlW );
2473         pFunc = GetProcAddress( hMod, routineNameA.Buffer );
2474         if (!pFunc)
2475         {
2476            hMod = GetModuleHandleW( halW );
2477            if (hMod) pFunc = GetProcAddress( hMod, routineNameA.Buffer );
2478         }
2479         RtlFreeAnsiString( &routineNameA );
2480     }
2481
2482     if (pFunc)
2483         TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName), pFunc );
2484     else
2485         FIXME( "%s not found\n", debugstr_us(SystemRoutineName) );
2486     return pFunc;
2487 }
2488
2489
2490 /***********************************************************************
2491  *           MmQuerySystemSize   (NTOSKRNL.EXE.@)
2492  */
2493 MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void)
2494 {
2495     FIXME("stub\n");
2496     return MmLargeSystem;
2497 }
2498
2499 /***********************************************************************
2500  *           KeInitializeDpc   (NTOSKRNL.EXE.@)
2501  */
2502 VOID WINAPI KeInitializeDpc(PRKDPC Dpc, PKDEFERRED_ROUTINE DeferredRoutine, PVOID DeferredContext)
2503 {
2504     FIXME("stub\n");
2505 }
2506
2507 /***********************************************************************
2508  *           READ_REGISTER_BUFFER_UCHAR   (NTOSKRNL.EXE.@)
2509  */
2510 VOID WINAPI READ_REGISTER_BUFFER_UCHAR(PUCHAR Register, PUCHAR Buffer, ULONG Count)
2511 {
2512     FIXME("stub\n");
2513 }
2514
2515 /*****************************************************
2516  *           PoSetPowerState   (NTOSKRNL.EXE.@)
2517  */
2518 POWER_STATE WINAPI PoSetPowerState(PDEVICE_OBJECT DeviceObject, POWER_STATE_TYPE Type, POWER_STATE State)
2519 {
2520     FIXME("(%p %u %u) stub\n", DeviceObject, Type, State.DeviceState);
2521     return State;
2522 }
2523
2524 /*****************************************************
2525  *           IoWMIRegistrationControl   (NTOSKRNL.EXE.@)
2526  */
2527 NTSTATUS WINAPI IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject, ULONG Action)
2528 {
2529     FIXME("(%p %u) stub\n", DeviceObject, Action);
2530     return STATUS_SUCCESS;
2531 }
2532
2533 /*****************************************************
2534  *           PsSetLoadImageNotifyRoutine   (NTOSKRNL.EXE.@)
2535  */
2536 NTSTATUS WINAPI PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine)
2537 {
2538     FIXME("(%p) stub\n", routine);
2539     return STATUS_SUCCESS;
2540 }
2541
2542 /*****************************************************
2543  *           PsLookupProcessByProcessId  (NTOSKRNL.EXE.@)
2544  */
2545 NTSTATUS WINAPI PsLookupProcessByProcessId(HANDLE processid, PEPROCESS *process)
2546 {
2547     static int once;
2548     if (!once++) FIXME("(%p %p) stub\n", processid, process);
2549     return STATUS_NOT_IMPLEMENTED;
2550 }
2551
2552
2553 /*****************************************************
2554  *           IoSetThreadHardErrorMode  (NTOSKRNL.EXE.@)
2555  */
2556 BOOLEAN WINAPI IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors)
2557 {
2558     FIXME("stub\n");
2559     return FALSE;
2560 }
2561
2562
2563 /*****************************************************
2564  *           IoInitializeRemoveLockEx  (NTOSKRNL.EXE.@)
2565  */
2566 VOID WINAPI IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock, ULONG tag,
2567                                      ULONG maxmin, ULONG high, ULONG size)
2568 {
2569     FIXME("(%p %u %u %u %u) stub\n", lock, tag, maxmin, high, size);
2570 }
2571
2572
2573 /*****************************************************
2574  *           IoAcquireRemoveLockEx  (NTOSKRNL.EXE.@)
2575  */
2576
2577 NTSTATUS WINAPI IoAcquireRemoveLockEx(PIO_REMOVE_LOCK lock, PVOID tag,
2578                                       LPCSTR file, ULONG line, ULONG lock_size)
2579 {
2580     FIXME("(%p, %p, %s, %u, %u): stub\n", lock, tag, debugstr_a(file), line, lock_size);
2581
2582     return STATUS_NOT_IMPLEMENTED;
2583 }
2584
2585
2586 /*****************************************************
2587  *           DllMain
2588  */
2589 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
2590 {
2591     static void *handler;
2592     LARGE_INTEGER count;
2593
2594     switch(reason)
2595     {
2596     case DLL_PROCESS_ATTACH:
2597         DisableThreadLibraryCalls( inst );
2598 #if defined(__i386__) || defined(__x86_64__)
2599         handler = RtlAddVectoredExceptionHandler( TRUE, vectored_handler );
2600 #endif
2601         KeQueryTickCount( &count );  /* initialize the global KeTickCount */
2602         break;
2603     case DLL_PROCESS_DETACH:
2604         if (reserved) break;
2605         RtlRemoveVectoredExceptionHandler( handler );
2606         break;
2607     }
2608     return TRUE;
2609 }
2610
2611 /*****************************************************
2612  *           Ke386IoSetAccessProcess  (NTOSKRNL.EXE.@)
2613  */
2614 BOOLEAN WINAPI Ke386IoSetAccessProcess(PEPROCESS *process, ULONG flag)
2615 {
2616     FIXME("(%p %d) stub\n", process, flag);
2617     return FALSE;
2618 }
2619
2620 /*****************************************************
2621  *           Ke386SetIoAccessMap  (NTOSKRNL.EXE.@)
2622  */
2623 BOOLEAN WINAPI Ke386SetIoAccessMap(ULONG flag, PVOID buffer)
2624 {
2625     FIXME("(%d %p) stub\n", flag, buffer);
2626     return FALSE;
2627 }
2628
2629 /*****************************************************
2630  *           IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
2631  */
2632 PKEVENT WINAPI IoCreateSynchronizationEvent(PUNICODE_STRING name, PHANDLE handle)
2633 {
2634     FIXME("(%p %p) stub\n", name, handle);
2635     return NULL;
2636 }
2637
2638 /*****************************************************
2639  *           IoStartNextPacket  (NTOSKRNL.EXE.@)
2640  */
2641 VOID WINAPI IoStartNextPacket(PDEVICE_OBJECT deviceobject, BOOLEAN cancelable)
2642 {
2643     FIXME("(%p %d) stub\n", deviceobject, cancelable);
2644 }
2645
2646 /*****************************************************
2647  *           ObQueryNameString  (NTOSKRNL.EXE.@)
2648  */
2649 NTSTATUS WINAPI ObQueryNameString(PVOID object, POBJECT_NAME_INFORMATION name, ULONG maxlength, PULONG returnlength)
2650 {
2651     FIXME("(%p %p %u %p) stub\n", object, name, maxlength, returnlength);
2652     return STATUS_NOT_IMPLEMENTED;
2653 }
2654
2655 /*****************************************************
2656  *           IoRegisterPlugPlayNotification  (NTOSKRNL.EXE.@)
2657  */
2658 NTSTATUS WINAPI IoRegisterPlugPlayNotification(IO_NOTIFICATION_EVENT_CATEGORY category, ULONG flags, PVOID data,
2659                                                PDRIVER_OBJECT driver, PDRIVER_NOTIFICATION_CALLBACK_ROUTINE callback,
2660                                                PVOID context, PVOID *notification)
2661 {
2662     FIXME("(%u %u %p %p %p %p %p) stub\n", category, flags, data, driver, callback, context, notification);
2663     return STATUS_SUCCESS;
2664 }
2665
2666 /*****************************************************
2667  *           IoCsqInitialize  (NTOSKRNL.EXE.@)
2668  */
2669 NTSTATUS WINAPI IoCsqInitialize(PIO_CSQ csq, PIO_CSQ_INSERT_IRP insert_irp, PIO_CSQ_REMOVE_IRP remove_irp,
2670                                 PIO_CSQ_PEEK_NEXT_IRP peek_irp, PIO_CSQ_ACQUIRE_LOCK acquire_lock,
2671                                 PIO_CSQ_RELEASE_LOCK release_lock, PIO_CSQ_COMPLETE_CANCELED_IRP complete_irp)
2672 {
2673     FIXME("(%p %p %p %p %p %p %p) stub\n",
2674           csq, insert_irp, remove_irp, peek_irp, acquire_lock, release_lock, complete_irp);
2675     return STATUS_SUCCESS;
2676 }
2677
2678 /***********************************************************************
2679  *           ExAcquireResourceExclusiveLite  (NTOSKRNL.EXE.@)
2680  */
2681 BOOLEAN WINAPI ExAcquireResourceExclusiveLite( PERESOURCE resource, BOOLEAN wait )
2682 {
2683     FIXME( ":%p %u stub\n", resource, wait );
2684     return TRUE;
2685 }
2686
2687 /***********************************************************************
2688  *           ExDeleteResourceLite  (NTOSKRNL.EXE.@)
2689  */
2690 NTSTATUS WINAPI ExDeleteResourceLite(PERESOURCE resource)
2691 {
2692     FIXME("(%p): stub\n", resource);
2693     return STATUS_NOT_IMPLEMENTED;
2694 }
2695
2696 /*****************************************************
2697  *           ExInterlockedRemoveHeadList  (NTOSKRNL.EXE.@)
2698  */
2699 PLIST_ENTRY WINAPI ExInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2700 {
2701     FIXME("(%p %p) stub\n", head, lock);
2702     return NULL;
2703 }
2704
2705 /***********************************************************************
2706  *           ExfInterlockedRemoveHeadList   (NTOSKRNL.EXE.@)
2707  */
2708 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
2709 DEFINE_FASTCALL2_ENTRYPOINT( ExfInterlockedRemoveHeadList )
2710 PLIST_ENTRY WINAPI DECLSPEC_HIDDEN __regs_ExfInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2711 #else
2712 PLIST_ENTRY WINAPI ExfInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2713 #endif
2714 {
2715     FIXME("(%p %p) stub\n", head, lock);
2716     return ExInterlockedRemoveHeadList( head, lock );
2717 }
2718
2719 /***********************************************************************
2720  *           ExReleaseResourceForThreadLite   (NTOSKRNL.EXE.@)
2721  */
2722 void WINAPI ExReleaseResourceForThreadLite( PERESOURCE resource, ERESOURCE_THREAD tid )
2723 {
2724     FIXME( "stub: %p %lu\n", resource, tid );
2725 }
2726
2727 /***********************************************************************
2728  *           KeEnterCriticalRegion  (NTOSKRNL.EXE.@)
2729  */
2730 void WINAPI KeEnterCriticalRegion(void)
2731 {
2732     FIXME(": stub\n");
2733 }
2734
2735 /***********************************************************************
2736  *           KeLeaveCriticalRegion  (NTOSKRNL.EXE.@)
2737  */
2738 void WINAPI KeLeaveCriticalRegion(void)
2739 {
2740     FIXME(": stub\n");
2741 }
2742
2743 /***********************************************************************
2744  *           ProbeForRead   (NTOSKRNL.EXE.@)
2745  */
2746 void WINAPI ProbeForRead(void *address, SIZE_T length, ULONG alignment)
2747 {
2748     FIXME("(%p %lu %u) stub\n", address, length, alignment);
2749 }
2750
2751 /***********************************************************************
2752  *           ProbeForWrite   (NTOSKRNL.EXE.@)
2753  */
2754 void WINAPI ProbeForWrite(void *address, SIZE_T length, ULONG alignment)
2755 {
2756     FIXME("(%p %lu %u) stub\n", address, length, alignment);
2757 }
2758
2759 /***********************************************************************
2760  *           CmRegisterCallback  (NTOSKRNL.EXE.@)
2761  */
2762 NTSTATUS WINAPI CmRegisterCallback(EX_CALLBACK_FUNCTION *function, void *context, LARGE_INTEGER *cookie)
2763 {
2764     FIXME("(%p %p %p): stub\n", function, context, cookie);
2765     return STATUS_NOT_IMPLEMENTED;
2766 }
2767
2768 /***********************************************************************
2769  *           CmUnRegisterCallback  (NTOSKRNL.EXE.@)
2770  */
2771 NTSTATUS WINAPI CmUnRegisterCallback(LARGE_INTEGER cookie)
2772 {
2773     FIXME("(%s): stub\n", wine_dbgstr_longlong(cookie.QuadPart));
2774     return STATUS_NOT_IMPLEMENTED;
2775 }
2776
2777 /***********************************************************************
2778  *           KeDelayExecutionThread  (NTOSKRNL.EXE.@)
2779  */
2780 NTSTATUS WINAPI KeDelayExecutionThread(KPROCESSOR_MODE waitmode, BOOLEAN alertable, PLARGE_INTEGER interval)
2781 {
2782     FIXME("(%u, %u, %p): stub\n", waitmode, alertable, interval);
2783     return STATUS_NOT_IMPLEMENTED;
2784 }
2785
2786 /***********************************************************************
2787  *           IoAttachDevice  (NTOSKRNL.EXE.@)
2788  */
2789 NTSTATUS WINAPI IoAttachDevice(DEVICE_OBJECT *source, UNICODE_STRING *target, DEVICE_OBJECT *attached)
2790 {
2791     FIXME("(%p, %s, %p): stub\n", source, debugstr_us(target), attached);
2792     return STATUS_NOT_IMPLEMENTED;
2793 }
2794
2795
2796 static NTSTATUS open_driver( const UNICODE_STRING *service_name, SC_HANDLE *service )
2797 {
2798     QUERY_SERVICE_CONFIGW *service_config = NULL;
2799     SC_HANDLE manager_handle;
2800     DWORD config_size = 0;
2801     WCHAR *name;
2802
2803     if (!(name = RtlAllocateHeap( GetProcessHeap(), 0, service_name->Length + sizeof(WCHAR) )))
2804         return STATUS_NO_MEMORY;
2805
2806     memcpy( name, service_name->Buffer, service_name->Length );
2807     name[ service_name->Length / sizeof(WCHAR) ] = 0;
2808
2809     if (strncmpW( name, servicesW, strlenW(servicesW) ))
2810     {
2811         FIXME( "service name %s is not a keypath\n", debugstr_us(service_name) );
2812         RtlFreeHeap( GetProcessHeap(), 0, name );
2813         return STATUS_NOT_IMPLEMENTED;
2814     }
2815
2816     if (!(manager_handle = OpenSCManagerW( NULL, NULL, SC_MANAGER_CONNECT )))
2817     {
2818         WARN( "failed to connect to service manager\n" );
2819         RtlFreeHeap( GetProcessHeap(), 0, name );
2820         return STATUS_NOT_SUPPORTED;
2821     }
2822
2823     *service = OpenServiceW( manager_handle, name + strlenW(servicesW), SERVICE_ALL_ACCESS );
2824     RtlFreeHeap( GetProcessHeap(), 0, name );
2825     CloseServiceHandle( manager_handle );
2826
2827     if (!*service)
2828     {
2829         WARN( "failed to open service %s\n", debugstr_us(service_name) );
2830         return STATUS_UNSUCCESSFUL;
2831     }
2832
2833     QueryServiceConfigW( *service, NULL, 0, &config_size );
2834     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
2835     {
2836         WARN( "failed to query service config\n" );
2837         goto error;
2838     }
2839
2840     if (!(service_config = RtlAllocateHeap( GetProcessHeap(), 0, config_size )))
2841         goto error;
2842
2843     if (!QueryServiceConfigW( *service, service_config, config_size, &config_size ))
2844     {
2845         WARN( "failed to query service config\n" );
2846         goto error;
2847     }
2848
2849     if (service_config->dwServiceType != SERVICE_KERNEL_DRIVER &&
2850         service_config->dwServiceType != SERVICE_FILE_SYSTEM_DRIVER)
2851     {
2852         WARN( "service %s is not a kernel driver\n", debugstr_us(service_name) );
2853         goto error;
2854     }
2855
2856     TRACE( "opened service for driver %s\n", debugstr_us(service_name) );
2857     RtlFreeHeap( GetProcessHeap(), 0, service_config );
2858     return STATUS_SUCCESS;
2859
2860 error:
2861     CloseServiceHandle( *service );
2862     RtlFreeHeap( GetProcessHeap(), 0, service_config );
2863     return STATUS_UNSUCCESSFUL;
2864 }
2865
2866
2867 /***********************************************************************
2868  *           ZwLoadDriver (NTOSKRNL.EXE.@)
2869  */
2870 NTSTATUS WINAPI ZwLoadDriver( const UNICODE_STRING *service_name )
2871 {
2872     SERVICE_STATUS_PROCESS service_status;
2873     SC_HANDLE service_handle;
2874     ULONGLONG start_time;
2875     NTSTATUS status;
2876     DWORD bytes;
2877
2878     TRACE( "(%s)\n", debugstr_us(service_name) );
2879
2880     if ((status = open_driver( service_name, &service_handle )) != STATUS_SUCCESS)
2881         return status;
2882
2883     TRACE( "trying to start %s\n", debugstr_us(service_name) );
2884
2885     start_time = GetTickCount64();
2886     for (;;)
2887     {
2888         if (StartServiceW( service_handle, 0, NULL )) break;
2889         if (GetLastError() == ERROR_SERVICE_ALREADY_RUNNING) break;
2890         if (GetLastError() != ERROR_SERVICE_DATABASE_LOCKED) goto error;
2891         if (GetTickCount64() - start_time > 30000) goto error;
2892         Sleep( 100 );
2893     }
2894
2895     start_time = GetTickCount64();
2896     for (;;)
2897     {
2898         if (!QueryServiceStatusEx( service_handle, SC_STATUS_PROCESS_INFO,
2899                                    (BYTE *)&service_status, sizeof(service_status), &bytes )) goto error;
2900         if (service_status.dwCurrentState != SERVICE_START_PENDING) break;
2901         if (GetTickCount64() - start_time > 30000) goto error;
2902         Sleep( 100 );
2903     }
2904
2905     if (service_status.dwCurrentState == SERVICE_RUNNING)
2906     {
2907         if (service_status.dwProcessId != GetCurrentProcessId())
2908             FIXME( "driver %s was loaded into a different process\n", debugstr_us(service_name) );
2909
2910         status = STATUS_SUCCESS;
2911         goto done;
2912     }
2913
2914 error:
2915     WARN( "failed to start service %s\n", debugstr_us(service_name) );
2916     status = STATUS_UNSUCCESSFUL;
2917
2918 done:
2919     TRACE( "returning status %08x\n", status );
2920     CloseServiceHandle( service_handle );
2921     return status;
2922 }
2923
2924
2925 /***********************************************************************
2926  *           ZwUnloadDriver (NTOSKRNL.EXE.@)
2927  */
2928 NTSTATUS WINAPI ZwUnloadDriver( const UNICODE_STRING *service_name )
2929 {
2930     SERVICE_STATUS service_status;
2931     SC_HANDLE service_handle;
2932     ULONGLONG start_time;
2933     NTSTATUS status;
2934
2935     TRACE( "(%s)\n", debugstr_us(service_name) );
2936
2937     if ((status = open_driver( service_name, &service_handle )) != STATUS_SUCCESS)
2938         return status;
2939
2940     if (!ControlService( service_handle, SERVICE_CONTROL_STOP, &service_status ))
2941         goto error;
2942
2943     start_time = GetTickCount64();
2944     for (;;)
2945     {
2946         if (!QueryServiceStatus( service_handle, &service_status )) goto error;
2947         if (service_status.dwCurrentState != SERVICE_STOP_PENDING) break;
2948         if (GetTickCount64() - start_time > 30000) goto error;
2949         Sleep( 100 );
2950     }
2951
2952     if (service_status.dwCurrentState == SERVICE_STOPPED)
2953     {
2954         status = STATUS_SUCCESS;
2955         goto done;
2956     }
2957
2958 error:
2959     WARN( "failed to stop service %s\n", debugstr_us(service_name) );
2960     status = STATUS_UNSUCCESSFUL;
2961
2962 done:
2963     TRACE( "returning status %08x\n", status );
2964     CloseServiceHandle( service_handle );
2965     return status;
2966 }
2967
2968
2969 static NTSTATUS WINAPI internal_complete( DEVICE_OBJECT *device, IRP *irp, void *context )
2970 {
2971     HANDLE event = context;
2972     SetEvent( event );
2973     return STATUS_MORE_PROCESSING_REQUIRED;
2974 }
2975
2976
2977 static NTSTATUS send_device_irp( DEVICE_OBJECT *device, IRP *irp, ULONG_PTR *info )
2978 {
2979     NTSTATUS status;
2980     HANDLE event = CreateEventA( NULL, FALSE, FALSE, NULL );
2981     DEVICE_OBJECT *toplevel_device;
2982
2983     irp->IoStatus.u.Status = STATUS_NOT_SUPPORTED;
2984     IoSetCompletionRoutine( irp, internal_complete, event, TRUE, TRUE, TRUE );
2985
2986     toplevel_device = IoGetAttachedDeviceReference( device );
2987     status = IoCallDriver( toplevel_device, irp );
2988
2989     if (status == STATUS_PENDING)
2990         WaitForSingleObject( event, INFINITE );
2991
2992     status = irp->IoStatus.u.Status;
2993     if (info)
2994         *info = irp->IoStatus.Information;
2995     IoCompleteRequest( irp, IO_NO_INCREMENT );
2996     ObDereferenceObject( toplevel_device );
2997     CloseHandle( event );
2998     return status;
2999 }
3000
3001
3002 static NTSTATUS get_device_id( DEVICE_OBJECT *device, BUS_QUERY_ID_TYPE type, WCHAR **id )
3003 {
3004     IO_STACK_LOCATION *irpsp;
3005     IO_STATUS_BLOCK irp_status;
3006     IRP *irp;
3007
3008     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_PNP, device, NULL, 0, NULL, NULL, &irp_status )))
3009         return STATUS_NO_MEMORY;
3010
3011     irpsp = IoGetNextIrpStackLocation( irp );
3012     irpsp->MinorFunction = IRP_MN_QUERY_ID;
3013     irpsp->Parameters.QueryId.IdType = type;
3014
3015     return send_device_irp( device, irp, (ULONG_PTR *)id );
3016 }
3017
3018
3019 static BOOL get_driver_for_id( const WCHAR *id, WCHAR *driver )
3020 {
3021     static const WCHAR serviceW[] = {'S','e','r','v','i','c','e',0};
3022     static const UNICODE_STRING service_str = { sizeof(serviceW) - sizeof(WCHAR), sizeof(serviceW), (WCHAR *)serviceW };
3023     static const WCHAR critical_fmtW[] =
3024         {'\\','R','e','g','i','s','t','r','y',
3025          '\\','M','a','c','h','i','n','e',
3026          '\\','S','y','s','t','e','m',
3027          '\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
3028          '\\','C','o','n','t','r','o','l',
3029          '\\','C','r','i','t','i','c','a','l','D','e','v','i','c','e','D','a','t','a','b','a','s','e',
3030          '\\','%','s',0};
3031     WCHAR buffer[FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data[MAX_SERVICE_NAME * sizeof(WCHAR)] )];
3032     KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
3033     OBJECT_ATTRIBUTES attr;
3034     UNICODE_STRING key;
3035     NTSTATUS status;
3036     HANDLE hkey;
3037     WCHAR *keyW;
3038     DWORD len;
3039
3040     if (!(keyW = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(critical_fmtW) + strlenW(id) * sizeof(WCHAR) )))
3041         return STATUS_NO_MEMORY;
3042
3043     sprintfW( keyW, critical_fmtW, id );
3044     RtlInitUnicodeString( &key, keyW );
3045     InitializeObjectAttributes( &attr, &key, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL );
3046
3047     status = NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr );
3048     RtlFreeUnicodeString( &key );
3049     if (status != STATUS_SUCCESS)
3050     {
3051         TRACE_(plugplay)( "no driver found for %s\n", debugstr_w(id) );
3052         return FALSE;
3053     }
3054
3055     status = NtQueryValueKey( hkey, &service_str, KeyValuePartialInformation,
3056                               info, sizeof(buffer) - sizeof(WCHAR), &len );
3057     NtClose( hkey );
3058     if (status != STATUS_SUCCESS || info->Type != REG_SZ)
3059     {
3060         TRACE_(plugplay)( "no driver found for %s\n", debugstr_w(id) );
3061         return FALSE;
3062     }
3063
3064     memcpy( driver, info->Data, info->DataLength );
3065     driver[ info->DataLength / sizeof(WCHAR) ] = 0;
3066     TRACE_(plugplay)( "found driver %s for %s\n", debugstr_w(driver), debugstr_w(id) );
3067     return TRUE;
3068 }
3069
3070
3071 static NTSTATUS send_pnp_irp( DEVICE_OBJECT *device, UCHAR minor )
3072 {
3073     IO_STACK_LOCATION *irpsp;
3074     IO_STATUS_BLOCK irp_status;
3075     IRP *irp;
3076
3077     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_PNP, device, NULL, 0, NULL, NULL, &irp_status )))
3078         return STATUS_NO_MEMORY;
3079
3080     irpsp = IoGetNextIrpStackLocation( irp );
3081     irpsp->MinorFunction = minor;
3082
3083     irpsp->Parameters.StartDevice.AllocatedResources = NULL;
3084     irpsp->Parameters.StartDevice.AllocatedResourcesTranslated = NULL;
3085
3086     return send_device_irp( device, irp, NULL );
3087 }
3088
3089
3090 static NTSTATUS send_power_irp( DEVICE_OBJECT *device, DEVICE_POWER_STATE power )
3091 {
3092     IO_STATUS_BLOCK irp_status;
3093     IO_STACK_LOCATION *irpsp;
3094     IRP *irp;
3095
3096     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_POWER, device, NULL, 0, NULL, NULL, &irp_status )))
3097         return STATUS_NO_MEMORY;
3098
3099     irpsp = IoGetNextIrpStackLocation( irp );
3100     irpsp->MinorFunction = IRP_MN_SET_POWER;
3101
3102     irpsp->Parameters.Power.Type = DevicePowerState;
3103     irpsp->Parameters.Power.State.DeviceState = power;
3104
3105     return send_device_irp( device, irp, NULL );
3106 }
3107
3108
3109 static void handle_bus_relations( DEVICE_OBJECT *device )
3110 {
3111     static const WCHAR driverW[] = {'\\','D','r','i','v','e','r','\\',0};
3112     WCHAR buffer[MAX_SERVICE_NAME + sizeof(servicesW)/sizeof(WCHAR)];
3113     WCHAR driver[MAX_SERVICE_NAME] = {0};
3114     DRIVER_OBJECT *driver_obj;
3115     UNICODE_STRING string;
3116     WCHAR *ids, *ptr;
3117     NTSTATUS status;
3118
3119     TRACE_(plugplay)( "(%p)\n", device );
3120
3121     /* We could (should?) do a full IRP_MN_QUERY_DEVICE_RELATIONS query,
3122      * but we don't have to, we have the DEVICE_OBJECT of the new device
3123      * so we can simply handle the process here */
3124
3125     status = get_device_id( device, BusQueryCompatibleIDs, &ids );
3126     if (status != STATUS_SUCCESS || !ids)
3127     {
3128         ERR_(plugplay)( "Failed to get device IDs\n" );
3129         return;
3130     }
3131
3132     for (ptr = ids; *ptr; ptr += strlenW(ptr) + 1)
3133     {
3134         if (get_driver_for_id( ptr, driver ))
3135             break;
3136     }
3137     RtlFreeHeap( GetProcessHeap(), 0, ids );
3138
3139     if (!driver[0])
3140     {
3141         ERR_(plugplay)( "No matching driver found for device\n" );
3142         return;
3143     }
3144
3145     strcpyW( buffer, servicesW );
3146     strcatW( buffer, driver );
3147     RtlInitUnicodeString( &string, buffer );
3148     if (ZwLoadDriver( &string ) != STATUS_SUCCESS)
3149     {
3150         ERR_(plugplay)( "Failed to load driver %s\n", debugstr_w(driver) );
3151         return;
3152     }
3153
3154     strcpyW( buffer, driverW );
3155     strcatW( buffer, driver );
3156     RtlInitUnicodeString( &string, buffer );
3157     if (ObReferenceObjectByName( &string, OBJ_CASE_INSENSITIVE, NULL,
3158                                  0, NULL, KernelMode, NULL, (void **)&driver_obj ) != STATUS_SUCCESS)
3159     {
3160         ERR_(plugplay)( "Failed to locate loaded driver %s\n", debugstr_w(driver) );
3161         return;
3162     }
3163
3164     if (driver_obj->DriverExtension->AddDevice)
3165         status = driver_obj->DriverExtension->AddDevice( driver_obj, device );
3166     else
3167         status = STATUS_NOT_IMPLEMENTED;
3168
3169     ObDereferenceObject( driver_obj );
3170
3171     if (status != STATUS_SUCCESS)
3172     {
3173         ERR_(plugplay)( "AddDevice failed for driver %s\n", debugstr_w(driver) );
3174         return;
3175     }
3176
3177     send_pnp_irp( device, IRP_MN_START_DEVICE );
3178     send_power_irp( device, PowerDeviceD0 );
3179 }
3180
3181
3182 static void handle_removal_relations( DEVICE_OBJECT *device )
3183 {
3184     TRACE_(plugplay)( "(%p)\n", device );
3185
3186     send_power_irp( device, PowerDeviceD3 );
3187     send_pnp_irp( device, IRP_MN_SURPRISE_REMOVAL );
3188     send_pnp_irp( device, IRP_MN_REMOVE_DEVICE );
3189 }
3190
3191
3192 /***********************************************************************
3193  *           IoInvalidateDeviceRelations (NTOSKRNL.EXE.@)
3194  */
3195 void WINAPI IoInvalidateDeviceRelations( DEVICE_OBJECT *device_object, DEVICE_RELATION_TYPE type )
3196 {
3197     TRACE( "(%p, %i)\n", device_object, type );
3198
3199     switch (type)
3200     {
3201         case BusRelations:
3202             handle_bus_relations( device_object );
3203             break;
3204         case RemovalRelations:
3205             handle_removal_relations( device_object );
3206             break;
3207         default:
3208             FIXME( "unhandled relation %i\n", type );
3209             break;
3210     }
3211 }
3212
3213 /***********************************************************************
3214  *           KeSetTimerEx (NTOSKRNL.EXE.@)
3215  */
3216 BOOL WINAPI KeSetTimerEx( KTIMER *timer, LARGE_INTEGER duetime, LONG period, KDPC *dpc )
3217 {
3218     FIXME("stub: %p %s %u %p\n", timer, wine_dbgstr_longlong(duetime.QuadPart), period, dpc);
3219     return TRUE;
3220 }
3221
3222 /***********************************************************************
3223  *           IoCreateFile (NTOSKRNL.EXE.@)
3224  */
3225 NTSTATUS WINAPI IoCreateFile(HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
3226                               IO_STATUS_BLOCK *io, LARGE_INTEGER *alloc_size, ULONG attributes, ULONG sharing,
3227                               ULONG disposition, ULONG create_options, VOID *ea_buffer, ULONG ea_length,
3228                               CREATE_FILE_TYPE file_type, VOID *parameters, ULONG options )
3229 {
3230     FIXME(": stub\n");
3231     return STATUS_NOT_IMPLEMENTED;
3232 }
3233
3234 /***********************************************************************
3235  *           KeClearEvent (NTOSKRNL.EXE.@)
3236  */
3237 VOID WINAPI KeClearEvent(PRKEVENT event)
3238 {
3239     FIXME("stub: %p\n", event);
3240 }
3241
3242 /***********************************************************************
3243  *           KeAcquireInStackQueuedSpinLock (NTOSKRNL.EXE.@)
3244  */
3245 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
3246 DEFINE_FASTCALL2_ENTRYPOINT( KeAcquireInStackQueuedSpinLock )
3247 void WINAPI DECLSPEC_HIDDEN __regs_KeAcquireInStackQueuedSpinLock( KSPIN_LOCK *spinlock,
3248                                                                    KLOCK_QUEUE_HANDLE *handle )
3249 #else
3250 void WINAPI KeAcquireInStackQueuedSpinLock( KSPIN_LOCK *spinlock, KLOCK_QUEUE_HANDLE *handle )
3251 #endif
3252 {
3253     FIXME( "stub: %p %p\n", spinlock, handle );
3254 }
3255
3256 /***********************************************************************
3257  *           KeReleaseInStackQueuedSpinLock (NTOSKRNL.EXE.@)
3258  */
3259 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
3260 DEFINE_FASTCALL1_ENTRYPOINT( KeReleaseInStackQueuedSpinLock )
3261 void WINAPI DECLSPEC_HIDDEN __regs_KeReleaseInStackQueuedSpinLock( KLOCK_QUEUE_HANDLE *handle )
3262 #else
3263 void WINAPI KeReleaseInStackQueuedSpinLock( KLOCK_QUEUE_HANDLE *handle )
3264 #endif
3265 {
3266     FIXME( "stub: %p\n", handle );
3267 }
3268
3269 /***********************************************************************
3270  *           KeAcquireSpinLockRaiseToDpc (NTOSKRNL.EXE.@)
3271  */
3272 KIRQL WINAPI KeAcquireSpinLockRaiseToDpc(KSPIN_LOCK *spinlock)
3273 {
3274     FIXME( "stub: %p\n", spinlock );
3275     return 0;
3276 }
3277
3278 /***********************************************************************
3279  *           KeReleaseSpinLock (NTOSKRNL.EXE.@)
3280  */
3281 void WINAPI KeReleaseSpinLock( KSPIN_LOCK *spinlock, KIRQL irql )
3282 {
3283     FIXME( "stub: %p %u\n", spinlock, irql );
3284 }
3285
3286 /***********************************************************************
3287  *           IoCreateNotificationEvent (NTOSKRNL.EXE.@)
3288  */
3289 PKEVENT WINAPI IoCreateNotificationEvent(UNICODE_STRING *name, HANDLE *handle)
3290 {
3291     FIXME( "stub: %s %p\n", debugstr_us(name), handle );
3292     return NULL;
3293 }