dlls/ntoskrnl.exe/ntoskrnl.c

   1 /*
   2  * ntoskrnl.exe implementation
   3  *
   4  * Copyright (C) 2007 Alexandre Julliard
   5  * Copyright (C) 2010 Damjan Jovanovic
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <stdarg.h>
  26
  27 #define NONAMELESSUNION
  28 #define NONAMELESSSTRUCT
  29
  30 #include "ntstatus.h"
  31 #define WIN32_NO_STATUS
  32 #include "windef.h"
  33 #include "winternl.h"
  34 #include "excpt.h"
  35 #include "winioctl.h"
  36 #include "ddk/csq.h"
  37 #include "ddk/ntddk.h"
  38 #include "ddk/ntifs.h"
  39 #include "wine/unicode.h"
  40 #include "wine/server.h"
  41 #include "wine/list.h"
  42 #include "wine/debug.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl);
  45 WINE_DECLARE_DEBUG_CHANNEL(relay);
  46
  47 BOOLEAN KdDebuggerEnabled = FALSE;
  48 ULONG InitSafeBootMode = 0;
  49
  50 extern LONG CALLBACK vectored_handler( EXCEPTION_POINTERS *ptrs );
  51
  52 KSYSTEM_TIME KeTickCount = { 0, 0, 0 };
  53
  54 typedef struct _KSERVICE_TABLE_DESCRIPTOR
  55 {
  56     PULONG_PTR Base;
  57     PULONG Count;
  58     ULONG Limit;
  59     PUCHAR Number;
  60 } KSERVICE_TABLE_DESCRIPTOR, *PKSERVICE_TABLE_DESCRIPTOR;
  61
  62 KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable[4] = { { 0 } };
  63
  64 typedef void (WINAPI *PCREATE_PROCESS_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
  65 typedef void (WINAPI *PCREATE_THREAD_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
  66
  67 /* tid of the thread running client request */
  68 static DWORD request_thread;
  69
  70 /* pid/tid of the client thread */
  71 static DWORD client_tid;
  72 static DWORD client_pid;
  73
  74 #ifdef __i386__
  75 #define DEFINE_FASTCALL1_ENTRYPOINT( name ) \
  76     __ASM_STDCALL_FUNC( name, 4, \
  77                        "popl %eax\n\t" \
  78                        "pushl %ecx\n\t" \
  79                        "pushl %eax\n\t" \
  80                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(4))
  81 #define DEFINE_FASTCALL2_ENTRYPOINT( name ) \
  82     __ASM_STDCALL_FUNC( name, 8, \
  83                        "popl %eax\n\t" \
  84                        "pushl %edx\n\t" \
  85                        "pushl %ecx\n\t" \
  86                        "pushl %eax\n\t" \
  87                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(8))
  88 #define DEFINE_FASTCALL3_ENTRYPOINT( name ) \
  89     __ASM_STDCALL_FUNC( name, 12, \
  90                        "popl %eax\n\t" \
  91                        "pushl %edx\n\t" \
  92                        "pushl %ecx\n\t" \
  93                        "pushl %eax\n\t" \
  94                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(12))
  95 #endif
  96
  97 static inline LPCSTR debugstr_us( const UNICODE_STRING *us )
  98 {
  99     if (!us) return "<null>";
 100     return debugstr_wn( us->Buffer, us->Length / sizeof(WCHAR) );
 101 }
 102
 103 static HANDLE get_device_manager(void)
 104 {
 105     static HANDLE device_manager;
 106     HANDLE handle = 0, ret = device_manager;
 107
 108     if (!ret)
 109     {
 110         SERVER_START_REQ( create_device_manager )
 111         {
 112             req->access     = SYNCHRONIZE;
 113             req->attributes = 0;
 114             if (!wine_server_call( req )) handle = wine_server_ptr_handle( reply->handle );
 115         }
 116         SERVER_END_REQ;
 117
 118         if (!handle)
 119         {
 120             ERR( "failed to create the device manager\n" );
 121             return 0;
 122         }
 123         if (!(ret = InterlockedCompareExchangePointer( &device_manager, handle, 0 )))
 124             ret = handle;
 125         else
 126             NtClose( handle );  /* somebody beat us to it */
 127     }
 128     return ret;
 129 }
 130
 131 /* process an ioctl request for a given device */
 132 static NTSTATUS process_ioctl( DEVICE_OBJECT *device, ULONG code, void *in_buff,
 133                                ULONG in_size, ULONG out_size, HANDLE ioctl )
 134 {
 135     IRP *irp;
 136     void *out_buff = NULL;
 137     FILE_OBJECT file;
 138     LARGE_INTEGER count;
 139
 140     TRACE( "ioctl %x device %p in_size %u out_size %u\n", code, device, in_size, out_size );
 141
 142     /* so we can spot things that we should initialize */
 143     memset( &file, 0x88, sizeof(file) );
 144
 145     if ((code & 3) == METHOD_BUFFERED) out_size = max( in_size, out_size );
 146
 147     if (out_size)
 148     {
 149         if (!(out_buff = HeapAlloc( GetProcessHeap(), 0, out_size ))) return STATUS_NO_MEMORY;
 150         if ((code & 3) == METHOD_BUFFERED)
 151         {
 152             memcpy( out_buff, in_buff, in_size );
 153             in_buff = out_buff;
 154         }
 155     }
 156
 157     /* note: we abuse UserIosb to store the server handle to the ioctl */
 158     irp = IoBuildDeviceIoControlRequest( code, device, in_buff, in_size, out_buff, out_size,
 159                                          FALSE, NULL, (IO_STATUS_BLOCK *)ioctl );
 160     if (!irp)
 161     {
 162         HeapFree( GetProcessHeap(), 0, out_buff );
 163         return STATUS_NO_MEMORY;
 164     }
 165     irp->RequestorMode = UserMode;
 166     irp->Tail.Overlay.OriginalFileObject = &file;
 167
 168     file.FsContext = NULL;
 169     file.FsContext2 = NULL;
 170
 171     KeQueryTickCount( &count );  /* update the global KeTickCount */
 172
 173     device->CurrentIrp = irp;
 174
 175     IoCallDriver( device, irp );
 176
 177     device->CurrentIrp = NULL;
 178
 179     return STATUS_SUCCESS;
 180 }
 181
 182
 183 /***********************************************************************
 184  *           wine_ntoskrnl_main_loop   (Not a Windows API)
 185  */
 186 NTSTATUS CDECL wine_ntoskrnl_main_loop( HANDLE stop_event )
 187 {
 188     HANDLE manager = get_device_manager();
 189     HANDLE irp = 0;
 190     NTSTATUS status = STATUS_SUCCESS;
 191     ULONG type, code;
 192     void *in_buff;
 193     DEVICE_OBJECT *device = NULL;
 194     ULONG in_size = 4096, out_size = 0;
 195     HANDLE handles[2];
 196
 197     request_thread = GetCurrentThreadId();
 198
 199     if (!(in_buff = HeapAlloc( GetProcessHeap(), 0, in_size )))
 200     {
 201         ERR( "failed to allocate buffer\n" );
 202         return STATUS_NO_MEMORY;
 203     }
 204
 205     handles[0] = stop_event;
 206     handles[1] = manager;
 207
 208     for (;;)
 209     {
 210         SERVER_START_REQ( get_next_device_request )
 211         {
 212             req->manager = wine_server_obj_handle( manager );
 213             req->prev = wine_server_obj_handle( irp );
 214             req->status = status;
 215             wine_server_set_reply( req, in_buff, in_size );
 216             if (!(status = wine_server_call( req )))
 217             {
 218                 type       = reply->type;
 219                 code       = reply->code;
 220                 irp        = wine_server_ptr_handle( reply->next );
 221                 device     = wine_server_get_ptr( reply->user_ptr );
 222                 client_tid = reply->client_tid;
 223                 client_pid = reply->client_pid;
 224                 in_size    = reply->in_size;
 225                 out_size   = reply->out_size;
 226             }
 227             else
 228             {
 229                 irp = 0; /* no previous irp */
 230                 out_size = 0;
 231                 in_size = reply->in_size;
 232             }
 233         }
 234         SERVER_END_REQ;
 235
 236         switch(status)
 237         {
 238         case STATUS_SUCCESS:
 239             switch (type)
 240             {
 241             case IRP_MJ_DEVICE_CONTROL:
 242                 status = process_ioctl( device, code, in_buff, in_size, out_size, irp );
 243                 break;
 244             default:
 245                 FIXME( "unsupported request %u\n", type );
 246                 status = STATUS_NOT_SUPPORTED;
 247                 break;
 248             }
 249             if (status == STATUS_SUCCESS) irp = 0;  /* status reported by IoCompleteRequest */
 250             break;
 251         case STATUS_BUFFER_OVERFLOW:
 252             HeapFree( GetProcessHeap(), 0, in_buff );
 253             in_buff = HeapAlloc( GetProcessHeap(), 0, in_size );
 254             /* restart with larger buffer */
 255             break;
 256         case STATUS_PENDING:
 257             for (;;)
 258             {
 259                 DWORD ret = WaitForMultipleObjectsEx( 2, handles, FALSE, INFINITE, TRUE );
 260                 if (ret == WAIT_OBJECT_0)
 261                 {
 262                     HeapFree( GetProcessHeap(), 0, in_buff );
 263                     return STATUS_SUCCESS;
 264                 }
 265                 if (ret != WAIT_IO_COMPLETION) break;
 266             }
 267             break;
 268         }
 269     }
 270 }
 271
 272
 273 /***********************************************************************
 274  *           IoAcquireCancelSpinLock  (NTOSKRNL.EXE.@)
 275  */
 276 void WINAPI IoAcquireCancelSpinLock(PKIRQL irql)
 277 {
 278     FIXME("(%p): stub\n", irql);
 279 }
 280
 281
 282 /***********************************************************************
 283  *           IoReleaseCancelSpinLock  (NTOSKRNL.EXE.@)
 284  */
 285 void WINAPI IoReleaseCancelSpinLock(PKIRQL irql)
 286 {
 287     FIXME("(%p): stub\n", irql);
 288 }
 289
 290
 291 /***********************************************************************
 292  *           IoAllocateDriverObjectExtension  (NTOSKRNL.EXE.@)
 293  */
 294 NTSTATUS WINAPI IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject,
 295                                                  PVOID ClientIdentificationAddress,
 296                                                  ULONG DriverObjectExtensionSize,
 297                                                  PVOID *DriverObjectExtension )
 298 {
 299     FIXME( "stub: %p, %p, %u, %p\n", DriverObject, ClientIdentificationAddress,
 300             DriverObjectExtensionSize, DriverObjectExtension );
 301     return STATUS_NOT_IMPLEMENTED;
 302 }
 303
 304
 305 /***********************************************************************
 306  *           IoGetDriverObjectExtension  (NTOSKRNL.EXE.@)
 307  */
 308 PVOID WINAPI IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject,
 309                                          PVOID ClientIdentificationAddress )
 310 {
 311     FIXME( "stub: %p, %p\n", DriverObject, ClientIdentificationAddress );
 312     return NULL;
 313 }
 314
 315
 316 /***********************************************************************
 317  *           IoInitializeIrp  (NTOSKRNL.EXE.@)
 318  */
 319 void WINAPI IoInitializeIrp( IRP *irp, USHORT size, CCHAR stack_size )
 320 {
 321     TRACE( "%p, %u, %d\n", irp, size, stack_size );
 322
 323     RtlZeroMemory( irp, size );
 324
 325     irp->Type = IO_TYPE_IRP;
 326     irp->Size = size;
 327     InitializeListHead( &irp->ThreadListEntry );
 328     irp->StackCount = stack_size;
 329     irp->CurrentLocation = stack_size + 1;
 330     irp->Tail.Overlay.s.u2.CurrentStackLocation =
 331             (PIO_STACK_LOCATION)(irp + 1) + stack_size;
 332 }
 333
 334
 335 /***********************************************************************
 336  *           IoInitializeTimer   (NTOSKRNL.EXE.@)
 337  */
 338 NTSTATUS WINAPI IoInitializeTimer(PDEVICE_OBJECT DeviceObject,
 339                                   PIO_TIMER_ROUTINE TimerRoutine,
 340                                   PVOID Context)
 341 {
 342     FIXME( "stub: %p, %p, %p\n", DeviceObject, TimerRoutine, Context );
 343     return STATUS_NOT_IMPLEMENTED;
 344 }
 345
 346
 347 /***********************************************************************
 348  *           IoStartTimer   (NTOSKRNL.EXE.@)
 349  */
 350 void WINAPI IoStartTimer(PDEVICE_OBJECT DeviceObject)
 351 {
 352     FIXME( "stub: %p\n", DeviceObject );
 353 }
 354
 355
 356 /***********************************************************************
 357  *           IoAllocateIrp  (NTOSKRNL.EXE.@)
 358  */
 359 PIRP WINAPI IoAllocateIrp( CCHAR stack_size, BOOLEAN charge_quota )
 360 {
 361     SIZE_T size;
 362     PIRP irp;
 363
 364     TRACE( "%d, %d\n", stack_size, charge_quota );
 365
 366     size = sizeof(IRP) + stack_size * sizeof(IO_STACK_LOCATION);
 367     irp = ExAllocatePool( NonPagedPool, size );
 368     if (irp == NULL)
 369         return NULL;
 370     IoInitializeIrp( irp, size, stack_size );
 371     irp->AllocationFlags = IRP_ALLOCATED_FIXED_SIZE;
 372     if (charge_quota)
 373         irp->AllocationFlags |= IRP_LOOKASIDE_ALLOCATION;
 374     return irp;
 375 }
 376
 377
 378 /***********************************************************************
 379  *           IoFreeIrp  (NTOSKRNL.EXE.@)
 380  */
 381 void WINAPI IoFreeIrp( IRP *irp )
 382 {
 383     MDL *mdl;
 384
 385     TRACE( "%p\n", irp );
 386
 387     mdl = irp->MdlAddress;
 388     while (mdl)
 389     {
 390         MDL *next = mdl->Next;
 391         IoFreeMdl( mdl );
 392         mdl = next;
 393     }
 394
 395     ExFreePool( irp );
 396 }
 397
 398
 399 /***********************************************************************
 400  *           IoAllocateErrorLogEntry  (NTOSKRNL.EXE.@)
 401  */
 402 PVOID WINAPI IoAllocateErrorLogEntry( PVOID IoObject, UCHAR EntrySize )
 403 {
 404     FIXME( "stub: %p, %u\n", IoObject, EntrySize );
 405     return NULL;
 406 }
 407
 408
 409 /***********************************************************************
 410  *           IoAllocateMdl  (NTOSKRNL.EXE.@)
 411  */
 412 PMDL WINAPI IoAllocateMdl( PVOID va, ULONG length, BOOLEAN secondary, BOOLEAN charge_quota, IRP *irp )
 413 {
 414     PMDL mdl;
 415     ULONG_PTR address = (ULONG_PTR)va;
 416     ULONG_PTR page_address;
 417     SIZE_T nb_pages, mdl_size;
 418
 419     TRACE("(%p, %u, %i, %i, %p)\n", va, length, secondary, charge_quota, irp);
 420
 421     if (charge_quota)
 422         FIXME("Charge quota is not yet supported\n");
 423
 424     /* FIXME: We suppose that page size is 4096 */
 425     page_address = address & ~(4096 - 1);
 426     nb_pages = (((address + length - 1) & ~(4096 - 1)) - page_address) / 4096 + 1;
 427
 428     mdl_size = sizeof(MDL) + nb_pages * sizeof(PVOID);
 429
 430     mdl = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, mdl_size);
 431     if (!mdl)
 432         return NULL;
 433
 434     mdl->Size = mdl_size;
 435     mdl->Process = NULL; /* FIXME: IoGetCurrentProcess */
 436     mdl->StartVa = (PVOID)page_address;
 437     mdl->ByteCount = length;
 438     mdl->ByteOffset = address - page_address;
 439
 440     if (!irp) return mdl;
 441
 442     if (secondary)  /* add it at the end */
 443     {
 444         MDL **pmdl = &irp->MdlAddress;
 445         while (*pmdl) pmdl = &(*pmdl)->Next;
 446         *pmdl = mdl;
 447     }
 448     else
 449     {
 450         mdl->Next = irp->MdlAddress;
 451         irp->MdlAddress = mdl;
 452     }
 453     return mdl;
 454 }
 455
 456
 457 /***********************************************************************
 458  *           IoFreeMdl  (NTOSKRNL.EXE.@)
 459  */
 460 void WINAPI IoFreeMdl(PMDL mdl)
 461 {
 462     TRACE("%p\n", mdl);
 463     HeapFree(GetProcessHeap(), 0, mdl);
 464 }
 465
 466
 467 /***********************************************************************
 468  *           IoAllocateWorkItem  (NTOSKRNL.EXE.@)
 469  */
 470 PIO_WORKITEM WINAPI IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject )
 471 {
 472     FIXME( "stub: %p\n", DeviceObject );
 473     return NULL;
 474 }
 475
 476
 477 /***********************************************************************
 478  *           IoAttachDeviceToDeviceStack  (NTOSKRNL.EXE.@)
 479  */
 480 PDEVICE_OBJECT WINAPI IoAttachDeviceToDeviceStack( DEVICE_OBJECT *source,
 481                                                    DEVICE_OBJECT *target )
 482 {
 483     TRACE( "%p, %p\n", source, target );
 484     target->AttachedDevice = source;
 485     source->StackSize = target->StackSize + 1;
 486     return target;
 487 }
 488
 489
 490 /***********************************************************************
 491  *           IoBuildDeviceIoControlRequest  (NTOSKRNL.EXE.@)
 492  */
 493 PIRP WINAPI IoBuildDeviceIoControlRequest( ULONG code, PDEVICE_OBJECT device,
 494                                            PVOID in_buff, ULONG in_len,
 495                                            PVOID out_buff, ULONG out_len,
 496                                            BOOLEAN internal, PKEVENT event,
 497                                            PIO_STATUS_BLOCK iosb )
 498 {
 499     PIRP irp;
 500     PIO_STACK_LOCATION irpsp;
 501
 502     TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
 503            code, device, in_buff, in_len, out_buff, out_len, internal, event, iosb );
 504
 505     if (device == NULL)
 506         return NULL;
 507
 508     irp = IoAllocateIrp( device->StackSize, FALSE );
 509     if (irp == NULL)
 510         return NULL;
 511
 512     irpsp = IoGetNextIrpStackLocation( irp );
 513     irpsp->MajorFunction = internal ? IRP_MJ_INTERNAL_DEVICE_CONTROL : IRP_MJ_DEVICE_CONTROL;
 514     irpsp->Parameters.DeviceIoControl.IoControlCode = code;
 515     irpsp->Parameters.DeviceIoControl.InputBufferLength = in_len;
 516     irpsp->Parameters.DeviceIoControl.OutputBufferLength = out_len;
 517     irpsp->DeviceObject = device;
 518     irpsp->CompletionRoutine = NULL;
 519
 520     switch (code & 3)
 521     {
 522     case METHOD_BUFFERED:
 523         irp->AssociatedIrp.SystemBuffer = in_buff;
 524         break;
 525     case METHOD_IN_DIRECT:
 526     case METHOD_OUT_DIRECT:
 527         irp->AssociatedIrp.SystemBuffer = in_buff;
 528         IoAllocateMdl( out_buff, out_len, FALSE, FALSE, irp );
 529         break;
 530     case METHOD_NEITHER:
 531         irpsp->Parameters.DeviceIoControl.Type3InputBuffer = in_buff;
 532         break;
 533     }
 534
 535     irp->RequestorMode = KernelMode;
 536     irp->UserBuffer = out_buff;
 537     irp->UserIosb = iosb;
 538     irp->UserEvent = event;
 539     return irp;
 540 }
 541
 542
 543 /**********************************************************
 544  *           IoBuildSynchronousFsdRequest  (NTOSKRNL.EXE.@)
 545  */
 546 PIRP WINAPI IoBuildSynchronousFsdRequest(ULONG majorfunc, PDEVICE_OBJECT device,
 547                                          PVOID buffer, ULONG length, PLARGE_INTEGER startoffset,
 548                                          PKEVENT event, PIO_STATUS_BLOCK iosb)
 549 {
 550     PIRP irp;
 551     PIO_STACK_LOCATION irpsp;
 552
 553     FIXME("(%d %p %p %d %p %p %p) stub\n", majorfunc, device, buffer, length, startoffset, event, iosb);
 554
 555     irp = IoAllocateIrp( device->StackSize, FALSE );
 556     if (irp == NULL)
 557         return NULL;
 558
 559     irpsp = IoGetNextIrpStackLocation( irp );
 560     irpsp->MajorFunction = majorfunc;
 561     /*irpsp->Parameters.DeviceIoControl.IoControlCode = IoControlCode;*/
 562
 563     irp->UserIosb = iosb;
 564     irp->UserEvent = event;
 565     irp->UserBuffer = buffer;
 566     return irp;
 567 }
 568
 569
 570 /***********************************************************************
 571  *           IoCreateDriver   (NTOSKRNL.EXE.@)
 572  */
 573 NTSTATUS WINAPI IoCreateDriver( UNICODE_STRING *name, PDRIVER_INITIALIZE init )
 574 {
 575     DRIVER_OBJECT *driver;
 576     DRIVER_EXTENSION *extension;
 577     NTSTATUS status;
 578
 579     TRACE("(%s, %p)\n", debugstr_us(name), init);
 580
 581     if (!(driver = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
 582                                     sizeof(*driver) + sizeof(*extension) )))
 583         return STATUS_NO_MEMORY;
 584
 585     if ((status = RtlDuplicateUnicodeString( 1, name, &driver->DriverName )))
 586     {
 587         RtlFreeHeap( GetProcessHeap(), 0, driver );
 588         return status;
 589     }
 590
 591     extension = (DRIVER_EXTENSION *)(driver + 1);
 592     driver->Size            = sizeof(*driver);
 593     driver->DriverInit      = init;
 594     driver->DriverExtension = extension;
 595     extension->DriverObject   = driver;
 596     extension->ServiceKeyName = driver->DriverName;
 597
 598     status = driver->DriverInit( driver, name );
 599
 600     if (status)
 601     {
 602         RtlFreeUnicodeString( &driver->DriverName );
 603         RtlFreeHeap( GetProcessHeap(), 0, driver );
 604     }
 605     return status;
 606 }
 607
 608
 609 /***********************************************************************
 610  *           IoDeleteDriver   (NTOSKRNL.EXE.@)
 611  */
 612 void WINAPI IoDeleteDriver( DRIVER_OBJECT *driver )
 613 {
 614     TRACE("(%p)\n", driver);
 615
 616     RtlFreeUnicodeString( &driver->DriverName );
 617     RtlFreeHeap( GetProcessHeap(), 0, driver );
 618 }
 619
 620
 621 /***********************************************************************
 622  *           IoCreateDevice   (NTOSKRNL.EXE.@)
 623  */
 624 NTSTATUS WINAPI IoCreateDevice( DRIVER_OBJECT *driver, ULONG ext_size,
 625                                 UNICODE_STRING *name, DEVICE_TYPE type,
 626                                 ULONG characteristics, BOOLEAN exclusive,
 627                                 DEVICE_OBJECT **ret_device )
 628 {
 629     NTSTATUS status;
 630     DEVICE_OBJECT *device;
 631     HANDLE handle = 0;
 632     HANDLE manager = get_device_manager();
 633
 634     TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
 635            driver, ext_size, debugstr_us(name), type, characteristics, exclusive, ret_device );
 636
 637     if (!(device = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*device) + ext_size )))
 638         return STATUS_NO_MEMORY;
 639
 640     SERVER_START_REQ( create_device )
 641     {
 642         req->access     = 0;
 643         req->attributes = 0;
 644         req->rootdir    = 0;
 645         req->manager    = wine_server_obj_handle( manager );
 646         req->user_ptr   = wine_server_client_ptr( device );
 647         if (name) wine_server_add_data( req, name->Buffer, name->Length );
 648         if (!(status = wine_server_call( req ))) handle = wine_server_ptr_handle( reply->handle );
 649     }
 650     SERVER_END_REQ;
 651
 652     if (status == STATUS_SUCCESS)
 653     {
 654         device->DriverObject    = driver;
 655         device->DeviceExtension = device + 1;
 656         device->DeviceType      = type;
 657         device->StackSize       = 1;
 658         device->Reserved        = handle;
 659
 660         device->NextDevice   = driver->DeviceObject;
 661         driver->DeviceObject = device;
 662
 663         *ret_device = device;
 664     }
 665     else HeapFree( GetProcessHeap(), 0, device );
 666
 667     return status;
 668 }
 669
 670
 671 /***********************************************************************
 672  *           IoDeleteDevice   (NTOSKRNL.EXE.@)
 673  */
 674 void WINAPI IoDeleteDevice( DEVICE_OBJECT *device )
 675 {
 676     NTSTATUS status;
 677
 678     TRACE( "%p\n", device );
 679
 680     SERVER_START_REQ( delete_device )
 681     {
 682         req->handle = wine_server_obj_handle( device->Reserved );
 683         status = wine_server_call( req );
 684     }
 685     SERVER_END_REQ;
 686
 687     if (status == STATUS_SUCCESS)
 688     {
 689         DEVICE_OBJECT **prev = &device->DriverObject->DeviceObject;
 690         while (*prev && *prev != device) prev = &(*prev)->NextDevice;
 691         if (*prev) *prev = (*prev)->NextDevice;
 692         NtClose( device->Reserved );
 693         HeapFree( GetProcessHeap(), 0, device );
 694     }
 695 }
 696
 697
 698 /***********************************************************************
 699  *           IoCreateSymbolicLink   (NTOSKRNL.EXE.@)
 700  */
 701 NTSTATUS WINAPI IoCreateSymbolicLink( UNICODE_STRING *name, UNICODE_STRING *target )
 702 {
 703     HANDLE handle;
 704     OBJECT_ATTRIBUTES attr;
 705
 706     attr.Length                   = sizeof(attr);
 707     attr.RootDirectory            = 0;
 708     attr.ObjectName               = name;
 709     attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
 710     attr.SecurityDescriptor       = NULL;
 711     attr.SecurityQualityOfService = NULL;
 712
 713     TRACE( "%s -> %s\n", debugstr_us(name), debugstr_us(target) );
 714     /* FIXME: store handle somewhere */
 715     return NtCreateSymbolicLinkObject( &handle, SYMBOLIC_LINK_ALL_ACCESS, &attr, target );
 716 }
 717
 718
 719 /***********************************************************************
 720  *           IoDeleteSymbolicLink   (NTOSKRNL.EXE.@)
 721  */
 722 NTSTATUS WINAPI IoDeleteSymbolicLink( UNICODE_STRING *name )
 723 {
 724     HANDLE handle;
 725     OBJECT_ATTRIBUTES attr;
 726     NTSTATUS status;
 727
 728     attr.Length                   = sizeof(attr);
 729     attr.RootDirectory            = 0;
 730     attr.ObjectName               = name;
 731     attr.Attributes               = OBJ_CASE_INSENSITIVE;
 732     attr.SecurityDescriptor       = NULL;
 733     attr.SecurityQualityOfService = NULL;
 734
 735     if (!(status = NtOpenSymbolicLinkObject( &handle, 0, &attr )))
 736     {
 737         SERVER_START_REQ( unlink_object )
 738         {
 739             req->handle = wine_server_obj_handle( handle );
 740             status = wine_server_call( req );
 741         }
 742         SERVER_END_REQ;
 743         NtClose( handle );
 744     }
 745     return status;
 746 }
 747
 748
 749 /***********************************************************************
 750  *           IoGetDeviceInterfaces   (NTOSKRNL.EXE.@)
 751  */
 752 NTSTATUS WINAPI IoGetDeviceInterfaces( const GUID *InterfaceClassGuid,
 753                                        PDEVICE_OBJECT PhysicalDeviceObject,
 754                                        ULONG Flags, PWSTR *SymbolicLinkList )
 755 {
 756     FIXME( "stub: %s %p %x %p\n", debugstr_guid(InterfaceClassGuid),
 757            PhysicalDeviceObject, Flags, SymbolicLinkList );
 758     return STATUS_NOT_IMPLEMENTED;
 759 }
 760
 761
 762 /***********************************************************************
 763  *           IoGetDeviceObjectPointer   (NTOSKRNL.EXE.@)
 764  */
 765 NTSTATUS  WINAPI IoGetDeviceObjectPointer( UNICODE_STRING *name, ACCESS_MASK access, PFILE_OBJECT *file, PDEVICE_OBJECT *device )
 766 {
 767     FIXME( "stub: %s %x %p %p\n", debugstr_us(name), access, file, device );
 768
 769     *file  = NULL;
 770     *device  = NULL;
 771
 772     return STATUS_SUCCESS;
 773 }
 774
 775 /***********************************************************************
 776  *           IoGetAttachedDevice   (NTOSKRNL.EXE.@)
 777  */
 778 PDEVICE_OBJECT WINAPI IoGetAttachedDevice( PDEVICE_OBJECT device )
 779 {
 780     FIXME( "stub: %p\n", device );
 781
 782     return device;
 783 }
 784
 785 /***********************************************************************
 786  *           IoGetDeviceProperty   (NTOSKRNL.EXE.@)
 787  */
 788 NTSTATUS WINAPI IoGetDeviceProperty( DEVICE_OBJECT *device, DEVICE_REGISTRY_PROPERTY device_property,
 789                                      ULONG buffer_length, PVOID property_buffer, PULONG result_length )
 790 {
 791     FIXME( "%p %d %u %p %p: stub\n", device, device_property, buffer_length,
 792            property_buffer, result_length );
 793     return STATUS_NOT_IMPLEMENTED;
 794 }
 795
 796
 797 /***********************************************************************
 798  *           IoCallDriver   (NTOSKRNL.EXE.@)
 799  */
 800 NTSTATUS WINAPI IoCallDriver( DEVICE_OBJECT *device, IRP *irp )
 801 {
 802     PDRIVER_DISPATCH dispatch;
 803     IO_STACK_LOCATION *irpsp;
 804     NTSTATUS status;
 805
 806     --irp->CurrentLocation;
 807     irpsp = --irp->Tail.Overlay.s.u2.CurrentStackLocation;
 808     dispatch = device->DriverObject->MajorFunction[irpsp->MajorFunction];
 809
 810     if (TRACE_ON(relay))
 811         DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
 812                  GetCurrentThreadId(), dispatch, device, irp );
 813
 814     status = dispatch( device, irp );
 815
 816     if (TRACE_ON(relay))
 817         DPRINTF( "%04x:Ret  driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
 818                  GetCurrentThreadId(), dispatch, device, irp, status );
 819
 820     return status;
 821 }
 822
 823
 824 /***********************************************************************
 825  *           IofCallDriver   (NTOSKRNL.EXE.@)
 826  */
 827 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
 828 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver )
 829 NTSTATUS WINAPI __regs_IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
 830 #else
 831 NTSTATUS WINAPI IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
 832 #endif
 833 {
 834     TRACE( "%p %p\n", device, irp );
 835     return IoCallDriver( device, irp );
 836 }
 837
 838
 839 /***********************************************************************
 840  *           IoGetRelatedDeviceObject    (NTOSKRNL.EXE.@)
 841  */
 842 PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject( PFILE_OBJECT obj )
 843 {
 844     FIXME( "stub: %p\n", obj );
 845     return NULL;
 846 }
 847
 848 static CONFIGURATION_INFORMATION configuration_information;
 849
 850 /***********************************************************************
 851  *           IoGetConfigurationInformation    (NTOSKRNL.EXE.@)
 852  */
 853 PCONFIGURATION_INFORMATION WINAPI IoGetConfigurationInformation(void)
 854 {
 855     FIXME( "partial stub\n" );
 856     /* FIXME: return actual devices on system */
 857     return &configuration_information;
 858 }
 859
 860
 861 /***********************************************************************
 862  *           IoIsWdmVersionAvailable     (NTOSKRNL.EXE.@)
 863  */
 864 NTSTATUS WINAPI IoIsWdmVersionAvailable(UCHAR MajorVersion, UCHAR MinorVersion)
 865 {
 866     DWORD version;
 867     DWORD major;
 868     DWORD minor;
 869
 870     TRACE( "%d, 0x%X\n", MajorVersion, MinorVersion );
 871
 872     version = GetVersion();
 873     major = LOBYTE(version);
 874     minor = HIBYTE(LOWORD(version));
 875
 876     if (MajorVersion == 6 && MinorVersion == 0)
 877     {
 878         /* Windows Vista, Windows Server 2008, Windows 7 */
 879     }
 880     else if (MajorVersion == 1)
 881     {
 882         if (MinorVersion == 0x30)
 883         {
 884             /* Windows server 2003 */
 885             MajorVersion = 6;
 886             MinorVersion = 0;
 887         }
 888         else if (MinorVersion == 0x20)
 889         {
 890             /* Windows XP */
 891             MajorVersion = 5;
 892             MinorVersion = 1;
 893         }
 894         else if (MinorVersion == 0x10)
 895         {
 896             /* Windows 2000 */
 897             MajorVersion = 5;
 898             MinorVersion = 0;
 899         }
 900         else if (MinorVersion == 0x05)
 901         {
 902             /* Windows ME */
 903             MajorVersion = 4;
 904             MinorVersion = 0x5a;
 905         }
 906         else if (MinorVersion == 0x00)
 907         {
 908             /* Windows 98 */
 909             MajorVersion = 4;
 910             MinorVersion = 0x0a;
 911         }
 912         else
 913         {
 914             FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
 915             return FALSE;
 916         }
 917     }
 918     else
 919     {
 920         FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
 921         return FALSE;
 922     }
 923     return major > MajorVersion || (major == MajorVersion && minor >= MinorVersion);
 924 }
 925
 926
 927 /***********************************************************************
 928  *           IoQueryDeviceDescription    (NTOSKRNL.EXE.@)
 929  */
 930 NTSTATUS WINAPI IoQueryDeviceDescription(PINTERFACE_TYPE itype, PULONG bus, PCONFIGURATION_TYPE ctype,
 931                                      PULONG cnum, PCONFIGURATION_TYPE ptype, PULONG pnum,
 932                                      PIO_QUERY_DEVICE_ROUTINE callout, PVOID context)
 933 {
 934     FIXME( "(%p %p %p %p %p %p %p %p)\n", itype, bus, ctype, cnum, ptype, pnum, callout, context);
 935     return STATUS_NOT_IMPLEMENTED;
 936 }
 937
 938
 939 /***********************************************************************
 940  *           IoRegisterDriverReinitialization    (NTOSKRNL.EXE.@)
 941  */
 942 void WINAPI IoRegisterDriverReinitialization( PDRIVER_OBJECT obj, PDRIVER_REINITIALIZE reinit, PVOID context )
 943 {
 944     FIXME( "stub: %p %p %p\n", obj, reinit, context );
 945 }
 946
 947
 948 /***********************************************************************
 949  *           IoRegisterShutdownNotification    (NTOSKRNL.EXE.@)
 950  */
 951 NTSTATUS WINAPI IoRegisterShutdownNotification( PDEVICE_OBJECT obj )
 952 {
 953     FIXME( "stub: %p\n", obj );
 954     return STATUS_SUCCESS;
 955 }
 956
 957
 958 /***********************************************************************
 959  *           IoUnregisterShutdownNotification    (NTOSKRNL.EXE.@)
 960  */
 961 VOID WINAPI IoUnregisterShutdownNotification( PDEVICE_OBJECT obj )
 962 {
 963     FIXME( "stub: %p\n", obj );
 964 }
 965
 966
 967 /***********************************************************************
 968  *           IoReportResourceUsage    (NTOSKRNL.EXE.@)
 969  */
 970 NTSTATUS WINAPI IoReportResourceUsage(PUNICODE_STRING name, PDRIVER_OBJECT drv_obj, PCM_RESOURCE_LIST drv_list,
 971                                       ULONG drv_size, PDRIVER_OBJECT dev_obj, PCM_RESOURCE_LIST dev_list,
 972                                       ULONG dev_size, BOOLEAN overwrite, PBOOLEAN detected)
 973 {
 974     FIXME("(%s %p %p %u %p %p %u %d %p) stub\n", debugstr_w(name? name->Buffer : NULL),
 975           drv_obj, drv_list, drv_size, dev_obj, dev_list, dev_size, overwrite, detected);
 976     return STATUS_NOT_IMPLEMENTED;
 977 }
 978
 979
 980 /***********************************************************************
 981  *           IoCompleteRequest   (NTOSKRNL.EXE.@)
 982  */
 983 VOID WINAPI IoCompleteRequest( IRP *irp, UCHAR priority_boost )
 984 {
 985     IO_STACK_LOCATION *irpsp;
 986     PIO_COMPLETION_ROUTINE routine;
 987     NTSTATUS status, stat;
 988     HANDLE handle;
 989     int call_flag = 0;
 990
 991     TRACE( "%p %u\n", irp, priority_boost );
 992
 993     status = irp->IoStatus.u.Status;
 994     while (irp->CurrentLocation <= irp->StackCount)
 995     {
 996         irpsp = irp->Tail.Overlay.s.u2.CurrentStackLocation;
 997         routine = irpsp->CompletionRoutine;
 998         call_flag = 0;
 999         /* FIXME: add SL_INVOKE_ON_CANCEL support */
1000         if (routine)
1001         {
1002             if ((irpsp->Control & SL_INVOKE_ON_SUCCESS) && STATUS_SUCCESS == status)
1003                 call_flag = 1;
1004             if ((irpsp->Control & SL_INVOKE_ON_ERROR) && STATUS_SUCCESS != status)
1005                 call_flag = 1;
1006         }
1007         ++irp->CurrentLocation;
1008         ++irp->Tail.Overlay.s.u2.CurrentStackLocation;
1009         if (call_flag)
1010         {
1011             TRACE( "calling %p( %p, %p, %p )\n", routine,
1012                     irpsp->DeviceObject, irp, irpsp->Context );
1013             stat = routine( irpsp->DeviceObject, irp, irpsp->Context );
1014             TRACE( "CompletionRoutine returned %x\n", stat );
1015             if (STATUS_MORE_PROCESSING_REQUIRED == stat)
1016                 return;
1017         }
1018     }
1019
1020     handle = (HANDLE)irp->UserIosb;
1021     if (handle)
1022     {
1023         HANDLE manager = get_device_manager();
1024         void *out_buff = irp->UserBuffer;
1025
1026         SERVER_START_REQ( set_irp_result )
1027         {
1028             req->manager = wine_server_obj_handle( manager );
1029             req->handle  = wine_server_obj_handle( handle );
1030             req->status  = irp->IoStatus.u.Status;
1031             if (irp->IoStatus.u.Status >= 0 && out_buff)
1032                 wine_server_add_data( req, out_buff, irp->IoStatus.Information );
1033             wine_server_call( req );
1034         }
1035         SERVER_END_REQ;
1036         HeapFree( GetProcessHeap(), 0, out_buff );
1037     }
1038
1039     IoFreeIrp( irp );
1040 }
1041
1042
1043 /***********************************************************************
1044  *           IofCompleteRequest   (NTOSKRNL.EXE.@)
1045  */
1046 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1047 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest )
1048 void WINAPI __regs_IofCompleteRequest( IRP *irp, UCHAR priority_boost )
1049 #else
1050 void WINAPI IofCompleteRequest( IRP *irp, UCHAR priority_boost )
1051 #endif
1052 {
1053     TRACE( "%p %u\n", irp, priority_boost );
1054     IoCompleteRequest( irp, priority_boost );
1055 }
1056
1057
1058 /***********************************************************************
1059  *           InterlockedCompareExchange   (NTOSKRNL.EXE.@)
1060  */
1061 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
1062 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange )
1063 LONG WINAPI __regs_NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
1064 #else
1065 LONG WINAPI NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
1066 #endif
1067 {
1068     return InterlockedCompareExchange( dest, xchg, compare );
1069 }
1070
1071
1072 /***********************************************************************
1073  *           InterlockedDecrement   (NTOSKRNL.EXE.@)
1074  */
1075 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1076 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement )
1077 LONG WINAPI __regs_NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
1078 #else
1079 LONG WINAPI NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
1080 #endif
1081 {
1082     return InterlockedDecrement( dest );
1083 }
1084
1085
1086 /***********************************************************************
1087  *           InterlockedExchange   (NTOSKRNL.EXE.@)
1088  */
1089 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1090 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange )
1091 LONG WINAPI __regs_NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
1092 #else
1093 LONG WINAPI NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
1094 #endif
1095 {
1096     return InterlockedExchange( dest, val );
1097 }
1098
1099
1100 /***********************************************************************
1101  *           InterlockedExchangeAdd   (NTOSKRNL.EXE.@)
1102  */
1103 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1104 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd )
1105 LONG WINAPI __regs_NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
1106 #else
1107 LONG WINAPI NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
1108 #endif
1109 {
1110     return InterlockedExchangeAdd( dest, incr );
1111 }
1112
1113
1114 /***********************************************************************
1115  *           InterlockedIncrement   (NTOSKRNL.EXE.@)
1116  */
1117 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1118 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement )
1119 LONG WINAPI __regs_NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1120 #else
1121 LONG WINAPI NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1122 #endif
1123 {
1124     return InterlockedIncrement( dest );
1125 }
1126
1127
1128 /***********************************************************************
1129  *           ExAllocatePool   (NTOSKRNL.EXE.@)
1130  */
1131 PVOID WINAPI ExAllocatePool( POOL_TYPE type, SIZE_T size )
1132 {
1133     return ExAllocatePoolWithTag( type, size, 0 );
1134 }
1135
1136
1137 /***********************************************************************
1138  *           ExAllocatePoolWithQuota   (NTOSKRNL.EXE.@)
1139  */
1140 PVOID WINAPI ExAllocatePoolWithQuota( POOL_TYPE type, SIZE_T size )
1141 {
1142     return ExAllocatePoolWithTag( type, size, 0 );
1143 }
1144
1145
1146 /***********************************************************************
1147  *           ExAllocatePoolWithTag   (NTOSKRNL.EXE.@)
1148  */
1149 PVOID WINAPI ExAllocatePoolWithTag( POOL_TYPE type, SIZE_T size, ULONG tag )
1150 {
1151     /* FIXME: handle page alignment constraints */
1152     void *ret = HeapAlloc( GetProcessHeap(), 0, size );
1153     TRACE( "%lu pool %u -> %p\n", size, type, ret );
1154     return ret;
1155 }
1156
1157
1158 /***********************************************************************
1159  *           ExAllocatePoolWithQuotaTag   (NTOSKRNL.EXE.@)
1160  */
1161 PVOID WINAPI ExAllocatePoolWithQuotaTag( POOL_TYPE type, SIZE_T size, ULONG tag )
1162 {
1163     return ExAllocatePoolWithTag( type, size, tag );
1164 }
1165
1166
1167 /***********************************************************************
1168  *           ExCreateCallback   (NTOSKRNL.EXE.@)
1169  */
1170 NTSTATUS WINAPI ExCreateCallback(PCALLBACK_OBJECT *obj, POBJECT_ATTRIBUTES attr,
1171                                  BOOLEAN create, BOOLEAN allow_multiple)
1172 {
1173     FIXME("(%p, %p, %u, %u): stub\n", obj, attr, create, allow_multiple);
1174
1175     return STATUS_NOT_IMPLEMENTED;
1176 }
1177
1178
1179 /***********************************************************************
1180  *           ExFreePool   (NTOSKRNL.EXE.@)
1181  */
1182 void WINAPI ExFreePool( void *ptr )
1183 {
1184     ExFreePoolWithTag( ptr, 0 );
1185 }
1186
1187
1188 /***********************************************************************
1189  *           ExFreePoolWithTag   (NTOSKRNL.EXE.@)
1190  */
1191 void WINAPI ExFreePoolWithTag( void *ptr, ULONG tag )
1192 {
1193     TRACE( "%p\n", ptr );
1194     HeapFree( GetProcessHeap(), 0, ptr );
1195 }
1196
1197
1198 /***********************************************************************
1199  *           ExInitializeResourceLite   (NTOSKRNL.EXE.@)
1200  */
1201 NTSTATUS WINAPI ExInitializeResourceLite(PERESOURCE Resource)
1202 {
1203     FIXME( "stub: %p\n", Resource );
1204     return STATUS_NOT_IMPLEMENTED;
1205 }
1206
1207
1208 /***********************************************************************
1209  *           ExInitializeNPagedLookasideList   (NTOSKRNL.EXE.@)
1210  */
1211 void WINAPI ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
1212                                             PALLOCATE_FUNCTION Allocate,
1213                                             PFREE_FUNCTION Free,
1214                                             ULONG Flags,
1215                                             SIZE_T Size,
1216                                             ULONG Tag,
1217                                             USHORT Depth)
1218 {
1219     FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1220 }
1221
1222 /***********************************************************************
1223  *           ExInitializePagedLookasideList   (NTOSKRNL.EXE.@)
1224  */
1225 void WINAPI ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside,
1226                                            PALLOCATE_FUNCTION Allocate,
1227                                            PFREE_FUNCTION Free,
1228                                            ULONG Flags,
1229                                            SIZE_T Size,
1230                                            ULONG Tag,
1231                                            USHORT Depth)
1232 {
1233     FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1234 }
1235
1236 /***********************************************************************
1237  *           ExInitializeZone   (NTOSKRNL.EXE.@)
1238  */
1239 NTSTATUS WINAPI ExInitializeZone(PZONE_HEADER Zone,
1240                                  ULONG BlockSize,
1241                                  PVOID InitialSegment,
1242                                  ULONG InitialSegmentSize)
1243 {
1244     FIXME( "stub: %p, %u, %p, %u\n", Zone, BlockSize, InitialSegment, InitialSegmentSize );
1245     return STATUS_NOT_IMPLEMENTED;
1246 }
1247
1248 /***********************************************************************
1249 *           FsRtlRegisterUncProvider   (NTOSKRNL.EXE.@)
1250 */
1251 NTSTATUS WINAPI FsRtlRegisterUncProvider(PHANDLE MupHandle, PUNICODE_STRING RedirDevName,
1252                                          BOOLEAN MailslotsSupported)
1253 {
1254     FIXME("(%p %p %d): stub\n", MupHandle, RedirDevName, MailslotsSupported);
1255     return STATUS_NOT_IMPLEMENTED;
1256 }
1257
1258 /***********************************************************************
1259  *           IoGetCurrentProcess / PsGetCurrentProcess   (NTOSKRNL.EXE.@)
1260  */
1261 PEPROCESS WINAPI IoGetCurrentProcess(void)
1262 {
1263     FIXME("() stub\n");
1264     return NULL;
1265 }
1266
1267 /***********************************************************************
1268  *           KeGetCurrentThread / PsGetCurrentThread   (NTOSKRNL.EXE.@)
1269  */
1270 PRKTHREAD WINAPI KeGetCurrentThread(void)
1271 {
1272     FIXME("() stub\n");
1273     return NULL;
1274 }
1275
1276 /***********************************************************************
1277  *           KeInitializeEvent   (NTOSKRNL.EXE.@)
1278  */
1279 void WINAPI KeInitializeEvent( PRKEVENT Event, EVENT_TYPE Type, BOOLEAN State )
1280 {
1281     FIXME( "stub: %p %d %d\n", Event, Type, State );
1282 }
1283
1284
1285  /***********************************************************************
1286  *           KeInitializeMutex   (NTOSKRNL.EXE.@)
1287  */
1288 void WINAPI KeInitializeMutex(PRKMUTEX Mutex, ULONG Level)
1289 {
1290     FIXME( "stub: %p, %u\n", Mutex, Level );
1291 }
1292
1293
1294  /***********************************************************************
1295  *           KeWaitForMutexObject   (NTOSKRNL.EXE.@)
1296  */
1297 NTSTATUS WINAPI KeWaitForMutexObject(PRKMUTEX Mutex, KWAIT_REASON WaitReason, KPROCESSOR_MODE WaitMode,
1298                                      BOOLEAN Alertable, PLARGE_INTEGER Timeout)
1299 {
1300     FIXME( "stub: %p, %d, %d, %d, %p\n", Mutex, WaitReason, WaitMode, Alertable, Timeout );
1301     return STATUS_NOT_IMPLEMENTED;
1302 }
1303
1304
1305  /***********************************************************************
1306  *           KeReleaseMutex   (NTOSKRNL.EXE.@)
1307  */
1308 LONG WINAPI KeReleaseMutex(PRKMUTEX Mutex, BOOLEAN Wait)
1309 {
1310     FIXME( "stub: %p, %d\n", Mutex, Wait );
1311     return STATUS_NOT_IMPLEMENTED;
1312 }
1313
1314
1315 /***********************************************************************
1316  *           KeInitializeSemaphore   (NTOSKRNL.EXE.@)
1317  */
1318 void WINAPI KeInitializeSemaphore( PRKSEMAPHORE Semaphore, LONG Count, LONG Limit )
1319 {
1320     FIXME( "(%p %d %d) stub\n", Semaphore , Count, Limit );
1321 }
1322
1323
1324 /***********************************************************************
1325  *           KeInitializeSpinLock   (NTOSKRNL.EXE.@)
1326  */
1327 void WINAPI KeInitializeSpinLock( PKSPIN_LOCK SpinLock )
1328 {
1329     FIXME( "stub: %p\n", SpinLock );
1330 }
1331
1332
1333 /***********************************************************************
1334  *           KeInitializeTimerEx   (NTOSKRNL.EXE.@)
1335  */
1336 void WINAPI KeInitializeTimerEx( PKTIMER Timer, TIMER_TYPE Type )
1337 {
1338     FIXME( "stub: %p %d\n", Timer, Type );
1339 }
1340
1341
1342 /***********************************************************************
1343  *           KeInitializeTimer   (NTOSKRNL.EXE.@)
1344  */
1345 void WINAPI KeInitializeTimer( PKTIMER Timer )
1346 {
1347     KeInitializeTimerEx(Timer, NotificationTimer);
1348 }
1349
1350 /***********************************************************************
1351  *           KeInsertQueue   (NTOSKRNL.EXE.@)
1352  */
1353 LONG WINAPI KeInsertQueue(PRKQUEUE Queue, PLIST_ENTRY Entry)
1354 {
1355     FIXME( "stub: %p %p\n", Queue, Entry );
1356     return 0;
1357 }
1358
1359 /**********************************************************************
1360  *           KeQueryActiveProcessors   (NTOSKRNL.EXE.@)
1361  *
1362  * Return the active Processors as bitmask
1363  *
1364  * RETURNS
1365  *   active Processors as bitmask
1366  *
1367  */
1368 KAFFINITY WINAPI KeQueryActiveProcessors( void )
1369 {
1370     DWORD_PTR AffinityMask;
1371
1372     GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask, NULL);
1373     return AffinityMask;
1374 }
1375
1376
1377 /**********************************************************************
1378  *           KeQueryInterruptTime   (NTOSKRNL.EXE.@)
1379  *
1380  * Return the interrupt time count
1381  *
1382  */
1383 ULONGLONG WINAPI KeQueryInterruptTime( void )
1384 {
1385     LARGE_INTEGER totaltime;
1386
1387     KeQueryTickCount(&totaltime);
1388     return totaltime.QuadPart;
1389 }
1390
1391
1392 /***********************************************************************
1393  *           KeQuerySystemTime   (NTOSKRNL.EXE.@)
1394  */
1395 void WINAPI KeQuerySystemTime( LARGE_INTEGER *time )
1396 {
1397     NtQuerySystemTime( time );
1398 }
1399
1400
1401 /***********************************************************************
1402  *           KeQueryTickCount   (NTOSKRNL.EXE.@)
1403  */
1404 void WINAPI KeQueryTickCount( LARGE_INTEGER *count )
1405 {
1406     count->QuadPart = NtGetTickCount();
1407     /* update the global variable too */
1408     KeTickCount.LowPart   = count->u.LowPart;
1409     KeTickCount.High1Time = count->u.HighPart;
1410     KeTickCount.High2Time = count->u.HighPart;
1411 }
1412
1413
1414 /***********************************************************************
1415  *           KeReleaseSemaphore   (NTOSKRNL.EXE.@)
1416  */
1417 LONG WINAPI KeReleaseSemaphore( PRKSEMAPHORE Semaphore, KPRIORITY Increment,
1418                                 LONG Adjustment, BOOLEAN Wait )
1419 {
1420     FIXME("(%p %d %d %d) stub\n", Semaphore, Increment, Adjustment, Wait );
1421     return 0;
1422 }
1423
1424
1425 /***********************************************************************
1426  *           KeQueryTimeIncrement   (NTOSKRNL.EXE.@)
1427  */
1428 ULONG WINAPI KeQueryTimeIncrement(void)
1429 {
1430     return 10000;
1431 }
1432
1433
1434 /***********************************************************************
1435  *           KeResetEvent   (NTOSKRNL.EXE.@)
1436  */
1437 LONG WINAPI KeResetEvent( PRKEVENT Event )
1438 {
1439     FIXME("(%p): stub\n", Event);
1440     return 0;
1441 }
1442
1443
1444 /***********************************************************************
1445  *           KeSetEvent   (NTOSKRNL.EXE.@)
1446  */
1447 LONG WINAPI KeSetEvent( PRKEVENT Event, KPRIORITY Increment, BOOLEAN Wait )
1448 {
1449     FIXME("(%p, %d, %d): stub\n", Event, Increment, Wait);
1450     return 0;
1451 }
1452
1453
1454 /***********************************************************************
1455  *           KeSetPriorityThread   (NTOSKRNL.EXE.@)
1456  */
1457 KPRIORITY WINAPI KeSetPriorityThread( PKTHREAD Thread, KPRIORITY Priority )
1458 {
1459     FIXME("(%p %d)\n", Thread, Priority);
1460     return Priority;
1461 }
1462
1463 /***********************************************************************
1464  *           KeSetSystemAffinityThread   (NTOSKRNL.EXE.@)
1465  */
1466 VOID WINAPI KeSetSystemAffinityThread(KAFFINITY Affinity)
1467 {
1468     FIXME("(%lx) stub\n", Affinity);
1469 }
1470
1471 /***********************************************************************
1472  *           KeWaitForSingleObject   (NTOSKRNL.EXE.@)
1473  */
1474 NTSTATUS WINAPI KeWaitForSingleObject(PVOID Object,
1475                                       KWAIT_REASON WaitReason,
1476                                       KPROCESSOR_MODE WaitMode,
1477                                       BOOLEAN Alertable,
1478                                       PLARGE_INTEGER Timeout)
1479 {
1480     FIXME( "stub: %p, %d, %d, %d, %p\n", Object, WaitReason, WaitMode, Alertable, Timeout );
1481     return STATUS_NOT_IMPLEMENTED;
1482 }
1483
1484 /***********************************************************************
1485  *           IoRegisterFileSystem   (NTOSKRNL.EXE.@)
1486  */
1487 VOID WINAPI IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject)
1488 {
1489     FIXME("(%p): stub\n", DeviceObject);
1490 }
1491
1492 /***********************************************************************
1493 *           IoUnregisterFileSystem   (NTOSKRNL.EXE.@)
1494 */
1495 VOID WINAPI IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject)
1496 {
1497     FIXME("(%p): stub\n", DeviceObject);
1498 }
1499
1500 /***********************************************************************
1501  *           MmAllocateNonCachedMemory   (NTOSKRNL.EXE.@)
1502  */
1503 PVOID WINAPI MmAllocateNonCachedMemory( SIZE_T size )
1504 {
1505     TRACE( "%lu\n", size );
1506     return VirtualAlloc( NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE|PAGE_NOCACHE );
1507 }
1508
1509 /***********************************************************************
1510  *           MmAllocateContiguousMemory   (NTOSKRNL.EXE.@)
1511  */
1512 PVOID WINAPI MmAllocateContiguousMemory( SIZE_T size, PHYSICAL_ADDRESS highest_valid_address )
1513 {
1514     FIXME( "%lu, %s stub\n", size, wine_dbgstr_longlong(highest_valid_address.QuadPart) );
1515     return NULL;
1516 }
1517
1518 /***********************************************************************
1519  *           MmAllocateContiguousMemorySpecifyCache   (NTOSKRNL.EXE.@)
1520  */
1521 PVOID WINAPI MmAllocateContiguousMemorySpecifyCache( SIZE_T size,
1522                                                      PHYSICAL_ADDRESS lowest_valid_address,
1523                                                      PHYSICAL_ADDRESS highest_valid_address,
1524                                                      PHYSICAL_ADDRESS BoundaryAddressMultiple,
1525                                                      MEMORY_CACHING_TYPE CacheType )
1526 {
1527     FIXME(": stub\n");
1528     return NULL;
1529 }
1530
1531 /***********************************************************************
1532  *           MmAllocatePagesForMdl   (NTOSKRNL.EXE.@)
1533  */
1534 PMDL WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress, PHYSICAL_ADDRESS highaddress,
1535                                   PHYSICAL_ADDRESS skipbytes, SIZE_T size)
1536 {
1537     FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress.QuadPart), wine_dbgstr_longlong(highaddress.QuadPart),
1538                                   wine_dbgstr_longlong(skipbytes.QuadPart), size);
1539     return NULL;
1540 }
1541
1542 /***********************************************************************
1543  *           MmFreeNonCachedMemory   (NTOSKRNL.EXE.@)
1544  */
1545 void WINAPI MmFreeNonCachedMemory( void *addr, SIZE_T size )
1546 {
1547     TRACE( "%p %lu\n", addr, size );
1548     VirtualFree( addr, 0, MEM_RELEASE );
1549 }
1550
1551 /***********************************************************************
1552  *           MmIsAddressValid   (NTOSKRNL.EXE.@)
1553  *
1554  * Check if the process can access the virtual address without a pagefault
1555  *
1556  * PARAMS
1557  *  VirtualAddress [I] Address to check
1558  *
1559  * RETURNS
1560  *  Failure: FALSE
1561  *  Success: TRUE  (Accessing the Address works without a Pagefault)
1562  *
1563  */
1564 BOOLEAN WINAPI MmIsAddressValid(PVOID VirtualAddress)
1565 {
1566     TRACE("(%p)\n", VirtualAddress);
1567     return !IsBadWritePtr(VirtualAddress, 1);
1568 }
1569
1570 /***********************************************************************
1571  *           MmMapIoSpace   (NTOSKRNL.EXE.@)
1572  */
1573 PVOID WINAPI MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress, DWORD NumberOfBytes, DWORD CacheType )
1574 {
1575     FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress.u.HighPart, PhysicalAddress.u.LowPart, NumberOfBytes, CacheType );
1576     return NULL;
1577 }
1578
1579
1580 /***********************************************************************
1581  *           MmLockPagableSectionByHandle  (NTOSKRNL.EXE.@)
1582  */
1583 VOID WINAPI MmLockPagableSectionByHandle(PVOID ImageSectionHandle)
1584 {
1585     FIXME("stub %p\n", ImageSectionHandle);
1586 }
1587
1588 /***********************************************************************
1589  *           MmMapLockedPagesSpecifyCache  (NTOSKRNL.EXE.@)
1590  */
1591 PVOID WINAPI  MmMapLockedPagesSpecifyCache(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, MEMORY_CACHING_TYPE CacheType,
1592                                            PVOID BaseAddress, ULONG BugCheckOnFailure, MM_PAGE_PRIORITY Priority)
1593 {
1594     FIXME("(%p, %u, %u, %p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, CacheType, BaseAddress, BugCheckOnFailure, Priority);
1595
1596     return NULL;
1597 }
1598
1599 /***********************************************************************
1600  *           MmUnlockPagableImageSection  (NTOSKRNL.EXE.@)
1601  */
1602 VOID WINAPI MmUnlockPagableImageSection(PVOID ImageSectionHandle)
1603 {
1604     FIXME("stub %p\n", ImageSectionHandle);
1605 }
1606
1607 /***********************************************************************
1608  *           MmPageEntireDriver   (NTOSKRNL.EXE.@)
1609  */
1610 PVOID WINAPI MmPageEntireDriver(PVOID AddrInSection)
1611 {
1612     TRACE("%p\n", AddrInSection);
1613     return AddrInSection;
1614 }
1615
1616
1617 /***********************************************************************
1618  *           MmProbeAndLockPages  (NTOSKRNL.EXE.@)
1619  */
1620 void WINAPI MmProbeAndLockPages(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, LOCK_OPERATION Operation)
1621 {
1622     FIXME("(%p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, Operation);
1623 }
1624
1625
1626 /***********************************************************************
1627  *           MmResetDriverPaging   (NTOSKRNL.EXE.@)
1628  */
1629 void WINAPI MmResetDriverPaging(PVOID AddrInSection)
1630 {
1631     TRACE("%p\n", AddrInSection);
1632 }
1633
1634
1635 /***********************************************************************
1636  *           MmUnlockPages  (NTOSKRNL.EXE.@)
1637  */
1638 void WINAPI  MmUnlockPages(PMDLX MemoryDescriptorList)
1639 {
1640     FIXME("(%p): stub\n", MemoryDescriptorList);
1641 }
1642
1643
1644 /***********************************************************************
1645  *           MmUnmapIoSpace   (NTOSKRNL.EXE.@)
1646  */
1647 VOID WINAPI MmUnmapIoSpace( PVOID BaseAddress, SIZE_T NumberOfBytes )
1648 {
1649     FIXME( "stub: %p, %lu\n", BaseAddress, NumberOfBytes );
1650 }
1651
1652 /***********************************************************************
1653  *           ObfReferenceObject   (NTOSKRNL.EXE.@)
1654  */
1655 VOID WINAPI ObfReferenceObject(PVOID Object)
1656 {
1657     FIXME("(%p): stub\n", Object);
1658 }
1659
1660  /***********************************************************************
1661  *           ObReferenceObjectByHandle    (NTOSKRNL.EXE.@)
1662  */
1663 NTSTATUS WINAPI ObReferenceObjectByHandle( HANDLE obj, ACCESS_MASK access,
1664                                            POBJECT_TYPE type,
1665                                            KPROCESSOR_MODE mode, PVOID* ptr,
1666                                            POBJECT_HANDLE_INFORMATION info)
1667 {
1668     FIXME( "stub: %p %x %p %d %p %p\n", obj, access, type, mode, ptr, info);
1669     return STATUS_NOT_IMPLEMENTED;
1670 }
1671
1672  /***********************************************************************
1673  *           ObReferenceObjectByName    (NTOSKRNL.EXE.@)
1674  */
1675 NTSTATUS WINAPI ObReferenceObjectByName( UNICODE_STRING *ObjectName,
1676                                          ULONG Attributes,
1677                                          ACCESS_STATE *AccessState,
1678                                          ACCESS_MASK DesiredAccess,
1679                                          POBJECT_TYPE ObjectType,
1680                                          KPROCESSOR_MODE AccessMode,
1681                                          void *ParseContext,
1682                                          void **Object)
1683 {
1684     FIXME("stub\n");
1685     return STATUS_NOT_IMPLEMENTED;
1686 }
1687
1688 /***********************************************************************
1689  *           ObfDereferenceObject   (NTOSKRNL.EXE.@)
1690  */
1691 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1692 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject )
1693 void WINAPI __regs_ObfDereferenceObject( VOID *obj )
1694 #else
1695 void WINAPI ObfDereferenceObject( VOID *obj )
1696 #endif
1697 {
1698     FIXME( "stub: %p\n", obj );
1699 }
1700
1701
1702 /***********************************************************************
1703  *           PsCreateSystemThread   (NTOSKRNL.EXE.@)
1704  */
1705 NTSTATUS WINAPI PsCreateSystemThread(PHANDLE ThreadHandle, ULONG DesiredAccess,
1706                                      POBJECT_ATTRIBUTES ObjectAttributes,
1707                                      HANDLE ProcessHandle, PCLIENT_ID ClientId,
1708                                      PKSTART_ROUTINE StartRoutine, PVOID StartContext)
1709 {
1710     if (!ProcessHandle) ProcessHandle = GetCurrentProcess();
1711     return RtlCreateUserThread(ProcessHandle, 0, FALSE, 0, 0,
1712                                0, StartRoutine, StartContext,
1713                                ThreadHandle, ClientId);
1714 }
1715
1716 /***********************************************************************
1717  *           PsGetCurrentProcessId   (NTOSKRNL.EXE.@)
1718  */
1719 HANDLE WINAPI PsGetCurrentProcessId(void)
1720 {
1721     if (GetCurrentThreadId() == request_thread)
1722         return UlongToHandle(client_pid);
1723     return UlongToHandle(GetCurrentProcessId());
1724 }
1725
1726
1727 /***********************************************************************
1728  *           PsGetCurrentThreadId   (NTOSKRNL.EXE.@)
1729  */
1730 HANDLE WINAPI PsGetCurrentThreadId(void)
1731 {
1732     if (GetCurrentThreadId() == request_thread)
1733         return UlongToHandle(client_tid);
1734     return UlongToHandle(GetCurrentThreadId());
1735 }
1736
1737
1738 /***********************************************************************
1739  *           PsGetVersion   (NTOSKRNL.EXE.@)
1740  */
1741 BOOLEAN WINAPI PsGetVersion(ULONG *major, ULONG *minor, ULONG *build, UNICODE_STRING *version )
1742 {
1743     RTL_OSVERSIONINFOEXW info;
1744
1745     info.dwOSVersionInfoSize = sizeof(info);
1746     RtlGetVersion( &info );
1747     if (major) *major = info.dwMajorVersion;
1748     if (minor) *minor = info.dwMinorVersion;
1749     if (build) *build = info.dwBuildNumber;
1750
1751     if (version)
1752     {
1753 #if 0  /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
1754         size_t len = min( strlenW(info.szCSDVersion)*sizeof(WCHAR), version->MaximumLength );
1755         memcpy( version->Buffer, info.szCSDVersion, len );
1756         if (len < version->MaximumLength) version->Buffer[len / sizeof(WCHAR)] = 0;
1757         version->Length = len;
1758 #endif
1759     }
1760     return TRUE;
1761 }
1762
1763
1764 /***********************************************************************
1765  *           PsImpersonateClient   (NTOSKRNL.EXE.@)
1766  */
1767 NTSTATUS WINAPI PsImpersonateClient(PETHREAD Thread, PACCESS_TOKEN Token, BOOLEAN CopyOnOpen,
1768                                     BOOLEAN EffectiveOnly, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
1769 {
1770     FIXME("(%p, %p, %u, %u, %u): stub\n", Thread, Token, CopyOnOpen, EffectiveOnly, ImpersonationLevel);
1771
1772     return STATUS_NOT_IMPLEMENTED;
1773 }
1774
1775
1776 /***********************************************************************
1777  *           PsSetCreateProcessNotifyRoutine   (NTOSKRNL.EXE.@)
1778  */
1779 NTSTATUS WINAPI PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback, BOOLEAN remove )
1780 {
1781     FIXME( "stub: %p %d\n", callback, remove );
1782     return STATUS_SUCCESS;
1783 }
1784
1785
1786 /***********************************************************************
1787  *           PsSetCreateThreadNotifyRoutine   (NTOSKRNL.EXE.@)
1788  */
1789 NTSTATUS WINAPI PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
1790 {
1791     FIXME( "stub: %p\n", NotifyRoutine );
1792     return STATUS_SUCCESS;
1793 }
1794
1795
1796 /***********************************************************************
1797  *           PsTerminateSystemThread   (NTOSKRNL.EXE.@)
1798  */
1799 NTSTATUS WINAPI PsTerminateSystemThread(NTSTATUS ExitStatus)
1800 {
1801     FIXME( "stub: %u\n", ExitStatus );
1802     return STATUS_NOT_IMPLEMENTED;
1803 }
1804
1805
1806 /***********************************************************************
1807  *           MmGetSystemRoutineAddress   (NTOSKRNL.EXE.@)
1808  */
1809 PVOID WINAPI MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName)
1810 {
1811     HMODULE hMod;
1812     STRING routineNameA;
1813     PVOID pFunc = NULL;
1814
1815     static const WCHAR ntoskrnlW[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
1816     static const WCHAR halW[] = {'h','a','l','.','d','l','l',0};
1817
1818     if (!SystemRoutineName) return NULL;
1819
1820     if (RtlUnicodeStringToAnsiString( &routineNameA, SystemRoutineName, TRUE ) == STATUS_SUCCESS)
1821     {
1822         /* We only support functions exported from ntoskrnl.exe or hal.dll */
1823         hMod = GetModuleHandleW( ntoskrnlW );
1824         pFunc = GetProcAddress( hMod, routineNameA.Buffer );
1825         if (!pFunc)
1826         {
1827            hMod = GetModuleHandleW( halW );
1828            if (hMod) pFunc = GetProcAddress( hMod, routineNameA.Buffer );
1829         }
1830         RtlFreeAnsiString( &routineNameA );
1831     }
1832
1833     if (pFunc)
1834         TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName), pFunc );
1835     else
1836         FIXME( "%s not found\n", debugstr_us(SystemRoutineName) );
1837     return pFunc;
1838 }
1839
1840
1841 /***********************************************************************
1842  *           MmQuerySystemSize   (NTOSKRNL.EXE.@)
1843  */
1844 MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void)
1845 {
1846     FIXME("stub\n");
1847     return MmLargeSystem;
1848 }
1849
1850 /***********************************************************************
1851  *           KeInitializeDpc   (NTOSKRNL.EXE.@)
1852  */
1853 VOID WINAPI KeInitializeDpc(PRKDPC Dpc, PKDEFERRED_ROUTINE DeferredRoutine, PVOID DeferredContext)
1854 {
1855     FIXME("stub\n");
1856 }
1857
1858 /***********************************************************************
1859  *           READ_REGISTER_BUFFER_UCHAR   (NTOSKRNL.EXE.@)
1860  */
1861 VOID WINAPI READ_REGISTER_BUFFER_UCHAR(PUCHAR Register, PUCHAR Buffer, ULONG Count)
1862 {
1863     FIXME("stub\n");
1864 }
1865
1866 /*****************************************************
1867  *           PoSetPowerState   (NTOSKRNL.EXE.@)
1868  */
1869 POWER_STATE WINAPI PoSetPowerState(PDEVICE_OBJECT DeviceObject, POWER_STATE_TYPE Type, POWER_STATE State)
1870 {
1871     FIXME("(%p %u %u) stub\n", DeviceObject, Type, State.DeviceState);
1872     return State;
1873 }
1874
1875 /*****************************************************
1876  *           IoWMIRegistrationControl   (NTOSKRNL.EXE.@)
1877  */
1878 NTSTATUS WINAPI IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject, ULONG Action)
1879 {
1880     FIXME("(%p %u) stub\n", DeviceObject, Action);
1881     return STATUS_SUCCESS;
1882 }
1883
1884 /*****************************************************
1885  *           PsSetLoadImageNotifyRoutine   (NTOSKRNL.EXE.@)
1886  */
1887 NTSTATUS WINAPI PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine)
1888 {
1889     FIXME("(%p) stub\n", routine);
1890     return STATUS_SUCCESS;
1891 }
1892
1893 /*****************************************************
1894  *           PsLookupProcessByProcessId  (NTOSKRNL.EXE.@)
1895  */
1896 NTSTATUS WINAPI PsLookupProcessByProcessId(HANDLE processid, PEPROCESS *process)
1897 {
1898     static int once;
1899     if (!once++) FIXME("(%p %p) stub\n", processid, process);
1900     return STATUS_NOT_IMPLEMENTED;
1901 }
1902
1903
1904 /*****************************************************
1905  *           IoSetThreadHardErrorMode  (NTOSKRNL.EXE.@)
1906  */
1907 BOOLEAN WINAPI IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors)
1908 {
1909     FIXME("stub\n");
1910     return FALSE;
1911 }
1912
1913
1914 /*****************************************************
1915  *           IoInitializeRemoveLockEx  (NTOSKRNL.EXE.@)
1916  */
1917 VOID WINAPI IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock, ULONG tag,
1918                                      ULONG maxmin, ULONG high, ULONG size)
1919 {
1920     FIXME("(%p %u %u %u %u) stub\n", lock, tag, maxmin, high, size);
1921 }
1922
1923
1924 /*****************************************************
1925  *           IoAcquireRemoveLockEx  (NTOSKRNL.EXE.@)
1926  */
1927
1928 NTSTATUS WINAPI IoAcquireRemoveLockEx(PIO_REMOVE_LOCK lock, PVOID tag,
1929                                       LPCSTR file, ULONG line, ULONG lock_size)
1930 {
1931     FIXME("(%p, %p, %s, %u, %u): stub\n", lock, tag, debugstr_a(file), line, lock_size);
1932
1933     return STATUS_NOT_IMPLEMENTED;
1934 }
1935
1936
1937 /*****************************************************
1938  *           DllMain
1939  */
1940 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
1941 {
1942     static void *handler;
1943     LARGE_INTEGER count;
1944
1945     switch(reason)
1946     {
1947     case DLL_PROCESS_ATTACH:
1948         DisableThreadLibraryCalls( inst );
1949 #ifdef __i386__
1950         handler = RtlAddVectoredExceptionHandler( TRUE, vectored_handler );
1951 #endif
1952         KeQueryTickCount( &count );  /* initialize the global KeTickCount */
1953         break;
1954     case DLL_PROCESS_DETACH:
1955         if (reserved) break;
1956         RtlRemoveVectoredExceptionHandler( handler );
1957         break;
1958     }
1959     return TRUE;
1960 }
1961
1962 /*****************************************************
1963  *           Ke386IoSetAccessProcess  (NTOSKRNL.EXE.@)
1964  */
1965 BOOLEAN WINAPI Ke386IoSetAccessProcess(PEPROCESS *process, ULONG flag)
1966 {
1967     FIXME("(%p %d) stub\n", process, flag);
1968     return FALSE;
1969 }
1970
1971 /*****************************************************
1972  *           Ke386SetIoAccessMap  (NTOSKRNL.EXE.@)
1973  */
1974 BOOLEAN WINAPI Ke386SetIoAccessMap(ULONG flag, PVOID buffer)
1975 {
1976     FIXME("(%d %p) stub\n", flag, buffer);
1977     return FALSE;
1978 }
1979
1980 /*****************************************************
1981  *           IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
1982  */
1983 PKEVENT WINAPI IoCreateSynchronizationEvent(PUNICODE_STRING name, PHANDLE handle)
1984 {
1985     FIXME("(%p %p) stub\n", name, handle);
1986     return NULL;
1987 }
1988
1989 /*****************************************************
1990  *           IoStartNextPacket  (NTOSKRNL.EXE.@)
1991  */
1992 VOID WINAPI IoStartNextPacket(PDEVICE_OBJECT deviceobject, BOOLEAN cancelable)
1993 {
1994     FIXME("(%p %d) stub\n", deviceobject, cancelable);
1995 }
1996
1997 /*****************************************************
1998  *           ObQueryNameString  (NTOSKRNL.EXE.@)
1999  */
2000 NTSTATUS WINAPI ObQueryNameString(PVOID object, POBJECT_NAME_INFORMATION name, ULONG maxlength, PULONG returnlength)
2001 {
2002     FIXME("(%p %p %u %p) stub\n", object, name, maxlength, returnlength);
2003     return STATUS_NOT_IMPLEMENTED;
2004 }
2005
2006 /*****************************************************
2007  *           IoRegisterPlugPlayNotification  (NTOSKRNL.EXE.@)
2008  */
2009 NTSTATUS WINAPI IoRegisterPlugPlayNotification(IO_NOTIFICATION_EVENT_CATEGORY category, ULONG flags, PVOID data,
2010                                                PDRIVER_OBJECT driver, PDRIVER_NOTIFICATION_CALLBACK_ROUTINE callback,
2011                                                PVOID context, PVOID *notification)
2012 {
2013     FIXME("(%u %u %p %p %p %p %p) stub\n", category, flags, data, driver, callback, context, notification);
2014     return STATUS_SUCCESS;
2015 }
2016
2017 /*****************************************************
2018  *           IoCsqInitialize  (NTOSKRNL.EXE.@)
2019  */
2020 NTSTATUS WINAPI IoCsqInitialize(PIO_CSQ csq, PIO_CSQ_INSERT_IRP insert_irp, PIO_CSQ_REMOVE_IRP remove_irp,
2021                                 PIO_CSQ_PEEK_NEXT_IRP peek_irp, PIO_CSQ_ACQUIRE_LOCK acquire_lock,
2022                                 PIO_CSQ_RELEASE_LOCK release_lock, PIO_CSQ_COMPLETE_CANCELED_IRP complete_irp)
2023 {
2024     FIXME("(%p %p %p %p %p %p %p) stub\n",
2025           csq, insert_irp, remove_irp, peek_irp, acquire_lock, release_lock, complete_irp);
2026     return STATUS_SUCCESS;
2027 }
2028
2029 /*****************************************************
2030  *           ExInterlockedRemoveHeadList  (NTOSKRNL.EXE.@)
2031  */
2032 PLIST_ENTRY WINAPI ExInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2033 {
2034     FIXME("(%p %p) stub\n", head, lock);
2035     return NULL;
2036 }
2037
2038 /***********************************************************************
2039  *           ExfInterlockedRemoveHeadList   (NTOSKRNL.EXE.@)
2040  */
2041 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
2042 DEFINE_FASTCALL2_ENTRYPOINT( ExfInterlockedRemoveHeadList )
2043 PLIST_ENTRY WINAPI __regs_ExfInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2044 #else
2045 PLIST_ENTRY WINAPI ExfInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2046 #endif
2047 {
2048     FIXME("(%p %p) stub\n", head, lock);
2049     return ExInterlockedRemoveHeadList( head, lock );
2050 }