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     if (TRACE_ON(relay))
1299         DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
1300                  GetCurrentThreadId(), dispatch, device, irp );
1301
1302     status = dispatch( device, irp );
1303
1304     if (TRACE_ON(relay))
1305         DPRINTF( "%04x:Ret  driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
1306                  GetCurrentThreadId(), dispatch, device, irp, status );
1307
1308     return status;
1309 }
1310
1311
1312 /***********************************************************************
1313  *           IofCallDriver   (NTOSKRNL.EXE.@)
1314  */
1315 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1316 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver )
1317 NTSTATUS WINAPI DECLSPEC_HIDDEN __regs_IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
1318 #else
1319 NTSTATUS WINAPI IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
1320 #endif
1321 {
1322     TRACE( "%p %p\n", device, irp );
1323     return IoCallDriver( device, irp );
1324 }
1325
1326
1327 /***********************************************************************
1328  *           IoGetRelatedDeviceObject    (NTOSKRNL.EXE.@)
1329  */
1330 PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject( PFILE_OBJECT obj )
1331 {
1332     FIXME( "stub: %p\n", obj );
1333     return NULL;
1334 }
1335
1336 static CONFIGURATION_INFORMATION configuration_information;
1337
1338 /***********************************************************************
1339  *           IoGetConfigurationInformation    (NTOSKRNL.EXE.@)
1340  */
1341 PCONFIGURATION_INFORMATION WINAPI IoGetConfigurationInformation(void)
1342 {
1343     FIXME( "partial stub\n" );
1344     /* FIXME: return actual devices on system */
1345     return &configuration_information;
1346 }
1347
1348
1349 /***********************************************************************
1350  *           IoIsWdmVersionAvailable     (NTOSKRNL.EXE.@)
1351  */
1352 NTSTATUS WINAPI IoIsWdmVersionAvailable(UCHAR MajorVersion, UCHAR MinorVersion)
1353 {
1354     DWORD version;
1355     DWORD major;
1356     DWORD minor;
1357
1358     TRACE( "%d, 0x%X\n", MajorVersion, MinorVersion );
1359
1360     version = GetVersion();
1361     major = LOBYTE(version);
1362     minor = HIBYTE(LOWORD(version));
1363
1364     if (MajorVersion == 6 && MinorVersion == 0)
1365     {
1366         /* Windows Vista, Windows Server 2008, Windows 7 */
1367     }
1368     else if (MajorVersion == 1)
1369     {
1370         if (MinorVersion == 0x30)
1371         {
1372             /* Windows server 2003 */
1373             MajorVersion = 6;
1374             MinorVersion = 0;
1375         }
1376         else if (MinorVersion == 0x20)
1377         {
1378             /* Windows XP */
1379             MajorVersion = 5;
1380             MinorVersion = 1;
1381         }
1382         else if (MinorVersion == 0x10)
1383         {
1384             /* Windows 2000 */
1385             MajorVersion = 5;
1386             MinorVersion = 0;
1387         }
1388         else if (MinorVersion == 0x05)
1389         {
1390             /* Windows ME */
1391             MajorVersion = 4;
1392             MinorVersion = 0x5a;
1393         }
1394         else if (MinorVersion == 0x00)
1395         {
1396             /* Windows 98 */
1397             MajorVersion = 4;
1398             MinorVersion = 0x0a;
1399         }
1400         else
1401         {
1402             FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
1403             return FALSE;
1404         }
1405     }
1406     else
1407     {
1408         FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
1409         return FALSE;
1410     }
1411     return major > MajorVersion || (major == MajorVersion && minor >= MinorVersion);
1412 }
1413
1414
1415 /***********************************************************************
1416  *           IoQueryDeviceDescription    (NTOSKRNL.EXE.@)
1417  */
1418 NTSTATUS WINAPI IoQueryDeviceDescription(PINTERFACE_TYPE itype, PULONG bus, PCONFIGURATION_TYPE ctype,
1419                                      PULONG cnum, PCONFIGURATION_TYPE ptype, PULONG pnum,
1420                                      PIO_QUERY_DEVICE_ROUTINE callout, PVOID context)
1421 {
1422     FIXME( "(%p %p %p %p %p %p %p %p)\n", itype, bus, ctype, cnum, ptype, pnum, callout, context);
1423     return STATUS_NOT_IMPLEMENTED;
1424 }
1425
1426
1427 /***********************************************************************
1428  *           IoRegisterDriverReinitialization    (NTOSKRNL.EXE.@)
1429  */
1430 void WINAPI IoRegisterDriverReinitialization( PDRIVER_OBJECT obj, PDRIVER_REINITIALIZE reinit, PVOID context )
1431 {
1432     FIXME( "stub: %p %p %p\n", obj, reinit, context );
1433 }
1434
1435
1436 /***********************************************************************
1437  *           IoRegisterShutdownNotification    (NTOSKRNL.EXE.@)
1438  */
1439 NTSTATUS WINAPI IoRegisterShutdownNotification( PDEVICE_OBJECT obj )
1440 {
1441     FIXME( "stub: %p\n", obj );
1442     return STATUS_SUCCESS;
1443 }
1444
1445
1446 /***********************************************************************
1447  *           IoUnregisterShutdownNotification    (NTOSKRNL.EXE.@)
1448  */
1449 VOID WINAPI IoUnregisterShutdownNotification( PDEVICE_OBJECT obj )
1450 {
1451     FIXME( "stub: %p\n", obj );
1452 }
1453
1454
1455 /***********************************************************************
1456  *           IoReportResourceForDetection   (NTOSKRNL.EXE.@)
1457  */
1458 NTSTATUS WINAPI IoReportResourceForDetection( DRIVER_OBJECT *drv_obj, CM_RESOURCE_LIST *drv_list, ULONG drv_size,
1459                                               DEVICE_OBJECT *dev_obj, CM_RESOURCE_LIST *dev_list, ULONG dev_size,
1460                                               BOOLEAN *conflict )
1461 {
1462     FIXME( "(%p, %p, %u, %p, %p, %u, %p): stub\n", drv_obj, drv_list, drv_size,
1463            dev_obj, dev_list, dev_size, conflict );
1464
1465     return STATUS_NOT_IMPLEMENTED;
1466 }
1467
1468
1469 /***********************************************************************
1470  *           IoReportResourceUsage    (NTOSKRNL.EXE.@)
1471  */
1472 NTSTATUS WINAPI IoReportResourceUsage( UNICODE_STRING *name, DRIVER_OBJECT *drv_obj, CM_RESOURCE_LIST *drv_list,
1473                                        ULONG drv_size, DRIVER_OBJECT *dev_obj, CM_RESOURCE_LIST *dev_list,
1474                                        ULONG dev_size, BOOLEAN overwrite, BOOLEAN *conflict )
1475 {
1476     FIXME( "(%s, %p, %p, %u, %p, %p, %u, %d, %p): stub\n", debugstr_us(name),
1477            drv_obj, drv_list, drv_size, dev_obj, dev_list, dev_size, overwrite, conflict );
1478
1479     return STATUS_NOT_IMPLEMENTED;
1480 }
1481
1482
1483 /***********************************************************************
1484  *           IoCompleteRequest   (NTOSKRNL.EXE.@)
1485  */
1486 VOID WINAPI IoCompleteRequest( IRP *irp, UCHAR priority_boost )
1487 {
1488     IO_STACK_LOCATION *irpsp;
1489     PIO_COMPLETION_ROUTINE routine;
1490     NTSTATUS status, stat;
1491     int call_flag = 0;
1492
1493     TRACE( "%p %u\n", irp, priority_boost );
1494
1495     status = irp->IoStatus.u.Status;
1496     while (irp->CurrentLocation <= irp->StackCount)
1497     {
1498         irpsp = irp->Tail.Overlay.s.u2.CurrentStackLocation;
1499         routine = irpsp->CompletionRoutine;
1500         call_flag = 0;
1501         /* FIXME: add SL_INVOKE_ON_CANCEL support */
1502         if (routine)
1503         {
1504             if ((irpsp->Control & SL_INVOKE_ON_SUCCESS) && STATUS_SUCCESS == status)
1505                 call_flag = 1;
1506             if ((irpsp->Control & SL_INVOKE_ON_ERROR) && STATUS_SUCCESS != status)
1507                 call_flag = 1;
1508         }
1509         ++irp->CurrentLocation;
1510         ++irp->Tail.Overlay.s.u2.CurrentStackLocation;
1511         if (call_flag)
1512         {
1513             TRACE( "calling %p( %p, %p, %p )\n", routine,
1514                     irpsp->DeviceObject, irp, irpsp->Context );
1515             stat = routine( irpsp->DeviceObject, irp, irpsp->Context );
1516             TRACE( "CompletionRoutine returned %x\n", stat );
1517             if (STATUS_MORE_PROCESSING_REQUIRED == stat)
1518                 return;
1519         }
1520     }
1521
1522     if (irp->Flags & IRP_DEALLOCATE_BUFFER)
1523         HeapFree( GetProcessHeap(), 0, irp->AssociatedIrp.SystemBuffer );
1524
1525     IoFreeIrp( irp );
1526 }
1527
1528
1529 /***********************************************************************
1530  *           IofCompleteRequest   (NTOSKRNL.EXE.@)
1531  */
1532 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1533 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest )
1534 void WINAPI DECLSPEC_HIDDEN __regs_IofCompleteRequest( IRP *irp, UCHAR priority_boost )
1535 #else
1536 void WINAPI IofCompleteRequest( IRP *irp, UCHAR priority_boost )
1537 #endif
1538 {
1539     TRACE( "%p %u\n", irp, priority_boost );
1540     IoCompleteRequest( irp, priority_boost );
1541 }
1542
1543
1544 /***********************************************************************
1545  *           InterlockedCompareExchange   (NTOSKRNL.EXE.@)
1546  */
1547 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
1548 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange )
1549 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
1550 #else
1551 LONG WINAPI NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
1552 #endif
1553 {
1554     return InterlockedCompareExchange( dest, xchg, compare );
1555 }
1556
1557
1558 /***********************************************************************
1559  *           InterlockedDecrement   (NTOSKRNL.EXE.@)
1560  */
1561 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1562 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement )
1563 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
1564 #else
1565 LONG WINAPI NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
1566 #endif
1567 {
1568     return InterlockedDecrement( dest );
1569 }
1570
1571
1572 /***********************************************************************
1573  *           InterlockedExchange   (NTOSKRNL.EXE.@)
1574  */
1575 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1576 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange )
1577 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
1578 #else
1579 LONG WINAPI NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
1580 #endif
1581 {
1582     return InterlockedExchange( dest, val );
1583 }
1584
1585
1586 /***********************************************************************
1587  *           InterlockedExchangeAdd   (NTOSKRNL.EXE.@)
1588  */
1589 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1590 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd )
1591 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
1592 #else
1593 LONG WINAPI NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
1594 #endif
1595 {
1596     return InterlockedExchangeAdd( dest, incr );
1597 }
1598
1599
1600 /***********************************************************************
1601  *           InterlockedIncrement   (NTOSKRNL.EXE.@)
1602  */
1603 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1604 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement )
1605 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1606 #else
1607 LONG WINAPI NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1608 #endif
1609 {
1610     return InterlockedIncrement( dest );
1611 }
1612
1613
1614 /***********************************************************************
1615  *           InterlockedPopEntrySList   (NTOSKRNL.EXE.@)
1616  */
1617 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1618 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedPopEntrySList )
1619 PSLIST_ENTRY WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedPopEntrySList( PSLIST_HEADER list )
1620 #else
1621 PSLIST_ENTRY WINAPI NTOSKRNL_InterlockedPopEntrySList( PSLIST_HEADER list )
1622 #endif
1623 {
1624     return InterlockedPopEntrySList( list );
1625 }
1626
1627
1628 /***********************************************************************
1629  *           InterlockedPushEntrySList   (NTOSKRNL.EXE.@)
1630  */
1631 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1632 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedPushEntrySList )
1633 PSLIST_ENTRY WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedPushEntrySList( PSLIST_HEADER list,
1634                                                                                PSLIST_ENTRY entry )
1635 #else
1636 PSLIST_ENTRY WINAPI NTOSKRNL_InterlockedPushEntrySList( PSLIST_HEADER list, PSLIST_ENTRY entry )
1637 #endif
1638 {
1639     return InterlockedPushEntrySList( list, entry );
1640 }
1641
1642
1643 /***********************************************************************
1644  *           ExAllocatePool   (NTOSKRNL.EXE.@)
1645  */
1646 PVOID WINAPI ExAllocatePool( POOL_TYPE type, SIZE_T size )
1647 {
1648     return ExAllocatePoolWithTag( type, size, 0 );
1649 }
1650
1651
1652 /***********************************************************************
1653  *           ExAllocatePoolWithQuota   (NTOSKRNL.EXE.@)
1654  */
1655 PVOID WINAPI ExAllocatePoolWithQuota( POOL_TYPE type, SIZE_T size )
1656 {
1657     return ExAllocatePoolWithTag( type, size, 0 );
1658 }
1659
1660
1661 /***********************************************************************
1662  *           ExAllocatePoolWithTag   (NTOSKRNL.EXE.@)
1663  */
1664 PVOID WINAPI ExAllocatePoolWithTag( POOL_TYPE type, SIZE_T size, ULONG tag )
1665 {
1666     /* FIXME: handle page alignment constraints */
1667     void *ret = HeapAlloc( GetProcessHeap(), 0, size );
1668     TRACE( "%lu pool %u -> %p\n", size, type, ret );
1669     return ret;
1670 }
1671
1672
1673 /***********************************************************************
1674  *           ExAllocatePoolWithQuotaTag   (NTOSKRNL.EXE.@)
1675  */
1676 PVOID WINAPI ExAllocatePoolWithQuotaTag( POOL_TYPE type, SIZE_T size, ULONG tag )
1677 {
1678     return ExAllocatePoolWithTag( type, size, tag );
1679 }
1680
1681
1682 /***********************************************************************
1683  *           ExCreateCallback   (NTOSKRNL.EXE.@)
1684  */
1685 NTSTATUS WINAPI ExCreateCallback(PCALLBACK_OBJECT *obj, POBJECT_ATTRIBUTES attr,
1686                                  BOOLEAN create, BOOLEAN allow_multiple)
1687 {
1688     FIXME("(%p, %p, %u, %u): stub\n", obj, attr, create, allow_multiple);
1689
1690     return STATUS_NOT_IMPLEMENTED;
1691 }
1692
1693
1694 /***********************************************************************
1695  *           ExDeleteNPagedLookasideList   (NTOSKRNL.EXE.@)
1696  */
1697 void WINAPI ExDeleteNPagedLookasideList( PNPAGED_LOOKASIDE_LIST lookaside )
1698 {
1699     FIXME("(%p) stub\n", lookaside);
1700 }
1701
1702
1703 /***********************************************************************
1704  *           ExDeletePagedLookasideList  (NTOSKRNL.EXE.@)
1705  */
1706 void WINAPI ExDeletePagedLookasideList( PPAGED_LOOKASIDE_LIST lookaside )
1707 {
1708     FIXME("(%p) stub\n", lookaside);
1709 }
1710
1711
1712 /***********************************************************************
1713  *           ExFreePool   (NTOSKRNL.EXE.@)
1714  */
1715 void WINAPI ExFreePool( void *ptr )
1716 {
1717     ExFreePoolWithTag( ptr, 0 );
1718 }
1719
1720
1721 /***********************************************************************
1722  *           ExFreePoolWithTag   (NTOSKRNL.EXE.@)
1723  */
1724 void WINAPI ExFreePoolWithTag( void *ptr, ULONG tag )
1725 {
1726     TRACE( "%p\n", ptr );
1727     HeapFree( GetProcessHeap(), 0, ptr );
1728 }
1729
1730
1731 /***********************************************************************
1732  *           ExInitializeResourceLite   (NTOSKRNL.EXE.@)
1733  */
1734 NTSTATUS WINAPI ExInitializeResourceLite(PERESOURCE Resource)
1735 {
1736     FIXME( "stub: %p\n", Resource );
1737     return STATUS_NOT_IMPLEMENTED;
1738 }
1739
1740
1741 /***********************************************************************
1742  *           ExInitializeNPagedLookasideList   (NTOSKRNL.EXE.@)
1743  */
1744 void WINAPI ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
1745                                             PALLOCATE_FUNCTION Allocate,
1746                                             PFREE_FUNCTION Free,
1747                                             ULONG Flags,
1748                                             SIZE_T Size,
1749                                             ULONG Tag,
1750                                             USHORT Depth)
1751 {
1752     FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1753 }
1754
1755 /***********************************************************************
1756  *           ExInitializePagedLookasideList   (NTOSKRNL.EXE.@)
1757  */
1758 void WINAPI ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside,
1759                                            PALLOCATE_FUNCTION Allocate,
1760                                            PFREE_FUNCTION Free,
1761                                            ULONG Flags,
1762                                            SIZE_T Size,
1763                                            ULONG Tag,
1764                                            USHORT Depth)
1765 {
1766     FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1767 }
1768
1769 /***********************************************************************
1770  *           ExInitializeZone   (NTOSKRNL.EXE.@)
1771  */
1772 NTSTATUS WINAPI ExInitializeZone(PZONE_HEADER Zone,
1773                                  ULONG BlockSize,
1774                                  PVOID InitialSegment,
1775                                  ULONG InitialSegmentSize)
1776 {
1777     FIXME( "stub: %p, %u, %p, %u\n", Zone, BlockSize, InitialSegment, InitialSegmentSize );
1778     return STATUS_NOT_IMPLEMENTED;
1779 }
1780
1781 /***********************************************************************
1782 *           FsRtlRegisterUncProvider   (NTOSKRNL.EXE.@)
1783 */
1784 NTSTATUS WINAPI FsRtlRegisterUncProvider(PHANDLE MupHandle, PUNICODE_STRING RedirDevName,
1785                                          BOOLEAN MailslotsSupported)
1786 {
1787     FIXME("(%p %p %d): stub\n", MupHandle, RedirDevName, MailslotsSupported);
1788     return STATUS_NOT_IMPLEMENTED;
1789 }
1790
1791 /***********************************************************************
1792  *           IoGetCurrentProcess / PsGetCurrentProcess   (NTOSKRNL.EXE.@)
1793  */
1794 PEPROCESS WINAPI IoGetCurrentProcess(void)
1795 {
1796     FIXME("() stub\n");
1797     return NULL;
1798 }
1799
1800 /***********************************************************************
1801  *           KeGetCurrentThread / PsGetCurrentThread   (NTOSKRNL.EXE.@)
1802  */
1803 PRKTHREAD WINAPI KeGetCurrentThread(void)
1804 {
1805     FIXME("() stub\n");
1806     return NULL;
1807 }
1808
1809 /***********************************************************************
1810  *           KeInitializeEvent   (NTOSKRNL.EXE.@)
1811  */
1812 void WINAPI KeInitializeEvent( PRKEVENT Event, EVENT_TYPE Type, BOOLEAN State )
1813 {
1814     FIXME( "stub: %p %d %d\n", Event, Type, State );
1815 }
1816
1817
1818  /***********************************************************************
1819  *           KeInitializeMutex   (NTOSKRNL.EXE.@)
1820  */
1821 void WINAPI KeInitializeMutex(PRKMUTEX Mutex, ULONG Level)
1822 {
1823     FIXME( "stub: %p, %u\n", Mutex, Level );
1824 }
1825
1826
1827  /***********************************************************************
1828  *           KeWaitForMutexObject   (NTOSKRNL.EXE.@)
1829  */
1830 NTSTATUS WINAPI KeWaitForMutexObject(PRKMUTEX Mutex, KWAIT_REASON WaitReason, KPROCESSOR_MODE WaitMode,
1831                                      BOOLEAN Alertable, PLARGE_INTEGER Timeout)
1832 {
1833     FIXME( "stub: %p, %d, %d, %d, %p\n", Mutex, WaitReason, WaitMode, Alertable, Timeout );
1834     return STATUS_NOT_IMPLEMENTED;
1835 }
1836
1837
1838  /***********************************************************************
1839  *           KeReleaseMutex   (NTOSKRNL.EXE.@)
1840  */
1841 LONG WINAPI KeReleaseMutex(PRKMUTEX Mutex, BOOLEAN Wait)
1842 {
1843     FIXME( "stub: %p, %d\n", Mutex, Wait );
1844     return STATUS_NOT_IMPLEMENTED;
1845 }
1846
1847
1848 /***********************************************************************
1849  *           KeInitializeSemaphore   (NTOSKRNL.EXE.@)
1850  */
1851 void WINAPI KeInitializeSemaphore( PRKSEMAPHORE Semaphore, LONG Count, LONG Limit )
1852 {
1853     FIXME( "(%p %d %d) stub\n", Semaphore , Count, Limit );
1854 }
1855
1856
1857 /***********************************************************************
1858  *           KeInitializeSpinLock   (NTOSKRNL.EXE.@)
1859  */
1860 void WINAPI KeInitializeSpinLock( PKSPIN_LOCK SpinLock )
1861 {
1862     FIXME( "stub: %p\n", SpinLock );
1863 }
1864
1865
1866 /***********************************************************************
1867  *           KeInitializeTimerEx   (NTOSKRNL.EXE.@)
1868  */
1869 void WINAPI KeInitializeTimerEx( PKTIMER Timer, TIMER_TYPE Type )
1870 {
1871     FIXME( "stub: %p %d\n", Timer, Type );
1872 }
1873
1874
1875 /***********************************************************************
1876  *           KeInitializeTimer   (NTOSKRNL.EXE.@)
1877  */
1878 void WINAPI KeInitializeTimer( PKTIMER Timer )
1879 {
1880     KeInitializeTimerEx(Timer, NotificationTimer);
1881 }
1882
1883 /***********************************************************************
1884  *           KeInsertQueue   (NTOSKRNL.EXE.@)
1885  */
1886 LONG WINAPI KeInsertQueue(PRKQUEUE Queue, PLIST_ENTRY Entry)
1887 {
1888     FIXME( "stub: %p %p\n", Queue, Entry );
1889     return 0;
1890 }
1891
1892 /**********************************************************************
1893  *           KeQueryActiveProcessors   (NTOSKRNL.EXE.@)
1894  *
1895  * Return the active Processors as bitmask
1896  *
1897  * RETURNS
1898  *   active Processors as bitmask
1899  *
1900  */
1901 KAFFINITY WINAPI KeQueryActiveProcessors( void )
1902 {
1903     DWORD_PTR AffinityMask;
1904
1905     GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask, NULL);
1906     return AffinityMask;
1907 }
1908
1909
1910 /**********************************************************************
1911  *           KeQueryInterruptTime   (NTOSKRNL.EXE.@)
1912  *
1913  * Return the interrupt time count
1914  *
1915  */
1916 ULONGLONG WINAPI KeQueryInterruptTime( void )
1917 {
1918     LARGE_INTEGER totaltime;
1919
1920     KeQueryTickCount(&totaltime);
1921     return totaltime.QuadPart;
1922 }
1923
1924
1925 /***********************************************************************
1926  *           KeQuerySystemTime   (NTOSKRNL.EXE.@)
1927  */
1928 void WINAPI KeQuerySystemTime( LARGE_INTEGER *time )
1929 {
1930     NtQuerySystemTime( time );
1931 }
1932
1933
1934 /***********************************************************************
1935  *           KeQueryTickCount   (NTOSKRNL.EXE.@)
1936  */
1937 void WINAPI KeQueryTickCount( LARGE_INTEGER *count )
1938 {
1939     count->QuadPart = NtGetTickCount();
1940     /* update the global variable too */
1941     KeTickCount.LowPart   = count->u.LowPart;
1942     KeTickCount.High1Time = count->u.HighPart;
1943     KeTickCount.High2Time = count->u.HighPart;
1944 }
1945
1946
1947 /***********************************************************************
1948  *           KeReleaseSemaphore   (NTOSKRNL.EXE.@)
1949  */
1950 LONG WINAPI KeReleaseSemaphore( PRKSEMAPHORE Semaphore, KPRIORITY Increment,
1951                                 LONG Adjustment, BOOLEAN Wait )
1952 {
1953     FIXME("(%p %d %d %d) stub\n", Semaphore, Increment, Adjustment, Wait );
1954     return 0;
1955 }
1956
1957
1958 /***********************************************************************
1959  *           KeQueryTimeIncrement   (NTOSKRNL.EXE.@)
1960  */
1961 ULONG WINAPI KeQueryTimeIncrement(void)
1962 {
1963     return 10000;
1964 }
1965
1966
1967 /***********************************************************************
1968  *           KeResetEvent   (NTOSKRNL.EXE.@)
1969  */
1970 LONG WINAPI KeResetEvent( PRKEVENT Event )
1971 {
1972     FIXME("(%p): stub\n", Event);
1973     return 0;
1974 }
1975
1976
1977 /***********************************************************************
1978  *           KeSetEvent   (NTOSKRNL.EXE.@)
1979  */
1980 LONG WINAPI KeSetEvent( PRKEVENT Event, KPRIORITY Increment, BOOLEAN Wait )
1981 {
1982     FIXME("(%p, %d, %d): stub\n", Event, Increment, Wait);
1983     return 0;
1984 }
1985
1986
1987 /***********************************************************************
1988  *           KeSetPriorityThread   (NTOSKRNL.EXE.@)
1989  */
1990 KPRIORITY WINAPI KeSetPriorityThread( PKTHREAD Thread, KPRIORITY Priority )
1991 {
1992     FIXME("(%p %d)\n", Thread, Priority);
1993     return Priority;
1994 }
1995
1996 /***********************************************************************
1997  *           KeSetSystemAffinityThread   (NTOSKRNL.EXE.@)
1998  */
1999 VOID WINAPI KeSetSystemAffinityThread(KAFFINITY Affinity)
2000 {
2001     FIXME("(%lx) stub\n", Affinity);
2002 }
2003
2004 /***********************************************************************
2005  *           KeWaitForSingleObject   (NTOSKRNL.EXE.@)
2006  */
2007 NTSTATUS WINAPI KeWaitForSingleObject(PVOID Object,
2008                                       KWAIT_REASON WaitReason,
2009                                       KPROCESSOR_MODE WaitMode,
2010                                       BOOLEAN Alertable,
2011                                       PLARGE_INTEGER Timeout)
2012 {
2013     FIXME( "stub: %p, %d, %d, %d, %p\n", Object, WaitReason, WaitMode, Alertable, Timeout );
2014     return STATUS_NOT_IMPLEMENTED;
2015 }
2016
2017 /***********************************************************************
2018  *           KeWaitForMultipleObjects   (NTOSKRNL.EXE.@)
2019  */
2020 NTSTATUS WINAPI KeWaitForMultipleObjects(ULONG Count, PVOID Object[], WAIT_TYPE WaitType,
2021                                          KWAIT_REASON WaitReason, KPROCESSOR_MODE WaitMode,
2022                                          BOOLEAN Alertable, PLARGE_INTEGER Timeout,
2023                                          PKWAIT_BLOCK WaitBlockArray)
2024 {
2025     FIXME( "stub: %u, %p, %d, %d, %d, %d, %p, %p\n", Count, Object, WaitType, WaitReason, WaitMode,
2026            Alertable, Timeout, WaitBlockArray );
2027     return STATUS_NOT_IMPLEMENTED;
2028 }
2029
2030 /***********************************************************************
2031  *           IoRegisterFileSystem   (NTOSKRNL.EXE.@)
2032  */
2033 VOID WINAPI IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject)
2034 {
2035     FIXME("(%p): stub\n", DeviceObject);
2036 }
2037
2038 /***********************************************************************
2039 *           IoUnregisterFileSystem   (NTOSKRNL.EXE.@)
2040 */
2041 VOID WINAPI IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject)
2042 {
2043     FIXME("(%p): stub\n", DeviceObject);
2044 }
2045
2046 /***********************************************************************
2047  *           MmAllocateNonCachedMemory   (NTOSKRNL.EXE.@)
2048  */
2049 PVOID WINAPI MmAllocateNonCachedMemory( SIZE_T size )
2050 {
2051     TRACE( "%lu\n", size );
2052     return VirtualAlloc( NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE|PAGE_NOCACHE );
2053 }
2054
2055 /***********************************************************************
2056  *           MmAllocateContiguousMemory   (NTOSKRNL.EXE.@)
2057  */
2058 PVOID WINAPI MmAllocateContiguousMemory( SIZE_T size, PHYSICAL_ADDRESS highest_valid_address )
2059 {
2060     FIXME( "%lu, %s stub\n", size, wine_dbgstr_longlong(highest_valid_address.QuadPart) );
2061     return NULL;
2062 }
2063
2064 /***********************************************************************
2065  *           MmAllocateContiguousMemorySpecifyCache   (NTOSKRNL.EXE.@)
2066  */
2067 PVOID WINAPI MmAllocateContiguousMemorySpecifyCache( SIZE_T size,
2068                                                      PHYSICAL_ADDRESS lowest_valid_address,
2069                                                      PHYSICAL_ADDRESS highest_valid_address,
2070                                                      PHYSICAL_ADDRESS BoundaryAddressMultiple,
2071                                                      MEMORY_CACHING_TYPE CacheType )
2072 {
2073     FIXME(": stub\n");
2074     return NULL;
2075 }
2076
2077 /***********************************************************************
2078  *           MmAllocatePagesForMdl   (NTOSKRNL.EXE.@)
2079  */
2080 PMDL WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress, PHYSICAL_ADDRESS highaddress,
2081                                   PHYSICAL_ADDRESS skipbytes, SIZE_T size)
2082 {
2083     FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress.QuadPart), wine_dbgstr_longlong(highaddress.QuadPart),
2084                                   wine_dbgstr_longlong(skipbytes.QuadPart), size);
2085     return NULL;
2086 }
2087
2088 /***********************************************************************
2089  *           MmFreeNonCachedMemory   (NTOSKRNL.EXE.@)
2090  */
2091 void WINAPI MmFreeNonCachedMemory( void *addr, SIZE_T size )
2092 {
2093     TRACE( "%p %lu\n", addr, size );
2094     VirtualFree( addr, 0, MEM_RELEASE );
2095 }
2096
2097 /***********************************************************************
2098  *           MmIsAddressValid   (NTOSKRNL.EXE.@)
2099  *
2100  * Check if the process can access the virtual address without a pagefault
2101  *
2102  * PARAMS
2103  *  VirtualAddress [I] Address to check
2104  *
2105  * RETURNS
2106  *  Failure: FALSE
2107  *  Success: TRUE  (Accessing the Address works without a Pagefault)
2108  *
2109  */
2110 BOOLEAN WINAPI MmIsAddressValid(PVOID VirtualAddress)
2111 {
2112     TRACE("(%p)\n", VirtualAddress);
2113     return !IsBadWritePtr(VirtualAddress, 1);
2114 }
2115
2116 /***********************************************************************
2117  *           MmMapIoSpace   (NTOSKRNL.EXE.@)
2118  */
2119 PVOID WINAPI MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress, DWORD NumberOfBytes, DWORD CacheType )
2120 {
2121     FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress.u.HighPart, PhysicalAddress.u.LowPart, NumberOfBytes, CacheType );
2122     return NULL;
2123 }
2124
2125
2126 /***********************************************************************
2127  *           MmLockPagableSectionByHandle  (NTOSKRNL.EXE.@)
2128  */
2129 VOID WINAPI MmLockPagableSectionByHandle(PVOID ImageSectionHandle)
2130 {
2131     FIXME("stub %p\n", ImageSectionHandle);
2132 }
2133
2134 /***********************************************************************
2135  *           MmMapLockedPagesSpecifyCache  (NTOSKRNL.EXE.@)
2136  */
2137 PVOID WINAPI  MmMapLockedPagesSpecifyCache(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, MEMORY_CACHING_TYPE CacheType,
2138                                            PVOID BaseAddress, ULONG BugCheckOnFailure, MM_PAGE_PRIORITY Priority)
2139 {
2140     FIXME("(%p, %u, %u, %p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, CacheType, BaseAddress, BugCheckOnFailure, Priority);
2141
2142     return NULL;
2143 }
2144
2145 /***********************************************************************
2146  *           MmUnlockPagableImageSection  (NTOSKRNL.EXE.@)
2147  */
2148 VOID WINAPI MmUnlockPagableImageSection(PVOID ImageSectionHandle)
2149 {
2150     FIXME("stub %p\n", ImageSectionHandle);
2151 }
2152
2153 /***********************************************************************
2154  *           MmPageEntireDriver   (NTOSKRNL.EXE.@)
2155  */
2156 PVOID WINAPI MmPageEntireDriver(PVOID AddrInSection)
2157 {
2158     TRACE("%p\n", AddrInSection);
2159     return AddrInSection;
2160 }
2161
2162
2163 /***********************************************************************
2164  *           MmProbeAndLockPages  (NTOSKRNL.EXE.@)
2165  */
2166 void WINAPI MmProbeAndLockPages(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, LOCK_OPERATION Operation)
2167 {
2168     FIXME("(%p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, Operation);
2169 }
2170
2171
2172 /***********************************************************************
2173  *           MmResetDriverPaging   (NTOSKRNL.EXE.@)
2174  */
2175 void WINAPI MmResetDriverPaging(PVOID AddrInSection)
2176 {
2177     TRACE("%p\n", AddrInSection);
2178 }
2179
2180
2181 /***********************************************************************
2182  *           MmUnlockPages  (NTOSKRNL.EXE.@)
2183  */
2184 void WINAPI  MmUnlockPages(PMDLX MemoryDescriptorList)
2185 {
2186     FIXME("(%p): stub\n", MemoryDescriptorList);
2187 }
2188
2189
2190 /***********************************************************************
2191  *           MmUnmapIoSpace   (NTOSKRNL.EXE.@)
2192  */
2193 VOID WINAPI MmUnmapIoSpace( PVOID BaseAddress, SIZE_T NumberOfBytes )
2194 {
2195     FIXME( "stub: %p, %lu\n", BaseAddress, NumberOfBytes );
2196 }
2197
2198
2199  /***********************************************************************
2200  *           ObReferenceObjectByHandle    (NTOSKRNL.EXE.@)
2201  */
2202 NTSTATUS WINAPI ObReferenceObjectByHandle( HANDLE obj, ACCESS_MASK access,
2203                                            POBJECT_TYPE type,
2204                                            KPROCESSOR_MODE mode, PVOID* ptr,
2205                                            POBJECT_HANDLE_INFORMATION info)
2206 {
2207     FIXME( "stub: %p %x %p %d %p %p\n", obj, access, type, mode, ptr, info);
2208     return STATUS_NOT_IMPLEMENTED;
2209 }
2210
2211  /***********************************************************************
2212  *           ObReferenceObjectByName    (NTOSKRNL.EXE.@)
2213  */
2214 NTSTATUS WINAPI ObReferenceObjectByName( UNICODE_STRING *ObjectName,
2215                                          ULONG Attributes,
2216                                          ACCESS_STATE *AccessState,
2217                                          ACCESS_MASK DesiredAccess,
2218                                          POBJECT_TYPE ObjectType,
2219                                          KPROCESSOR_MODE AccessMode,
2220                                          void *ParseContext,
2221                                          void **Object)
2222 {
2223     struct wine_driver *driver;
2224     struct wine_rb_entry *entry;
2225
2226     TRACE("mostly-stub:%s %i %p %i %p %i %p %p\n", debugstr_us(ObjectName),
2227         Attributes, AccessState, DesiredAccess, ObjectType, AccessMode,
2228         ParseContext, Object);
2229
2230     if (AccessState) FIXME("Unhandled AccessState\n");
2231     if (DesiredAccess) FIXME("Unhandled DesiredAccess\n");
2232     if (ParseContext) FIXME("Unhandled ParseContext\n");
2233     if (ObjectType) FIXME("Unhandled ObjectType\n");
2234
2235     if (AccessMode != KernelMode)
2236     {
2237         FIXME("UserMode access not implemented\n");
2238         return STATUS_NOT_IMPLEMENTED;
2239     }
2240
2241     EnterCriticalSection(&drivers_cs);
2242     entry = wine_rb_get(&wine_drivers, ObjectName);
2243     LeaveCriticalSection(&drivers_cs);
2244     if (!entry)
2245     {
2246         FIXME("Object (%s) not found, may not be tracked.\n", debugstr_us(ObjectName));
2247         return STATUS_NOT_IMPLEMENTED;
2248     }
2249
2250     driver = WINE_RB_ENTRY_VALUE(entry, struct wine_driver, entry);
2251     *Object = &driver->driver_obj;
2252     return STATUS_SUCCESS;
2253 }
2254
2255
2256 static void ObReferenceObject( void *obj )
2257 {
2258     TRACE( "(%p): stub\n", obj );
2259 }
2260
2261
2262 /***********************************************************************
2263  *           ObDereferenceObject   (NTOSKRNL.EXE.@)
2264  */
2265 void WINAPI ObDereferenceObject( void *obj )
2266 {
2267     TRACE( "(%p): stub\n", obj );
2268 }
2269
2270
2271 /***********************************************************************
2272  *           ObfReferenceObject   (NTOSKRNL.EXE.@)
2273  */
2274 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
2275 DEFINE_FASTCALL1_ENTRYPOINT( ObfReferenceObject )
2276 void WINAPI DECLSPEC_HIDDEN __regs_ObfReferenceObject( void *obj )
2277 #else
2278 void WINAPI ObfReferenceObject( void *obj )
2279 #endif
2280 {
2281     ObReferenceObject( obj );
2282 }
2283
2284
2285 /***********************************************************************
2286  *           ObfDereferenceObject   (NTOSKRNL.EXE.@)
2287  */
2288 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
2289 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject )
2290 void WINAPI DECLSPEC_HIDDEN __regs_ObfDereferenceObject( void *obj )
2291 #else
2292 void WINAPI ObfDereferenceObject( void *obj )
2293 #endif
2294 {
2295     ObDereferenceObject( obj );
2296 }
2297
2298
2299 /***********************************************************************
2300  *           IoGetAttachedDeviceReference   (NTOSKRNL.EXE.@)
2301  */
2302 DEVICE_OBJECT* WINAPI IoGetAttachedDeviceReference( DEVICE_OBJECT *device )
2303 {
2304     DEVICE_OBJECT *result = IoGetAttachedDevice( device );
2305     ObReferenceObject( result );
2306     return result;
2307 }
2308
2309
2310 /***********************************************************************
2311  *           PsCreateSystemThread   (NTOSKRNL.EXE.@)
2312  */
2313 NTSTATUS WINAPI PsCreateSystemThread(PHANDLE ThreadHandle, ULONG DesiredAccess,
2314                                      POBJECT_ATTRIBUTES ObjectAttributes,
2315                                      HANDLE ProcessHandle, PCLIENT_ID ClientId,
2316                                      PKSTART_ROUTINE StartRoutine, PVOID StartContext)
2317 {
2318     if (!ProcessHandle) ProcessHandle = GetCurrentProcess();
2319     return RtlCreateUserThread(ProcessHandle, 0, FALSE, 0, 0,
2320                                0, StartRoutine, StartContext,
2321                                ThreadHandle, ClientId);
2322 }
2323
2324 /***********************************************************************
2325  *           PsGetCurrentProcessId   (NTOSKRNL.EXE.@)
2326  */
2327 HANDLE WINAPI PsGetCurrentProcessId(void)
2328 {
2329     if (GetCurrentThreadId() == request_thread)
2330         return UlongToHandle(client_pid);
2331     return UlongToHandle(GetCurrentProcessId());
2332 }
2333
2334
2335 /***********************************************************************
2336  *           PsGetCurrentThreadId   (NTOSKRNL.EXE.@)
2337  */
2338 HANDLE WINAPI PsGetCurrentThreadId(void)
2339 {
2340     if (GetCurrentThreadId() == request_thread)
2341         return UlongToHandle(client_tid);
2342     return UlongToHandle(GetCurrentThreadId());
2343 }
2344
2345
2346 /***********************************************************************
2347  *           PsGetVersion   (NTOSKRNL.EXE.@)
2348  */
2349 BOOLEAN WINAPI PsGetVersion(ULONG *major, ULONG *minor, ULONG *build, UNICODE_STRING *version )
2350 {
2351     RTL_OSVERSIONINFOEXW info;
2352
2353     info.dwOSVersionInfoSize = sizeof(info);
2354     RtlGetVersion( &info );
2355     if (major) *major = info.dwMajorVersion;
2356     if (minor) *minor = info.dwMinorVersion;
2357     if (build) *build = info.dwBuildNumber;
2358
2359     if (version)
2360     {
2361 #if 0  /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
2362         size_t len = min( strlenW(info.szCSDVersion)*sizeof(WCHAR), version->MaximumLength );
2363         memcpy( version->Buffer, info.szCSDVersion, len );
2364         if (len < version->MaximumLength) version->Buffer[len / sizeof(WCHAR)] = 0;
2365         version->Length = len;
2366 #endif
2367     }
2368     return TRUE;
2369 }
2370
2371
2372 /***********************************************************************
2373  *           PsImpersonateClient   (NTOSKRNL.EXE.@)
2374  */
2375 NTSTATUS WINAPI PsImpersonateClient(PETHREAD Thread, PACCESS_TOKEN Token, BOOLEAN CopyOnOpen,
2376                                     BOOLEAN EffectiveOnly, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
2377 {
2378     FIXME("(%p, %p, %u, %u, %u): stub\n", Thread, Token, CopyOnOpen, EffectiveOnly, ImpersonationLevel);
2379
2380     return STATUS_NOT_IMPLEMENTED;
2381 }
2382
2383
2384 /***********************************************************************
2385  *           PsSetCreateProcessNotifyRoutine   (NTOSKRNL.EXE.@)
2386  */
2387 NTSTATUS WINAPI PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback, BOOLEAN remove )
2388 {
2389     FIXME( "stub: %p %d\n", callback, remove );
2390     return STATUS_SUCCESS;
2391 }
2392
2393
2394 /***********************************************************************
2395  *           PsSetCreateThreadNotifyRoutine   (NTOSKRNL.EXE.@)
2396  */
2397 NTSTATUS WINAPI PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
2398 {
2399     FIXME( "stub: %p\n", NotifyRoutine );
2400     return STATUS_SUCCESS;
2401 }
2402
2403
2404 /***********************************************************************
2405  *           PsRemoveCreateThreadNotifyRoutine  (NTOSKRNL.EXE.@)
2406  */
2407 NTSTATUS WINAPI PsRemoveCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
2408 {
2409     FIXME( "stub: %p\n", NotifyRoutine );
2410     return STATUS_SUCCESS;
2411 }
2412
2413
2414 /***********************************************************************
2415  *           PsRemoveLoadImageNotifyRoutine  (NTOSKRNL.EXE.@)
2416  */
2417  NTSTATUS WINAPI PsRemoveLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE NotifyRoutine)
2418  {
2419     FIXME( "stub: %p\n", NotifyRoutine );
2420     return STATUS_SUCCESS;
2421  }
2422
2423
2424 /***********************************************************************
2425  *           PsTerminateSystemThread   (NTOSKRNL.EXE.@)
2426  */
2427 NTSTATUS WINAPI PsTerminateSystemThread(NTSTATUS ExitStatus)
2428 {
2429     FIXME( "stub: %u\n", ExitStatus );
2430     return STATUS_NOT_IMPLEMENTED;
2431 }
2432
2433
2434 /***********************************************************************
2435  *           MmGetSystemRoutineAddress   (NTOSKRNL.EXE.@)
2436  */
2437 PVOID WINAPI MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName)
2438 {
2439     HMODULE hMod;
2440     STRING routineNameA;
2441     PVOID pFunc = NULL;
2442
2443     static const WCHAR ntoskrnlW[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
2444     static const WCHAR halW[] = {'h','a','l','.','d','l','l',0};
2445
2446     if (!SystemRoutineName) return NULL;
2447
2448     if (RtlUnicodeStringToAnsiString( &routineNameA, SystemRoutineName, TRUE ) == STATUS_SUCCESS)
2449     {
2450         /* We only support functions exported from ntoskrnl.exe or hal.dll */
2451         hMod = GetModuleHandleW( ntoskrnlW );
2452         pFunc = GetProcAddress( hMod, routineNameA.Buffer );
2453         if (!pFunc)
2454         {
2455            hMod = GetModuleHandleW( halW );
2456            if (hMod) pFunc = GetProcAddress( hMod, routineNameA.Buffer );
2457         }
2458         RtlFreeAnsiString( &routineNameA );
2459     }
2460
2461     if (pFunc)
2462         TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName), pFunc );
2463     else
2464         FIXME( "%s not found\n", debugstr_us(SystemRoutineName) );
2465     return pFunc;
2466 }
2467
2468
2469 /***********************************************************************
2470  *           MmQuerySystemSize   (NTOSKRNL.EXE.@)
2471  */
2472 MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void)
2473 {
2474     FIXME("stub\n");
2475     return MmLargeSystem;
2476 }
2477
2478 /***********************************************************************
2479  *           KeInitializeDpc   (NTOSKRNL.EXE.@)
2480  */
2481 VOID WINAPI KeInitializeDpc(PRKDPC Dpc, PKDEFERRED_ROUTINE DeferredRoutine, PVOID DeferredContext)
2482 {
2483     FIXME("stub\n");
2484 }
2485
2486 /***********************************************************************
2487  *           READ_REGISTER_BUFFER_UCHAR   (NTOSKRNL.EXE.@)
2488  */
2489 VOID WINAPI READ_REGISTER_BUFFER_UCHAR(PUCHAR Register, PUCHAR Buffer, ULONG Count)
2490 {
2491     FIXME("stub\n");
2492 }
2493
2494 /*****************************************************
2495  *           PoSetPowerState   (NTOSKRNL.EXE.@)
2496  */
2497 POWER_STATE WINAPI PoSetPowerState(PDEVICE_OBJECT DeviceObject, POWER_STATE_TYPE Type, POWER_STATE State)
2498 {
2499     FIXME("(%p %u %u) stub\n", DeviceObject, Type, State.DeviceState);
2500     return State;
2501 }
2502
2503 /*****************************************************
2504  *           IoWMIRegistrationControl   (NTOSKRNL.EXE.@)
2505  */
2506 NTSTATUS WINAPI IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject, ULONG Action)
2507 {
2508     FIXME("(%p %u) stub\n", DeviceObject, Action);
2509     return STATUS_SUCCESS;
2510 }
2511
2512 /*****************************************************
2513  *           PsSetLoadImageNotifyRoutine   (NTOSKRNL.EXE.@)
2514  */
2515 NTSTATUS WINAPI PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine)
2516 {
2517     FIXME("(%p) stub\n", routine);
2518     return STATUS_SUCCESS;
2519 }
2520
2521 /*****************************************************
2522  *           PsLookupProcessByProcessId  (NTOSKRNL.EXE.@)
2523  */
2524 NTSTATUS WINAPI PsLookupProcessByProcessId(HANDLE processid, PEPROCESS *process)
2525 {
2526     static int once;
2527     if (!once++) FIXME("(%p %p) stub\n", processid, process);
2528     return STATUS_NOT_IMPLEMENTED;
2529 }
2530
2531
2532 /*****************************************************
2533  *           IoSetThreadHardErrorMode  (NTOSKRNL.EXE.@)
2534  */
2535 BOOLEAN WINAPI IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors)
2536 {
2537     FIXME("stub\n");
2538     return FALSE;
2539 }
2540
2541
2542 /*****************************************************
2543  *           IoInitializeRemoveLockEx  (NTOSKRNL.EXE.@)
2544  */
2545 VOID WINAPI IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock, ULONG tag,
2546                                      ULONG maxmin, ULONG high, ULONG size)
2547 {
2548     FIXME("(%p %u %u %u %u) stub\n", lock, tag, maxmin, high, size);
2549 }
2550
2551
2552 /*****************************************************
2553  *           IoAcquireRemoveLockEx  (NTOSKRNL.EXE.@)
2554  */
2555
2556 NTSTATUS WINAPI IoAcquireRemoveLockEx(PIO_REMOVE_LOCK lock, PVOID tag,
2557                                       LPCSTR file, ULONG line, ULONG lock_size)
2558 {
2559     FIXME("(%p, %p, %s, %u, %u): stub\n", lock, tag, debugstr_a(file), line, lock_size);
2560
2561     return STATUS_NOT_IMPLEMENTED;
2562 }
2563
2564
2565 /*****************************************************
2566  *           DllMain
2567  */
2568 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
2569 {
2570     static void *handler;
2571     LARGE_INTEGER count;
2572
2573     switch(reason)
2574     {
2575     case DLL_PROCESS_ATTACH:
2576         DisableThreadLibraryCalls( inst );
2577 #if defined(__i386__) || defined(__x86_64__)
2578         handler = RtlAddVectoredExceptionHandler( TRUE, vectored_handler );
2579 #endif
2580         KeQueryTickCount( &count );  /* initialize the global KeTickCount */
2581         break;
2582     case DLL_PROCESS_DETACH:
2583         if (reserved) break;
2584         RtlRemoveVectoredExceptionHandler( handler );
2585         break;
2586     }
2587     return TRUE;
2588 }
2589
2590 /*****************************************************
2591  *           Ke386IoSetAccessProcess  (NTOSKRNL.EXE.@)
2592  */
2593 BOOLEAN WINAPI Ke386IoSetAccessProcess(PEPROCESS *process, ULONG flag)
2594 {
2595     FIXME("(%p %d) stub\n", process, flag);
2596     return FALSE;
2597 }
2598
2599 /*****************************************************
2600  *           Ke386SetIoAccessMap  (NTOSKRNL.EXE.@)
2601  */
2602 BOOLEAN WINAPI Ke386SetIoAccessMap(ULONG flag, PVOID buffer)
2603 {
2604     FIXME("(%d %p) stub\n", flag, buffer);
2605     return FALSE;
2606 }
2607
2608 /*****************************************************
2609  *           IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
2610  */
2611 PKEVENT WINAPI IoCreateSynchronizationEvent(PUNICODE_STRING name, PHANDLE handle)
2612 {
2613     FIXME("(%p %p) stub\n", name, handle);
2614     return NULL;
2615 }
2616
2617 /*****************************************************
2618  *           IoStartNextPacket  (NTOSKRNL.EXE.@)
2619  */
2620 VOID WINAPI IoStartNextPacket(PDEVICE_OBJECT deviceobject, BOOLEAN cancelable)
2621 {
2622     FIXME("(%p %d) stub\n", deviceobject, cancelable);
2623 }
2624
2625 /*****************************************************
2626  *           ObQueryNameString  (NTOSKRNL.EXE.@)
2627  */
2628 NTSTATUS WINAPI ObQueryNameString(PVOID object, POBJECT_NAME_INFORMATION name, ULONG maxlength, PULONG returnlength)
2629 {
2630     FIXME("(%p %p %u %p) stub\n", object, name, maxlength, returnlength);
2631     return STATUS_NOT_IMPLEMENTED;
2632 }
2633
2634 /*****************************************************
2635  *           IoRegisterPlugPlayNotification  (NTOSKRNL.EXE.@)
2636  */
2637 NTSTATUS WINAPI IoRegisterPlugPlayNotification(IO_NOTIFICATION_EVENT_CATEGORY category, ULONG flags, PVOID data,
2638                                                PDRIVER_OBJECT driver, PDRIVER_NOTIFICATION_CALLBACK_ROUTINE callback,
2639                                                PVOID context, PVOID *notification)
2640 {
2641     FIXME("(%u %u %p %p %p %p %p) stub\n", category, flags, data, driver, callback, context, notification);
2642     return STATUS_SUCCESS;
2643 }
2644
2645 /*****************************************************
2646  *           IoCsqInitialize  (NTOSKRNL.EXE.@)
2647  */
2648 NTSTATUS WINAPI IoCsqInitialize(PIO_CSQ csq, PIO_CSQ_INSERT_IRP insert_irp, PIO_CSQ_REMOVE_IRP remove_irp,
2649                                 PIO_CSQ_PEEK_NEXT_IRP peek_irp, PIO_CSQ_ACQUIRE_LOCK acquire_lock,
2650                                 PIO_CSQ_RELEASE_LOCK release_lock, PIO_CSQ_COMPLETE_CANCELED_IRP complete_irp)
2651 {
2652     FIXME("(%p %p %p %p %p %p %p) stub\n",
2653           csq, insert_irp, remove_irp, peek_irp, acquire_lock, release_lock, complete_irp);
2654     return STATUS_SUCCESS;
2655 }
2656
2657 /***********************************************************************
2658  *           ExAcquireResourceExclusiveLite  (NTOSKRNL.EXE.@)
2659  */
2660 BOOLEAN WINAPI ExAcquireResourceExclusiveLite( PERESOURCE resource, BOOLEAN wait )
2661 {
2662     FIXME( ":%p %u stub\n", resource, wait );
2663     return TRUE;
2664 }
2665
2666 /***********************************************************************
2667  *           ExDeleteResourceLite  (NTOSKRNL.EXE.@)
2668  */
2669 NTSTATUS WINAPI ExDeleteResourceLite(PERESOURCE resource)
2670 {
2671     FIXME("(%p): stub\n", resource);
2672     return STATUS_NOT_IMPLEMENTED;
2673 }
2674
2675 /*****************************************************
2676  *           ExInterlockedRemoveHeadList  (NTOSKRNL.EXE.@)
2677  */
2678 PLIST_ENTRY WINAPI ExInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2679 {
2680     FIXME("(%p %p) stub\n", head, lock);
2681     return NULL;
2682 }
2683
2684 /***********************************************************************
2685  *           ExfInterlockedRemoveHeadList   (NTOSKRNL.EXE.@)
2686  */
2687 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
2688 DEFINE_FASTCALL2_ENTRYPOINT( ExfInterlockedRemoveHeadList )
2689 PLIST_ENTRY WINAPI DECLSPEC_HIDDEN __regs_ExfInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2690 #else
2691 PLIST_ENTRY WINAPI ExfInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2692 #endif
2693 {
2694     FIXME("(%p %p) stub\n", head, lock);
2695     return ExInterlockedRemoveHeadList( head, lock );
2696 }
2697
2698 /***********************************************************************
2699  *           ExReleaseResourceForThreadLite   (NTOSKRNL.EXE.@)
2700  */
2701 void WINAPI ExReleaseResourceForThreadLite( PERESOURCE resource, ERESOURCE_THREAD tid )
2702 {
2703     FIXME( "stub: %p %lu\n", resource, tid );
2704 }
2705
2706 /***********************************************************************
2707  *           KeEnterCriticalRegion  (NTOSKRNL.EXE.@)
2708  */
2709 void WINAPI KeEnterCriticalRegion(void)
2710 {
2711     FIXME(": stub\n");
2712 }
2713
2714 /***********************************************************************
2715  *           KeLeaveCriticalRegion  (NTOSKRNL.EXE.@)
2716  */
2717 void WINAPI KeLeaveCriticalRegion(void)
2718 {
2719     FIXME(": stub\n");
2720 }
2721
2722 /***********************************************************************
2723  *           ProbeForRead   (NTOSKRNL.EXE.@)
2724  */
2725 void WINAPI ProbeForRead(void *address, SIZE_T length, ULONG alignment)
2726 {
2727     FIXME("(%p %lu %u) stub\n", address, length, alignment);
2728 }
2729
2730 /***********************************************************************
2731  *           ProbeForWrite   (NTOSKRNL.EXE.@)
2732  */
2733 void WINAPI ProbeForWrite(void *address, SIZE_T length, ULONG alignment)
2734 {
2735     FIXME("(%p %lu %u) stub\n", address, length, alignment);
2736 }
2737
2738 /***********************************************************************
2739  *           CmRegisterCallback  (NTOSKRNL.EXE.@)
2740  */
2741 NTSTATUS WINAPI CmRegisterCallback(EX_CALLBACK_FUNCTION *function, void *context, LARGE_INTEGER *cookie)
2742 {
2743     FIXME("(%p %p %p): stub\n", function, context, cookie);
2744     return STATUS_NOT_IMPLEMENTED;
2745 }
2746
2747 /***********************************************************************
2748  *           CmUnRegisterCallback  (NTOSKRNL.EXE.@)
2749  */
2750 NTSTATUS WINAPI CmUnRegisterCallback(LARGE_INTEGER cookie)
2751 {
2752     FIXME("(%s): stub\n", wine_dbgstr_longlong(cookie.QuadPart));
2753     return STATUS_NOT_IMPLEMENTED;
2754 }
2755
2756 /***********************************************************************
2757  *           KeDelayExecutionThread  (NTOSKRNL.EXE.@)
2758  */
2759 NTSTATUS WINAPI KeDelayExecutionThread(KPROCESSOR_MODE waitmode, BOOLEAN alertable, PLARGE_INTEGER interval)
2760 {
2761     FIXME("(%u, %u, %p): stub\n", waitmode, alertable, interval);
2762     return STATUS_NOT_IMPLEMENTED;
2763 }
2764
2765 /***********************************************************************
2766  *           IoAttachDevice  (NTOSKRNL.EXE.@)
2767  */
2768 NTSTATUS WINAPI IoAttachDevice(DEVICE_OBJECT *source, UNICODE_STRING *target, DEVICE_OBJECT *attached)
2769 {
2770     FIXME("(%p, %s, %p): stub\n", source, debugstr_us(target), attached);
2771     return STATUS_NOT_IMPLEMENTED;
2772 }
2773
2774
2775 static NTSTATUS open_driver( const UNICODE_STRING *service_name, SC_HANDLE *service )
2776 {
2777     QUERY_SERVICE_CONFIGW *service_config = NULL;
2778     SC_HANDLE manager_handle;
2779     DWORD config_size = 0;
2780     WCHAR *name;
2781
2782     if (!(name = RtlAllocateHeap( GetProcessHeap(), 0, service_name->Length + sizeof(WCHAR) )))
2783         return STATUS_NO_MEMORY;
2784
2785     memcpy( name, service_name->Buffer, service_name->Length );
2786     name[ service_name->Length / sizeof(WCHAR) ] = 0;
2787
2788     if (strncmpW( name, servicesW, strlenW(servicesW) ))
2789     {
2790         FIXME( "service name %s is not a keypath\n", debugstr_us(service_name) );
2791         RtlFreeHeap( GetProcessHeap(), 0, name );
2792         return STATUS_NOT_IMPLEMENTED;
2793     }
2794
2795     if (!(manager_handle = OpenSCManagerW( NULL, NULL, SC_MANAGER_CONNECT )))
2796     {
2797         WARN( "failed to connect to service manager\n" );
2798         RtlFreeHeap( GetProcessHeap(), 0, name );
2799         return STATUS_NOT_SUPPORTED;
2800     }
2801
2802     *service = OpenServiceW( manager_handle, name + strlenW(servicesW), SERVICE_ALL_ACCESS );
2803     RtlFreeHeap( GetProcessHeap(), 0, name );
2804     CloseServiceHandle( manager_handle );
2805
2806     if (!*service)
2807     {
2808         WARN( "failed to open service %s\n", debugstr_us(service_name) );
2809         return STATUS_UNSUCCESSFUL;
2810     }
2811
2812     QueryServiceConfigW( *service, NULL, 0, &config_size );
2813     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
2814     {
2815         WARN( "failed to query service config\n" );
2816         goto error;
2817     }
2818
2819     if (!(service_config = RtlAllocateHeap( GetProcessHeap(), 0, config_size )))
2820         goto error;
2821
2822     if (!QueryServiceConfigW( *service, service_config, config_size, &config_size ))
2823     {
2824         WARN( "failed to query service config\n" );
2825         goto error;
2826     }
2827
2828     if (service_config->dwServiceType != SERVICE_KERNEL_DRIVER &&
2829         service_config->dwServiceType != SERVICE_FILE_SYSTEM_DRIVER)
2830     {
2831         WARN( "service %s is not a kernel driver\n", debugstr_us(service_name) );
2832         goto error;
2833     }
2834
2835     TRACE( "opened service for driver %s\n", debugstr_us(service_name) );
2836     RtlFreeHeap( GetProcessHeap(), 0, service_config );
2837     return STATUS_SUCCESS;
2838
2839 error:
2840     CloseServiceHandle( *service );
2841     RtlFreeHeap( GetProcessHeap(), 0, service_config );
2842     return STATUS_UNSUCCESSFUL;
2843 }
2844
2845
2846 /***********************************************************************
2847  *           ZwLoadDriver (NTOSKRNL.EXE.@)
2848  */
2849 NTSTATUS WINAPI ZwLoadDriver( const UNICODE_STRING *service_name )
2850 {
2851     SERVICE_STATUS_PROCESS service_status;
2852     SC_HANDLE service_handle;
2853     ULONGLONG start_time;
2854     NTSTATUS status;
2855     DWORD bytes;
2856
2857     TRACE( "(%s)\n", debugstr_us(service_name) );
2858
2859     if ((status = open_driver( service_name, &service_handle )) != STATUS_SUCCESS)
2860         return status;
2861
2862     TRACE( "trying to start %s\n", debugstr_us(service_name) );
2863
2864     start_time = GetTickCount64();
2865     for (;;)
2866     {
2867         if (StartServiceW( service_handle, 0, NULL )) break;
2868         if (GetLastError() == ERROR_SERVICE_ALREADY_RUNNING) break;
2869         if (GetLastError() != ERROR_SERVICE_DATABASE_LOCKED) goto error;
2870         if (GetTickCount64() - start_time > 30000) goto error;
2871         Sleep( 100 );
2872     }
2873
2874     start_time = GetTickCount64();
2875     for (;;)
2876     {
2877         if (!QueryServiceStatusEx( service_handle, SC_STATUS_PROCESS_INFO,
2878                                    (BYTE *)&service_status, sizeof(service_status), &bytes )) goto error;
2879         if (service_status.dwCurrentState != SERVICE_START_PENDING) break;
2880         if (GetTickCount64() - start_time > 30000) goto error;
2881         Sleep( 100 );
2882     }
2883
2884     if (service_status.dwCurrentState == SERVICE_RUNNING)
2885     {
2886         if (service_status.dwProcessId != GetCurrentProcessId())
2887             FIXME( "driver %s was loaded into a different process\n", debugstr_us(service_name) );
2888
2889         status = STATUS_SUCCESS;
2890         goto done;
2891     }
2892
2893 error:
2894     WARN( "failed to start service %s\n", debugstr_us(service_name) );
2895     status = STATUS_UNSUCCESSFUL;
2896
2897 done:
2898     TRACE( "returning status %08x\n", status );
2899     CloseServiceHandle( service_handle );
2900     return status;
2901 }
2902
2903
2904 /***********************************************************************
2905  *           ZwUnloadDriver (NTOSKRNL.EXE.@)
2906  */
2907 NTSTATUS WINAPI ZwUnloadDriver( const UNICODE_STRING *service_name )
2908 {
2909     SERVICE_STATUS service_status;
2910     SC_HANDLE service_handle;
2911     ULONGLONG start_time;
2912     NTSTATUS status;
2913
2914     TRACE( "(%s)\n", debugstr_us(service_name) );
2915
2916     if ((status = open_driver( service_name, &service_handle )) != STATUS_SUCCESS)
2917         return status;
2918
2919     if (!ControlService( service_handle, SERVICE_CONTROL_STOP, &service_status ))
2920         goto error;
2921
2922     start_time = GetTickCount64();
2923     for (;;)
2924     {
2925         if (!QueryServiceStatus( service_handle, &service_status )) goto error;
2926         if (service_status.dwCurrentState != SERVICE_STOP_PENDING) break;
2927         if (GetTickCount64() - start_time > 30000) goto error;
2928         Sleep( 100 );
2929     }
2930
2931     if (service_status.dwCurrentState == SERVICE_STOPPED)
2932     {
2933         status = STATUS_SUCCESS;
2934         goto done;
2935     }
2936
2937 error:
2938     WARN( "failed to stop service %s\n", debugstr_us(service_name) );
2939     status = STATUS_UNSUCCESSFUL;
2940
2941 done:
2942     TRACE( "returning status %08x\n", status );
2943     CloseServiceHandle( service_handle );
2944     return status;
2945 }
2946
2947
2948 static NTSTATUS WINAPI internal_complete( DEVICE_OBJECT *device, IRP *irp, void *context )
2949 {
2950     HANDLE event = context;
2951     SetEvent( event );
2952     return STATUS_MORE_PROCESSING_REQUIRED;
2953 }
2954
2955
2956 static NTSTATUS send_device_irp( DEVICE_OBJECT *device, IRP *irp, ULONG_PTR *info )
2957 {
2958     NTSTATUS status;
2959     HANDLE event = CreateEventA( NULL, FALSE, FALSE, NULL );
2960     DEVICE_OBJECT *toplevel_device;
2961
2962     irp->IoStatus.u.Status = STATUS_NOT_SUPPORTED;
2963     IoSetCompletionRoutine( irp, internal_complete, event, TRUE, TRUE, TRUE );
2964
2965     toplevel_device = IoGetAttachedDeviceReference( device );
2966     status = IoCallDriver( toplevel_device, irp );
2967
2968     if (status == STATUS_PENDING)
2969         WaitForSingleObject( event, INFINITE );
2970
2971     status = irp->IoStatus.u.Status;
2972     if (info)
2973         *info = irp->IoStatus.Information;
2974     IoCompleteRequest( irp, IO_NO_INCREMENT );
2975     ObDereferenceObject( toplevel_device );
2976     CloseHandle( event );
2977     return status;
2978 }
2979
2980
2981 static NTSTATUS get_device_id( DEVICE_OBJECT *device, BUS_QUERY_ID_TYPE type, WCHAR **id )
2982 {
2983     IO_STACK_LOCATION *irpsp;
2984     IO_STATUS_BLOCK irp_status;
2985     IRP *irp;
2986
2987     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_PNP, device, NULL, 0, NULL, NULL, &irp_status )))
2988         return STATUS_NO_MEMORY;
2989
2990     irpsp = IoGetNextIrpStackLocation( irp );
2991     irpsp->MinorFunction = IRP_MN_QUERY_ID;
2992     irpsp->Parameters.QueryId.IdType = type;
2993
2994     return send_device_irp( device, irp, (ULONG_PTR *)id );
2995 }
2996
2997
2998 static BOOL get_driver_for_id( const WCHAR *id, WCHAR *driver )
2999 {
3000     static const WCHAR serviceW[] = {'S','e','r','v','i','c','e',0};
3001     static const UNICODE_STRING service_str = { sizeof(serviceW) - sizeof(WCHAR), sizeof(serviceW), (WCHAR *)serviceW };
3002     static const WCHAR critical_fmtW[] =
3003         {'\\','R','e','g','i','s','t','r','y',
3004          '\\','M','a','c','h','i','n','e',
3005          '\\','S','y','s','t','e','m',
3006          '\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
3007          '\\','C','o','n','t','r','o','l',
3008          '\\','C','r','i','t','i','c','a','l','D','e','v','i','c','e','D','a','t','a','b','a','s','e',
3009          '\\','%','s',0};
3010     WCHAR buffer[FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data[MAX_SERVICE_NAME * sizeof(WCHAR)] )];
3011     KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
3012     OBJECT_ATTRIBUTES attr;
3013     UNICODE_STRING key;
3014     NTSTATUS status;
3015     HANDLE hkey;
3016     WCHAR *keyW;
3017     DWORD len;
3018
3019     if (!(keyW = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(critical_fmtW) + strlenW(id) * sizeof(WCHAR) )))
3020         return STATUS_NO_MEMORY;
3021
3022     sprintfW( keyW, critical_fmtW, id );
3023     RtlInitUnicodeString( &key, keyW );
3024     InitializeObjectAttributes( &attr, &key, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL );
3025
3026     status = NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr );
3027     RtlFreeUnicodeString( &key );
3028     if (status != STATUS_SUCCESS)
3029     {
3030         TRACE_(plugplay)( "no driver found for %s\n", debugstr_w(id) );
3031         return FALSE;
3032     }
3033
3034     status = NtQueryValueKey( hkey, &service_str, KeyValuePartialInformation,
3035                               info, sizeof(buffer) - sizeof(WCHAR), &len );
3036     NtClose( hkey );
3037     if (status != STATUS_SUCCESS || info->Type != REG_SZ)
3038     {
3039         TRACE_(plugplay)( "no driver found for %s\n", debugstr_w(id) );
3040         return FALSE;
3041     }
3042
3043     memcpy( driver, info->Data, info->DataLength );
3044     driver[ info->DataLength / sizeof(WCHAR) ] = 0;
3045     TRACE_(plugplay)( "found driver %s for %s\n", debugstr_w(driver), debugstr_w(id) );
3046     return TRUE;
3047 }
3048
3049
3050 static NTSTATUS send_pnp_irp( DEVICE_OBJECT *device, UCHAR minor )
3051 {
3052     IO_STACK_LOCATION *irpsp;
3053     IO_STATUS_BLOCK irp_status;
3054     IRP *irp;
3055
3056     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_PNP, device, NULL, 0, NULL, NULL, &irp_status )))
3057         return STATUS_NO_MEMORY;
3058
3059     irpsp = IoGetNextIrpStackLocation( irp );
3060     irpsp->MinorFunction = minor;
3061
3062     irpsp->Parameters.StartDevice.AllocatedResources = NULL;
3063     irpsp->Parameters.StartDevice.AllocatedResourcesTranslated = NULL;
3064
3065     return send_device_irp( device, irp, NULL );
3066 }
3067
3068
3069 static NTSTATUS send_power_irp( DEVICE_OBJECT *device, DEVICE_POWER_STATE power )
3070 {
3071     IO_STATUS_BLOCK irp_status;
3072     IO_STACK_LOCATION *irpsp;
3073     IRP *irp;
3074
3075     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_POWER, device, NULL, 0, NULL, NULL, &irp_status )))
3076         return STATUS_NO_MEMORY;
3077
3078     irpsp = IoGetNextIrpStackLocation( irp );
3079     irpsp->MinorFunction = IRP_MN_SET_POWER;
3080
3081     irpsp->Parameters.Power.Type = DevicePowerState;
3082     irpsp->Parameters.Power.State.DeviceState = power;
3083
3084     return send_device_irp( device, irp, NULL );
3085 }
3086
3087
3088 static void handle_bus_relations( DEVICE_OBJECT *device )
3089 {
3090     static const WCHAR driverW[] = {'\\','D','r','i','v','e','r','\\',0};
3091     WCHAR buffer[MAX_SERVICE_NAME + sizeof(servicesW)/sizeof(WCHAR)];
3092     WCHAR driver[MAX_SERVICE_NAME] = {0};
3093     DRIVER_OBJECT *driver_obj;
3094     UNICODE_STRING string;
3095     WCHAR *ids, *ptr;
3096     NTSTATUS status;
3097
3098     TRACE_(plugplay)( "(%p)\n", device );
3099
3100     /* We could (should?) do a full IRP_MN_QUERY_DEVICE_RELATIONS query,
3101      * but we don't have to, we have the DEVICE_OBJECT of the new device
3102      * so we can simply handle the process here */
3103
3104     status = get_device_id( device, BusQueryCompatibleIDs, &ids );
3105     if (status != STATUS_SUCCESS || !ids)
3106     {
3107         ERR_(plugplay)( "Failed to get device IDs\n" );
3108         return;
3109     }
3110
3111     for (ptr = ids; *ptr; ptr += strlenW(ptr) + 1)
3112     {
3113         if (get_driver_for_id( ptr, driver ))
3114             break;
3115     }
3116     RtlFreeHeap( GetProcessHeap(), 0, ids );
3117
3118     if (!driver[0])
3119     {
3120         ERR_(plugplay)( "No matching driver found for device\n" );
3121         return;
3122     }
3123
3124     strcpyW( buffer, servicesW );
3125     strcatW( buffer, driver );
3126     RtlInitUnicodeString( &string, buffer );
3127     if (ZwLoadDriver( &string ) != STATUS_SUCCESS)
3128     {
3129         ERR_(plugplay)( "Failed to load driver %s\n", debugstr_w(driver) );
3130         return;
3131     }
3132
3133     strcpyW( buffer, driverW );
3134     strcatW( buffer, driver );
3135     RtlInitUnicodeString( &string, buffer );
3136     if (ObReferenceObjectByName( &string, OBJ_CASE_INSENSITIVE, NULL,
3137                                  0, NULL, KernelMode, NULL, (void **)&driver_obj ) != STATUS_SUCCESS)
3138     {
3139         ERR_(plugplay)( "Failed to locate loaded driver %s\n", debugstr_w(driver) );
3140         return;
3141     }
3142
3143     if (driver_obj->DriverExtension->AddDevice)
3144         status = driver_obj->DriverExtension->AddDevice( driver_obj, device );
3145     else
3146         status = STATUS_NOT_IMPLEMENTED;
3147
3148     ObDereferenceObject( driver_obj );
3149
3150     if (status != STATUS_SUCCESS)
3151     {
3152         ERR_(plugplay)( "AddDevice failed for driver %s\n", debugstr_w(driver) );
3153         return;
3154     }
3155
3156     send_pnp_irp( device, IRP_MN_START_DEVICE );
3157     send_power_irp( device, PowerDeviceD0 );
3158 }
3159
3160
3161 static void handle_removal_relations( DEVICE_OBJECT *device )
3162 {
3163     TRACE_(plugplay)( "(%p)\n", device );
3164
3165     send_power_irp( device, PowerDeviceD3 );
3166     send_pnp_irp( device, IRP_MN_SURPRISE_REMOVAL );
3167     send_pnp_irp( device, IRP_MN_REMOVE_DEVICE );
3168 }
3169
3170
3171 /***********************************************************************
3172  *           IoInvalidateDeviceRelations (NTOSKRNL.EXE.@)
3173  */
3174 void WINAPI IoInvalidateDeviceRelations( DEVICE_OBJECT *device_object, DEVICE_RELATION_TYPE type )
3175 {
3176     TRACE( "(%p, %i)\n", device_object, type );
3177
3178     switch (type)
3179     {
3180         case BusRelations:
3181             handle_bus_relations( device_object );
3182             break;
3183         case RemovalRelations:
3184             handle_removal_relations( device_object );
3185             break;
3186         default:
3187             FIXME( "unhandled relation %i\n", type );
3188             break;
3189     }
3190 }
3191
3192 /***********************************************************************
3193  *           KeSetTimerEx (NTOSKRNL.EXE.@)
3194  */
3195 BOOL WINAPI KeSetTimerEx( KTIMER *timer, LARGE_INTEGER duetime, LONG period, KDPC *dpc )
3196 {
3197     FIXME("stub: %p %s %u %p\n", timer, wine_dbgstr_longlong(duetime.QuadPart), period, dpc);
3198     return TRUE;
3199 }
3200
3201 /***********************************************************************
3202  *           IoCreateFile (NTOSKRNL.EXE.@)
3203  */
3204 NTSTATUS WINAPI IoCreateFile(HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
3205                               IO_STATUS_BLOCK *io, LARGE_INTEGER *alloc_size, ULONG attributes, ULONG sharing,
3206                               ULONG disposition, ULONG create_options, VOID *ea_buffer, ULONG ea_length,
3207                               CREATE_FILE_TYPE file_type, VOID *parameters, ULONG options )
3208 {
3209     FIXME(": stub\n");
3210     return STATUS_NOT_IMPLEMENTED;
3211 }
3212
3213 /***********************************************************************
3214  *           KeClearEvent (NTOSKRNL.EXE.@)
3215  */
3216 VOID WINAPI KeClearEvent(PRKEVENT event)
3217 {
3218     FIXME("stub: %p\n", event);
3219 }
3220
3221 /***********************************************************************
3222  *           KeAcquireInStackQueuedSpinLock (NTOSKRNL.EXE.@)
3223  */
3224 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
3225 DEFINE_FASTCALL2_ENTRYPOINT( KeAcquireInStackQueuedSpinLock )
3226 void WINAPI DECLSPEC_HIDDEN __regs_KeAcquireInStackQueuedSpinLock( KSPIN_LOCK *spinlock,
3227                                                                    KLOCK_QUEUE_HANDLE *handle )
3228 #else
3229 void WINAPI KeAcquireInStackQueuedSpinLock( KSPIN_LOCK *spinlock, KLOCK_QUEUE_HANDLE *handle )
3230 #endif
3231 {
3232     FIXME( "stub: %p %p\n", spinlock, handle );
3233 }
3234
3235 /***********************************************************************
3236  *           KeReleaseInStackQueuedSpinLock (NTOSKRNL.EXE.@)
3237  */
3238 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
3239 DEFINE_FASTCALL1_ENTRYPOINT( KeReleaseInStackQueuedSpinLock )
3240 void WINAPI DECLSPEC_HIDDEN __regs_KeReleaseInStackQueuedSpinLock( KLOCK_QUEUE_HANDLE *handle )
3241 #else
3242 void WINAPI KeReleaseInStackQueuedSpinLock( KLOCK_QUEUE_HANDLE *handle )
3243 #endif
3244 {
3245     FIXME( "stub: %p\n", handle );
3246 }
3247
3248 /***********************************************************************
3249  *           KeAcquireSpinLockRaiseToDpc (NTOSKRNL.EXE.@)
3250  */
3251 KIRQL WINAPI KeAcquireSpinLockRaiseToDpc(KSPIN_LOCK *spinlock)
3252 {
3253     FIXME( "stub: %p\n", spinlock );
3254     return 0;
3255 }
3256
3257 /***********************************************************************
3258  *           KeReleaseSpinLock (NTOSKRNL.EXE.@)
3259  */
3260 void WINAPI KeReleaseSpinLock( KSPIN_LOCK *spinlock, KIRQL irql )
3261 {
3262     FIXME( "stub: %p %u\n", spinlock, irql );
3263 }
3264
3265 /***********************************************************************
3266  *           IoCreateNotificationEvent (NTOSKRNL.EXE.@)
3267  */
3268 PKEVENT WINAPI IoCreateNotificationEvent(UNICODE_STRING *name, HANDLE *handle)
3269 {
3270     FIXME( "stub: %s %p\n", debugstr_us(name), handle );
3271     return NULL;
3272 }