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 "winbase.h"
  40 #include "winuser.h"
  41 #include "dbt.h"
  42 #include "winreg.h"
  43 #include "setupapi.h"
  44 #include "ddk/csq.h"
  45 #include "ddk/ntddk.h"
  46 #include "ddk/ntifs.h"
  47 #include "ddk/wdm.h"
  48 #include "wine/unicode.h"
  49 #include "wine/server.h"
  50 #include "wine/debug.h"
  51 #include "wine/heap.h"
  52 #include "wine/rbtree.h"
  53 #include "wine/svcctl.h"
  54
  55 #include "ntoskrnl_private.h"
  56
  57 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl);
  58 WINE_DECLARE_DEBUG_CHANNEL(relay);
  59 WINE_DECLARE_DEBUG_CHANNEL(plugplay);
  60
  61 BOOLEAN KdDebuggerEnabled = FALSE;
  62 ULONG InitSafeBootMode = 0;
  63
  64 extern LONG CALLBACK vectored_handler( EXCEPTION_POINTERS *ptrs );
  65
  66 KSYSTEM_TIME KeTickCount = { 0, 0, 0 };
  67
  68 typedef struct _KSERVICE_TABLE_DESCRIPTOR
  69 {
  70     PULONG_PTR Base;
  71     PULONG Count;
  72     ULONG Limit;
  73     PUCHAR Number;
  74 } KSERVICE_TABLE_DESCRIPTOR, *PKSERVICE_TABLE_DESCRIPTOR;
  75
  76 KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable[4] = { { 0 } };
  77
  78 typedef void (WINAPI *PCREATE_PROCESS_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
  79 typedef void (WINAPI *PCREATE_PROCESS_NOTIFY_ROUTINE_EX)(PEPROCESS,HANDLE,PPS_CREATE_NOTIFY_INFO);
  80 typedef void (WINAPI *PCREATE_THREAD_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
  81
  82 static const WCHAR servicesW[] = {'\\','R','e','g','i','s','t','r','y',
  83                                   '\\','M','a','c','h','i','n','e',
  84                                   '\\','S','y','s','t','e','m',
  85                                   '\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
  86                                   '\\','S','e','r','v','i','c','e','s',
  87                                   '\\',0};
  88
  89 #define MAX_SERVICE_NAME 260
  90
  91 /* tid of the thread running client request */
  92 static DWORD request_thread;
  93
  94 /* pid/tid of the client thread */
  95 static DWORD client_tid;
  96 static DWORD client_pid;
  97
  98 struct wine_driver
  99 {
 100     struct wine_rb_entry entry;
 101
 102     DRIVER_OBJECT driver_obj;
 103     DRIVER_EXTENSION driver_extension;
 104     SERVICE_STATUS_HANDLE service_handle;
 105 };
 106
 107 struct device_interface
 108 {
 109     struct wine_rb_entry entry;
 110
 111     UNICODE_STRING symbolic_link;
 112     DEVICE_OBJECT *device;
 113     GUID interface_class;
 114     BOOL enabled;
 115 };
 116
 117 static NTSTATUS get_device_id( DEVICE_OBJECT *device, BUS_QUERY_ID_TYPE type, WCHAR **id );
 118
 119 static int wine_drivers_rb_compare( const void *key, const struct wine_rb_entry *entry )
 120 {
 121     const struct wine_driver *driver = WINE_RB_ENTRY_VALUE( entry, const struct wine_driver, entry );
 122     const UNICODE_STRING *k = key;
 123
 124     return RtlCompareUnicodeString( k, &driver->driver_obj.DriverName, FALSE );
 125 }
 126
 127 static struct wine_rb_tree wine_drivers = { wine_drivers_rb_compare };
 128
 129 static int interface_rb_compare( const void *key, const struct wine_rb_entry *entry)
 130 {
 131     const struct device_interface *iface = WINE_RB_ENTRY_VALUE( entry, const struct device_interface, entry );
 132     const UNICODE_STRING *k = key;
 133
 134     return RtlCompareUnicodeString( k, &iface->symbolic_link, FALSE );
 135 }
 136
 137 static struct wine_rb_tree device_interfaces = { interface_rb_compare };
 138
 139 static CRITICAL_SECTION drivers_cs;
 140 static CRITICAL_SECTION_DEBUG critsect_debug =
 141 {
 142     0, 0, &drivers_cs,
 143     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 144       0, 0, { (DWORD_PTR)(__FILE__ ": drivers_cs") }
 145 };
 146 static CRITICAL_SECTION drivers_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
 147
 148 static inline LPCSTR debugstr_us( const UNICODE_STRING *us )
 149 {
 150     if (!us) return "<null>";
 151     return debugstr_wn( us->Buffer, us->Length / sizeof(WCHAR) );
 152 }
 153
 154 static inline BOOL is_valid_hex(WCHAR c)
 155 {
 156     if (!(((c >= '0') && (c <= '9'))  ||
 157           ((c >= 'a') && (c <= 'f'))  ||
 158           ((c >= 'A') && (c <= 'F'))))
 159         return FALSE;
 160     return TRUE;
 161 }
 162
 163 static const BYTE guid_conv_table[256] =
 164 {
 165   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 */
 166   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */
 167   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */
 168   0,   1,   2,   3,   4,   5,   6, 7, 8, 9, 0, 0, 0, 0, 0, 0, /* 0x30 */
 169   0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */
 170   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */
 171   0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf                             /* 0x60 */
 172 };
 173
 174 static BOOL guid_from_string(const WCHAR *s, GUID *id)
 175 {
 176     int i;
 177
 178     if (!s || s[0] != '{')
 179     {
 180         memset( id, 0, sizeof (CLSID) );
 181         return FALSE;
 182     }
 183
 184     id->Data1 = 0;
 185     for (i = 1; i < 9; i++)
 186     {
 187         if (!is_valid_hex(s[i])) return FALSE;
 188         id->Data1 = (id->Data1 << 4) | guid_conv_table[s[i]];
 189     }
 190     if (s[9] != '-') return FALSE;
 191
 192     id->Data2 = 0;
 193     for (i = 10; i < 14; i++)
 194     {
 195         if (!is_valid_hex(s[i])) return FALSE;
 196         id->Data2 = (id->Data2 << 4) | guid_conv_table[s[i]];
 197     }
 198     if (s[14] != '-') return FALSE;
 199
 200     id->Data3 = 0;
 201     for (i = 15; i < 19; i++)
 202     {
 203         if (!is_valid_hex(s[i])) return FALSE;
 204         id->Data3 = (id->Data3 << 4) | guid_conv_table[s[i]];
 205     }
 206     if (s[19] != '-') return FALSE;
 207
 208     for (i = 20; i < 37; i += 2)
 209     {
 210         if (i == 24)
 211         {
 212             if (s[i] != '-') return FALSE;
 213             i++;
 214         }
 215         if (!is_valid_hex(s[i]) || !is_valid_hex(s[i+1])) return FALSE;
 216         id->Data4[(i-20)/2] = guid_conv_table[s[i]] << 4 | guid_conv_table[s[i+1]];
 217     }
 218
 219     if (s[37] == '}')
 220         return TRUE;
 221
 222     return FALSE;
 223 }
 224
 225 static HANDLE get_device_manager(void)
 226 {
 227     static HANDLE device_manager;
 228     HANDLE handle = 0, ret = device_manager;
 229
 230     if (!ret)
 231     {
 232         SERVER_START_REQ( create_device_manager )
 233         {
 234             req->access     = SYNCHRONIZE;
 235             req->attributes = 0;
 236             if (!wine_server_call( req )) handle = wine_server_ptr_handle( reply->handle );
 237         }
 238         SERVER_END_REQ;
 239
 240         if (!handle)
 241         {
 242             ERR( "failed to create the device manager\n" );
 243             return 0;
 244         }
 245         if (!(ret = InterlockedCompareExchangePointer( &device_manager, handle, 0 )))
 246             ret = handle;
 247         else
 248             NtClose( handle );  /* somebody beat us to it */
 249     }
 250     return ret;
 251 }
 252
 253 /* transfer result of IRP back to wineserver */
 254 static NTSTATUS WINAPI dispatch_irp_completion( DEVICE_OBJECT *device, IRP *irp, void *context )
 255 {
 256     FILE_OBJECT *file = irp->Tail.Overlay.OriginalFileObject;
 257     HANDLE irp_handle = context;
 258     void *out_buff = irp->UserBuffer;
 259
 260     if (irp->Flags & IRP_WRITE_OPERATION)
 261         out_buff = NULL;  /* do not transfer back input buffer */
 262
 263     SERVER_START_REQ( set_irp_result )
 264     {
 265         req->handle   = wine_server_obj_handle( irp_handle );
 266         req->status   = irp->IoStatus.u.Status;
 267         req->file_ptr = wine_server_client_ptr( file );
 268         if (irp->IoStatus.u.Status >= 0)
 269         {
 270             req->size = irp->IoStatus.Information;
 271             if (out_buff) wine_server_add_data( req, out_buff, irp->IoStatus.Information );
 272         }
 273         wine_server_call( req );
 274     }
 275     SERVER_END_REQ;
 276
 277     if (irp->Flags & IRP_CLOSE_OPERATION)
 278     {
 279         HeapFree( GetProcessHeap(), 0, file );
 280         irp->Tail.Overlay.OriginalFileObject = NULL;
 281     }
 282
 283     if (irp->UserBuffer != irp->AssociatedIrp.SystemBuffer)
 284     {
 285         HeapFree( GetProcessHeap(), 0, irp->UserBuffer );
 286         irp->UserBuffer = NULL;
 287     }
 288     return STATUS_SUCCESS;
 289 }
 290
 291 static void dispatch_irp( DEVICE_OBJECT *device, IRP *irp, HANDLE irp_handle )
 292 {
 293     LARGE_INTEGER count;
 294
 295     IoSetCompletionRoutine( irp, dispatch_irp_completion, irp_handle, TRUE, TRUE, TRUE );
 296     KeQueryTickCount( &count );  /* update the global KeTickCount */
 297
 298     device->CurrentIrp = irp;
 299     IoCallDriver( device, irp );
 300     device->CurrentIrp = NULL;
 301 }
 302
 303 /* process a create request for a given file */
 304 static NTSTATUS dispatch_create( const irp_params_t *params, void *in_buff, ULONG in_size,
 305                                  ULONG out_size, HANDLE irp_handle )
 306 {
 307     IRP *irp;
 308     IO_STACK_LOCATION *irpsp;
 309     FILE_OBJECT *file;
 310     DEVICE_OBJECT *device = wine_server_get_ptr( params->create.device );
 311
 312     if (!(file = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*file) ))) return STATUS_NO_MEMORY;
 313
 314     TRACE( "device %p -> file %p\n", device, file );
 315
 316     file->Type = 5;  /* MSDN */
 317     file->Size = sizeof(*file);
 318     file->DeviceObject = device;
 319
 320     if (!(irp = IoAllocateIrp( device->StackSize, FALSE )))
 321     {
 322         HeapFree( GetProcessHeap(), 0, file );
 323         return STATUS_NO_MEMORY;
 324     }
 325
 326     irpsp = IoGetNextIrpStackLocation( irp );
 327     irpsp->MajorFunction = IRP_MJ_CREATE;
 328     irpsp->DeviceObject = device;
 329     irpsp->Parameters.Create.SecurityContext = NULL;  /* FIXME */
 330     irpsp->Parameters.Create.Options = params->create.options;
 331     irpsp->Parameters.Create.ShareAccess = params->create.sharing;
 332     irpsp->Parameters.Create.FileAttributes = 0;
 333     irpsp->Parameters.Create.EaLength = 0;
 334
 335     irp->Tail.Overlay.OriginalFileObject = file;
 336     irp->RequestorMode = UserMode;
 337     irp->AssociatedIrp.SystemBuffer = NULL;
 338     irp->UserBuffer = NULL;
 339     irp->UserIosb = NULL;
 340     irp->UserEvent = NULL;
 341
 342     irp->Flags |= IRP_CREATE_OPERATION;
 343     dispatch_irp( device, irp, irp_handle );
 344
 345     HeapFree( GetProcessHeap(), 0, in_buff );
 346     return STATUS_SUCCESS;
 347 }
 348
 349 /* process a close request for a given file */
 350 static NTSTATUS dispatch_close( const irp_params_t *params, void *in_buff, ULONG in_size,
 351                                  ULONG out_size, HANDLE irp_handle )
 352 {
 353     IRP *irp;
 354     IO_STACK_LOCATION *irpsp;
 355     DEVICE_OBJECT *device;
 356     FILE_OBJECT *file = wine_server_get_ptr( params->close.file );
 357
 358     if (!file) return STATUS_INVALID_HANDLE;
 359
 360     device = file->DeviceObject;
 361
 362     TRACE( "device %p file %p\n", device, file );
 363
 364     if (!(irp = IoAllocateIrp( device->StackSize, FALSE )))
 365     {
 366         HeapFree( GetProcessHeap(), 0, file );
 367         return STATUS_NO_MEMORY;
 368     }
 369
 370     irpsp = IoGetNextIrpStackLocation( irp );
 371     irpsp->MajorFunction = IRP_MJ_CLOSE;
 372     irpsp->DeviceObject = device;
 373
 374     irp->Tail.Overlay.OriginalFileObject = file;
 375     irp->RequestorMode = UserMode;
 376     irp->AssociatedIrp.SystemBuffer = NULL;
 377     irp->UserBuffer = NULL;
 378     irp->UserIosb = NULL;
 379     irp->UserEvent = NULL;
 380
 381     irp->Flags |= IRP_CLOSE_OPERATION;
 382     dispatch_irp( device, irp, irp_handle );
 383
 384     HeapFree( GetProcessHeap(), 0, in_buff );
 385     return STATUS_SUCCESS;
 386 }
 387
 388 /* process a read request for a given device */
 389 static NTSTATUS dispatch_read( const irp_params_t *params, void *in_buff, ULONG in_size,
 390                                ULONG out_size, HANDLE irp_handle )
 391 {
 392     IRP *irp;
 393     void *out_buff;
 394     LARGE_INTEGER offset;
 395     IO_STACK_LOCATION *irpsp;
 396     DEVICE_OBJECT *device;
 397     FILE_OBJECT *file = wine_server_get_ptr( params->read.file );
 398
 399     if (!file) return STATUS_INVALID_HANDLE;
 400
 401     device = file->DeviceObject;
 402
 403     TRACE( "device %p file %p size %u\n", device, file, out_size );
 404
 405     if (!(out_buff = HeapAlloc( GetProcessHeap(), 0, out_size ))) return STATUS_NO_MEMORY;
 406
 407     offset.QuadPart = params->read.pos;
 408
 409     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_READ, device, out_buff, out_size,
 410                                               &offset, NULL, NULL )))
 411     {
 412         HeapFree( GetProcessHeap(), 0, out_buff );
 413         return STATUS_NO_MEMORY;
 414     }
 415
 416     irp->Tail.Overlay.OriginalFileObject = file;
 417     irp->RequestorMode = UserMode;
 418
 419     irpsp = IoGetNextIrpStackLocation( irp );
 420     irpsp->Parameters.Read.Key = params->read.key;
 421
 422     irp->Flags |= IRP_READ_OPERATION;
 423     irp->Flags |= IRP_DEALLOCATE_BUFFER;  /* deallocate out_buff */
 424     dispatch_irp( device, irp, irp_handle );
 425
 426     HeapFree( GetProcessHeap(), 0, in_buff );
 427     return STATUS_SUCCESS;
 428 }
 429
 430 /* process a write request for a given device */
 431 static NTSTATUS dispatch_write( const irp_params_t *params, void *in_buff, ULONG in_size,
 432                                 ULONG out_size, HANDLE irp_handle )
 433 {
 434     IRP *irp;
 435     LARGE_INTEGER offset;
 436     IO_STACK_LOCATION *irpsp;
 437     DEVICE_OBJECT *device;
 438     FILE_OBJECT *file = wine_server_get_ptr( params->write.file );
 439
 440     if (!file) return STATUS_INVALID_HANDLE;
 441
 442     device = file->DeviceObject;
 443
 444     TRACE( "device %p file %p size %u\n", device, file, in_size );
 445
 446     offset.QuadPart = params->write.pos;
 447
 448     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_WRITE, device, in_buff, in_size,
 449                                               &offset, NULL, NULL )))
 450         return STATUS_NO_MEMORY;
 451
 452     irp->Tail.Overlay.OriginalFileObject = file;
 453     irp->RequestorMode = UserMode;
 454
 455     irpsp = IoGetNextIrpStackLocation( irp );
 456     irpsp->Parameters.Write.Key = params->write.key;
 457
 458     irp->Flags |= IRP_WRITE_OPERATION;
 459     irp->Flags |= IRP_DEALLOCATE_BUFFER;  /* deallocate in_buff */
 460     dispatch_irp( device, irp, irp_handle );
 461
 462     return STATUS_SUCCESS;
 463 }
 464
 465 /* process a flush request for a given device */
 466 static NTSTATUS dispatch_flush( const irp_params_t *params, void *in_buff, ULONG in_size,
 467                                 ULONG out_size, HANDLE irp_handle )
 468 {
 469     IRP *irp;
 470     DEVICE_OBJECT *device;
 471     FILE_OBJECT *file = wine_server_get_ptr( params->flush.file );
 472
 473     if (!file) return STATUS_INVALID_HANDLE;
 474
 475     device = file->DeviceObject;
 476
 477     TRACE( "device %p file %p\n", device, file );
 478
 479     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_FLUSH_BUFFERS, device, NULL, 0,
 480                                               NULL, NULL, NULL )))
 481         return STATUS_NO_MEMORY;
 482
 483     irp->Tail.Overlay.OriginalFileObject = file;
 484     irp->RequestorMode = UserMode;
 485
 486     dispatch_irp( device, irp, irp_handle );
 487
 488     HeapFree( GetProcessHeap(), 0, in_buff );
 489     return STATUS_SUCCESS;
 490 }
 491
 492 /* process an ioctl request for a given device */
 493 static NTSTATUS dispatch_ioctl( const irp_params_t *params, void *in_buff, ULONG in_size,
 494                                 ULONG out_size, HANDLE irp_handle )
 495 {
 496     IRP *irp;
 497     void *out_buff = NULL;
 498     void *to_free = NULL;
 499     DEVICE_OBJECT *device;
 500     FILE_OBJECT *file = wine_server_get_ptr( params->ioctl.file );
 501
 502     if (!file) return STATUS_INVALID_HANDLE;
 503
 504     device = file->DeviceObject;
 505
 506     TRACE( "ioctl %x device %p file %p in_size %u out_size %u\n",
 507            params->ioctl.code, device, file, in_size, out_size );
 508
 509     if (out_size)
 510     {
 511         if ((params->ioctl.code & 3) != METHOD_BUFFERED)
 512         {
 513             if (in_size < out_size) return STATUS_INVALID_DEVICE_REQUEST;
 514             in_size -= out_size;
 515             if (!(out_buff = HeapAlloc( GetProcessHeap(), 0, out_size ))) return STATUS_NO_MEMORY;
 516             memcpy( out_buff, (char *)in_buff + in_size, out_size );
 517         }
 518         else if (out_size > in_size)
 519         {
 520             if (!(out_buff = HeapAlloc( GetProcessHeap(), 0, out_size ))) return STATUS_NO_MEMORY;
 521             memcpy( out_buff, in_buff, in_size );
 522             to_free = in_buff;
 523             in_buff = out_buff;
 524         }
 525         else
 526         {
 527             out_buff = in_buff;
 528             out_size = in_size;
 529         }
 530     }
 531
 532     irp = IoBuildDeviceIoControlRequest( params->ioctl.code, device, in_buff, in_size, out_buff, out_size,
 533                                          FALSE, NULL, NULL );
 534     if (!irp)
 535     {
 536         HeapFree( GetProcessHeap(), 0, out_buff );
 537         return STATUS_NO_MEMORY;
 538     }
 539
 540     if (out_size && (params->ioctl.code & 3) != METHOD_BUFFERED)
 541         HeapReAlloc( GetProcessHeap(), HEAP_REALLOC_IN_PLACE_ONLY, in_buff, in_size );
 542
 543     irp->Tail.Overlay.OriginalFileObject = file;
 544     irp->RequestorMode = UserMode;
 545     irp->AssociatedIrp.SystemBuffer = in_buff;
 546
 547     irp->Flags |= IRP_DEALLOCATE_BUFFER;  /* deallocate in_buff */
 548     dispatch_irp( device, irp, irp_handle );
 549
 550     HeapFree( GetProcessHeap(), 0, to_free );
 551     return STATUS_SUCCESS;
 552 }
 553
 554 typedef NTSTATUS (*dispatch_func)( const irp_params_t *params, void *in_buff, ULONG in_size,
 555                                    ULONG out_size, HANDLE irp_handle );
 556
 557 static const dispatch_func dispatch_funcs[IRP_MJ_MAXIMUM_FUNCTION + 1] =
 558 {
 559     dispatch_create,   /* IRP_MJ_CREATE */
 560     NULL,              /* IRP_MJ_CREATE_NAMED_PIPE */
 561     dispatch_close,    /* IRP_MJ_CLOSE */
 562     dispatch_read,     /* IRP_MJ_READ */
 563     dispatch_write,    /* IRP_MJ_WRITE */
 564     NULL,              /* IRP_MJ_QUERY_INFORMATION */
 565     NULL,              /* IRP_MJ_SET_INFORMATION */
 566     NULL,              /* IRP_MJ_QUERY_EA */
 567     NULL,              /* IRP_MJ_SET_EA */
 568     dispatch_flush,    /* IRP_MJ_FLUSH_BUFFERS */
 569     NULL,              /* IRP_MJ_QUERY_VOLUME_INFORMATION */
 570     NULL,              /* IRP_MJ_SET_VOLUME_INFORMATION */
 571     NULL,              /* IRP_MJ_DIRECTORY_CONTROL */
 572     NULL,              /* IRP_MJ_FILE_SYSTEM_CONTROL */
 573     dispatch_ioctl,    /* IRP_MJ_DEVICE_CONTROL */
 574     NULL,              /* IRP_MJ_INTERNAL_DEVICE_CONTROL */
 575     NULL,              /* IRP_MJ_SHUTDOWN */
 576     NULL,              /* IRP_MJ_LOCK_CONTROL */
 577     NULL,              /* IRP_MJ_CLEANUP */
 578     NULL,              /* IRP_MJ_CREATE_MAILSLOT */
 579     NULL,              /* IRP_MJ_QUERY_SECURITY */
 580     NULL,              /* IRP_MJ_SET_SECURITY */
 581     NULL,              /* IRP_MJ_POWER */
 582     NULL,              /* IRP_MJ_SYSTEM_CONTROL */
 583     NULL,              /* IRP_MJ_DEVICE_CHANGE */
 584     NULL,              /* IRP_MJ_QUERY_QUOTA */
 585     NULL,              /* IRP_MJ_SET_QUOTA */
 586     NULL,              /* IRP_MJ_PNP */
 587 };
 588
 589 /* helper function to update service status */
 590 static void set_service_status( SERVICE_STATUS_HANDLE handle, DWORD state, DWORD accepted )
 591 {
 592     SERVICE_STATUS status;
 593     status.dwServiceType             = SERVICE_WIN32;
 594     status.dwCurrentState            = state;
 595     status.dwControlsAccepted        = accepted;
 596     status.dwWin32ExitCode           = 0;
 597     status.dwServiceSpecificExitCode = 0;
 598     status.dwCheckPoint              = 0;
 599     status.dwWaitHint                = (state == SERVICE_START_PENDING) ? 10000 : 0;
 600     SetServiceStatus( handle, &status );
 601 }
 602
 603 static void unload_driver( struct wine_rb_entry *entry, void *context )
 604 {
 605     struct wine_driver *driver = WINE_RB_ENTRY_VALUE( entry, struct wine_driver, entry );
 606     SERVICE_STATUS_HANDLE service_handle = driver->service_handle;
 607     LDR_MODULE *ldr;
 608
 609     if (!service_handle) return;    /* not a service */
 610
 611     TRACE("%s\n", debugstr_us(&driver->driver_obj.DriverName));
 612
 613     if (!driver->driver_obj.DriverUnload)
 614     {
 615         TRACE( "driver %s does not support unloading\n", debugstr_us(&driver->driver_obj.DriverName) );
 616         return;
 617     }
 618
 619     ldr = driver->driver_obj.DriverSection;
 620
 621     set_service_status( service_handle, SERVICE_STOP_PENDING, 0 );
 622
 623     TRACE_(relay)( "\1Call driver unload %p (obj=%p)\n", driver->driver_obj.DriverUnload, &driver->driver_obj );
 624
 625     driver->driver_obj.DriverUnload( &driver->driver_obj );
 626
 627     TRACE_(relay)( "\1Ret  driver unload %p (obj=%p)\n", driver->driver_obj.DriverUnload, &driver->driver_obj );
 628
 629     FreeLibrary( ldr->BaseAddress );
 630     IoDeleteDriver( &driver->driver_obj );
 631
 632     set_service_status( service_handle, SERVICE_STOPPED, 0 );
 633     CloseServiceHandle( (void *)service_handle );
 634 }
 635
 636 /***********************************************************************
 637  *           wine_ntoskrnl_main_loop   (Not a Windows API)
 638  */
 639 NTSTATUS CDECL wine_ntoskrnl_main_loop( HANDLE stop_event )
 640 {
 641     HANDLE manager = get_device_manager();
 642     HANDLE irp = 0;
 643     NTSTATUS status = STATUS_SUCCESS;
 644     irp_params_t irp_params;
 645     ULONG in_size = 4096, out_size = 0;
 646     void *in_buff = NULL;
 647     HANDLE handles[2];
 648
 649     request_thread = GetCurrentThreadId();
 650
 651     handles[0] = stop_event;
 652     handles[1] = manager;
 653
 654     for (;;)
 655     {
 656         if (!in_buff && !(in_buff = HeapAlloc( GetProcessHeap(), 0, in_size )))
 657         {
 658             ERR( "failed to allocate buffer\n" );
 659             status = STATUS_NO_MEMORY;
 660             goto done;
 661         }
 662
 663         SERVER_START_REQ( get_next_device_request )
 664         {
 665             req->manager = wine_server_obj_handle( manager );
 666             req->prev = wine_server_obj_handle( irp );
 667             req->status = status;
 668             wine_server_set_reply( req, in_buff, in_size );
 669             if (!(status = wine_server_call( req )))
 670             {
 671                 irp        = wine_server_ptr_handle( reply->next );
 672                 irp_params = reply->params;
 673                 client_tid = reply->client_tid;
 674                 client_pid = reply->client_pid;
 675                 in_size    = reply->in_size;
 676                 out_size   = reply->out_size;
 677             }
 678             else
 679             {
 680                 irp = 0; /* no previous irp */
 681                 if (status == STATUS_BUFFER_OVERFLOW)
 682                     in_size = reply->in_size;
 683             }
 684         }
 685         SERVER_END_REQ;
 686
 687         switch (status)
 688         {
 689         case STATUS_SUCCESS:
 690             if (irp_params.major > IRP_MJ_MAXIMUM_FUNCTION || !dispatch_funcs[irp_params.major])
 691             {
 692                 WARN( "unsupported request %u\n", irp_params.major );
 693                 status = STATUS_NOT_SUPPORTED;
 694                 break;
 695             }
 696             status = dispatch_funcs[irp_params.major]( &irp_params, in_buff, in_size, out_size, irp );
 697             if (status == STATUS_SUCCESS)
 698             {
 699                 irp = 0;  /* status reported by IoCompleteRequest */
 700                 in_size = 4096;
 701                 in_buff = NULL;
 702             }
 703             break;
 704         case STATUS_BUFFER_OVERFLOW:
 705             HeapFree( GetProcessHeap(), 0, in_buff );
 706             in_buff = NULL;
 707             /* restart with larger buffer */
 708             break;
 709         case STATUS_PENDING:
 710             for (;;)
 711             {
 712                 DWORD ret = WaitForMultipleObjectsEx( 2, handles, FALSE, INFINITE, TRUE );
 713                 if (ret == WAIT_OBJECT_0)
 714                 {
 715                     HeapFree( GetProcessHeap(), 0, in_buff );
 716                     status = STATUS_SUCCESS;
 717                     goto done;
 718                 }
 719                 if (ret != WAIT_IO_COMPLETION) break;
 720             }
 721             break;
 722         }
 723     }
 724
 725 done:
 726     wine_rb_destroy( &wine_drivers, unload_driver, NULL );
 727     return status;
 728 }
 729
 730 /***********************************************************************
 731  *           IoAllocateDriverObjectExtension  (NTOSKRNL.EXE.@)
 732  */
 733 NTSTATUS WINAPI IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject,
 734                                                  PVOID ClientIdentificationAddress,
 735                                                  ULONG DriverObjectExtensionSize,
 736                                                  PVOID *DriverObjectExtension )
 737 {
 738     FIXME( "stub: %p, %p, %u, %p\n", DriverObject, ClientIdentificationAddress,
 739             DriverObjectExtensionSize, DriverObjectExtension );
 740     return STATUS_NOT_IMPLEMENTED;
 741 }
 742
 743
 744 /***********************************************************************
 745  *           IoGetDriverObjectExtension  (NTOSKRNL.EXE.@)
 746  */
 747 PVOID WINAPI IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject,
 748                                          PVOID ClientIdentificationAddress )
 749 {
 750     FIXME( "stub: %p, %p\n", DriverObject, ClientIdentificationAddress );
 751     return NULL;
 752 }
 753
 754
 755 /***********************************************************************
 756  *           IoInitializeIrp  (NTOSKRNL.EXE.@)
 757  */
 758 void WINAPI IoInitializeIrp( IRP *irp, USHORT size, CCHAR stack_size )
 759 {
 760     TRACE( "%p, %u, %d\n", irp, size, stack_size );
 761
 762     RtlZeroMemory( irp, size );
 763
 764     irp->Type = IO_TYPE_IRP;
 765     irp->Size = size;
 766     InitializeListHead( &irp->ThreadListEntry );
 767     irp->StackCount = stack_size;
 768     irp->CurrentLocation = stack_size + 1;
 769     irp->Tail.Overlay.s.u2.CurrentStackLocation =
 770             (PIO_STACK_LOCATION)(irp + 1) + stack_size;
 771 }
 772
 773
 774 /***********************************************************************
 775  *           IoInitializeTimer   (NTOSKRNL.EXE.@)
 776  */
 777 NTSTATUS WINAPI IoInitializeTimer(PDEVICE_OBJECT DeviceObject,
 778                                   PIO_TIMER_ROUTINE TimerRoutine,
 779                                   PVOID Context)
 780 {
 781     FIXME( "stub: %p, %p, %p\n", DeviceObject, TimerRoutine, Context );
 782     return STATUS_NOT_IMPLEMENTED;
 783 }
 784
 785
 786 /***********************************************************************
 787  *           IoStartTimer   (NTOSKRNL.EXE.@)
 788  */
 789 void WINAPI IoStartTimer(PDEVICE_OBJECT DeviceObject)
 790 {
 791     FIXME( "stub: %p\n", DeviceObject );
 792 }
 793
 794
 795 /***********************************************************************
 796  *           IoStopTimer   (NTOSKRNL.EXE.@)
 797  */
 798 void WINAPI IoStopTimer(PDEVICE_OBJECT DeviceObject)
 799 {
 800     FIXME( "stub: %p\n", DeviceObject );
 801 }
 802
 803
 804 /***********************************************************************
 805  *           IoAllocateIrp  (NTOSKRNL.EXE.@)
 806  */
 807 PIRP WINAPI IoAllocateIrp( CCHAR stack_size, BOOLEAN charge_quota )
 808 {
 809     SIZE_T size;
 810     PIRP irp;
 811     CCHAR loc_count = stack_size;
 812
 813     TRACE( "%d, %d\n", stack_size, charge_quota );
 814
 815     if (loc_count < 8 && loc_count != 1)
 816         loc_count = 8;
 817
 818     size = sizeof(IRP) + loc_count * sizeof(IO_STACK_LOCATION);
 819     irp = ExAllocatePool( NonPagedPool, size );
 820     if (irp == NULL)
 821         return NULL;
 822     IoInitializeIrp( irp, size, stack_size );
 823     if (stack_size >= 1 && stack_size <= 8)
 824         irp->AllocationFlags = IRP_ALLOCATED_FIXED_SIZE;
 825     if (charge_quota)
 826         irp->AllocationFlags |= IRP_LOOKASIDE_ALLOCATION;
 827     return irp;
 828 }
 829
 830
 831 /***********************************************************************
 832  *           IoFreeIrp  (NTOSKRNL.EXE.@)
 833  */
 834 void WINAPI IoFreeIrp( IRP *irp )
 835 {
 836     MDL *mdl;
 837
 838     TRACE( "%p\n", irp );
 839
 840     mdl = irp->MdlAddress;
 841     while (mdl)
 842     {
 843         MDL *next = mdl->Next;
 844         IoFreeMdl( mdl );
 845         mdl = next;
 846     }
 847
 848     ExFreePool( irp );
 849 }
 850
 851
 852 /***********************************************************************
 853  *           IoAllocateErrorLogEntry  (NTOSKRNL.EXE.@)
 854  */
 855 PVOID WINAPI IoAllocateErrorLogEntry( PVOID IoObject, UCHAR EntrySize )
 856 {
 857     FIXME( "stub: %p, %u\n", IoObject, EntrySize );
 858     return NULL;
 859 }
 860
 861
 862 /***********************************************************************
 863  *           IoAllocateMdl  (NTOSKRNL.EXE.@)
 864  */
 865 PMDL WINAPI IoAllocateMdl( PVOID va, ULONG length, BOOLEAN secondary, BOOLEAN charge_quota, IRP *irp )
 866 {
 867     SIZE_T mdl_size;
 868     PMDL mdl;
 869
 870     TRACE("(%p, %u, %i, %i, %p)\n", va, length, secondary, charge_quota, irp);
 871
 872     if (charge_quota)
 873         FIXME("Charge quota is not yet supported\n");
 874
 875     mdl_size = sizeof(MDL) + sizeof(PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(va, length);
 876     mdl = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, mdl_size );
 877     if (!mdl)
 878         return NULL;
 879
 880     MmInitializeMdl( mdl, va, length );
 881
 882     if (!irp) return mdl;
 883
 884     if (secondary)  /* add it at the end */
 885     {
 886         MDL **pmdl = &irp->MdlAddress;
 887         while (*pmdl) pmdl = &(*pmdl)->Next;
 888         *pmdl = mdl;
 889     }
 890     else
 891     {
 892         mdl->Next = irp->MdlAddress;
 893         irp->MdlAddress = mdl;
 894     }
 895     return mdl;
 896 }
 897
 898
 899 /***********************************************************************
 900  *           IoFreeMdl  (NTOSKRNL.EXE.@)
 901  */
 902 void WINAPI IoFreeMdl(PMDL mdl)
 903 {
 904     TRACE("%p\n", mdl);
 905     HeapFree(GetProcessHeap(), 0, mdl);
 906 }
 907
 908
 909 /***********************************************************************
 910  *           IoAllocateWorkItem  (NTOSKRNL.EXE.@)
 911  */
 912 PIO_WORKITEM WINAPI IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject )
 913 {
 914     FIXME( "stub: %p\n", DeviceObject );
 915     return NULL;
 916 }
 917
 918
 919 /***********************************************************************
 920  *           IoAttachDeviceToDeviceStack  (NTOSKRNL.EXE.@)
 921  */
 922 PDEVICE_OBJECT WINAPI IoAttachDeviceToDeviceStack( DEVICE_OBJECT *source,
 923                                                    DEVICE_OBJECT *target )
 924 {
 925     TRACE( "%p, %p\n", source, target );
 926     target->AttachedDevice = source;
 927     source->StackSize = target->StackSize + 1;
 928     return target;
 929 }
 930
 931
 932 /***********************************************************************
 933  *           IoBuildDeviceIoControlRequest  (NTOSKRNL.EXE.@)
 934  */
 935 PIRP WINAPI IoBuildDeviceIoControlRequest( ULONG code, PDEVICE_OBJECT device,
 936                                            PVOID in_buff, ULONG in_len,
 937                                            PVOID out_buff, ULONG out_len,
 938                                            BOOLEAN internal, PKEVENT event,
 939                                            PIO_STATUS_BLOCK iosb )
 940 {
 941     PIRP irp;
 942     PIO_STACK_LOCATION irpsp;
 943     MDL *mdl;
 944
 945     TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
 946            code, device, in_buff, in_len, out_buff, out_len, internal, event, iosb );
 947
 948     if (device == NULL)
 949         return NULL;
 950
 951     irp = IoAllocateIrp( device->StackSize, FALSE );
 952     if (irp == NULL)
 953         return NULL;
 954
 955     irpsp = IoGetNextIrpStackLocation( irp );
 956     irpsp->MajorFunction = internal ? IRP_MJ_INTERNAL_DEVICE_CONTROL : IRP_MJ_DEVICE_CONTROL;
 957     irpsp->Parameters.DeviceIoControl.IoControlCode = code;
 958     irpsp->Parameters.DeviceIoControl.InputBufferLength = in_len;
 959     irpsp->Parameters.DeviceIoControl.OutputBufferLength = out_len;
 960     irpsp->DeviceObject = device;
 961     irpsp->CompletionRoutine = NULL;
 962
 963     switch (code & 3)
 964     {
 965     case METHOD_BUFFERED:
 966         irp->AssociatedIrp.SystemBuffer = in_buff;
 967         break;
 968     case METHOD_IN_DIRECT:
 969     case METHOD_OUT_DIRECT:
 970         irp->AssociatedIrp.SystemBuffer = in_buff;
 971
 972         mdl = IoAllocateMdl( out_buff, out_len, FALSE, FALSE, irp );
 973         if (!mdl)
 974         {
 975             IoFreeIrp( irp );
 976             return NULL;
 977         }
 978
 979         mdl->MdlFlags |= MDL_MAPPED_TO_SYSTEM_VA;
 980         mdl->MappedSystemVa = out_buff;
 981         break;
 982     case METHOD_NEITHER:
 983         irpsp->Parameters.DeviceIoControl.Type3InputBuffer = in_buff;
 984         break;
 985     }
 986
 987     irp->RequestorMode = KernelMode;
 988     irp->UserBuffer = out_buff;
 989     irp->UserIosb = iosb;
 990     irp->UserEvent = event;
 991     return irp;
 992 }
 993
 994
 995 /**********************************************************
 996  *           IoBuildSynchronousFsdRequest  (NTOSKRNL.EXE.@)
 997  */
 998 PIRP WINAPI IoBuildSynchronousFsdRequest(ULONG majorfunc, PDEVICE_OBJECT device,
 999                                          PVOID buffer, ULONG length, PLARGE_INTEGER startoffset,
1000                                          PKEVENT event, PIO_STATUS_BLOCK iosb)
1001 {
1002     PIRP irp;
1003     PIO_STACK_LOCATION irpsp;
1004
1005     TRACE("(%d %p %p %d %p %p %p)\n", majorfunc, device, buffer, length, startoffset, event, iosb);
1006
1007     if (!(irp = IoAllocateIrp( device->StackSize, FALSE ))) return NULL;
1008
1009     irpsp = IoGetNextIrpStackLocation( irp );
1010     irpsp->MajorFunction = majorfunc;
1011     irpsp->DeviceObject = device;
1012     irpsp->CompletionRoutine = NULL;
1013
1014     irp->AssociatedIrp.SystemBuffer = buffer;
1015
1016     if (device->Flags & DO_DIRECT_IO)
1017     {
1018         MDL *mdl = IoAllocateMdl( buffer, length, FALSE, FALSE, irp );
1019         if (!mdl)
1020         {
1021             IoFreeIrp( irp );
1022             return NULL;
1023         }
1024
1025         mdl->MdlFlags |= MDL_MAPPED_TO_SYSTEM_VA;
1026         mdl->MappedSystemVa = buffer;
1027     }
1028
1029     switch (majorfunc)
1030     {
1031     case IRP_MJ_READ:
1032         irpsp->Parameters.Read.Length = length;
1033         irpsp->Parameters.Read.ByteOffset = *startoffset;
1034         break;
1035     case IRP_MJ_WRITE:
1036         irpsp->Parameters.Write.Length = length;
1037         irpsp->Parameters.Write.ByteOffset = *startoffset;
1038         break;
1039     }
1040     irp->RequestorMode = KernelMode;
1041     irp->UserIosb = iosb;
1042     irp->UserEvent = event;
1043     irp->UserBuffer = buffer;
1044     return irp;
1045 }
1046
1047 static void build_driver_keypath( const WCHAR *name, UNICODE_STRING *keypath )
1048 {
1049     static const WCHAR driverW[] = {'\\','D','r','i','v','e','r','\\',0};
1050     WCHAR *str;
1051
1052     /* Check what prefix is present */
1053     if (strncmpW( name, servicesW, strlenW(servicesW) ) == 0)
1054     {
1055         FIXME( "Driver name %s is malformed as the keypath\n", debugstr_w(name) );
1056         RtlCreateUnicodeString( keypath, name );
1057         return;
1058     }
1059     if (strncmpW( name, driverW, strlenW(driverW) ) == 0)
1060         name += strlenW(driverW);
1061     else
1062         FIXME( "Driver name %s does not properly begin with \\Driver\\\n", debugstr_w(name) );
1063
1064     str = HeapAlloc( GetProcessHeap(), 0, sizeof(servicesW) + strlenW(name)*sizeof(WCHAR));
1065     lstrcpyW( str, servicesW );
1066     lstrcatW( str, name );
1067     RtlInitUnicodeString( keypath, str );
1068 }
1069
1070
1071 static NTSTATUS WINAPI unhandled_irp( DEVICE_OBJECT *device, IRP *irp )
1072 {
1073     TRACE( "(%p, %p)\n", device, irp );
1074     irp->IoStatus.u.Status = STATUS_INVALID_DEVICE_REQUEST;
1075     IoCompleteRequest( irp, IO_NO_INCREMENT );
1076     return STATUS_INVALID_DEVICE_REQUEST;
1077 }
1078
1079
1080 /***********************************************************************
1081  *           IoCreateDriver   (NTOSKRNL.EXE.@)
1082  */
1083 NTSTATUS WINAPI IoCreateDriver( UNICODE_STRING *name, PDRIVER_INITIALIZE init )
1084 {
1085     struct wine_driver *driver;
1086     NTSTATUS status;
1087     unsigned int i;
1088
1089     TRACE("(%s, %p)\n", debugstr_us(name), init);
1090
1091     if (!(driver = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
1092                                     sizeof(*driver) )))
1093         return STATUS_NO_MEMORY;
1094
1095     if ((status = RtlDuplicateUnicodeString( 1, name, &driver->driver_obj.DriverName )))
1096     {
1097         RtlFreeHeap( GetProcessHeap(), 0, driver );
1098         return status;
1099     }
1100
1101     driver->driver_obj.Size            = sizeof(driver->driver_obj);
1102     driver->driver_obj.DriverInit      = init;
1103     driver->driver_obj.DriverExtension = &driver->driver_extension;
1104     driver->driver_extension.DriverObject   = &driver->driver_obj;
1105     build_driver_keypath( driver->driver_obj.DriverName.Buffer, &driver->driver_extension.ServiceKeyName );
1106     for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
1107         driver->driver_obj.MajorFunction[i] = unhandled_irp;
1108
1109     status = driver->driver_obj.DriverInit( &driver->driver_obj, &driver->driver_extension.ServiceKeyName );
1110     if (status)
1111     {
1112         RtlFreeUnicodeString( &driver->driver_obj.DriverName );
1113         RtlFreeUnicodeString( &driver->driver_extension.ServiceKeyName );
1114         RtlFreeHeap( GetProcessHeap(), 0, driver );
1115         return status;
1116     }
1117
1118     for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
1119     {
1120         if (driver->driver_obj.MajorFunction[i]) continue;
1121         driver->driver_obj.MajorFunction[i] = unhandled_irp;
1122     }
1123
1124     EnterCriticalSection( &drivers_cs );
1125     if (wine_rb_put( &wine_drivers, &driver->driver_obj.DriverName, &driver->entry ))
1126         ERR( "failed to insert driver %s in tree\n", debugstr_us(name) );
1127     LeaveCriticalSection( &drivers_cs );
1128     return STATUS_SUCCESS;
1129 }
1130
1131
1132 /***********************************************************************
1133  *           IoDeleteDriver   (NTOSKRNL.EXE.@)
1134  */
1135 void WINAPI IoDeleteDriver( DRIVER_OBJECT *driver_object )
1136 {
1137     TRACE( "(%p)\n", driver_object );
1138
1139     EnterCriticalSection( &drivers_cs );
1140     wine_rb_remove_key( &wine_drivers, &driver_object->DriverName );
1141     LeaveCriticalSection( &drivers_cs );
1142
1143     RtlFreeUnicodeString( &driver_object->DriverName );
1144     RtlFreeUnicodeString( &driver_object->DriverExtension->ServiceKeyName );
1145     RtlFreeHeap( GetProcessHeap(), 0, CONTAINING_RECORD( driver_object, struct wine_driver, driver_obj ) );
1146 }
1147
1148
1149 /***********************************************************************
1150  *           IoCreateDevice   (NTOSKRNL.EXE.@)
1151  */
1152 NTSTATUS WINAPI IoCreateDevice( DRIVER_OBJECT *driver, ULONG ext_size,
1153                                 UNICODE_STRING *name, DEVICE_TYPE type,
1154                                 ULONG characteristics, BOOLEAN exclusive,
1155                                 DEVICE_OBJECT **ret_device )
1156 {
1157     NTSTATUS status;
1158     DEVICE_OBJECT *device;
1159     HANDLE handle = 0;
1160     HANDLE manager = get_device_manager();
1161
1162     TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
1163            driver, ext_size, debugstr_us(name), type, characteristics, exclusive, ret_device );
1164
1165     if (!(device = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*device) + ext_size )))
1166         return STATUS_NO_MEMORY;
1167
1168     SERVER_START_REQ( create_device )
1169     {
1170         req->access     = 0;
1171         req->attributes = 0;
1172         req->rootdir    = 0;
1173         req->manager    = wine_server_obj_handle( manager );
1174         req->user_ptr   = wine_server_client_ptr( device );
1175         if (name) wine_server_add_data( req, name->Buffer, name->Length );
1176         if (!(status = wine_server_call( req ))) handle = wine_server_ptr_handle( reply->handle );
1177     }
1178     SERVER_END_REQ;
1179
1180     if (status == STATUS_SUCCESS)
1181     {
1182         device->DriverObject    = driver;
1183         device->DeviceExtension = device + 1;
1184         device->DeviceType      = type;
1185         device->StackSize       = 1;
1186         device->Reserved        = handle;
1187
1188         device->NextDevice   = driver->DeviceObject;
1189         driver->DeviceObject = device;
1190
1191         *ret_device = device;
1192     }
1193     else HeapFree( GetProcessHeap(), 0, device );
1194
1195     return status;
1196 }
1197
1198
1199 /***********************************************************************
1200  *           IoDeleteDevice   (NTOSKRNL.EXE.@)
1201  */
1202 void WINAPI IoDeleteDevice( DEVICE_OBJECT *device )
1203 {
1204     NTSTATUS status;
1205
1206     TRACE( "%p\n", device );
1207
1208     SERVER_START_REQ( delete_device )
1209     {
1210         req->handle = wine_server_obj_handle( device->Reserved );
1211         status = wine_server_call( req );
1212     }
1213     SERVER_END_REQ;
1214
1215     if (status == STATUS_SUCCESS)
1216     {
1217         DEVICE_OBJECT **prev = &device->DriverObject->DeviceObject;
1218         while (*prev && *prev != device) prev = &(*prev)->NextDevice;
1219         if (*prev) *prev = (*prev)->NextDevice;
1220         NtClose( device->Reserved );
1221         HeapFree( GetProcessHeap(), 0, device );
1222     }
1223 }
1224
1225
1226 /***********************************************************************
1227  *           IoCreateSymbolicLink   (NTOSKRNL.EXE.@)
1228  */
1229 NTSTATUS WINAPI IoCreateSymbolicLink( UNICODE_STRING *name, UNICODE_STRING *target )
1230 {
1231     HANDLE handle;
1232     OBJECT_ATTRIBUTES attr;
1233
1234     attr.Length                   = sizeof(attr);
1235     attr.RootDirectory            = 0;
1236     attr.ObjectName               = name;
1237     attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
1238     attr.SecurityDescriptor       = NULL;
1239     attr.SecurityQualityOfService = NULL;
1240
1241     TRACE( "%s -> %s\n", debugstr_us(name), debugstr_us(target) );
1242     /* FIXME: store handle somewhere */
1243     return NtCreateSymbolicLinkObject( &handle, SYMBOLIC_LINK_ALL_ACCESS, &attr, target );
1244 }
1245
1246
1247 /***********************************************************************
1248  *           IoDeleteSymbolicLink   (NTOSKRNL.EXE.@)
1249  */
1250 NTSTATUS WINAPI IoDeleteSymbolicLink( UNICODE_STRING *name )
1251 {
1252     HANDLE handle;
1253     OBJECT_ATTRIBUTES attr;
1254     NTSTATUS status;
1255
1256     attr.Length                   = sizeof(attr);
1257     attr.RootDirectory            = 0;
1258     attr.ObjectName               = name;
1259     attr.Attributes               = OBJ_CASE_INSENSITIVE;
1260     attr.SecurityDescriptor       = NULL;
1261     attr.SecurityQualityOfService = NULL;
1262
1263     if (!(status = NtOpenSymbolicLinkObject( &handle, 0, &attr )))
1264     {
1265         SERVER_START_REQ( unlink_object )
1266         {
1267             req->handle = wine_server_obj_handle( handle );
1268             status = wine_server_call( req );
1269         }
1270         SERVER_END_REQ;
1271         NtClose( handle );
1272     }
1273     return status;
1274 }
1275
1276 static NTSTATUS create_device_symlink( DEVICE_OBJECT *device, UNICODE_STRING *symlink_name )
1277 {
1278     UNICODE_STRING device_nameU;
1279     WCHAR *device_name;
1280     ULONG len = 0;
1281     NTSTATUS ret;
1282
1283     ret = IoGetDeviceProperty( device, DevicePropertyPhysicalDeviceObjectName, 0, NULL, &len );
1284     if (ret != STATUS_BUFFER_TOO_SMALL)
1285         return ret;
1286
1287     device_name = heap_alloc( len );
1288     ret = IoGetDeviceProperty( device, DevicePropertyPhysicalDeviceObjectName, len, device_name, &len );
1289     if (ret)
1290     {
1291         heap_free( device_name );
1292         return ret;
1293     }
1294
1295     RtlInitUnicodeString( &device_nameU, device_name );
1296     ret = IoCreateSymbolicLink( symlink_name, &device_nameU );
1297     heap_free( device_name );
1298     return ret;
1299 }
1300
1301 /***********************************************************************
1302  *           IoSetDeviceInterfaceState   (NTOSKRNL.EXE.@)
1303  */
1304 NTSTATUS WINAPI IoSetDeviceInterfaceState( UNICODE_STRING *name, BOOLEAN enable )
1305 {
1306     static const WCHAR DeviceClassesW[] = {'\\','R','E','G','I','S','T','R','Y','\\',
1307         'M','a','c','h','i','n','e','\\','S','y','s','t','e','m','\\',
1308         'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
1309         'C','o','n','t','r','o','l','\\',
1310         'D','e','v','i','c','e','C','l','a','s','s','e','s','\\',0};
1311     static const WCHAR controlW[] = {'C','o','n','t','r','o','l',0};
1312     static const WCHAR linkedW[] = {'L','i','n','k','e','d',0};
1313     static const WCHAR slashW[] = {'\\',0};
1314     static const WCHAR hashW[] = {'#',0};
1315
1316     size_t namelen = name->Length / sizeof(WCHAR);
1317     DEV_BROADCAST_DEVICEINTERFACE_W *broadcast;
1318     struct device_interface *iface;
1319     HANDLE iface_key, control_key;
1320     OBJECT_ATTRIBUTES attr = {0};
1321     struct wine_rb_entry *entry;
1322     WCHAR *path, *refstr, *p;
1323     UNICODE_STRING string;
1324     DWORD data = enable;
1325     NTSTATUS ret;
1326     GUID class;
1327     ULONG len;
1328
1329     TRACE("(%s, %d)\n", debugstr_us(name), enable);
1330
1331     entry = wine_rb_get( &device_interfaces, name );
1332     if (!entry)
1333         return STATUS_OBJECT_NAME_NOT_FOUND;
1334
1335     iface = WINE_RB_ENTRY_VALUE( entry, struct device_interface, entry );
1336
1337     if (!enable && !iface->enabled)
1338         return STATUS_OBJECT_NAME_NOT_FOUND;
1339
1340     if (enable && iface->enabled)
1341         return STATUS_OBJECT_NAME_EXISTS;
1342
1343     refstr = memrchrW(name->Buffer + 4, '\\', namelen - 4);
1344
1345     if (!guid_from_string( (refstr ? refstr : name->Buffer + namelen) - 38, &class ))
1346         return STATUS_INVALID_PARAMETER;
1347
1348     len = strlenW(DeviceClassesW) + 38 + 1 + namelen + 2 + 1;
1349
1350     if (!(path = heap_alloc( len * sizeof(WCHAR) )))
1351         return STATUS_NO_MEMORY;
1352
1353     strcpyW( path, DeviceClassesW );
1354     lstrcpynW( path + strlenW( path ), (refstr ? refstr : name->Buffer + namelen) - 38, 39 );
1355     strcatW( path, slashW );
1356     p = path + strlenW( path );
1357     lstrcpynW( path + strlenW( path ), name->Buffer, (refstr ? (refstr - name->Buffer) : namelen) + 1 );
1358     p[0] = p[1] = p[3] = '#';
1359     strcatW( path, slashW );
1360     strcatW( path, hashW );
1361     if (refstr)
1362         lstrcpynW( path + strlenW( path ), refstr, name->Buffer + namelen - refstr + 1 );
1363
1364     attr.Length = sizeof(attr);
1365     attr.ObjectName = &string;
1366     RtlInitUnicodeString( &string, path );
1367     ret = NtOpenKey( &iface_key, KEY_CREATE_SUB_KEY, &attr );
1368     heap_free(path);
1369     if (ret)
1370         return ret;
1371
1372     attr.RootDirectory = iface_key;
1373     RtlInitUnicodeString( &string, controlW );
1374     ret = NtCreateKey( &control_key, KEY_SET_VALUE, &attr, 0, NULL, 0, NULL );
1375     NtClose( iface_key );
1376     if (ret)
1377         return ret;
1378
1379     RtlInitUnicodeString( &string, linkedW );
1380     ret = NtSetValueKey( control_key, &string, 0, REG_DWORD, &data, sizeof(data) );
1381     if (ret)
1382     {
1383         NtClose( control_key );
1384         return ret;
1385     }
1386
1387     if (enable)
1388         ret = create_device_symlink( iface->device, name );
1389     else
1390         ret = IoDeleteSymbolicLink( name );
1391     if (ret)
1392     {
1393         NtDeleteValueKey( control_key, &string );
1394         NtClose( control_key );
1395         return ret;
1396     }
1397
1398     iface->enabled = enable;
1399
1400     len = offsetof(DEV_BROADCAST_DEVICEINTERFACE_W, dbcc_name[namelen + 1]);
1401
1402     if ((broadcast = heap_alloc( len )))
1403     {
1404         broadcast->dbcc_size = len;
1405         broadcast->dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
1406         broadcast->dbcc_classguid = class;
1407         lstrcpynW( broadcast->dbcc_name, name->Buffer, namelen + 1 );
1408         BroadcastSystemMessageW( BSF_FORCEIFHUNG | BSF_QUERY, NULL, WM_DEVICECHANGE,
1409             enable ? DBT_DEVICEARRIVAL : DBT_DEVICEREMOVECOMPLETE, (LPARAM)broadcast );
1410
1411         heap_free( broadcast );
1412     }
1413     return ret;
1414 }
1415
1416
1417 /***********************************************************************
1418  *           IoGetDeviceInterfaces   (NTOSKRNL.EXE.@)
1419  */
1420 NTSTATUS WINAPI IoGetDeviceInterfaces( const GUID *InterfaceClassGuid,
1421                                        PDEVICE_OBJECT PhysicalDeviceObject,
1422                                        ULONG Flags, PWSTR *SymbolicLinkList )
1423 {
1424     FIXME( "stub: %s %p %x %p\n", debugstr_guid(InterfaceClassGuid),
1425            PhysicalDeviceObject, Flags, SymbolicLinkList );
1426     return STATUS_NOT_IMPLEMENTED;
1427 }
1428
1429
1430 /***********************************************************************
1431  *           IoGetDeviceObjectPointer   (NTOSKRNL.EXE.@)
1432  */
1433 NTSTATUS  WINAPI IoGetDeviceObjectPointer( UNICODE_STRING *name, ACCESS_MASK access, PFILE_OBJECT *file, PDEVICE_OBJECT *device )
1434 {
1435     static DEVICE_OBJECT stub_device;
1436     static DRIVER_OBJECT stub_driver;
1437
1438     FIXME( "stub: %s %x %p %p\n", debugstr_us(name), access, file, device );
1439
1440     stub_device.StackSize = 0x80; /* minimum value to appease SecuROM 5.x */
1441     stub_device.DriverObject = &stub_driver;
1442
1443     *file  = NULL;
1444     *device = &stub_device;
1445
1446     return STATUS_SUCCESS;
1447 }
1448
1449 /***********************************************************************
1450  *           IoGetAttachedDevice   (NTOSKRNL.EXE.@)
1451  */
1452 DEVICE_OBJECT* WINAPI IoGetAttachedDevice( DEVICE_OBJECT *device )
1453 {
1454     DEVICE_OBJECT *result = device;
1455
1456     TRACE( "(%p)\n", device );
1457
1458     while (result->AttachedDevice)
1459         result = result->AttachedDevice;
1460
1461     return result;
1462 }
1463
1464
1465 /***********************************************************************
1466  *           IoGetDeviceProperty   (NTOSKRNL.EXE.@)
1467  */
1468 NTSTATUS WINAPI IoGetDeviceProperty( DEVICE_OBJECT *device, DEVICE_REGISTRY_PROPERTY device_property,
1469                                      ULONG buffer_length, PVOID property_buffer, PULONG result_length )
1470 {
1471     NTSTATUS status = STATUS_NOT_IMPLEMENTED;
1472     TRACE( "%p %d %u %p %p\n", device, device_property, buffer_length,
1473            property_buffer, result_length );
1474     switch (device_property)
1475     {
1476         case DevicePropertyEnumeratorName:
1477         {
1478             WCHAR *id, *ptr;
1479
1480             status = get_device_id( device, BusQueryInstanceID, &id );
1481             if (status != STATUS_SUCCESS)
1482             {
1483                 ERR( "Failed to get device id\n" );
1484                 break;
1485             }
1486
1487             struprW( id );
1488             ptr = strchrW( id, '\\' );
1489             if (ptr) *ptr = 0;
1490
1491             *result_length = sizeof(WCHAR) * (strlenW(id) + 1);
1492             if (buffer_length >= *result_length)
1493                 memcpy( property_buffer, id, *result_length );
1494             else
1495                 status = STATUS_BUFFER_TOO_SMALL;
1496
1497             HeapFree( GetProcessHeap(), 0, id );
1498             break;
1499         }
1500         case DevicePropertyPhysicalDeviceObjectName:
1501         {
1502             ULONG used_len, len = buffer_length + sizeof(OBJECT_NAME_INFORMATION);
1503             OBJECT_NAME_INFORMATION *name = HeapAlloc(GetProcessHeap(), 0, len);
1504
1505             status = NtQueryObject(device->Reserved, ObjectNameInformation, name, len, &used_len);
1506             if (status == STATUS_SUCCESS)
1507             {
1508                 /* Ensure room for NULL termination */
1509                 if (buffer_length >= name->Name.MaximumLength)
1510                     memcpy(property_buffer, name->Name.Buffer, name->Name.MaximumLength);
1511                 else
1512                     status = STATUS_BUFFER_TOO_SMALL;
1513                 *result_length = name->Name.MaximumLength;
1514             }
1515             else
1516             {
1517                 if (status == STATUS_INFO_LENGTH_MISMATCH ||
1518                     status == STATUS_BUFFER_OVERFLOW)
1519                 {
1520                     status = STATUS_BUFFER_TOO_SMALL;
1521                     *result_length = used_len - sizeof(OBJECT_NAME_INFORMATION);
1522                 }
1523                 else
1524                     *result_length = 0;
1525             }
1526             HeapFree(GetProcessHeap(), 0, name);
1527             break;
1528         }
1529         default:
1530             FIXME("unhandled property %d\n", device_property);
1531     }
1532     return status;
1533 }
1534
1535
1536 /***********************************************************************
1537  *           IoCallDriver   (NTOSKRNL.EXE.@)
1538  */
1539 NTSTATUS WINAPI IoCallDriver( DEVICE_OBJECT *device, IRP *irp )
1540 {
1541     PDRIVER_DISPATCH dispatch;
1542     IO_STACK_LOCATION *irpsp;
1543     NTSTATUS status;
1544
1545     --irp->CurrentLocation;
1546     irpsp = --irp->Tail.Overlay.s.u2.CurrentStackLocation;
1547     dispatch = device->DriverObject->MajorFunction[irpsp->MajorFunction];
1548
1549     TRACE_(relay)( "\1Call driver dispatch %p (device=%p,irp=%p)\n", dispatch, device, irp );
1550
1551     status = dispatch( device, irp );
1552
1553     TRACE_(relay)( "\1Ret  driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
1554                    dispatch, device, irp, status );
1555
1556     return status;
1557 }
1558
1559
1560 /***********************************************************************
1561  *           IofCallDriver   (NTOSKRNL.EXE.@)
1562  */
1563 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1564 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver )
1565 NTSTATUS WINAPI DECLSPEC_HIDDEN __regs_IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
1566 #else
1567 NTSTATUS WINAPI IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
1568 #endif
1569 {
1570     TRACE( "%p %p\n", device, irp );
1571     return IoCallDriver( device, irp );
1572 }
1573
1574
1575 /***********************************************************************
1576  *           IoGetRelatedDeviceObject    (NTOSKRNL.EXE.@)
1577  */
1578 PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject( PFILE_OBJECT obj )
1579 {
1580     FIXME( "stub: %p\n", obj );
1581     return NULL;
1582 }
1583
1584 static CONFIGURATION_INFORMATION configuration_information;
1585
1586 /***********************************************************************
1587  *           IoGetConfigurationInformation    (NTOSKRNL.EXE.@)
1588  */
1589 PCONFIGURATION_INFORMATION WINAPI IoGetConfigurationInformation(void)
1590 {
1591     FIXME( "partial stub\n" );
1592     /* FIXME: return actual devices on system */
1593     return &configuration_information;
1594 }
1595
1596
1597 /***********************************************************************
1598  *           IoIsWdmVersionAvailable     (NTOSKRNL.EXE.@)
1599  */
1600 NTSTATUS WINAPI IoIsWdmVersionAvailable(UCHAR MajorVersion, UCHAR MinorVersion)
1601 {
1602     DWORD version;
1603     DWORD major;
1604     DWORD minor;
1605
1606     TRACE( "%d, 0x%X\n", MajorVersion, MinorVersion );
1607
1608     version = GetVersion();
1609     major = LOBYTE(version);
1610     minor = HIBYTE(LOWORD(version));
1611
1612     if (MajorVersion == 6 && MinorVersion == 0)
1613     {
1614         /* Windows Vista, Windows Server 2008, Windows 7 */
1615     }
1616     else if (MajorVersion == 1)
1617     {
1618         if (MinorVersion == 0x30)
1619         {
1620             /* Windows server 2003 */
1621             MajorVersion = 6;
1622             MinorVersion = 0;
1623         }
1624         else if (MinorVersion == 0x20)
1625         {
1626             /* Windows XP */
1627             MajorVersion = 5;
1628             MinorVersion = 1;
1629         }
1630         else if (MinorVersion == 0x10)
1631         {
1632             /* Windows 2000 */
1633             MajorVersion = 5;
1634             MinorVersion = 0;
1635         }
1636         else if (MinorVersion == 0x05)
1637         {
1638             /* Windows ME */
1639             MajorVersion = 4;
1640             MinorVersion = 0x5a;
1641         }
1642         else if (MinorVersion == 0x00)
1643         {
1644             /* Windows 98 */
1645             MajorVersion = 4;
1646             MinorVersion = 0x0a;
1647         }
1648         else
1649         {
1650             FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
1651             return FALSE;
1652         }
1653     }
1654     else
1655     {
1656         FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
1657         return FALSE;
1658     }
1659     return major > MajorVersion || (major == MajorVersion && minor >= MinorVersion);
1660 }
1661
1662
1663 /***********************************************************************
1664  *           IoQueryDeviceDescription    (NTOSKRNL.EXE.@)
1665  */
1666 NTSTATUS WINAPI IoQueryDeviceDescription(PINTERFACE_TYPE itype, PULONG bus, PCONFIGURATION_TYPE ctype,
1667                                      PULONG cnum, PCONFIGURATION_TYPE ptype, PULONG pnum,
1668                                      PIO_QUERY_DEVICE_ROUTINE callout, PVOID context)
1669 {
1670     FIXME( "(%p %p %p %p %p %p %p %p)\n", itype, bus, ctype, cnum, ptype, pnum, callout, context);
1671     return STATUS_NOT_IMPLEMENTED;
1672 }
1673
1674
1675 static NTSTATUS get_instance_id(DEVICE_OBJECT *device, WCHAR **instance_id)
1676 {
1677     WCHAR *id, *ptr;
1678     NTSTATUS status;
1679
1680     status = get_device_id( device, BusQueryInstanceID, &id );
1681     if (status != STATUS_SUCCESS) return status;
1682
1683     struprW( id );
1684     for (ptr = id; *ptr; ptr++)if (*ptr == '\\') *ptr = '#';
1685
1686     *instance_id = id;
1687     return STATUS_SUCCESS;
1688 }
1689
1690
1691 /*****************************************************
1692  *           IoRegisterDeviceInterface(NTOSKRNL.EXE.@)
1693  */
1694 NTSTATUS WINAPI IoRegisterDeviceInterface(DEVICE_OBJECT *device, const GUID *class_guid, UNICODE_STRING *reference_string, UNICODE_STRING *symbolic_link)
1695 {
1696     WCHAR *instance_id;
1697     NTSTATUS status = STATUS_SUCCESS;
1698     HDEVINFO infoset;
1699     WCHAR *referenceW = NULL;
1700     SP_DEVINFO_DATA devInfo;
1701     SP_DEVICE_INTERFACE_DATA infoData;
1702     SP_DEVICE_INTERFACE_DETAIL_DATA_W *data;
1703     DWORD required;
1704     BOOL rc;
1705     struct device_interface *iface;
1706
1707     TRACE( "(%p, %s, %s, %p)\n", device, debugstr_guid(class_guid), debugstr_us(reference_string), symbolic_link );
1708
1709     if (reference_string != NULL)
1710         referenceW = reference_string->Buffer;
1711
1712     infoset = SetupDiGetClassDevsW( class_guid, referenceW, NULL, DIGCF_DEVICEINTERFACE );
1713     if (infoset == INVALID_HANDLE_VALUE) return STATUS_UNSUCCESSFUL;
1714
1715     status = get_instance_id( device, &instance_id );
1716     if (status != STATUS_SUCCESS) return status;
1717
1718     devInfo.cbSize = sizeof( devInfo );
1719     rc = SetupDiCreateDeviceInfoW( infoset, instance_id, class_guid, NULL, NULL, 0, &devInfo );
1720     if (rc == 0)
1721     {
1722         if (GetLastError() == ERROR_DEVINST_ALREADY_EXISTS)
1723         {
1724             DWORD index = 0;
1725             DWORD size = strlenW(instance_id) + 2;
1726             WCHAR *id = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) );
1727             do
1728             {
1729                 rc = SetupDiEnumDeviceInfo( infoset, index, &devInfo );
1730                 if (rc && IsEqualGUID( &devInfo.ClassGuid, class_guid ))
1731                 {
1732                     BOOL check;
1733                     check = SetupDiGetDeviceInstanceIdW( infoset, &devInfo, id, size, &required );
1734                     if (check && strcmpW( id, instance_id ) == 0)
1735                         break;
1736                 }
1737                 index++;
1738             } while (rc);
1739
1740             HeapFree( GetProcessHeap(), 0, id );
1741             if (!rc)
1742             {
1743                 HeapFree( GetProcessHeap(), 0, instance_id );
1744                 return STATUS_UNSUCCESSFUL;
1745             }
1746         }
1747         else
1748         {
1749             HeapFree( GetProcessHeap(), 0, instance_id );
1750             return STATUS_UNSUCCESSFUL;
1751         }
1752     }
1753     HeapFree( GetProcessHeap(), 0, instance_id );
1754
1755     infoData.cbSize = sizeof( infoData );
1756     rc = SetupDiCreateDeviceInterfaceW( infoset, &devInfo, class_guid, NULL, 0, &infoData );
1757     if (!rc) return STATUS_UNSUCCESSFUL;
1758
1759     required = 0;
1760     SetupDiGetDeviceInterfaceDetailW( infoset, &infoData, NULL, 0, &required, NULL );
1761     if (required == 0) return STATUS_UNSUCCESSFUL;
1762
1763     data = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY , required );
1764     data->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA_W);
1765
1766     rc = SetupDiGetDeviceInterfaceDetailW( infoset, &infoData, data, required, NULL, NULL );
1767     if (!rc)
1768     {
1769         HeapFree( GetProcessHeap(), 0, data );
1770         return STATUS_UNSUCCESSFUL;
1771     }
1772
1773     data->DevicePath[1] = '?';
1774     TRACE( "Device path %s\n",debugstr_w(data->DevicePath) );
1775
1776     iface = heap_alloc_zero( sizeof(struct device_interface) );
1777     iface->device = device;
1778     iface->interface_class = *class_guid;
1779     RtlCreateUnicodeString(&iface->symbolic_link, data->DevicePath);
1780     if (symbolic_link)
1781         RtlCreateUnicodeString( symbolic_link, data->DevicePath);
1782
1783     if (wine_rb_put( &device_interfaces, &iface->symbolic_link, &iface->entry ))
1784         ERR( "failed to insert interface %s into tree\n", debugstr_us(&iface->symbolic_link) );
1785
1786     HeapFree( GetProcessHeap(), 0, data );
1787
1788     return status;
1789 }
1790
1791
1792 /***********************************************************************
1793  *           IoRegisterDriverReinitialization    (NTOSKRNL.EXE.@)
1794  */
1795 void WINAPI IoRegisterDriverReinitialization( PDRIVER_OBJECT obj, PDRIVER_REINITIALIZE reinit, PVOID context )
1796 {
1797     FIXME( "stub: %p %p %p\n", obj, reinit, context );
1798 }
1799
1800
1801 /***********************************************************************
1802  *           IoRegisterShutdownNotification    (NTOSKRNL.EXE.@)
1803  */
1804 NTSTATUS WINAPI IoRegisterShutdownNotification( PDEVICE_OBJECT obj )
1805 {
1806     FIXME( "stub: %p\n", obj );
1807     return STATUS_SUCCESS;
1808 }
1809
1810
1811 /***********************************************************************
1812  *           IoUnregisterShutdownNotification    (NTOSKRNL.EXE.@)
1813  */
1814 VOID WINAPI IoUnregisterShutdownNotification( PDEVICE_OBJECT obj )
1815 {
1816     FIXME( "stub: %p\n", obj );
1817 }
1818
1819
1820 /***********************************************************************
1821  *           IoReportResourceForDetection   (NTOSKRNL.EXE.@)
1822  */
1823 NTSTATUS WINAPI IoReportResourceForDetection( DRIVER_OBJECT *drv_obj, CM_RESOURCE_LIST *drv_list, ULONG drv_size,
1824                                               DEVICE_OBJECT *dev_obj, CM_RESOURCE_LIST *dev_list, ULONG dev_size,
1825                                               BOOLEAN *conflict )
1826 {
1827     FIXME( "(%p, %p, %u, %p, %p, %u, %p): stub\n", drv_obj, drv_list, drv_size,
1828            dev_obj, dev_list, dev_size, conflict );
1829
1830     return STATUS_NOT_IMPLEMENTED;
1831 }
1832
1833
1834 /***********************************************************************
1835  *           IoReportResourceUsage    (NTOSKRNL.EXE.@)
1836  */
1837 NTSTATUS WINAPI IoReportResourceUsage( UNICODE_STRING *name, DRIVER_OBJECT *drv_obj, CM_RESOURCE_LIST *drv_list,
1838                                        ULONG drv_size, DRIVER_OBJECT *dev_obj, CM_RESOURCE_LIST *dev_list,
1839                                        ULONG dev_size, BOOLEAN overwrite, BOOLEAN *conflict )
1840 {
1841     FIXME( "(%s, %p, %p, %u, %p, %p, %u, %d, %p): stub\n", debugstr_us(name),
1842            drv_obj, drv_list, drv_size, dev_obj, dev_list, dev_size, overwrite, conflict );
1843
1844     return STATUS_NOT_IMPLEMENTED;
1845 }
1846
1847
1848 /***********************************************************************
1849  *           IoCompleteRequest   (NTOSKRNL.EXE.@)
1850  */
1851 VOID WINAPI IoCompleteRequest( IRP *irp, UCHAR priority_boost )
1852 {
1853     IO_STACK_LOCATION *irpsp;
1854     PIO_COMPLETION_ROUTINE routine;
1855     NTSTATUS status, stat;
1856     int call_flag = 0;
1857
1858     TRACE( "%p %u\n", irp, priority_boost );
1859
1860     status = irp->IoStatus.u.Status;
1861     while (irp->CurrentLocation <= irp->StackCount)
1862     {
1863         irpsp = irp->Tail.Overlay.s.u2.CurrentStackLocation;
1864         routine = irpsp->CompletionRoutine;
1865         call_flag = 0;
1866         /* FIXME: add SL_INVOKE_ON_CANCEL support */
1867         if (routine)
1868         {
1869             if ((irpsp->Control & SL_INVOKE_ON_SUCCESS) && STATUS_SUCCESS == status)
1870                 call_flag = 1;
1871             if ((irpsp->Control & SL_INVOKE_ON_ERROR) && STATUS_SUCCESS != status)
1872                 call_flag = 1;
1873         }
1874         ++irp->CurrentLocation;
1875         ++irp->Tail.Overlay.s.u2.CurrentStackLocation;
1876         if (call_flag)
1877         {
1878             TRACE( "calling %p( %p, %p, %p )\n", routine,
1879                     irpsp->DeviceObject, irp, irpsp->Context );
1880             stat = routine( irpsp->DeviceObject, irp, irpsp->Context );
1881             TRACE( "CompletionRoutine returned %x\n", stat );
1882             if (STATUS_MORE_PROCESSING_REQUIRED == stat)
1883                 return;
1884         }
1885     }
1886
1887     if (irp->Flags & IRP_DEALLOCATE_BUFFER)
1888         HeapFree( GetProcessHeap(), 0, irp->AssociatedIrp.SystemBuffer );
1889
1890     IoFreeIrp( irp );
1891 }
1892
1893
1894 /***********************************************************************
1895  *           IofCompleteRequest   (NTOSKRNL.EXE.@)
1896  */
1897 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1898 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest )
1899 void WINAPI DECLSPEC_HIDDEN __regs_IofCompleteRequest( IRP *irp, UCHAR priority_boost )
1900 #else
1901 void WINAPI IofCompleteRequest( IRP *irp, UCHAR priority_boost )
1902 #endif
1903 {
1904     TRACE( "%p %u\n", irp, priority_boost );
1905     IoCompleteRequest( irp, priority_boost );
1906 }
1907
1908
1909 /***********************************************************************
1910  *           InterlockedCompareExchange   (NTOSKRNL.EXE.@)
1911  */
1912 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
1913 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange )
1914 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
1915 #else
1916 LONG WINAPI NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
1917 #endif
1918 {
1919     return InterlockedCompareExchange( dest, xchg, compare );
1920 }
1921
1922
1923 /***********************************************************************
1924  *           InterlockedDecrement   (NTOSKRNL.EXE.@)
1925  */
1926 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1927 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement )
1928 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
1929 #else
1930 LONG WINAPI NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
1931 #endif
1932 {
1933     return InterlockedDecrement( dest );
1934 }
1935
1936
1937 /***********************************************************************
1938  *           InterlockedExchange   (NTOSKRNL.EXE.@)
1939  */
1940 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1941 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange )
1942 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
1943 #else
1944 LONG WINAPI NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
1945 #endif
1946 {
1947     return InterlockedExchange( dest, val );
1948 }
1949
1950
1951 /***********************************************************************
1952  *           InterlockedExchangeAdd   (NTOSKRNL.EXE.@)
1953  */
1954 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1955 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd )
1956 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
1957 #else
1958 LONG WINAPI NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
1959 #endif
1960 {
1961     return InterlockedExchangeAdd( dest, incr );
1962 }
1963
1964
1965 /***********************************************************************
1966  *           InterlockedIncrement   (NTOSKRNL.EXE.@)
1967  */
1968 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1969 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement )
1970 LONG WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1971 #else
1972 LONG WINAPI NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1973 #endif
1974 {
1975     return InterlockedIncrement( dest );
1976 }
1977
1978
1979 /***********************************************************************
1980  *           InterlockedPopEntrySList   (NTOSKRNL.EXE.@)
1981  */
1982 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1983 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedPopEntrySList )
1984 PSLIST_ENTRY WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedPopEntrySList( PSLIST_HEADER list )
1985 #else
1986 PSLIST_ENTRY WINAPI NTOSKRNL_InterlockedPopEntrySList( PSLIST_HEADER list )
1987 #endif
1988 {
1989     return InterlockedPopEntrySList( list );
1990 }
1991
1992
1993 /***********************************************************************
1994  *           ExInterlockedPopEntrySList   (NTOSKRNL.EXE.@)
1995  */
1996 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1997 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_ExInterlockedPopEntrySList )
1998 PSLIST_ENTRY WINAPI __regs_NTOSKRNL_ExInterlockedPopEntrySList( PSLIST_HEADER list, PKSPIN_LOCK lock )
1999 #else
2000 PSLIST_ENTRY WINAPI NTOSKRNL_ExInterlockedPopEntrySList( PSLIST_HEADER list, PKSPIN_LOCK lock )
2001 #endif
2002 {
2003     return InterlockedPopEntrySList( list );
2004 }
2005
2006
2007 /***********************************************************************
2008  *           InterlockedPushEntrySList   (NTOSKRNL.EXE.@)
2009  */
2010 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
2011 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedPushEntrySList )
2012 PSLIST_ENTRY WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_InterlockedPushEntrySList( PSLIST_HEADER list,
2013                                                                                PSLIST_ENTRY entry )
2014 #else
2015 PSLIST_ENTRY WINAPI NTOSKRNL_InterlockedPushEntrySList( PSLIST_HEADER list, PSLIST_ENTRY entry )
2016 #endif
2017 {
2018     return InterlockedPushEntrySList( list, entry );
2019 }
2020
2021 /***********************************************************************
2022  *           ExInterlockedPushEntrySList   (NTOSKRNL.EXE.@)
2023  */
2024 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
2025 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_ExInterlockedPushEntrySList )
2026 PSLIST_ENTRY WINAPI DECLSPEC_HIDDEN __regs_NTOSKRNL_ExInterlockedPushEntrySList( PSLIST_HEADER list,
2027                                                                                PSLIST_ENTRY entry,
2028                                                                                PKSPIN_LOCK lock )
2029 #else
2030 PSLIST_ENTRY WINAPI NTOSKRNL_ExInterlockedPushEntrySList( PSLIST_HEADER list, PSLIST_ENTRY entry, PKSPIN_LOCK lock )
2031 #endif
2032 {
2033     return InterlockedPushEntrySList( list, entry );
2034 }
2035
2036 /***********************************************************************
2037  *           ExAllocatePool   (NTOSKRNL.EXE.@)
2038  */
2039 PVOID WINAPI ExAllocatePool( POOL_TYPE type, SIZE_T size )
2040 {
2041     return ExAllocatePoolWithTag( type, size, 0 );
2042 }
2043
2044
2045 /***********************************************************************
2046  *           ExAllocatePoolWithQuota   (NTOSKRNL.EXE.@)
2047  */
2048 PVOID WINAPI ExAllocatePoolWithQuota( POOL_TYPE type, SIZE_T size )
2049 {
2050     return ExAllocatePoolWithTag( type, size, 0 );
2051 }
2052
2053
2054 /***********************************************************************
2055  *           ExAllocatePoolWithTag   (NTOSKRNL.EXE.@)
2056  */
2057 PVOID WINAPI ExAllocatePoolWithTag( POOL_TYPE type, SIZE_T size, ULONG tag )
2058 {
2059     /* FIXME: handle page alignment constraints */
2060     void *ret = HeapAlloc( GetProcessHeap(), 0, size );
2061     TRACE( "%lu pool %u -> %p\n", size, type, ret );
2062     return ret;
2063 }
2064
2065
2066 /***********************************************************************
2067  *           ExAllocatePoolWithQuotaTag   (NTOSKRNL.EXE.@)
2068  */
2069 PVOID WINAPI ExAllocatePoolWithQuotaTag( POOL_TYPE type, SIZE_T size, ULONG tag )
2070 {
2071     return ExAllocatePoolWithTag( type, size, tag );
2072 }
2073
2074
2075 /***********************************************************************
2076  *           ExCreateCallback   (NTOSKRNL.EXE.@)
2077  */
2078 NTSTATUS WINAPI ExCreateCallback(PCALLBACK_OBJECT *obj, POBJECT_ATTRIBUTES attr,
2079                                  BOOLEAN create, BOOLEAN allow_multiple)
2080 {
2081     FIXME("(%p, %p, %u, %u): stub\n", obj, attr, create, allow_multiple);
2082
2083     return STATUS_NOT_IMPLEMENTED;
2084 }
2085
2086
2087 /***********************************************************************
2088  *           ExDeleteNPagedLookasideList   (NTOSKRNL.EXE.@)
2089  */
2090 void WINAPI ExDeleteNPagedLookasideList( PNPAGED_LOOKASIDE_LIST lookaside )
2091 {
2092     FIXME("(%p) stub\n", lookaside);
2093 }
2094
2095
2096 /***********************************************************************
2097  *           ExDeletePagedLookasideList  (NTOSKRNL.EXE.@)
2098  */
2099 void WINAPI ExDeletePagedLookasideList( PPAGED_LOOKASIDE_LIST lookaside )
2100 {
2101     FIXME("(%p) stub\n", lookaside);
2102 }
2103
2104
2105 /***********************************************************************
2106  *           ExFreePool   (NTOSKRNL.EXE.@)
2107  */
2108 void WINAPI ExFreePool( void *ptr )
2109 {
2110     ExFreePoolWithTag( ptr, 0 );
2111 }
2112
2113
2114 /***********************************************************************
2115  *           ExFreePoolWithTag   (NTOSKRNL.EXE.@)
2116  */
2117 void WINAPI ExFreePoolWithTag( void *ptr, ULONG tag )
2118 {
2119     TRACE( "%p\n", ptr );
2120     HeapFree( GetProcessHeap(), 0, ptr );
2121 }
2122
2123
2124 /***********************************************************************
2125  *           ExInitializeResourceLite   (NTOSKRNL.EXE.@)
2126  */
2127 NTSTATUS WINAPI ExInitializeResourceLite(PERESOURCE Resource)
2128 {
2129     FIXME( "stub: %p\n", Resource );
2130     return STATUS_NOT_IMPLEMENTED;
2131 }
2132
2133
2134 /***********************************************************************
2135  *           ExInitializeNPagedLookasideList   (NTOSKRNL.EXE.@)
2136  */
2137 void WINAPI ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
2138                                             PALLOCATE_FUNCTION Allocate,
2139                                             PFREE_FUNCTION Free,
2140                                             ULONG Flags,
2141                                             SIZE_T Size,
2142                                             ULONG Tag,
2143                                             USHORT Depth)
2144 {
2145     FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
2146 }
2147
2148 /***********************************************************************
2149  *           ExInitializePagedLookasideList   (NTOSKRNL.EXE.@)
2150  */
2151 void WINAPI ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside,
2152                                            PALLOCATE_FUNCTION Allocate,
2153                                            PFREE_FUNCTION Free,
2154                                            ULONG Flags,
2155                                            SIZE_T Size,
2156                                            ULONG Tag,
2157                                            USHORT Depth)
2158 {
2159     FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
2160 }
2161
2162 /***********************************************************************
2163  *           ExInitializeZone   (NTOSKRNL.EXE.@)
2164  */
2165 NTSTATUS WINAPI ExInitializeZone(PZONE_HEADER Zone,
2166                                  ULONG BlockSize,
2167                                  PVOID InitialSegment,
2168                                  ULONG InitialSegmentSize)
2169 {
2170     FIXME( "stub: %p, %u, %p, %u\n", Zone, BlockSize, InitialSegment, InitialSegmentSize );
2171     return STATUS_NOT_IMPLEMENTED;
2172 }
2173
2174 /***********************************************************************
2175 *           FsRtlIsNameInExpression   (NTOSKRNL.EXE.@)
2176 */
2177 BOOLEAN WINAPI FsRtlIsNameInExpression(PUNICODE_STRING expression, PUNICODE_STRING name,
2178                                        BOOLEAN ignore, PWCH upcase)
2179 {
2180     FIXME("stub: %p %p %d %p\n", expression, name, ignore, upcase);
2181     return FALSE;
2182 }
2183
2184 /***********************************************************************
2185 *           FsRtlRegisterUncProvider   (NTOSKRNL.EXE.@)
2186 */
2187 NTSTATUS WINAPI FsRtlRegisterUncProvider(PHANDLE MupHandle, PUNICODE_STRING RedirDevName,
2188                                          BOOLEAN MailslotsSupported)
2189 {
2190     FIXME("(%p %p %d): stub\n", MupHandle, RedirDevName, MailslotsSupported);
2191     return STATUS_NOT_IMPLEMENTED;
2192 }
2193
2194 /***********************************************************************
2195  *           IoGetCurrentProcess / PsGetCurrentProcess   (NTOSKRNL.EXE.@)
2196  */
2197 PEPROCESS WINAPI IoGetCurrentProcess(void)
2198 {
2199     FIXME("() stub\n");
2200     return NULL;
2201 }
2202
2203 /***********************************************************************
2204  *           KeGetCurrentThread / PsGetCurrentThread   (NTOSKRNL.EXE.@)
2205  */
2206 PRKTHREAD WINAPI KeGetCurrentThread(void)
2207 {
2208     FIXME("() stub\n");
2209     return NULL;
2210 }
2211
2212 /***********************************************************************
2213  *           KeInsertQueue   (NTOSKRNL.EXE.@)
2214  */
2215 LONG WINAPI KeInsertQueue(PRKQUEUE Queue, PLIST_ENTRY Entry)
2216 {
2217     FIXME( "stub: %p %p\n", Queue, Entry );
2218     return 0;
2219 }
2220
2221 /**********************************************************************
2222  *           KeQueryActiveProcessors   (NTOSKRNL.EXE.@)
2223  *
2224  * Return the active Processors as bitmask
2225  *
2226  * RETURNS
2227  *   active Processors as bitmask
2228  *
2229  */
2230 KAFFINITY WINAPI KeQueryActiveProcessors( void )
2231 {
2232     DWORD_PTR AffinityMask;
2233
2234     GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask, NULL);
2235     return AffinityMask;
2236 }
2237
2238
2239 /**********************************************************************
2240  *           KeQueryInterruptTime   (NTOSKRNL.EXE.@)
2241  *
2242  * Return the interrupt time count
2243  *
2244  */
2245 ULONGLONG WINAPI KeQueryInterruptTime( void )
2246 {
2247     LARGE_INTEGER totaltime;
2248
2249     KeQueryTickCount(&totaltime);
2250     return totaltime.QuadPart;
2251 }
2252
2253
2254 /***********************************************************************
2255  *           KeQuerySystemTime   (NTOSKRNL.EXE.@)
2256  */
2257 void WINAPI KeQuerySystemTime( LARGE_INTEGER *time )
2258 {
2259     NtQuerySystemTime( time );
2260 }
2261
2262
2263 /***********************************************************************
2264  *           KeQueryTickCount   (NTOSKRNL.EXE.@)
2265  */
2266 void WINAPI KeQueryTickCount( LARGE_INTEGER *count )
2267 {
2268     count->QuadPart = NtGetTickCount();
2269     /* update the global variable too */
2270     KeTickCount.LowPart   = count->u.LowPart;
2271     KeTickCount.High1Time = count->u.HighPart;
2272     KeTickCount.High2Time = count->u.HighPart;
2273 }
2274
2275
2276 /***********************************************************************
2277  *           KeQueryTimeIncrement   (NTOSKRNL.EXE.@)
2278  */
2279 ULONG WINAPI KeQueryTimeIncrement(void)
2280 {
2281     return 10000;
2282 }
2283
2284
2285 /***********************************************************************
2286  *           KeSetPriorityThread   (NTOSKRNL.EXE.@)
2287  */
2288 KPRIORITY WINAPI KeSetPriorityThread( PKTHREAD Thread, KPRIORITY Priority )
2289 {
2290     FIXME("(%p %d)\n", Thread, Priority);
2291     return Priority;
2292 }
2293
2294 /***********************************************************************
2295  *           KeSetSystemAffinityThread   (NTOSKRNL.EXE.@)
2296  */
2297 VOID WINAPI KeSetSystemAffinityThread(KAFFINITY Affinity)
2298 {
2299     FIXME("(%lx) stub\n", Affinity);
2300 }
2301
2302 /***********************************************************************
2303  *           IoRegisterFileSystem   (NTOSKRNL.EXE.@)
2304  */
2305 VOID WINAPI IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject)
2306 {
2307     FIXME("(%p): stub\n", DeviceObject);
2308 }
2309
2310 /***********************************************************************
2311  *           KeExpandKernelStackAndCalloutEx   (NTOSKRNL.EXE.@)
2312  */
2313 NTSTATUS WINAPI KeExpandKernelStackAndCalloutEx(PEXPAND_STACK_CALLOUT callout, void *parameter, SIZE_T size,
2314                                                 BOOLEAN wait, void *context)
2315 {
2316     WARN("(%p %p %lu %x %p) semi-stub: ignoring stack expand\n", callout, parameter, size, wait, context);
2317     callout(parameter);
2318     return STATUS_SUCCESS;
2319 }
2320
2321 /***********************************************************************
2322  *           KeExpandKernelStackAndCallout   (NTOSKRNL.EXE.@)
2323  */
2324 NTSTATUS WINAPI KeExpandKernelStackAndCallout(PEXPAND_STACK_CALLOUT callout, void *parameter, SIZE_T size)
2325 {
2326     return KeExpandKernelStackAndCalloutEx(callout, parameter, size, TRUE, NULL);
2327 }
2328
2329 /***********************************************************************
2330 *           IoUnregisterFileSystem   (NTOSKRNL.EXE.@)
2331 */
2332 VOID WINAPI IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject)
2333 {
2334     FIXME("(%p): stub\n", DeviceObject);
2335 }
2336
2337 /***********************************************************************
2338  *           MmAllocateNonCachedMemory   (NTOSKRNL.EXE.@)
2339  */
2340 PVOID WINAPI MmAllocateNonCachedMemory( SIZE_T size )
2341 {
2342     TRACE( "%lu\n", size );
2343     return VirtualAlloc( NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE|PAGE_NOCACHE );
2344 }
2345
2346 /***********************************************************************
2347  *           MmAllocateContiguousMemory   (NTOSKRNL.EXE.@)
2348  */
2349 PVOID WINAPI MmAllocateContiguousMemory( SIZE_T size, PHYSICAL_ADDRESS highest_valid_address )
2350 {
2351     FIXME( "%lu, %s stub\n", size, wine_dbgstr_longlong(highest_valid_address.QuadPart) );
2352     return NULL;
2353 }
2354
2355 /***********************************************************************
2356  *           MmAllocateContiguousMemorySpecifyCache   (NTOSKRNL.EXE.@)
2357  */
2358 PVOID WINAPI MmAllocateContiguousMemorySpecifyCache( SIZE_T size,
2359                                                      PHYSICAL_ADDRESS lowest_valid_address,
2360                                                      PHYSICAL_ADDRESS highest_valid_address,
2361                                                      PHYSICAL_ADDRESS BoundaryAddressMultiple,
2362                                                      MEMORY_CACHING_TYPE CacheType )
2363 {
2364     FIXME(": stub\n");
2365     return NULL;
2366 }
2367
2368 /***********************************************************************
2369  *           MmAllocatePagesForMdl   (NTOSKRNL.EXE.@)
2370  */
2371 PMDL WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress, PHYSICAL_ADDRESS highaddress,
2372                                   PHYSICAL_ADDRESS skipbytes, SIZE_T size)
2373 {
2374     FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress.QuadPart), wine_dbgstr_longlong(highaddress.QuadPart),
2375                                   wine_dbgstr_longlong(skipbytes.QuadPart), size);
2376     return NULL;
2377 }
2378
2379 /***********************************************************************
2380  *           MmCreateSection   (NTOSKRNL.EXE.@)
2381  */
2382 NTSTATUS WINAPI MmCreateSection( HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
2383                                  LARGE_INTEGER *size, ULONG protect, ULONG alloc_attr,
2384                                  HANDLE file, FILE_OBJECT *file_obj )
2385 {
2386     FIXME("%p %#x %p %s %#x %#x %p %p: stub\n", handle, access, attr,
2387         wine_dbgstr_longlong(size->QuadPart), protect, alloc_attr, file, file_obj);
2388     return STATUS_NOT_IMPLEMENTED;
2389 }
2390
2391 /***********************************************************************
2392  *           MmFreeNonCachedMemory   (NTOSKRNL.EXE.@)
2393  */
2394 void WINAPI MmFreeNonCachedMemory( void *addr, SIZE_T size )
2395 {
2396     TRACE( "%p %lu\n", addr, size );
2397     VirtualFree( addr, 0, MEM_RELEASE );
2398 }
2399
2400 /***********************************************************************
2401  *           MmIsAddressValid   (NTOSKRNL.EXE.@)
2402  *
2403  * Check if the process can access the virtual address without a pagefault
2404  *
2405  * PARAMS
2406  *  VirtualAddress [I] Address to check
2407  *
2408  * RETURNS
2409  *  Failure: FALSE
2410  *  Success: TRUE  (Accessing the Address works without a Pagefault)
2411  *
2412  */
2413 BOOLEAN WINAPI MmIsAddressValid(PVOID VirtualAddress)
2414 {
2415     TRACE("(%p)\n", VirtualAddress);
2416     return !IsBadReadPtr(VirtualAddress, 1);
2417 }
2418
2419 /***********************************************************************
2420  *           MmMapIoSpace   (NTOSKRNL.EXE.@)
2421  */
2422 PVOID WINAPI MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress, DWORD NumberOfBytes, DWORD CacheType )
2423 {
2424     FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress.u.HighPart, PhysicalAddress.u.LowPart, NumberOfBytes, CacheType );
2425     return NULL;
2426 }
2427
2428
2429 /***********************************************************************
2430  *           MmLockPagableSectionByHandle  (NTOSKRNL.EXE.@)
2431  */
2432 VOID WINAPI MmLockPagableSectionByHandle(PVOID ImageSectionHandle)
2433 {
2434     FIXME("stub %p\n", ImageSectionHandle);
2435 }
2436
2437 /***********************************************************************
2438  *           MmMapLockedPagesSpecifyCache  (NTOSKRNL.EXE.@)
2439  */
2440 PVOID WINAPI  MmMapLockedPagesSpecifyCache(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, MEMORY_CACHING_TYPE CacheType,
2441                                            PVOID BaseAddress, ULONG BugCheckOnFailure, MM_PAGE_PRIORITY Priority)
2442 {
2443     FIXME("(%p, %u, %u, %p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, CacheType, BaseAddress, BugCheckOnFailure, Priority);
2444
2445     return NULL;
2446 }
2447
2448 /***********************************************************************
2449  *           MmUnlockPagableImageSection  (NTOSKRNL.EXE.@)
2450  */
2451 VOID WINAPI MmUnlockPagableImageSection(PVOID ImageSectionHandle)
2452 {
2453     FIXME("stub %p\n", ImageSectionHandle);
2454 }
2455
2456 /***********************************************************************
2457  *           MmPageEntireDriver   (NTOSKRNL.EXE.@)
2458  */
2459 PVOID WINAPI MmPageEntireDriver(PVOID AddrInSection)
2460 {
2461     TRACE("%p\n", AddrInSection);
2462     return AddrInSection;
2463 }
2464
2465
2466 /***********************************************************************
2467  *           MmProbeAndLockPages  (NTOSKRNL.EXE.@)
2468  */
2469 void WINAPI MmProbeAndLockPages(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, LOCK_OPERATION Operation)
2470 {
2471     FIXME("(%p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, Operation);
2472 }
2473
2474
2475 /***********************************************************************
2476  *           MmResetDriverPaging   (NTOSKRNL.EXE.@)
2477  */
2478 void WINAPI MmResetDriverPaging(PVOID AddrInSection)
2479 {
2480     TRACE("%p\n", AddrInSection);
2481 }
2482
2483
2484 /***********************************************************************
2485  *           MmUnlockPages  (NTOSKRNL.EXE.@)
2486  */
2487 void WINAPI  MmUnlockPages(PMDLX MemoryDescriptorList)
2488 {
2489     FIXME("(%p): stub\n", MemoryDescriptorList);
2490 }
2491
2492
2493 /***********************************************************************
2494  *           MmUnmapIoSpace   (NTOSKRNL.EXE.@)
2495  */
2496 VOID WINAPI MmUnmapIoSpace( PVOID BaseAddress, SIZE_T NumberOfBytes )
2497 {
2498     FIXME( "stub: %p, %lu\n", BaseAddress, NumberOfBytes );
2499 }
2500
2501
2502  /***********************************************************************
2503  *           ObReferenceObjectByHandle    (NTOSKRNL.EXE.@)
2504  */
2505 NTSTATUS WINAPI ObReferenceObjectByHandle( HANDLE obj, ACCESS_MASK access,
2506                                            POBJECT_TYPE type,
2507                                            KPROCESSOR_MODE mode, PVOID* ptr,
2508                                            POBJECT_HANDLE_INFORMATION info)
2509 {
2510     FIXME( "stub: %p %x %p %d %p %p\n", obj, access, type, mode, ptr, info);
2511
2512     if(ptr)
2513         *ptr = UlongToHandle(0xdeadbeaf);
2514
2515     return STATUS_SUCCESS;
2516 }
2517
2518  /***********************************************************************
2519  *           ObReferenceObjectByName    (NTOSKRNL.EXE.@)
2520  */
2521 NTSTATUS WINAPI ObReferenceObjectByName( UNICODE_STRING *ObjectName,
2522                                          ULONG Attributes,
2523                                          ACCESS_STATE *AccessState,
2524                                          ACCESS_MASK DesiredAccess,
2525                                          POBJECT_TYPE ObjectType,
2526                                          KPROCESSOR_MODE AccessMode,
2527                                          void *ParseContext,
2528                                          void **Object)
2529 {
2530     struct wine_driver *driver;
2531     struct wine_rb_entry *entry;
2532
2533     TRACE("mostly-stub:%s %i %p %i %p %i %p %p\n", debugstr_us(ObjectName),
2534         Attributes, AccessState, DesiredAccess, ObjectType, AccessMode,
2535         ParseContext, Object);
2536
2537     if (AccessState) FIXME("Unhandled AccessState\n");
2538     if (DesiredAccess) FIXME("Unhandled DesiredAccess\n");
2539     if (ParseContext) FIXME("Unhandled ParseContext\n");
2540     if (ObjectType) FIXME("Unhandled ObjectType\n");
2541
2542     if (AccessMode != KernelMode)
2543     {
2544         FIXME("UserMode access not implemented\n");
2545         return STATUS_NOT_IMPLEMENTED;
2546     }
2547
2548     EnterCriticalSection(&drivers_cs);
2549     entry = wine_rb_get(&wine_drivers, ObjectName);
2550     LeaveCriticalSection(&drivers_cs);
2551     if (!entry)
2552     {
2553         FIXME("Object (%s) not found, may not be tracked.\n", debugstr_us(ObjectName));
2554         return STATUS_NOT_IMPLEMENTED;
2555     }
2556
2557     driver = WINE_RB_ENTRY_VALUE(entry, struct wine_driver, entry);
2558     *Object = &driver->driver_obj;
2559     return STATUS_SUCCESS;
2560 }
2561
2562
2563 static void ObReferenceObject( void *obj )
2564 {
2565     TRACE( "(%p): stub\n", obj );
2566 }
2567
2568
2569 /***********************************************************************
2570  *           ObReferenceObjectByPointer   (NTOSKRNL.EXE.@)
2571  */
2572 NTSTATUS WINAPI ObReferenceObjectByPointer(void *obj, ACCESS_MASK access,
2573                                            POBJECT_TYPE type,
2574                                            KPROCESSOR_MODE mode)
2575 {
2576     FIXME("(%p, %x, %p, %d): stub\n", obj, access, type, mode);
2577
2578     return STATUS_NOT_IMPLEMENTED;
2579 }
2580
2581
2582 /***********************************************************************
2583  *           ObDereferenceObject   (NTOSKRNL.EXE.@)
2584  */
2585 void WINAPI ObDereferenceObject( void *obj )
2586 {
2587     TRACE( "(%p): stub\n", obj );
2588 }
2589
2590
2591 /***********************************************************************
2592  *           ObfReferenceObject   (NTOSKRNL.EXE.@)
2593  */
2594 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
2595 DEFINE_FASTCALL1_ENTRYPOINT( ObfReferenceObject )
2596 void WINAPI DECLSPEC_HIDDEN __regs_ObfReferenceObject( void *obj )
2597 #else
2598 void WINAPI ObfReferenceObject( void *obj )
2599 #endif
2600 {
2601     ObReferenceObject( obj );
2602 }
2603
2604
2605 /***********************************************************************
2606  *           ObfDereferenceObject   (NTOSKRNL.EXE.@)
2607  */
2608 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
2609 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject )
2610 void WINAPI DECLSPEC_HIDDEN __regs_ObfDereferenceObject( void *obj )
2611 #else
2612 void WINAPI ObfDereferenceObject( void *obj )
2613 #endif
2614 {
2615     ObDereferenceObject( obj );
2616 }
2617
2618 /***********************************************************************
2619  *           ObRegisterCallbacks (NTOSKRNL.EXE.@)
2620  */
2621 NTSTATUS WINAPI ObRegisterCallbacks(POB_CALLBACK_REGISTRATION *callBack, void **handle)
2622 {
2623     FIXME( "stub: %p %p\n", callBack, handle );
2624
2625     if(handle)
2626         *handle = UlongToHandle(0xdeadbeaf);
2627
2628     return STATUS_SUCCESS;
2629 }
2630
2631 /***********************************************************************
2632  *           ObUnRegisterCallbacks (NTOSKRNL.EXE.@)
2633  */
2634 void WINAPI ObUnRegisterCallbacks(void *handle)
2635 {
2636     FIXME( "stub: %p\n", handle );
2637 }
2638
2639 /***********************************************************************
2640  *           ObGetFilterVersion (NTOSKRNL.EXE.@)
2641  */
2642 USHORT WINAPI ObGetFilterVersion(void)
2643 {
2644     FIXME( "stub:\n" );
2645
2646     return OB_FLT_REGISTRATION_VERSION;
2647 }
2648
2649 /***********************************************************************
2650  *           ObGetObjectType (NTOSKRNL.EXE.@)
2651  */
2652 POBJECT_TYPE WINAPI ObGetObjectType(void *object)
2653 {
2654     FIXME("stub: %p\n", object);
2655
2656     return NULL;
2657 }
2658
2659 /***********************************************************************
2660  *           IoGetAttachedDeviceReference   (NTOSKRNL.EXE.@)
2661  */
2662 DEVICE_OBJECT* WINAPI IoGetAttachedDeviceReference( DEVICE_OBJECT *device )
2663 {
2664     DEVICE_OBJECT *result = IoGetAttachedDevice( device );
2665     ObReferenceObject( result );
2666     return result;
2667 }
2668
2669
2670 /***********************************************************************
2671  *           PsCreateSystemThread   (NTOSKRNL.EXE.@)
2672  */
2673 NTSTATUS WINAPI PsCreateSystemThread(PHANDLE ThreadHandle, ULONG DesiredAccess,
2674                                      POBJECT_ATTRIBUTES ObjectAttributes,
2675                                      HANDLE ProcessHandle, PCLIENT_ID ClientId,
2676                                      PKSTART_ROUTINE StartRoutine, PVOID StartContext)
2677 {
2678     if (!ProcessHandle) ProcessHandle = GetCurrentProcess();
2679     return RtlCreateUserThread(ProcessHandle, 0, FALSE, 0, 0,
2680                                0, StartRoutine, StartContext,
2681                                ThreadHandle, ClientId);
2682 }
2683
2684 /***********************************************************************
2685  *           PsGetCurrentProcessId   (NTOSKRNL.EXE.@)
2686  */
2687 HANDLE WINAPI PsGetCurrentProcessId(void)
2688 {
2689     if (GetCurrentThreadId() == request_thread)
2690         return UlongToHandle(client_pid);
2691     return UlongToHandle(GetCurrentProcessId());
2692 }
2693
2694
2695 /***********************************************************************
2696  *           PsGetCurrentThreadId   (NTOSKRNL.EXE.@)
2697  */
2698 HANDLE WINAPI PsGetCurrentThreadId(void)
2699 {
2700     if (GetCurrentThreadId() == request_thread)
2701         return UlongToHandle(client_tid);
2702     return UlongToHandle(GetCurrentThreadId());
2703 }
2704
2705
2706 /***********************************************************************
2707  *           PsGetVersion   (NTOSKRNL.EXE.@)
2708  */
2709 BOOLEAN WINAPI PsGetVersion(ULONG *major, ULONG *minor, ULONG *build, UNICODE_STRING *version )
2710 {
2711     RTL_OSVERSIONINFOEXW info;
2712
2713     info.dwOSVersionInfoSize = sizeof(info);
2714     RtlGetVersion( &info );
2715     if (major) *major = info.dwMajorVersion;
2716     if (minor) *minor = info.dwMinorVersion;
2717     if (build) *build = info.dwBuildNumber;
2718
2719     if (version)
2720     {
2721 #if 0  /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
2722         size_t len = min( strlenW(info.szCSDVersion)*sizeof(WCHAR), version->MaximumLength );
2723         memcpy( version->Buffer, info.szCSDVersion, len );
2724         if (len < version->MaximumLength) version->Buffer[len / sizeof(WCHAR)] = 0;
2725         version->Length = len;
2726 #endif
2727     }
2728     return TRUE;
2729 }
2730
2731
2732 /***********************************************************************
2733  *           PsImpersonateClient   (NTOSKRNL.EXE.@)
2734  */
2735 NTSTATUS WINAPI PsImpersonateClient(PETHREAD Thread, PACCESS_TOKEN Token, BOOLEAN CopyOnOpen,
2736                                     BOOLEAN EffectiveOnly, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
2737 {
2738     FIXME("(%p, %p, %u, %u, %u): stub\n", Thread, Token, CopyOnOpen, EffectiveOnly, ImpersonationLevel);
2739
2740     return STATUS_NOT_IMPLEMENTED;
2741 }
2742
2743
2744 /***********************************************************************
2745  *           PsSetCreateProcessNotifyRoutine   (NTOSKRNL.EXE.@)
2746  */
2747 NTSTATUS WINAPI PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback, BOOLEAN remove )
2748 {
2749     FIXME( "stub: %p %d\n", callback, remove );
2750     return STATUS_SUCCESS;
2751 }
2752
2753
2754 /***********************************************************************
2755  *           PsSetCreateProcessNotifyRoutineEx   (NTOSKRNL.EXE.@)
2756  */
2757 NTSTATUS WINAPI PsSetCreateProcessNotifyRoutineEx( PCREATE_PROCESS_NOTIFY_ROUTINE_EX callback, BOOLEAN remove )
2758 {
2759     FIXME( "stub: %p %d\n", callback, remove );
2760     return STATUS_SUCCESS;
2761 }
2762
2763
2764 /***********************************************************************
2765  *           PsSetCreateThreadNotifyRoutine   (NTOSKRNL.EXE.@)
2766  */
2767 NTSTATUS WINAPI PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
2768 {
2769     FIXME( "stub: %p\n", NotifyRoutine );
2770     return STATUS_SUCCESS;
2771 }
2772
2773
2774 /***********************************************************************
2775  *           PsRemoveCreateThreadNotifyRoutine  (NTOSKRNL.EXE.@)
2776  */
2777 NTSTATUS WINAPI PsRemoveCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
2778 {
2779     FIXME( "stub: %p\n", NotifyRoutine );
2780     return STATUS_SUCCESS;
2781 }
2782
2783
2784 /***********************************************************************
2785  *           PsRemoveLoadImageNotifyRoutine  (NTOSKRNL.EXE.@)
2786  */
2787  NTSTATUS WINAPI PsRemoveLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE NotifyRoutine)
2788  {
2789     FIXME( "stub: %p\n", NotifyRoutine );
2790     return STATUS_SUCCESS;
2791  }
2792
2793
2794 /***********************************************************************
2795  *           PsTerminateSystemThread   (NTOSKRNL.EXE.@)
2796  */
2797 NTSTATUS WINAPI PsTerminateSystemThread(NTSTATUS status)
2798 {
2799     TRACE("status %#x.\n", status);
2800     ExitThread( status );
2801 }
2802
2803
2804 /***********************************************************************
2805  *           MmGetSystemRoutineAddress   (NTOSKRNL.EXE.@)
2806  */
2807 PVOID WINAPI MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName)
2808 {
2809     HMODULE hMod;
2810     STRING routineNameA;
2811     PVOID pFunc = NULL;
2812
2813     static const WCHAR ntoskrnlW[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
2814     static const WCHAR halW[] = {'h','a','l','.','d','l','l',0};
2815
2816     if (!SystemRoutineName) return NULL;
2817
2818     if (RtlUnicodeStringToAnsiString( &routineNameA, SystemRoutineName, TRUE ) == STATUS_SUCCESS)
2819     {
2820         /* We only support functions exported from ntoskrnl.exe or hal.dll */
2821         hMod = GetModuleHandleW( ntoskrnlW );
2822         pFunc = GetProcAddress( hMod, routineNameA.Buffer );
2823         if (!pFunc)
2824         {
2825            hMod = GetModuleHandleW( halW );
2826            if (hMod) pFunc = GetProcAddress( hMod, routineNameA.Buffer );
2827         }
2828         RtlFreeAnsiString( &routineNameA );
2829     }
2830
2831     if (pFunc)
2832         TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName), pFunc );
2833     else
2834         FIXME( "%s not found\n", debugstr_us(SystemRoutineName) );
2835     return pFunc;
2836 }
2837
2838
2839 /***********************************************************************
2840  *           MmQuerySystemSize   (NTOSKRNL.EXE.@)
2841  */
2842 MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void)
2843 {
2844     FIXME("stub\n");
2845     return MmLargeSystem;
2846 }
2847
2848 /***********************************************************************
2849  *           KeInitializeDpc   (NTOSKRNL.EXE.@)
2850  */
2851 VOID WINAPI KeInitializeDpc(PRKDPC Dpc, PKDEFERRED_ROUTINE DeferredRoutine, PVOID DeferredContext)
2852 {
2853     FIXME("stub\n");
2854 }
2855
2856 /***********************************************************************
2857  *          KeSetTargetProcessorDpc   (NTOSKRNL.EXE.@)
2858  */
2859 VOID WINAPI KeSetTargetProcessorDpc(PRKDPC dpc, CCHAR number)
2860 {
2861     FIXME("%p, %d stub\n", dpc, number);
2862 }
2863
2864 /***********************************************************************
2865  *           READ_REGISTER_BUFFER_UCHAR   (NTOSKRNL.EXE.@)
2866  */
2867 VOID WINAPI READ_REGISTER_BUFFER_UCHAR(PUCHAR Register, PUCHAR Buffer, ULONG Count)
2868 {
2869     FIXME("stub\n");
2870 }
2871
2872 /*****************************************************
2873  *           PoSetPowerState   (NTOSKRNL.EXE.@)
2874  */
2875 POWER_STATE WINAPI PoSetPowerState(PDEVICE_OBJECT DeviceObject, POWER_STATE_TYPE Type, POWER_STATE State)
2876 {
2877     FIXME("(%p %u %u) stub\n", DeviceObject, Type, State.DeviceState);
2878     return State;
2879 }
2880
2881 /*****************************************************
2882  *           IoWMIRegistrationControl   (NTOSKRNL.EXE.@)
2883  */
2884 NTSTATUS WINAPI IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject, ULONG Action)
2885 {
2886     FIXME("(%p %u) stub\n", DeviceObject, Action);
2887     return STATUS_SUCCESS;
2888 }
2889
2890 /*****************************************************
2891  *           PsSetLoadImageNotifyRoutine   (NTOSKRNL.EXE.@)
2892  */
2893 NTSTATUS WINAPI PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine)
2894 {
2895     FIXME("(%p) stub\n", routine);
2896     return STATUS_SUCCESS;
2897 }
2898
2899 /*****************************************************
2900  *           PsLookupProcessByProcessId  (NTOSKRNL.EXE.@)
2901  */
2902 NTSTATUS WINAPI PsLookupProcessByProcessId(HANDLE processid, PEPROCESS *process)
2903 {
2904     static int once;
2905     if (!once++) FIXME("(%p %p) stub\n", processid, process);
2906     return STATUS_NOT_IMPLEMENTED;
2907 }
2908
2909
2910 /*****************************************************
2911  *           IoSetThreadHardErrorMode  (NTOSKRNL.EXE.@)
2912  */
2913 BOOLEAN WINAPI IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors)
2914 {
2915     FIXME("stub\n");
2916     return FALSE;
2917 }
2918
2919
2920 /*****************************************************
2921  *           IoInitializeRemoveLockEx  (NTOSKRNL.EXE.@)
2922  */
2923 VOID WINAPI IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock, ULONG tag,
2924                                      ULONG maxmin, ULONG high, ULONG size)
2925 {
2926     FIXME("(%p %u %u %u %u) stub\n", lock, tag, maxmin, high, size);
2927 }
2928
2929
2930 /*****************************************************
2931  *           IoAcquireRemoveLockEx  (NTOSKRNL.EXE.@)
2932  */
2933
2934 NTSTATUS WINAPI IoAcquireRemoveLockEx(PIO_REMOVE_LOCK lock, PVOID tag,
2935                                       LPCSTR file, ULONG line, ULONG lock_size)
2936 {
2937     FIXME("(%p, %p, %s, %u, %u): stub\n", lock, tag, debugstr_a(file), line, lock_size);
2938
2939     return STATUS_NOT_IMPLEMENTED;
2940 }
2941
2942
2943 /*****************************************************
2944  *           DllMain
2945  */
2946 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
2947 {
2948     static void *handler;
2949     LARGE_INTEGER count;
2950
2951     switch(reason)
2952     {
2953     case DLL_PROCESS_ATTACH:
2954         DisableThreadLibraryCalls( inst );
2955 #if defined(__i386__) || defined(__x86_64__)
2956         handler = RtlAddVectoredExceptionHandler( TRUE, vectored_handler );
2957 #endif
2958         KeQueryTickCount( &count );  /* initialize the global KeTickCount */
2959         break;
2960     case DLL_PROCESS_DETACH:
2961         if (reserved) break;
2962         RtlRemoveVectoredExceptionHandler( handler );
2963         break;
2964     }
2965     return TRUE;
2966 }
2967
2968 /*****************************************************
2969  *           Ke386IoSetAccessProcess  (NTOSKRNL.EXE.@)
2970  */
2971 BOOLEAN WINAPI Ke386IoSetAccessProcess(PEPROCESS *process, ULONG flag)
2972 {
2973     FIXME("(%p %d) stub\n", process, flag);
2974     return FALSE;
2975 }
2976
2977 /*****************************************************
2978  *           Ke386SetIoAccessMap  (NTOSKRNL.EXE.@)
2979  */
2980 BOOLEAN WINAPI Ke386SetIoAccessMap(ULONG flag, PVOID buffer)
2981 {
2982     FIXME("(%d %p) stub\n", flag, buffer);
2983     return FALSE;
2984 }
2985
2986 /*****************************************************
2987  *           IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
2988  */
2989 PKEVENT WINAPI IoCreateSynchronizationEvent(PUNICODE_STRING name, PHANDLE handle)
2990 {
2991     FIXME("(%p %p) stub\n", name, handle);
2992     return (KEVENT *)0xdeadbeaf;
2993 }
2994
2995 /*****************************************************
2996  *           IoStartNextPacket  (NTOSKRNL.EXE.@)
2997  */
2998 VOID WINAPI IoStartNextPacket(PDEVICE_OBJECT deviceobject, BOOLEAN cancelable)
2999 {
3000     FIXME("(%p %d) stub\n", deviceobject, cancelable);
3001 }
3002
3003 /*****************************************************
3004  *           ObQueryNameString  (NTOSKRNL.EXE.@)
3005  */
3006 NTSTATUS WINAPI ObQueryNameString(PVOID object, POBJECT_NAME_INFORMATION name, ULONG maxlength, PULONG returnlength)
3007 {
3008     FIXME("(%p %p %u %p) stub\n", object, name, maxlength, returnlength);
3009     return STATUS_NOT_IMPLEMENTED;
3010 }
3011
3012 /*****************************************************
3013  *           IoRegisterPlugPlayNotification  (NTOSKRNL.EXE.@)
3014  */
3015 NTSTATUS WINAPI IoRegisterPlugPlayNotification(IO_NOTIFICATION_EVENT_CATEGORY category, ULONG flags, PVOID data,
3016                                                PDRIVER_OBJECT driver, PDRIVER_NOTIFICATION_CALLBACK_ROUTINE callback,
3017                                                PVOID context, PVOID *notification)
3018 {
3019     FIXME("(%u %u %p %p %p %p %p) stub\n", category, flags, data, driver, callback, context, notification);
3020     return STATUS_SUCCESS;
3021 }
3022
3023 /*****************************************************
3024  *           IoUnregisterPlugPlayNotification    (NTOSKRNL.EXE.@)
3025  */
3026 NTSTATUS WINAPI IoUnregisterPlugPlayNotification(PVOID notification)
3027 {
3028     FIXME("stub: %p\n", notification);
3029     return STATUS_SUCCESS;
3030 }
3031
3032 /*****************************************************
3033  *           IoCsqInitialize  (NTOSKRNL.EXE.@)
3034  */
3035 NTSTATUS WINAPI IoCsqInitialize(PIO_CSQ csq, PIO_CSQ_INSERT_IRP insert_irp, PIO_CSQ_REMOVE_IRP remove_irp,
3036                                 PIO_CSQ_PEEK_NEXT_IRP peek_irp, PIO_CSQ_ACQUIRE_LOCK acquire_lock,
3037                                 PIO_CSQ_RELEASE_LOCK release_lock, PIO_CSQ_COMPLETE_CANCELED_IRP complete_irp)
3038 {
3039     FIXME("(%p %p %p %p %p %p %p) stub\n",
3040           csq, insert_irp, remove_irp, peek_irp, acquire_lock, release_lock, complete_irp);
3041     return STATUS_SUCCESS;
3042 }
3043
3044 /***********************************************************************
3045  *           ExAcquireResourceExclusiveLite  (NTOSKRNL.EXE.@)
3046  */
3047 BOOLEAN WINAPI ExAcquireResourceExclusiveLite( PERESOURCE resource, BOOLEAN wait )
3048 {
3049     FIXME( ":%p %u stub\n", resource, wait );
3050     return TRUE;
3051 }
3052
3053 /***********************************************************************
3054  *           ExDeleteResourceLite  (NTOSKRNL.EXE.@)
3055  */
3056 NTSTATUS WINAPI ExDeleteResourceLite(PERESOURCE resource)
3057 {
3058     FIXME("(%p): stub\n", resource);
3059     return STATUS_NOT_IMPLEMENTED;
3060 }
3061
3062 /***********************************************************************
3063  *           ExReleaseResourceForThreadLite   (NTOSKRNL.EXE.@)
3064  */
3065 void WINAPI ExReleaseResourceForThreadLite( PERESOURCE resource, ERESOURCE_THREAD tid )
3066 {
3067     FIXME( "stub: %p %lu\n", resource, tid );
3068 }
3069
3070 /***********************************************************************
3071  *           KeEnterCriticalRegion  (NTOSKRNL.EXE.@)
3072  */
3073 void WINAPI KeEnterCriticalRegion(void)
3074 {
3075     FIXME(": stub\n");
3076 }
3077
3078 /***********************************************************************
3079  *           KeLeaveCriticalRegion  (NTOSKRNL.EXE.@)
3080  */
3081 void WINAPI KeLeaveCriticalRegion(void)
3082 {
3083     FIXME(": stub\n");
3084 }
3085
3086 /***********************************************************************
3087  *           ProbeForRead   (NTOSKRNL.EXE.@)
3088  */
3089 void WINAPI ProbeForRead(void *address, SIZE_T length, ULONG alignment)
3090 {
3091     FIXME("(%p %lu %u) stub\n", address, length, alignment);
3092 }
3093
3094 /***********************************************************************
3095  *           ProbeForWrite   (NTOSKRNL.EXE.@)
3096  */
3097 void WINAPI ProbeForWrite(void *address, SIZE_T length, ULONG alignment)
3098 {
3099     FIXME("(%p %lu %u) stub\n", address, length, alignment);
3100 }
3101
3102 /***********************************************************************
3103  *           CmRegisterCallback  (NTOSKRNL.EXE.@)
3104  */
3105 NTSTATUS WINAPI CmRegisterCallback(EX_CALLBACK_FUNCTION *function, void *context, LARGE_INTEGER *cookie)
3106 {
3107     FIXME("(%p %p %p): stub\n", function, context, cookie);
3108     return STATUS_NOT_IMPLEMENTED;
3109 }
3110
3111 /***********************************************************************
3112  *           CmUnRegisterCallback  (NTOSKRNL.EXE.@)
3113  */
3114 NTSTATUS WINAPI CmUnRegisterCallback(LARGE_INTEGER cookie)
3115 {
3116     FIXME("(%s): stub\n", wine_dbgstr_longlong(cookie.QuadPart));
3117     return STATUS_NOT_IMPLEMENTED;
3118 }
3119
3120 /***********************************************************************
3121  *           IoAttachDevice  (NTOSKRNL.EXE.@)
3122  */
3123 NTSTATUS WINAPI IoAttachDevice(DEVICE_OBJECT *source, UNICODE_STRING *target, DEVICE_OBJECT *attached)
3124 {
3125     FIXME("(%p, %s, %p): stub\n", source, debugstr_us(target), attached);
3126     return STATUS_NOT_IMPLEMENTED;
3127 }
3128
3129
3130 static NTSTATUS open_driver( const UNICODE_STRING *service_name, SC_HANDLE *service )
3131 {
3132     QUERY_SERVICE_CONFIGW *service_config = NULL;
3133     SC_HANDLE manager_handle;
3134     DWORD config_size = 0;
3135     WCHAR *name;
3136
3137     if (!(name = RtlAllocateHeap( GetProcessHeap(), 0, service_name->Length + sizeof(WCHAR) )))
3138         return STATUS_NO_MEMORY;
3139
3140     memcpy( name, service_name->Buffer, service_name->Length );
3141     name[ service_name->Length / sizeof(WCHAR) ] = 0;
3142
3143     if (strncmpW( name, servicesW, strlenW(servicesW) ))
3144     {
3145         FIXME( "service name %s is not a keypath\n", debugstr_us(service_name) );
3146         RtlFreeHeap( GetProcessHeap(), 0, name );
3147         return STATUS_NOT_IMPLEMENTED;
3148     }
3149
3150     if (!(manager_handle = OpenSCManagerW( NULL, NULL, SC_MANAGER_CONNECT )))
3151     {
3152         WARN( "failed to connect to service manager\n" );
3153         RtlFreeHeap( GetProcessHeap(), 0, name );
3154         return STATUS_NOT_SUPPORTED;
3155     }
3156
3157     *service = OpenServiceW( manager_handle, name + strlenW(servicesW),
3158                              SERVICE_QUERY_CONFIG | SERVICE_SET_STATUS );
3159     RtlFreeHeap( GetProcessHeap(), 0, name );
3160     CloseServiceHandle( manager_handle );
3161
3162     if (!*service)
3163     {
3164         WARN( "failed to open service %s\n", debugstr_us(service_name) );
3165         return STATUS_UNSUCCESSFUL;
3166     }
3167
3168     QueryServiceConfigW( *service, NULL, 0, &config_size );
3169     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
3170     {
3171         WARN( "failed to query service config\n" );
3172         goto error;
3173     }
3174
3175     if (!(service_config = RtlAllocateHeap( GetProcessHeap(), 0, config_size )))
3176         goto error;
3177
3178     if (!QueryServiceConfigW( *service, service_config, config_size, &config_size ))
3179     {
3180         WARN( "failed to query service config\n" );
3181         goto error;
3182     }
3183
3184     if (service_config->dwServiceType != SERVICE_KERNEL_DRIVER &&
3185         service_config->dwServiceType != SERVICE_FILE_SYSTEM_DRIVER)
3186     {
3187         WARN( "service %s is not a kernel driver\n", debugstr_us(service_name) );
3188         goto error;
3189     }
3190
3191     TRACE( "opened service for driver %s\n", debugstr_us(service_name) );
3192     RtlFreeHeap( GetProcessHeap(), 0, service_config );
3193     return STATUS_SUCCESS;
3194
3195 error:
3196     CloseServiceHandle( *service );
3197     RtlFreeHeap( GetProcessHeap(), 0, service_config );
3198     return STATUS_UNSUCCESSFUL;
3199 }
3200
3201 /* find the LDR_MODULE corresponding to the driver module */
3202 static LDR_MODULE *find_ldr_module( HMODULE module )
3203 {
3204     LDR_MODULE *ldr;
3205     ULONG_PTR magic;
3206
3207     LdrLockLoaderLock( 0, NULL, &magic );
3208     if (LdrFindEntryForAddress( module, &ldr ))
3209     {
3210         WARN( "module not found for %p\n", module );
3211         ldr = NULL;
3212     }
3213     LdrUnlockLoaderLock( 0, magic );
3214
3215     return ldr;
3216 }
3217
3218 /* load the driver module file */
3219 static HMODULE load_driver_module( const WCHAR *name )
3220 {
3221     IMAGE_NT_HEADERS *nt;
3222     const IMAGE_IMPORT_DESCRIPTOR *imports;
3223     SYSTEM_BASIC_INFORMATION info;
3224     int i;
3225     INT_PTR delta;
3226     ULONG size;
3227     HMODULE module = LoadLibraryW( name );
3228
3229     if (!module) return NULL;
3230     nt = RtlImageNtHeader( module );
3231
3232     if (!(delta = (char *)module - (char *)nt->OptionalHeader.ImageBase)) return module;
3233
3234     /* the loader does not apply relocations to non page-aligned binaries or executables,
3235      * we have to do it ourselves */
3236
3237     NtQuerySystemInformation( SystemBasicInformation, &info, sizeof(info), NULL );
3238     if (nt->OptionalHeader.SectionAlignment < info.PageSize ||
3239         !(nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
3240     {
3241         DWORD old;
3242         IMAGE_BASE_RELOCATION *rel, *end;
3243
3244         if ((rel = RtlImageDirectoryEntryToData( module, TRUE, IMAGE_DIRECTORY_ENTRY_BASERELOC, &size )))
3245         {
3246             TRACE( "%s: relocating from %p to %p\n", wine_dbgstr_w(name), (char *)module - delta, module );
3247             end = (IMAGE_BASE_RELOCATION *)((char *)rel + size);
3248             while (rel < end && rel->SizeOfBlock)
3249             {
3250                 void *page = (char *)module + rel->VirtualAddress;
3251                 VirtualProtect( page, info.PageSize, PAGE_EXECUTE_READWRITE, &old );
3252                 rel = LdrProcessRelocationBlock( page, (rel->SizeOfBlock - sizeof(*rel)) / sizeof(USHORT),
3253                                                  (USHORT *)(rel + 1), delta );
3254                 if (old != PAGE_EXECUTE_READWRITE) VirtualProtect( page, info.PageSize, old, &old );
3255                 if (!rel) goto error;
3256             }
3257             /* make sure we don't try again */
3258             size = FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) + nt->FileHeader.SizeOfOptionalHeader;
3259             VirtualProtect( nt, size, PAGE_READWRITE, &old );
3260             nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = 0;
3261             VirtualProtect( nt, size, old, &old );
3262         }
3263     }
3264
3265     /* make sure imports are relocated too */
3266
3267     if ((imports = RtlImageDirectoryEntryToData( module, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &size )))
3268     {
3269         for (i = 0; imports[i].Name && imports[i].FirstThunk; i++)
3270         {
3271             char *name = (char *)module + imports[i].Name;
3272             WCHAR buffer[32], *p = buffer;
3273
3274             while (p < buffer + 32) if (!(*p++ = *name++)) break;
3275             if (p <= buffer + 32) FreeLibrary( load_driver_module( buffer ) );
3276         }
3277     }
3278
3279     return module;
3280
3281 error:
3282     FreeLibrary( module );
3283     return NULL;
3284 }
3285
3286 /* load the .sys module for a device driver */
3287 static HMODULE load_driver( const WCHAR *driver_name, const UNICODE_STRING *keyname )
3288 {
3289     static const WCHAR driversW[] = {'\\','d','r','i','v','e','r','s','\\',0};
3290     static const WCHAR systemrootW[] = {'\\','S','y','s','t','e','m','R','o','o','t','\\',0};
3291     static const WCHAR postfixW[] = {'.','s','y','s',0};
3292     static const WCHAR ntprefixW[] = {'\\','?','?','\\',0};
3293     static const WCHAR ImagePathW[] = {'I','m','a','g','e','P','a','t','h',0};
3294     HKEY driver_hkey;
3295     HMODULE module;
3296     LPWSTR path = NULL, str;
3297     DWORD type, size;
3298
3299     if (RegOpenKeyW( HKEY_LOCAL_MACHINE, keyname->Buffer + 18 /* skip \registry\machine */, &driver_hkey ))
3300     {
3301         ERR( "cannot open key %s, err=%u\n", wine_dbgstr_w(keyname->Buffer), GetLastError() );
3302         return NULL;
3303     }
3304
3305     /* read the executable path from memory */
3306     size = 0;
3307     if (!RegQueryValueExW( driver_hkey, ImagePathW, NULL, &type, NULL, &size ))
3308     {
3309         str = HeapAlloc( GetProcessHeap(), 0, size );
3310         if (!RegQueryValueExW( driver_hkey, ImagePathW, NULL, &type, (LPBYTE)str, &size ))
3311         {
3312             size = ExpandEnvironmentStringsW(str,NULL,0);
3313             path = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR));
3314             ExpandEnvironmentStringsW(str,path,size);
3315         }
3316         HeapFree( GetProcessHeap(), 0, str );
3317         if (!path)
3318         {
3319             RegCloseKey( driver_hkey );
3320             return NULL;
3321         }
3322
3323         if (!strncmpiW( path, systemrootW, 12 ))
3324         {
3325             WCHAR buffer[MAX_PATH];
3326
3327             GetWindowsDirectoryW(buffer, MAX_PATH);
3328
3329             str = HeapAlloc(GetProcessHeap(), 0, (size -11 + strlenW(buffer))
3330                                                         * sizeof(WCHAR));
3331             lstrcpyW(str, buffer);
3332             lstrcatW(str, path + 11);
3333             HeapFree( GetProcessHeap(), 0, path );
3334             path = str;
3335         }
3336         else if (!strncmpW( path, ntprefixW, 4 ))
3337             str = path + 4;
3338         else
3339             str = path;
3340     }
3341     else
3342     {
3343         /* default is to use the driver name + ".sys" */
3344         WCHAR buffer[MAX_PATH];
3345         GetSystemDirectoryW(buffer, MAX_PATH);
3346         path = HeapAlloc(GetProcessHeap(),0,
3347           (strlenW(buffer) + strlenW(driversW) + strlenW(driver_name) + strlenW(postfixW) + 1)
3348           *sizeof(WCHAR));
3349         lstrcpyW(path, buffer);
3350         lstrcatW(path, driversW);
3351         lstrcatW(path, driver_name);
3352         lstrcatW(path, postfixW);
3353         str = path;
3354     }
3355     RegCloseKey( driver_hkey );
3356
3357     TRACE( "loading driver %s\n", wine_dbgstr_w(str) );
3358
3359     module = load_driver_module( str );
3360     HeapFree( GetProcessHeap(), 0, path );
3361     return module;
3362 }
3363
3364 /* call the driver init entry point */
3365 static NTSTATUS WINAPI init_driver( DRIVER_OBJECT *driver_object, UNICODE_STRING *keyname )
3366 {
3367     unsigned int i;
3368     NTSTATUS status;
3369     const IMAGE_NT_HEADERS *nt;
3370     const WCHAR *driver_name;
3371     HMODULE module;
3372
3373     /* Retrieve driver name from the keyname */
3374     driver_name = strrchrW( keyname->Buffer, '\\' );
3375     driver_name++;
3376
3377     module = load_driver( driver_name, keyname );
3378     if (!module)
3379         return STATUS_DLL_INIT_FAILED;
3380
3381     driver_object->DriverSection = find_ldr_module( module );
3382
3383     nt = RtlImageNtHeader( module );
3384     if (!nt->OptionalHeader.AddressOfEntryPoint) return STATUS_SUCCESS;
3385     driver_object->DriverInit = (PDRIVER_INITIALIZE)((char *)module + nt->OptionalHeader.AddressOfEntryPoint);
3386
3387     TRACE_(relay)( "\1Call driver init %p (obj=%p,str=%s)\n",
3388                    driver_object->DriverInit, driver_object, wine_dbgstr_w(keyname->Buffer) );
3389
3390     status = driver_object->DriverInit( driver_object, keyname );
3391
3392     TRACE_(relay)( "\1Ret  driver init %p (obj=%p,str=%s) retval=%08x\n",
3393                    driver_object->DriverInit, driver_object, wine_dbgstr_w(keyname->Buffer), status );
3394
3395     TRACE( "init done for %s obj %p\n", wine_dbgstr_w(driver_name), driver_object );
3396     TRACE( "- DriverInit = %p\n", driver_object->DriverInit );
3397     TRACE( "- DriverStartIo = %p\n", driver_object->DriverStartIo );
3398     TRACE( "- DriverUnload = %p\n", driver_object->DriverUnload );
3399     for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
3400         TRACE( "- MajorFunction[%d] = %p\n", i, driver_object->MajorFunction[i] );
3401
3402     return status;
3403 }
3404
3405 static BOOLEAN get_drv_name( UNICODE_STRING *drv_name, const UNICODE_STRING *service_name )
3406 {
3407     static const WCHAR driverW[] = {'\\','D','r','i','v','e','r','\\',0};
3408     WCHAR *str;
3409
3410     if (!(str = heap_alloc( sizeof(driverW) + service_name->Length - strlenW(servicesW)*sizeof(WCHAR) )))
3411         return FALSE;
3412
3413     lstrcpyW( str, driverW );
3414     lstrcpynW( str + strlenW(driverW), service_name->Buffer + strlenW(servicesW),
3415             service_name->Length/sizeof(WCHAR) - strlenW(servicesW) + 1 );
3416     RtlInitUnicodeString( drv_name, str );
3417     return TRUE;
3418 }
3419
3420 /***********************************************************************
3421  *           ZwLoadDriver (NTOSKRNL.EXE.@)
3422  */
3423 NTSTATUS WINAPI ZwLoadDriver( const UNICODE_STRING *service_name )
3424 {
3425     SERVICE_STATUS_HANDLE service_handle;
3426     struct wine_rb_entry *entry;
3427     struct wine_driver *driver;
3428     UNICODE_STRING drv_name;
3429     NTSTATUS status;
3430
3431     TRACE( "(%s)\n", debugstr_us(service_name) );
3432
3433     if ((status = open_driver( service_name, (SC_HANDLE *)&service_handle )) != STATUS_SUCCESS)
3434         return status;
3435
3436     if (!get_drv_name( &drv_name, service_name ))
3437     {
3438         CloseServiceHandle( (void *)service_handle );
3439         return STATUS_NO_MEMORY;
3440     }
3441
3442     if (wine_rb_get( &wine_drivers, &drv_name ))
3443     {
3444         TRACE( "driver %s already loaded\n", debugstr_us(&drv_name) );
3445         RtlFreeUnicodeString( &drv_name );
3446         CloseServiceHandle( (void *)service_handle );
3447         return STATUS_IMAGE_ALREADY_LOADED;
3448     }
3449
3450     set_service_status( service_handle, SERVICE_START_PENDING, 0 );
3451
3452     status = IoCreateDriver( &drv_name, init_driver );
3453     entry = wine_rb_get( &wine_drivers, &drv_name );
3454     RtlFreeUnicodeString( &drv_name );
3455     if (status != STATUS_SUCCESS)
3456     {
3457         ERR( "failed to create driver %s: %08x\n", debugstr_us(service_name), status );
3458         goto error;
3459     }
3460
3461     driver = WINE_RB_ENTRY_VALUE( entry, struct wine_driver, entry );
3462     driver->service_handle = service_handle;
3463
3464     set_service_status( service_handle, SERVICE_RUNNING,
3465                         SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN );
3466     return STATUS_SUCCESS;
3467
3468 error:
3469     set_service_status( service_handle, SERVICE_STOPPED, 0 );
3470     CloseServiceHandle( (void *)service_handle );
3471     return status;
3472 }
3473
3474 /***********************************************************************
3475  *           ZwUnloadDriver (NTOSKRNL.EXE.@)
3476  */
3477 NTSTATUS WINAPI ZwUnloadDriver( const UNICODE_STRING *service_name )
3478 {
3479     struct wine_rb_entry *entry;
3480     UNICODE_STRING drv_name;
3481
3482     TRACE( "(%s)\n", debugstr_us(service_name) );
3483
3484     if (!get_drv_name( &drv_name, service_name ))
3485         return STATUS_NO_MEMORY;
3486
3487     entry = wine_rb_get( &wine_drivers, &drv_name );
3488     RtlFreeUnicodeString( &drv_name );
3489     if (!entry)
3490     {
3491         ERR( "failed to locate driver %s\n", debugstr_us(service_name) );
3492         return STATUS_OBJECT_NAME_NOT_FOUND;
3493     }
3494
3495     unload_driver( entry, NULL );
3496
3497     return STATUS_SUCCESS;
3498 }
3499
3500
3501 static NTSTATUS WINAPI internal_complete( DEVICE_OBJECT *device, IRP *irp, void *context )
3502 {
3503     HANDLE event = context;
3504     SetEvent( event );
3505     return STATUS_MORE_PROCESSING_REQUIRED;
3506 }
3507
3508
3509 static NTSTATUS send_device_irp( DEVICE_OBJECT *device, IRP *irp, ULONG_PTR *info )
3510 {
3511     NTSTATUS status;
3512     HANDLE event = CreateEventA( NULL, FALSE, FALSE, NULL );
3513     DEVICE_OBJECT *toplevel_device;
3514
3515     irp->IoStatus.u.Status = STATUS_NOT_SUPPORTED;
3516     IoSetCompletionRoutine( irp, internal_complete, event, TRUE, TRUE, TRUE );
3517
3518     toplevel_device = IoGetAttachedDeviceReference( device );
3519     status = IoCallDriver( toplevel_device, irp );
3520
3521     if (status == STATUS_PENDING)
3522         WaitForSingleObject( event, INFINITE );
3523
3524     status = irp->IoStatus.u.Status;
3525     if (info)
3526         *info = irp->IoStatus.Information;
3527     IoCompleteRequest( irp, IO_NO_INCREMENT );
3528     ObDereferenceObject( toplevel_device );
3529     CloseHandle( event );
3530     return status;
3531 }
3532
3533
3534 static NTSTATUS get_device_id( DEVICE_OBJECT *device, BUS_QUERY_ID_TYPE type, WCHAR **id )
3535 {
3536     IO_STACK_LOCATION *irpsp;
3537     IO_STATUS_BLOCK irp_status;
3538     IRP *irp;
3539
3540     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_PNP, device, NULL, 0, NULL, NULL, &irp_status )))
3541         return STATUS_NO_MEMORY;
3542
3543     irpsp = IoGetNextIrpStackLocation( irp );
3544     irpsp->MinorFunction = IRP_MN_QUERY_ID;
3545     irpsp->Parameters.QueryId.IdType = type;
3546
3547     return send_device_irp( device, irp, (ULONG_PTR *)id );
3548 }
3549
3550
3551 static BOOL get_driver_for_id( const WCHAR *id, WCHAR *driver )
3552 {
3553     static const WCHAR serviceW[] = {'S','e','r','v','i','c','e',0};
3554     static const UNICODE_STRING service_str = { sizeof(serviceW) - sizeof(WCHAR), sizeof(serviceW), (WCHAR *)serviceW };
3555     static const WCHAR critical_fmtW[] =
3556         {'\\','R','e','g','i','s','t','r','y',
3557          '\\','M','a','c','h','i','n','e',
3558          '\\','S','y','s','t','e','m',
3559          '\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
3560          '\\','C','o','n','t','r','o','l',
3561          '\\','C','r','i','t','i','c','a','l','D','e','v','i','c','e','D','a','t','a','b','a','s','e',
3562          '\\','%','s',0};
3563     WCHAR buffer[FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data[MAX_SERVICE_NAME * sizeof(WCHAR)] )];
3564     KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
3565     OBJECT_ATTRIBUTES attr;
3566     UNICODE_STRING key;
3567     NTSTATUS status;
3568     HANDLE hkey;
3569     WCHAR *keyW;
3570     DWORD len;
3571
3572     if (!(keyW = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(critical_fmtW) + strlenW(id) * sizeof(WCHAR) )))
3573         return STATUS_NO_MEMORY;
3574
3575     sprintfW( keyW, critical_fmtW, id );
3576     RtlInitUnicodeString( &key, keyW );
3577     InitializeObjectAttributes( &attr, &key, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL );
3578
3579     status = NtOpenKey( &hkey, KEY_ALL_ACCESS, &attr );
3580     RtlFreeUnicodeString( &key );
3581     if (status != STATUS_SUCCESS)
3582     {
3583         TRACE_(plugplay)( "no driver found for %s\n", debugstr_w(id) );
3584         return FALSE;
3585     }
3586
3587     status = NtQueryValueKey( hkey, &service_str, KeyValuePartialInformation,
3588                               info, sizeof(buffer) - sizeof(WCHAR), &len );
3589     NtClose( hkey );
3590     if (status != STATUS_SUCCESS || info->Type != REG_SZ)
3591     {
3592         TRACE_(plugplay)( "no driver found for %s\n", debugstr_w(id) );
3593         return FALSE;
3594     }
3595
3596     memcpy( driver, info->Data, info->DataLength );
3597     driver[ info->DataLength / sizeof(WCHAR) ] = 0;
3598     TRACE_(plugplay)( "found driver %s for %s\n", debugstr_w(driver), debugstr_w(id) );
3599     return TRUE;
3600 }
3601
3602
3603 static NTSTATUS send_pnp_irp( DEVICE_OBJECT *device, UCHAR minor )
3604 {
3605     IO_STACK_LOCATION *irpsp;
3606     IO_STATUS_BLOCK irp_status;
3607     IRP *irp;
3608
3609     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_PNP, device, NULL, 0, NULL, NULL, &irp_status )))
3610         return STATUS_NO_MEMORY;
3611
3612     irpsp = IoGetNextIrpStackLocation( irp );
3613     irpsp->MinorFunction = minor;
3614
3615     irpsp->Parameters.StartDevice.AllocatedResources = NULL;
3616     irpsp->Parameters.StartDevice.AllocatedResourcesTranslated = NULL;
3617
3618     return send_device_irp( device, irp, NULL );
3619 }
3620
3621
3622 static NTSTATUS send_power_irp( DEVICE_OBJECT *device, DEVICE_POWER_STATE power )
3623 {
3624     IO_STATUS_BLOCK irp_status;
3625     IO_STACK_LOCATION *irpsp;
3626     IRP *irp;
3627
3628     if (!(irp = IoBuildSynchronousFsdRequest( IRP_MJ_POWER, device, NULL, 0, NULL, NULL, &irp_status )))
3629         return STATUS_NO_MEMORY;
3630
3631     irpsp = IoGetNextIrpStackLocation( irp );
3632     irpsp->MinorFunction = IRP_MN_SET_POWER;
3633
3634     irpsp->Parameters.Power.Type = DevicePowerState;
3635     irpsp->Parameters.Power.State.DeviceState = power;
3636
3637     return send_device_irp( device, irp, NULL );
3638 }
3639
3640
3641 static void handle_bus_relations( DEVICE_OBJECT *device )
3642 {
3643     static const WCHAR driverW[] = {'\\','D','r','i','v','e','r','\\',0};
3644     WCHAR buffer[MAX_SERVICE_NAME + ARRAY_SIZE(servicesW)];
3645     WCHAR driver[MAX_SERVICE_NAME] = {0};
3646     DRIVER_OBJECT *driver_obj;
3647     UNICODE_STRING string;
3648     WCHAR *ids, *ptr;
3649     NTSTATUS status;
3650
3651     TRACE_(plugplay)( "(%p)\n", device );
3652
3653     /* We could (should?) do a full IRP_MN_QUERY_DEVICE_RELATIONS query,
3654      * but we don't have to, we have the DEVICE_OBJECT of the new device
3655      * so we can simply handle the process here */
3656
3657     status = get_device_id( device, BusQueryCompatibleIDs, &ids );
3658     if (status != STATUS_SUCCESS || !ids)
3659     {
3660         ERR_(plugplay)( "Failed to get device IDs\n" );
3661         return;
3662     }
3663
3664     for (ptr = ids; *ptr; ptr += strlenW(ptr) + 1)
3665     {
3666         if (get_driver_for_id( ptr, driver ))
3667             break;
3668     }
3669     RtlFreeHeap( GetProcessHeap(), 0, ids );
3670
3671     if (!driver[0])
3672     {
3673         ERR_(plugplay)( "No matching driver found for device\n" );
3674         return;
3675     }
3676
3677     strcpyW( buffer, servicesW );
3678     strcatW( buffer, driver );
3679     RtlInitUnicodeString( &string, buffer );
3680     status = ZwLoadDriver( &string );
3681     if (status != STATUS_SUCCESS && status != STATUS_IMAGE_ALREADY_LOADED)
3682     {
3683         ERR_(plugplay)( "Failed to load driver %s\n", debugstr_w(driver) );
3684         return;
3685     }
3686
3687     strcpyW( buffer, driverW );
3688     strcatW( buffer, driver );
3689     RtlInitUnicodeString( &string, buffer );
3690     if (ObReferenceObjectByName( &string, OBJ_CASE_INSENSITIVE, NULL,
3691                                  0, NULL, KernelMode, NULL, (void **)&driver_obj ) != STATUS_SUCCESS)
3692     {
3693         ERR_(plugplay)( "Failed to locate loaded driver %s\n", debugstr_w(driver) );
3694         return;
3695     }
3696
3697     if (driver_obj->DriverExtension->AddDevice)
3698         status = driver_obj->DriverExtension->AddDevice( driver_obj, device );
3699     else
3700         status = STATUS_NOT_IMPLEMENTED;
3701
3702     ObDereferenceObject( driver_obj );
3703
3704     if (status != STATUS_SUCCESS)
3705     {
3706         ERR_(plugplay)( "AddDevice failed for driver %s\n", debugstr_w(driver) );
3707         return;
3708     }
3709
3710     send_pnp_irp( device, IRP_MN_START_DEVICE );
3711     send_power_irp( device, PowerDeviceD0 );
3712 }
3713
3714
3715 static void handle_removal_relations( DEVICE_OBJECT *device )
3716 {
3717     TRACE_(plugplay)( "(%p)\n", device );
3718
3719     send_power_irp( device, PowerDeviceD3 );
3720     send_pnp_irp( device, IRP_MN_SURPRISE_REMOVAL );
3721     send_pnp_irp( device, IRP_MN_REMOVE_DEVICE );
3722 }
3723
3724
3725 /***********************************************************************
3726  *           IoInvalidateDeviceRelations (NTOSKRNL.EXE.@)
3727  */
3728 void WINAPI IoInvalidateDeviceRelations( DEVICE_OBJECT *device_object, DEVICE_RELATION_TYPE type )
3729 {
3730     TRACE( "(%p, %i)\n", device_object, type );
3731
3732     switch (type)
3733     {
3734         case BusRelations:
3735             handle_bus_relations( device_object );
3736             break;
3737         case RemovalRelations:
3738             handle_removal_relations( device_object );
3739             break;
3740         default:
3741             FIXME( "unhandled relation %i\n", type );
3742             break;
3743     }
3744 }
3745
3746 /***********************************************************************
3747  *           IoCreateFile (NTOSKRNL.EXE.@)
3748  */
3749 NTSTATUS WINAPI IoCreateFile(HANDLE *handle, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr,
3750                               IO_STATUS_BLOCK *io, LARGE_INTEGER *alloc_size, ULONG attributes, ULONG sharing,
3751                               ULONG disposition, ULONG create_options, VOID *ea_buffer, ULONG ea_length,
3752                               CREATE_FILE_TYPE file_type, VOID *parameters, ULONG options )
3753 {
3754     FIXME(": stub\n");
3755     return STATUS_NOT_IMPLEMENTED;
3756 }
3757
3758 /***********************************************************************
3759  *           IoCreateNotificationEvent (NTOSKRNL.EXE.@)
3760  */
3761 PKEVENT WINAPI IoCreateNotificationEvent(UNICODE_STRING *name, HANDLE *handle)
3762 {
3763     FIXME( "stub: %s %p\n", debugstr_us(name), handle );
3764     return NULL;
3765 }
3766
3767
3768 /*********************************************************************
3769  *                  memcpy   (NTOSKRNL.@)
3770  *
3771  * NOTES
3772  *  Behaves like memmove.
3773  */
3774 void * __cdecl NTOSKRNL_memcpy( void *dst, const void *src, size_t n )
3775 {
3776     return memmove( dst, src, n );
3777 }
3778
3779 /*********************************************************************
3780  *                  memset   (NTOSKRNL.@)
3781  */
3782 void * __cdecl NTOSKRNL_memset( void *dst, int c, size_t n )
3783 {
3784     return memset( dst, c, n );
3785 }
3786
3787 /*********************************************************************
3788  *                  _stricmp   (NTOSKRNL.@)
3789  */
3790 int __cdecl NTOSKRNL__stricmp( LPCSTR str1, LPCSTR str2 )
3791 {
3792     return strcasecmp( str1, str2 );
3793 }
3794
3795 /*********************************************************************
3796  *                  _strnicmp   (NTOSKRNL.@)
3797  */
3798 int __cdecl NTOSKRNL__strnicmp( LPCSTR str1, LPCSTR str2, size_t n )
3799 {
3800     return strncasecmp( str1, str2, n );
3801 }
3802
3803 /*********************************************************************
3804  *           _wcsnicmp    (NTOSKRNL.@)
3805  */
3806 INT __cdecl NTOSKRNL__wcsnicmp( LPCWSTR str1, LPCWSTR str2, INT n )
3807 {
3808     return strncmpiW( str1, str2, n );
3809 }
3810
3811 /*********************************************************************
3812  *           wcsncmp    (NTOSKRNL.@)
3813  */
3814 INT __cdecl NTOSKRNL_wcsncmp( LPCWSTR str1, LPCWSTR str2, INT n )
3815 {
3816     return strncmpW( str1, str2, n );
3817 }
3818
3819
3820 #ifdef __x86_64__
3821 /**************************************************************************
3822  *              __chkstk (NTOSKRNL.@)
3823  *
3824  * Supposed to touch all the stack pages, but we shouldn't need that.
3825  */
3826 __ASM_GLOBAL_FUNC( __chkstk, "ret" );
3827
3828 #elif defined(__i386__)
3829 /**************************************************************************
3830  *           _chkstk   (NTOSKRNL.@)
3831  */
3832 __ASM_STDCALL_FUNC( _chkstk, 0,
3833                    "negl %eax\n\t"
3834                    "addl %esp,%eax\n\t"
3835                    "xchgl %esp,%eax\n\t"
3836                    "movl 0(%eax),%eax\n\t"  /* copy return address from old location */
3837                    "movl %eax,0(%esp)\n\t"
3838                    "ret" )
3839 #elif defined(__arm__)
3840 /**************************************************************************
3841  *              __chkstk (NTDLL.@)
3842  *
3843  * Incoming r4 contains words to allocate, converting to bytes then return
3844  */
3845 __ASM_GLOBAL_FUNC( __chkstk, "lsl r4, r4, #2\n\t"
3846                              "bx lr" )
3847 #endif
3848
3849 /*********************************************************************
3850  *           PsAcquireProcessExitSynchronization    (NTOSKRNL.@)
3851 */
3852 NTSTATUS WINAPI PsAcquireProcessExitSynchronization(PEPROCESS process)
3853 {
3854     FIXME("stub: %p\n", process);
3855
3856     return STATUS_NOT_IMPLEMENTED;
3857 }
3858
3859 /*********************************************************************
3860  *           PsReleaseProcessExitSynchronization    (NTOSKRNL.@)
3861  */
3862 void WINAPI PsReleaseProcessExitSynchronization(PEPROCESS process)
3863 {
3864     FIXME("stub: %p\n", process);
3865 }
3866
3867 typedef struct _EX_PUSH_LOCK_WAIT_BLOCK *PEX_PUSH_LOCK_WAIT_BLOCK;
3868 /*********************************************************************
3869  *           ExfUnblockPushLock    (NTOSKRNL.@)
3870  */
3871 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
3872 DEFINE_FASTCALL2_ENTRYPOINT( ExfUnblockPushLock )
3873 void WINAPI DECLSPEC_HIDDEN __regs_ExfUnblockPushLock( EX_PUSH_LOCK *lock,
3874                                                        PEX_PUSH_LOCK_WAIT_BLOCK block)
3875 #else
3876 void WINAPI ExfUnblockPushLock( EX_PUSH_LOCK *lock, PEX_PUSH_LOCK_WAIT_BLOCK block )
3877 #endif
3878 {
3879     FIXME( "stub: %p, %p\n", lock, block );
3880 }
3881
3882 /*********************************************************************
3883  *           PsGetProcessId    (NTOSKRNL.@)
3884  */
3885 HANDLE WINAPI PsGetProcessId(PEPROCESS process)
3886 {
3887     FIXME("stub: %p\n", process);
3888
3889     return 0;
3890 }
3891
3892 /*********************************************************************
3893  *           FsRtlRegisterFileSystemFilterCallbacks    (NTOSKRNL.@)
3894  */
3895 NTSTATUS WINAPI FsRtlRegisterFileSystemFilterCallbacks( DRIVER_OBJECT *object, PFS_FILTER_CALLBACKS callbacks)
3896 {
3897     FIXME("stub: %p %p\n", object, callbacks);
3898     return STATUS_NOT_IMPLEMENTED;
3899 }
3900
3901 /*********************************************************************
3902  *           SeSinglePrivilegeCheck    (NTOSKRNL.@)
3903  */
3904 BOOLEAN WINAPI SeSinglePrivilegeCheck(LUID privilege, KPROCESSOR_MODE mode)
3905 {
3906     FIXME("stub: %08x%08x %u\n", privilege.HighPart, privilege.LowPart, mode);
3907     return TRUE;
3908 }
3909
3910 /*********************************************************************
3911  *           KeFlushQueuedDpcs    (NTOSKRNL.@)
3912  */
3913 void WINAPI KeFlushQueuedDpcs(void)
3914 {
3915     FIXME("stub!\n");
3916 }
3917
3918 /*********************************************************************
3919  *           IoReleaseRemoveLockAndWaitEx    (NTOSKRNL.@)
3920  */
3921 void WINAPI IoReleaseRemoveLockAndWaitEx(PIO_REMOVE_LOCK lock, PVOID tag, ULONG size)
3922 {
3923     FIXME("stub: %p %p %u\n", lock, tag, size);
3924 }
3925
3926 /*********************************************************************
3927  *           DbgQueryDebugFilterState    (NTOSKRNL.@)
3928  */
3929 NTSTATUS WINAPI DbgQueryDebugFilterState(ULONG component, ULONG level)
3930 {
3931     FIXME("stub: %d %d\n", component, level);
3932     return STATUS_NOT_IMPLEMENTED;
3933 }
3934
3935 /*********************************************************************
3936  *           ExReleaseResourceLite    (NTOSKRNL.@)
3937  */
3938 void WINAPI ExReleaseResourceLite(PERESOURCE resource)
3939 {
3940     FIXME("stub: %p\n", resource);
3941 }
3942
3943 /*********************************************************************
3944  *           PsGetProcessWow64Process    (NTOSKRNL.@)
3945  */
3946 PVOID WINAPI PsGetProcessWow64Process(PEPROCESS process)
3947 {
3948     FIXME("stub: %p\n", process);
3949     return NULL;
3950 }
3951
3952 /*********************************************************************
3953  *           MmCopyVirtualMemory    (NTOSKRNL.@)
3954  */
3955 NTSTATUS WINAPI MmCopyVirtualMemory(PEPROCESS fromprocess, PVOID fromaddress, PEPROCESS toprocess,
3956                                     PVOID toaddress, SIZE_T bufsize, KPROCESSOR_MODE mode,
3957                                     PSIZE_T copied)
3958 {
3959     FIXME("stub: %p %p %p %p %lu %d %p\n", fromprocess, fromaddress, toprocess, toaddress, bufsize, mode, copied);
3960     return STATUS_NOT_IMPLEMENTED;
3961 }
3962
3963 /*********************************************************************
3964  *           KeEnterGuardedRegion    (NTOSKRNL.@)
3965  */
3966 void WINAPI KeEnterGuardedRegion(void)
3967 {
3968     FIXME("\n");
3969 }
3970
3971 /*********************************************************************
3972  *           KeLeaveGuardedRegion    (NTOSKRNL.@)
3973  */
3974 void WINAPI KeLeaveGuardedRegion(void)
3975 {
3976     FIXME("\n");
3977 }