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