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