git.oblomov.eu Git - wine/blob - 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 "ddk/ntddk.h"
  36 #include "wine/unicode.h"
  37 #include "wine/server.h"
  38 #include "wine/list.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(ntoskrnl);
  42 WINE_DECLARE_DEBUG_CHANNEL(relay);
  43
  44 extern LONG CALLBACK vectored_handler( EXCEPTION_POINTERS *ptrs );
  45
  46 KSYSTEM_TIME KeTickCount = { 0, 0, 0 };
  47
  48 typedef struct _KSERVICE_TABLE_DESCRIPTOR
  49 {
  50     PULONG_PTR Base;
  51     PULONG Count;
  52     ULONG Limit;
  53     PUCHAR Number;
  54 } KSERVICE_TABLE_DESCRIPTOR, *PKSERVICE_TABLE_DESCRIPTOR;
  55
  56 KSERVICE_TABLE_DESCRIPTOR KeServiceDescriptorTable[4] = { { 0 } };
  57
  58 typedef void (WINAPI *PCREATE_PROCESS_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
  59 typedef void (WINAPI *PCREATE_THREAD_NOTIFY_ROUTINE)(HANDLE,HANDLE,BOOLEAN);
  60
  61 static struct list Irps = LIST_INIT(Irps);
  62
  63 struct IrpInstance
  64 {
  65     struct list entry;
  66     IRP *irp;
  67 };
  68
  69 #ifdef __i386__
  70 #define DEFINE_FASTCALL1_ENTRYPOINT( name ) \
  71     __ASM_STDCALL_FUNC( name, 4, \
  72                        "popl %eax\n\t" \
  73                        "pushl %ecx\n\t" \
  74                        "pushl %eax\n\t" \
  75                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(4))
  76 #define DEFINE_FASTCALL2_ENTRYPOINT( name ) \
  77     __ASM_STDCALL_FUNC( name, 8, \
  78                        "popl %eax\n\t" \
  79                        "pushl %edx\n\t" \
  80                        "pushl %ecx\n\t" \
  81                        "pushl %eax\n\t" \
  82                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(8))
  83 #define DEFINE_FASTCALL3_ENTRYPOINT( name ) \
  84     __ASM_STDCALL_FUNC( name, 12, \
  85                        "popl %eax\n\t" \
  86                        "pushl %edx\n\t" \
  87                        "pushl %ecx\n\t" \
  88                        "pushl %eax\n\t" \
  89                        "jmp " __ASM_NAME("__regs_") #name __ASM_STDCALL(12))
  90 #endif
  91
  92 static inline LPCSTR debugstr_us( const UNICODE_STRING *us )
  93 {
  94     if (!us) return "<null>";
  95     return debugstr_wn( us->Buffer, us->Length / sizeof(WCHAR) );
  96 }
  97
  98 static HANDLE get_device_manager(void)
  99 {
 100     static HANDLE device_manager;
 101     HANDLE handle = 0, ret = device_manager;
 102
 103     if (!ret)
 104     {
 105         SERVER_START_REQ( create_device_manager )
 106         {
 107             req->access     = SYNCHRONIZE;
 108             req->attributes = 0;
 109             if (!wine_server_call( req )) handle = wine_server_ptr_handle( reply->handle );
 110         }
 111         SERVER_END_REQ;
 112
 113         if (!handle)
 114         {
 115             ERR( "failed to create the device manager\n" );
 116             return 0;
 117         }
 118         if (!(ret = InterlockedCompareExchangePointer( &device_manager, handle, 0 )))
 119             ret = handle;
 120         else
 121             NtClose( handle );  /* somebody beat us to it */
 122     }
 123     return ret;
 124 }
 125
 126 /* process an ioctl request for a given device */
 127 static NTSTATUS process_ioctl( DEVICE_OBJECT *device, ULONG code, void *in_buff, ULONG in_size,
 128                                void *out_buff, ULONG *out_size )
 129 {
 130     IRP irp;
 131     MDL mdl;
 132     IO_STACK_LOCATION irpsp;
 133     PDRIVER_DISPATCH dispatch = device->DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL];
 134     NTSTATUS status;
 135     LARGE_INTEGER count;
 136
 137     TRACE( "ioctl %x device %p in_size %u out_size %u\n", code, device, in_size, *out_size );
 138
 139     /* so we can spot things that we should initialize */
 140     memset( &irp, 0x55, sizeof(irp) );
 141     memset( &irpsp, 0x66, sizeof(irpsp) );
 142     memset( &mdl, 0x77, sizeof(mdl) );
 143
 144     irp.RequestorMode = UserMode;
 145     irp.AssociatedIrp.SystemBuffer = in_buff;
 146     irp.UserBuffer = out_buff;
 147     irp.MdlAddress = &mdl;
 148     irp.Tail.Overlay.s.u2.CurrentStackLocation = &irpsp;
 149     irp.UserIosb = NULL;
 150
 151     irpsp.MajorFunction = IRP_MJ_DEVICE_CONTROL;
 152     irpsp.Parameters.DeviceIoControl.OutputBufferLength = *out_size;
 153     irpsp.Parameters.DeviceIoControl.InputBufferLength = in_size;
 154     irpsp.Parameters.DeviceIoControl.IoControlCode = code;
 155     irpsp.Parameters.DeviceIoControl.Type3InputBuffer = in_buff;
 156     irpsp.DeviceObject = device;
 157     irpsp.CompletionRoutine = NULL;
 158
 159     mdl.Next = NULL;
 160     mdl.Size = 0;
 161     mdl.StartVa = out_buff;
 162     mdl.ByteCount = *out_size;
 163     mdl.ByteOffset = 0;
 164
 165     device->CurrentIrp = &irp;
 166
 167     KeQueryTickCount( &count );  /* update the global KeTickCount */
 168
 169     if (TRACE_ON(relay))
 170         DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
 171                  GetCurrentThreadId(), dispatch, device, &irp );
 172
 173     status = dispatch( device, &irp );
 174
 175     if (TRACE_ON(relay))
 176         DPRINTF( "%04x:Ret  driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
 177                  GetCurrentThreadId(), dispatch, device, &irp, status );
 178
 179     *out_size = (irp.IoStatus.u.Status >= 0) ? irp.IoStatus.Information : 0;
 180     return irp.IoStatus.u.Status;
 181 }
 182
 183
 184 /***********************************************************************
 185  *           wine_ntoskrnl_main_loop   (Not a Windows API)
 186  */
 187 NTSTATUS CDECL wine_ntoskrnl_main_loop( HANDLE stop_event )
 188 {
 189     HANDLE manager = get_device_manager();
 190     obj_handle_t ioctl = 0;
 191     NTSTATUS status = STATUS_SUCCESS;
 192     ULONG code = 0;
 193     void *in_buff, *out_buff = NULL;
 194     DEVICE_OBJECT *device = NULL;
 195     ULONG in_size = 4096, out_size = 0;
 196     HANDLE handles[2];
 197
 198     if (!(in_buff = HeapAlloc( GetProcessHeap(), 0, in_size )))
 199     {
 200         ERR( "failed to allocate buffer\n" );
 201         return STATUS_NO_MEMORY;
 202     }
 203
 204     handles[0] = stop_event;
 205     handles[1] = manager;
 206
 207     for (;;)
 208     {
 209         SERVER_START_REQ( get_next_device_request )
 210         {
 211             req->manager = wine_server_obj_handle( manager );
 212             req->prev = ioctl;
 213             req->status = status;
 214             wine_server_add_data( req, out_buff, out_size );
 215             wine_server_set_reply( req, in_buff, in_size );
 216             if (!(status = wine_server_call( req )))
 217             {
 218                 code     = reply->code;
 219                 ioctl    = reply->next;
 220                 device   = wine_server_get_ptr( reply->user_ptr );
 221                 in_size  = reply->in_size;
 222                 out_size = reply->out_size;
 223             }
 224             else
 225             {
 226                 ioctl = 0; /* no previous ioctl */
 227                 out_size = 0;
 228                 in_size = reply->in_size;
 229             }
 230         }
 231         SERVER_END_REQ;
 232
 233         switch(status)
 234         {
 235         case STATUS_SUCCESS:
 236             HeapFree( GetProcessHeap(), 0, out_buff );
 237             if (out_size) out_buff = HeapAlloc( GetProcessHeap(), 0, out_size );
 238             else out_buff = NULL;
 239             status = process_ioctl( device, code, in_buff, in_size, out_buff, &out_size );
 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             if (WaitForMultipleObjects( 2, handles, FALSE, INFINITE ) == WAIT_OBJECT_0)
 248             {
 249                 HeapFree( GetProcessHeap(), 0, in_buff );
 250                 HeapFree( GetProcessHeap(), 0, out_buff );
 251                 return STATUS_SUCCESS;
 252             }
 253             break;
 254         }
 255     }
 256 }
 257
 258
 259 /***********************************************************************
 260  *           IoAllocateDriverObjectExtension  (NTOSKRNL.EXE.@)
 261  */
 262 NTSTATUS WINAPI IoAllocateDriverObjectExtension( PDRIVER_OBJECT DriverObject,
 263                                                  PVOID ClientIdentificationAddress,
 264                                                  ULONG DriverObjectExtensionSize,
 265                                                  PVOID *DriverObjectExtension )
 266 {
 267     FIXME( "stub: %p, %p, %u, %p\n", DriverObject, ClientIdentificationAddress,
 268             DriverObjectExtensionSize, DriverObjectExtension );
 269     return STATUS_NOT_IMPLEMENTED;
 270 }
 271
 272
 273 /***********************************************************************
 274  *           IoGetDriverObjectExtension  (NTOSKRNL.EXE.@)
 275  */
 276 PVOID WINAPI IoGetDriverObjectExtension( PDRIVER_OBJECT DriverObject,
 277                                          PVOID ClientIdentificationAddress )
 278 {
 279     FIXME( "stub: %p, %p\n", DriverObject, ClientIdentificationAddress );
 280     return NULL;
 281 }
 282
 283
 284 /***********************************************************************
 285  *           IoInitializeIrp  (NTOSKRNL.EXE.@)
 286  */
 287 void WINAPI IoInitializeIrp( IRP *irp, USHORT size, CCHAR stack_size )
 288 {
 289     TRACE( "%p, %u, %d\n", irp, size, stack_size );
 290
 291     RtlZeroMemory( irp, size );
 292
 293     irp->Type = IO_TYPE_IRP;
 294     irp->Size = size;
 295     InitializeListHead( &irp->ThreadListEntry );
 296     irp->StackCount = stack_size;
 297     irp->CurrentLocation = stack_size + 1;
 298     irp->Tail.Overlay.s.u2.CurrentStackLocation =
 299             (PIO_STACK_LOCATION)(irp + 1) + stack_size;
 300 }
 301
 302
 303 /***********************************************************************
 304  *           IoInitializeTimer   (NTOSKRNL.EXE.@)
 305  */
 306 NTSTATUS WINAPI IoInitializeTimer(PDEVICE_OBJECT DeviceObject,
 307                                   PIO_TIMER_ROUTINE TimerRoutine,
 308                                   PVOID Context)
 309 {
 310     FIXME( "stub: %p, %p, %p\n", DeviceObject, TimerRoutine, Context );
 311     return STATUS_NOT_IMPLEMENTED;
 312 }
 313
 314
 315 /***********************************************************************
 316  *           IoStartTimer   (NTOSKRNL.EXE.@)
 317  */
 318 void WINAPI IoStartTimer(PDEVICE_OBJECT DeviceObject)
 319 {
 320     FIXME( "stub: %p\n", DeviceObject );
 321 }
 322
 323
 324 /***********************************************************************
 325  *           IoAllocateIrp  (NTOSKRNL.EXE.@)
 326  */
 327 PIRP WINAPI IoAllocateIrp( CCHAR stack_size, BOOLEAN charge_quota )
 328 {
 329     SIZE_T size;
 330     PIRP irp;
 331
 332     TRACE( "%d, %d\n", stack_size, charge_quota );
 333
 334     size = sizeof(IRP) + stack_size * sizeof(IO_STACK_LOCATION);
 335     irp = ExAllocatePool( NonPagedPool, size );
 336     if (irp == NULL)
 337         return NULL;
 338     IoInitializeIrp( irp, size, stack_size );
 339     irp->AllocationFlags = IRP_ALLOCATED_FIXED_SIZE;
 340     if (charge_quota)
 341         irp->AllocationFlags |= IRP_LOOKASIDE_ALLOCATION;
 342     return irp;
 343 }
 344
 345
 346 /***********************************************************************
 347  *           IoFreeIrp  (NTOSKRNL.EXE.@)
 348  */
 349 void WINAPI IoFreeIrp( IRP *irp )
 350 {
 351     TRACE( "%p\n", irp );
 352
 353     ExFreePool( irp );
 354 }
 355
 356
 357 /***********************************************************************
 358  *           IoAllocateErrorLogEntry  (NTOSKRNL.EXE.@)
 359  */
 360 PVOID WINAPI IoAllocateErrorLogEntry( PVOID IoObject, UCHAR EntrySize )
 361 {
 362     FIXME( "stub: %p, %u\n", IoObject, EntrySize );
 363     return NULL;
 364 }
 365
 366
 367 /***********************************************************************
 368  *           IoAllocateMdl  (NTOSKRNL.EXE.@)
 369  */
 370 PMDL WINAPI IoAllocateMdl( PVOID VirtualAddress, ULONG Length, BOOLEAN SecondaryBuffer, BOOLEAN ChargeQuota, PIRP Irp )
 371 {
 372     FIXME( "stub: %p, %u, %i, %i, %p\n", VirtualAddress, Length, SecondaryBuffer, ChargeQuota, Irp );
 373     return NULL;
 374 }
 375
 376
 377 /***********************************************************************
 378  *           IoAllocateWorkItem  (NTOSKRNL.EXE.@)
 379  */
 380 PIO_WORKITEM WINAPI IoAllocateWorkItem( PDEVICE_OBJECT DeviceObject )
 381 {
 382     FIXME( "stub: %p\n", DeviceObject );
 383     return NULL;
 384 }
 385
 386
 387 /***********************************************************************
 388  *           IoAttachDeviceToDeviceStack  (NTOSKRNL.EXE.@)
 389  */
 390 PDEVICE_OBJECT WINAPI IoAttachDeviceToDeviceStack( DEVICE_OBJECT *source,
 391                                                    DEVICE_OBJECT *target )
 392 {
 393     TRACE( "%p, %p\n", source, target );
 394     target->AttachedDevice = source;
 395     source->StackSize = target->StackSize + 1;
 396     return target;
 397 }
 398
 399
 400 /***********************************************************************
 401  *           IoBuildDeviceIoControlRequest  (NTOSKRNL.EXE.@)
 402  */
 403 PIRP WINAPI IoBuildDeviceIoControlRequest( ULONG IoControlCode,
 404                                            PDEVICE_OBJECT DeviceObject,
 405                                            PVOID InputBuffer,
 406                                            ULONG InputBufferLength,
 407                                            PVOID OutputBuffer,
 408                                            ULONG OutputBufferLength,
 409                                            BOOLEAN InternalDeviceIoControl,
 410                                            PKEVENT Event,
 411                                            PIO_STATUS_BLOCK IoStatusBlock )
 412 {
 413     PIRP irp;
 414     PIO_STACK_LOCATION irpsp;
 415     struct IrpInstance *instance;
 416
 417     TRACE( "%x, %p, %p, %u, %p, %u, %u, %p, %p\n",
 418            IoControlCode, DeviceObject, InputBuffer, InputBufferLength,
 419            OutputBuffer, OutputBufferLength, InternalDeviceIoControl,
 420            Event, IoStatusBlock );
 421
 422     if (DeviceObject == NULL)
 423         return NULL;
 424
 425     irp = IoAllocateIrp( DeviceObject->StackSize, FALSE );
 426     if (irp == NULL)
 427         return NULL;
 428
 429     instance = HeapAlloc( GetProcessHeap(), 0, sizeof(struct IrpInstance) );
 430     if (instance == NULL)
 431     {
 432         IoFreeIrp( irp );
 433         return NULL;
 434     }
 435     instance->irp = irp;
 436     list_add_tail( &Irps, &instance->entry );
 437
 438     irpsp = IoGetNextIrpStackLocation( irp );
 439     irpsp->MajorFunction = InternalDeviceIoControl ?
 440             IRP_MJ_INTERNAL_DEVICE_CONTROL : IRP_MJ_DEVICE_CONTROL;
 441     irpsp->Parameters.DeviceIoControl.IoControlCode = IoControlCode;
 442     irp->UserIosb = IoStatusBlock;
 443     irp->UserEvent = Event;
 444
 445     return irp;
 446 }
 447
 448
 449 /***********************************************************************
 450  *           IoCreateDriver   (NTOSKRNL.EXE.@)
 451  */
 452 NTSTATUS WINAPI IoCreateDriver( UNICODE_STRING *name, PDRIVER_INITIALIZE init )
 453 {
 454     DRIVER_OBJECT *driver;
 455     DRIVER_EXTENSION *extension;
 456     NTSTATUS status;
 457
 458     if (!(driver = RtlAllocateHeap( GetProcessHeap(), HEAP_ZERO_MEMORY,
 459                                     sizeof(*driver) + sizeof(*extension) )))
 460         return STATUS_NO_MEMORY;
 461
 462     if ((status = RtlDuplicateUnicodeString( 1, name, &driver->DriverName )))
 463     {
 464         RtlFreeHeap( GetProcessHeap(), 0, driver );
 465         return status;
 466     }
 467
 468     extension = (DRIVER_EXTENSION *)(driver + 1);
 469     driver->Size            = sizeof(*driver);
 470     driver->DriverInit      = init;
 471     driver->DriverExtension = extension;
 472     extension->DriverObject   = driver;
 473     extension->ServiceKeyName = driver->DriverName;
 474
 475     status = driver->DriverInit( driver, name );
 476
 477     if (status)
 478     {
 479         RtlFreeUnicodeString( &driver->DriverName );
 480         RtlFreeHeap( GetProcessHeap(), 0, driver );
 481     }
 482     return status;
 483 }
 484
 485
 486 /***********************************************************************
 487  *           IoDeleteDriver   (NTOSKRNL.EXE.@)
 488  */
 489 void WINAPI IoDeleteDriver( DRIVER_OBJECT *driver )
 490 {
 491     RtlFreeUnicodeString( &driver->DriverName );
 492     RtlFreeHeap( GetProcessHeap(), 0, driver );
 493 }
 494
 495
 496 /***********************************************************************
 497  *           IoCreateDevice   (NTOSKRNL.EXE.@)
 498  */
 499 NTSTATUS WINAPI IoCreateDevice( DRIVER_OBJECT *driver, ULONG ext_size,
 500                                 UNICODE_STRING *name, DEVICE_TYPE type,
 501                                 ULONG characteristics, BOOLEAN exclusive,
 502                                 DEVICE_OBJECT **ret_device )
 503 {
 504     NTSTATUS status;
 505     DEVICE_OBJECT *device;
 506     HANDLE handle = 0;
 507     HANDLE manager = get_device_manager();
 508
 509     TRACE( "(%p, %u, %s, %u, %x, %u, %p)\n",
 510            driver, ext_size, debugstr_us(name), type, characteristics, exclusive, ret_device );
 511
 512     if (!(device = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*device) + ext_size )))
 513         return STATUS_NO_MEMORY;
 514
 515     SERVER_START_REQ( create_device )
 516     {
 517         req->access     = 0;
 518         req->attributes = 0;
 519         req->rootdir    = 0;
 520         req->manager    = wine_server_obj_handle( manager );
 521         req->user_ptr   = wine_server_client_ptr( device );
 522         if (name) wine_server_add_data( req, name->Buffer, name->Length );
 523         if (!(status = wine_server_call( req ))) handle = wine_server_ptr_handle( reply->handle );
 524     }
 525     SERVER_END_REQ;
 526
 527     if (status == STATUS_SUCCESS)
 528     {
 529         device->DriverObject    = driver;
 530         device->DeviceExtension = device + 1;
 531         device->DeviceType      = type;
 532         device->StackSize       = 1;
 533         device->Reserved        = handle;
 534
 535         device->NextDevice   = driver->DeviceObject;
 536         driver->DeviceObject = device;
 537
 538         *ret_device = device;
 539     }
 540     else HeapFree( GetProcessHeap(), 0, device );
 541
 542     return status;
 543 }
 544
 545
 546 /***********************************************************************
 547  *           IoDeleteDevice   (NTOSKRNL.EXE.@)
 548  */
 549 void WINAPI IoDeleteDevice( DEVICE_OBJECT *device )
 550 {
 551     NTSTATUS status;
 552
 553     TRACE( "%p\n", device );
 554
 555     SERVER_START_REQ( delete_device )
 556     {
 557         req->handle = wine_server_obj_handle( device->Reserved );
 558         status = wine_server_call( req );
 559     }
 560     SERVER_END_REQ;
 561
 562     if (status == STATUS_SUCCESS)
 563     {
 564         DEVICE_OBJECT **prev = &device->DriverObject->DeviceObject;
 565         while (*prev && *prev != device) prev = &(*prev)->NextDevice;
 566         if (*prev) *prev = (*prev)->NextDevice;
 567         NtClose( device->Reserved );
 568         HeapFree( GetProcessHeap(), 0, device );
 569     }
 570 }
 571
 572
 573 /***********************************************************************
 574  *           IoCreateSymbolicLink   (NTOSKRNL.EXE.@)
 575  */
 576 NTSTATUS WINAPI IoCreateSymbolicLink( UNICODE_STRING *name, UNICODE_STRING *target )
 577 {
 578     HANDLE handle;
 579     OBJECT_ATTRIBUTES attr;
 580
 581     attr.Length                   = sizeof(attr);
 582     attr.RootDirectory            = 0;
 583     attr.ObjectName               = name;
 584     attr.Attributes               = OBJ_CASE_INSENSITIVE | OBJ_OPENIF;
 585     attr.SecurityDescriptor       = NULL;
 586     attr.SecurityQualityOfService = NULL;
 587
 588     TRACE( "%s -> %s\n", debugstr_us(name), debugstr_us(target) );
 589     /* FIXME: store handle somewhere */
 590     return NtCreateSymbolicLinkObject( &handle, SYMBOLIC_LINK_ALL_ACCESS, &attr, target );
 591 }
 592
 593
 594 /***********************************************************************
 595  *           IoDeleteSymbolicLink   (NTOSKRNL.EXE.@)
 596  */
 597 NTSTATUS WINAPI IoDeleteSymbolicLink( UNICODE_STRING *name )
 598 {
 599     HANDLE handle;
 600     OBJECT_ATTRIBUTES attr;
 601     NTSTATUS status;
 602
 603     attr.Length                   = sizeof(attr);
 604     attr.RootDirectory            = 0;
 605     attr.ObjectName               = name;
 606     attr.Attributes               = OBJ_CASE_INSENSITIVE;
 607     attr.SecurityDescriptor       = NULL;
 608     attr.SecurityQualityOfService = NULL;
 609
 610     if (!(status = NtOpenSymbolicLinkObject( &handle, 0, &attr )))
 611     {
 612         SERVER_START_REQ( unlink_object )
 613         {
 614             req->handle = wine_server_obj_handle( handle );
 615             status = wine_server_call( req );
 616         }
 617         SERVER_END_REQ;
 618         NtClose( handle );
 619     }
 620     return status;
 621 }
 622
 623
 624 /***********************************************************************
 625  *           IoGetDeviceObjectPointer   (NTOSKRNL.EXE.@)
 626  */
 627 NTSTATUS  WINAPI IoGetDeviceObjectPointer( UNICODE_STRING *name, ACCESS_MASK access, PFILE_OBJECT *file, PDEVICE_OBJECT *device )
 628 {
 629     FIXME( "stub: %s %x %p %p\n", debugstr_us(name), access, file, device );
 630     return STATUS_NOT_IMPLEMENTED;
 631 }
 632
 633
 634 /***********************************************************************
 635  *           IofCallDriver   (NTOSKRNL.EXE.@)
 636  */
 637 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
 638 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver )
 639 NTSTATUS WINAPI __regs_IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
 640 #else
 641 NTSTATUS WINAPI IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
 642 #endif
 643 {
 644     PDRIVER_DISPATCH dispatch;
 645     IO_STACK_LOCATION *irpsp;
 646     NTSTATUS status;
 647
 648     TRACE( "%p %p\n", device, irp );
 649
 650     --irp->CurrentLocation;
 651     irpsp = --irp->Tail.Overlay.s.u2.CurrentStackLocation;
 652     dispatch = device->DriverObject->MajorFunction[irpsp->MajorFunction];
 653     status = dispatch( device, irp );
 654
 655     return status;
 656 }
 657
 658
 659 /***********************************************************************
 660  *           IoGetRelatedDeviceObject    (NTOSKRNL.EXE.@)
 661  */
 662 PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject( PFILE_OBJECT obj )
 663 {
 664     FIXME( "stub: %p\n", obj );
 665     return NULL;
 666 }
 667
 668 static CONFIGURATION_INFORMATION configuration_information;
 669
 670 /***********************************************************************
 671  *           IoGetConfigurationInformation    (NTOSKRNL.EXE.@)
 672  */
 673 PCONFIGURATION_INFORMATION WINAPI IoGetConfigurationInformation(void)
 674 {
 675     FIXME( "partial stub\n" );
 676     /* FIXME: return actual devices on system */
 677     return &configuration_information;
 678 }
 679
 680
 681 /***********************************************************************
 682  *           IoIsWdmVersionAvailable     (NTOSKRNL.EXE.@)
 683  */
 684 NTSTATUS WINAPI IoIsWdmVersionAvailable(UCHAR MajorVersion, UCHAR MinorVersion)
 685 {
 686     DWORD version;
 687     DWORD major;
 688     DWORD minor;
 689
 690     TRACE( "%d, 0x%X\n", MajorVersion, MinorVersion );
 691
 692     version = GetVersion();
 693     major = LOBYTE(version);
 694     minor = HIBYTE(LOWORD(version));
 695
 696     if (MajorVersion == 6 && MinorVersion == 0)
 697     {
 698         /* Windows Vista, Windows Server 2008, Windows 7 */
 699     }
 700     else if (MajorVersion == 1)
 701     {
 702         if (MinorVersion == 0x30)
 703         {
 704             /* Windows server 2003 */
 705             MajorVersion = 6;
 706             MinorVersion = 0;
 707         }
 708         else if (MinorVersion == 0x20)
 709         {
 710             /* Windows XP */
 711             MajorVersion = 5;
 712             MinorVersion = 1;
 713         }
 714         else if (MinorVersion == 0x10)
 715         {
 716             /* Windows 2000 */
 717             MajorVersion = 5;
 718             MinorVersion = 0;
 719         }
 720         else if (MinorVersion == 0x05)
 721         {
 722             /* Windows ME */
 723             MajorVersion = 4;
 724             MinorVersion = 0x5a;
 725         }
 726         else if (MinorVersion == 0x00)
 727         {
 728             /* Windows 98 */
 729             MajorVersion = 4;
 730             MinorVersion = 0x0a;
 731         }
 732         else
 733         {
 734             FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
 735             return FALSE;
 736         }
 737     }
 738     else
 739     {
 740         FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
 741         return FALSE;
 742     }
 743     return major > MajorVersion || (major == MajorVersion && minor >= MinorVersion);
 744 }
 745
 746
 747 /***********************************************************************
 748  *           IoQueryDeviceDescription    (NTOSKRNL.EXE.@)
 749  */
 750 NTSTATUS WINAPI IoQueryDeviceDescription(PINTERFACE_TYPE itype, PULONG bus, PCONFIGURATION_TYPE ctype,
 751                                      PULONG cnum, PCONFIGURATION_TYPE ptype, PULONG pnum,
 752                                      PIO_QUERY_DEVICE_ROUTINE callout, PVOID context)
 753 {
 754     FIXME( "(%p %p %p %p %p %p %p %p)\n", itype, bus, ctype, cnum, ptype, pnum, callout, context);
 755     return STATUS_NOT_IMPLEMENTED;
 756 }
 757
 758
 759 /***********************************************************************
 760  *           IoRegisterDriverReinitialization    (NTOSKRNL.EXE.@)
 761  */
 762 void WINAPI IoRegisterDriverReinitialization( PDRIVER_OBJECT obj, PDRIVER_REINITIALIZE reinit, PVOID context )
 763 {
 764     FIXME( "stub: %p %p %p\n", obj, reinit, context );
 765 }
 766
 767
 768 /***********************************************************************
 769  *           IoRegisterShutdownNotification    (NTOSKRNL.EXE.@)
 770  */
 771 NTSTATUS WINAPI IoRegisterShutdownNotification( PDEVICE_OBJECT obj )
 772 {
 773     FIXME( "stub: %p\n", obj );
 774     return STATUS_SUCCESS;
 775 }
 776
 777
 778 /***********************************************************************
 779  *           IoReportResourceUsage    (NTOSKRNL.EXE.@)
 780  */
 781 NTSTATUS WINAPI IoReportResourceUsage(PUNICODE_STRING name, PDRIVER_OBJECT drv_obj, PCM_RESOURCE_LIST drv_list,
 782                                       ULONG drv_size, PDRIVER_OBJECT dev_obj, PCM_RESOURCE_LIST dev_list,
 783                                       ULONG dev_size, BOOLEAN overwrite, PBOOLEAN detected)
 784 {
 785     FIXME("(%s %p %p %u %p %p %u %d %p) stub\n", debugstr_w(name? name->Buffer : NULL),
 786           drv_obj, drv_list, drv_size, dev_obj, dev_list, dev_size, overwrite, detected);
 787     return STATUS_NOT_IMPLEMENTED;
 788 }
 789
 790
 791 /***********************************************************************
 792  *           IoCompleteRequest   (NTOSKRNL.EXE.@)
 793  */
 794 VOID WINAPI IoCompleteRequest( IRP *irp, UCHAR priority_boost )
 795 {
 796     IO_STACK_LOCATION *irpsp;
 797     PIO_COMPLETION_ROUTINE routine;
 798     IO_STATUS_BLOCK *iosb;
 799     struct IrpInstance *instance;
 800     NTSTATUS status, stat;
 801     int call_flag = 0;
 802
 803     TRACE( "%p %u\n", irp, priority_boost );
 804
 805     iosb = irp->UserIosb;
 806     status = irp->IoStatus.u.Status;
 807     while (irp->CurrentLocation <= irp->StackCount)
 808     {
 809         irpsp = irp->Tail.Overlay.s.u2.CurrentStackLocation;
 810         routine = irpsp->CompletionRoutine;
 811         call_flag = 0;
 812         /* FIXME: add SL_INVOKE_ON_CANCEL support */
 813         if (routine)
 814         {
 815             if ((irpsp->Control & SL_INVOKE_ON_SUCCESS) && STATUS_SUCCESS == status)
 816                 call_flag = 1;
 817             if ((irpsp->Control & SL_INVOKE_ON_ERROR) && STATUS_SUCCESS != status)
 818                 call_flag = 1;
 819         }
 820         ++irp->CurrentLocation;
 821         ++irp->Tail.Overlay.s.u2.CurrentStackLocation;
 822         if (call_flag)
 823         {
 824             TRACE( "calling %p( %p, %p, %p )\n", routine,
 825                     irpsp->DeviceObject, irp, irpsp->Context );
 826             stat = routine( irpsp->DeviceObject, irp, irpsp->Context );
 827             TRACE( "CompletionRoutine returned %x\n", stat );
 828             if (STATUS_MORE_PROCESSING_REQUIRED == stat)
 829                 return;
 830         }
 831     }
 832     if (iosb && STATUS_SUCCESS == status)
 833     {
 834         iosb->u.Status = irp->IoStatus.u.Status;
 835         iosb->Information = irp->IoStatus.Information;
 836     }
 837     LIST_FOR_EACH_ENTRY( instance, &Irps, struct IrpInstance, entry )
 838     {
 839         if (instance->irp == irp)
 840         {
 841             list_remove( &instance->entry );
 842             HeapFree( GetProcessHeap(), 0, instance );
 843             IoFreeIrp( irp );
 844             break;
 845         }
 846     }
 847 }
 848
 849
 850 /***********************************************************************
 851  *           IofCompleteRequest   (NTOSKRNL.EXE.@)
 852  */
 853 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
 854 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest )
 855 void WINAPI __regs_IofCompleteRequest( IRP *irp, UCHAR priority_boost )
 856 #else
 857 void WINAPI IofCompleteRequest( IRP *irp, UCHAR priority_boost )
 858 #endif
 859 {
 860     TRACE( "%p %u\n", irp, priority_boost );
 861     IoCompleteRequest( irp, priority_boost );
 862 }
 863
 864
 865 /***********************************************************************
 866  *           InterlockedCompareExchange   (NTOSKRNL.EXE.@)
 867  */
 868 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
 869 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange )
 870 LONG WINAPI __regs_NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
 871 #else
 872 LONG WINAPI NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
 873 #endif
 874 {
 875     return InterlockedCompareExchange( dest, xchg, compare );
 876 }
 877
 878
 879 /***********************************************************************
 880  *           InterlockedDecrement   (NTOSKRNL.EXE.@)
 881  */
 882 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
 883 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement )
 884 LONG WINAPI __regs_NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
 885 #else
 886 LONG WINAPI NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
 887 #endif
 888 {
 889     return InterlockedDecrement( dest );
 890 }
 891
 892
 893 /***********************************************************************
 894  *           InterlockedExchange   (NTOSKRNL.EXE.@)
 895  */
 896 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
 897 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange )
 898 LONG WINAPI __regs_NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
 899 #else
 900 LONG WINAPI NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
 901 #endif
 902 {
 903     return InterlockedExchange( dest, val );
 904 }
 905
 906
 907 /***********************************************************************
 908  *           InterlockedExchangeAdd   (NTOSKRNL.EXE.@)
 909  */
 910 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
 911 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd )
 912 LONG WINAPI __regs_NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
 913 #else
 914 LONG WINAPI NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
 915 #endif
 916 {
 917     return InterlockedExchangeAdd( dest, incr );
 918 }
 919
 920
 921 /***********************************************************************
 922  *           InterlockedIncrement   (NTOSKRNL.EXE.@)
 923  */
 924 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
 925 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement )
 926 LONG WINAPI __regs_NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
 927 #else
 928 LONG WINAPI NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
 929 #endif
 930 {
 931     return InterlockedIncrement( dest );
 932 }
 933
 934
 935 /***********************************************************************
 936  *           ExAllocatePool   (NTOSKRNL.EXE.@)
 937  */
 938 PVOID WINAPI ExAllocatePool( POOL_TYPE type, SIZE_T size )
 939 {
 940     return ExAllocatePoolWithTag( type, size, 0 );
 941 }
 942
 943
 944 /***********************************************************************
 945  *           ExAllocatePoolWithQuota   (NTOSKRNL.EXE.@)
 946  */
 947 PVOID WINAPI ExAllocatePoolWithQuota( POOL_TYPE type, SIZE_T size )
 948 {
 949     return ExAllocatePoolWithTag( type, size, 0 );
 950 }
 951
 952
 953 /***********************************************************************
 954  *           ExAllocatePoolWithTag   (NTOSKRNL.EXE.@)
 955  */
 956 PVOID WINAPI ExAllocatePoolWithTag( POOL_TYPE type, SIZE_T size, ULONG tag )
 957 {
 958     /* FIXME: handle page alignment constraints */
 959     void *ret = HeapAlloc( GetProcessHeap(), 0, size );
 960     TRACE( "%lu pool %u -> %p\n", size, type, ret );
 961     return ret;
 962 }
 963
 964
 965 /***********************************************************************
 966  *           ExAllocatePoolWithQuotaTag   (NTOSKRNL.EXE.@)
 967  */
 968 PVOID WINAPI ExAllocatePoolWithQuotaTag( POOL_TYPE type, SIZE_T size, ULONG tag )
 969 {
 970     return ExAllocatePoolWithTag( type, size, tag );
 971 }
 972
 973
 974 /***********************************************************************
 975  *           ExFreePool   (NTOSKRNL.EXE.@)
 976  */
 977 void WINAPI ExFreePool( void *ptr )
 978 {
 979     ExFreePoolWithTag( ptr, 0 );
 980 }
 981
 982
 983 /***********************************************************************
 984  *           ExFreePoolWithTag   (NTOSKRNL.EXE.@)
 985  */
 986 void WINAPI ExFreePoolWithTag( void *ptr, ULONG tag )
 987 {
 988     TRACE( "%p\n", ptr );
 989     HeapFree( GetProcessHeap(), 0, ptr );
 990 }
 991
 992
 993 /***********************************************************************
 994  *           ExInitializeResourceLite   (NTOSKRNL.EXE.@)
 995  */
 996 NTSTATUS WINAPI ExInitializeResourceLite(PERESOURCE Resource)
 997 {
 998     FIXME( "stub: %p\n", Resource );
 999     return STATUS_NOT_IMPLEMENTED;
1000 }
1001
1002
1003 /***********************************************************************
1004  *           ExInitializeNPagedLookasideList   (NTOSKRNL.EXE.@)
1005  */
1006 void WINAPI ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
1007                                             PALLOCATE_FUNCTION Allocate,
1008                                             PFREE_FUNCTION Free,
1009                                             ULONG Flags,
1010                                             SIZE_T Size,
1011                                             ULONG Tag,
1012                                             USHORT Depth)
1013 {
1014     FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1015 }
1016
1017
1018 /***********************************************************************
1019  *           ExInitializeZone   (NTOSKRNL.EXE.@)
1020  */
1021 NTSTATUS WINAPI ExInitializeZone(PZONE_HEADER Zone,
1022                                  ULONG BlockSize,
1023                                  PVOID InitialSegment,
1024                                  ULONG InitialSegmentSize)
1025 {
1026     FIXME( "stub: %p, %u, %p, %u\n", Zone, BlockSize, InitialSegment, InitialSegmentSize );
1027     return STATUS_NOT_IMPLEMENTED;
1028 }
1029
1030 /***********************************************************************
1031 *           FsRtlRegisterUncProvider   (NTOSKRNL.EXE.@)
1032 */
1033 NTSTATUS WINAPI FsRtlRegisterUncProvider(PHANDLE MupHandle, PUNICODE_STRING RedirDevName,
1034                                          BOOLEAN MailslotsSupported)
1035 {
1036     FIXME("(%p %p %d): stub\n", MupHandle, RedirDevName, MailslotsSupported);
1037     return STATUS_NOT_IMPLEMENTED;
1038 }
1039
1040 /***********************************************************************
1041  *           KeGetCurrentThread / PsGetCurrentThread   (NTOSKRNL.EXE.@)
1042  */
1043 PRKTHREAD WINAPI KeGetCurrentThread(void)
1044 {
1045     FIXME("() stub\n");
1046     return NULL;
1047 }
1048
1049 /***********************************************************************
1050  *           KeInitializeEvent   (NTOSKRNL.EXE.@)
1051  */
1052 void WINAPI KeInitializeEvent( PRKEVENT Event, EVENT_TYPE Type, BOOLEAN State )
1053 {
1054     FIXME( "stub: %p %d %d\n", Event, Type, State );
1055 }
1056
1057
1058  /***********************************************************************
1059  *           KeInitializeMutex   (NTOSKRNL.EXE.@)
1060  */
1061 void WINAPI KeInitializeMutex(PRKMUTEX Mutex, ULONG Level)
1062 {
1063     FIXME( "stub: %p, %u\n", Mutex, Level );
1064 }
1065
1066
1067 /***********************************************************************
1068  *           KeInitializeSemaphore   (NTOSKRNL.EXE.@)
1069  */
1070 void WINAPI KeInitializeSemaphore( PRKSEMAPHORE Semaphore, LONG Count, LONG Limit )
1071 {
1072     FIXME( "(%p %d %d) stub\n", Semaphore , Count, Limit );
1073 }
1074
1075
1076 /***********************************************************************
1077  *           KeInitializeSpinLock   (NTOSKRNL.EXE.@)
1078  */
1079 void WINAPI KeInitializeSpinLock( PKSPIN_LOCK SpinLock )
1080 {
1081     FIXME( "stub: %p\n", SpinLock );
1082 }
1083
1084
1085 /***********************************************************************
1086  *           KeInitializeTimerEx   (NTOSKRNL.EXE.@)
1087  */
1088 void WINAPI KeInitializeTimerEx( PKTIMER Timer, TIMER_TYPE Type )
1089 {
1090     FIXME( "stub: %p %d\n", Timer, Type );
1091 }
1092
1093
1094 /***********************************************************************
1095  *           KeInitializeTimer   (NTOSKRNL.EXE.@)
1096  */
1097 void WINAPI KeInitializeTimer( PKTIMER Timer )
1098 {
1099     KeInitializeTimerEx(Timer, NotificationTimer);
1100 }
1101
1102
1103 /**********************************************************************
1104  *           KeQueryActiveProcessors   (NTOSKRNL.EXE.@)
1105  *
1106  * Return the active Processors as bitmask
1107  *
1108  * RETURNS
1109  *   active Processors as bitmask
1110  *
1111  */
1112 KAFFINITY WINAPI KeQueryActiveProcessors( void )
1113 {
1114     DWORD_PTR AffinityMask;
1115
1116     GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask, NULL);
1117     return AffinityMask;
1118 }
1119
1120
1121 /**********************************************************************
1122  *           KeQueryInterruptTime   (NTOSKRNL.EXE.@)
1123  *
1124  * Return the interrupt time count
1125  *
1126  */
1127 ULONGLONG WINAPI KeQueryInterruptTime( void )
1128 {
1129     LARGE_INTEGER totaltime;
1130
1131     KeQueryTickCount(&totaltime);
1132     return totaltime.QuadPart;
1133 }
1134
1135
1136 /***********************************************************************
1137  *           KeQuerySystemTime   (NTOSKRNL.EXE.@)
1138  */
1139 void WINAPI KeQuerySystemTime( LARGE_INTEGER *time )
1140 {
1141     NtQuerySystemTime( time );
1142 }
1143
1144
1145 /***********************************************************************
1146  *           KeQueryTickCount   (NTOSKRNL.EXE.@)
1147  */
1148 void WINAPI KeQueryTickCount( LARGE_INTEGER *count )
1149 {
1150     count->QuadPart = NtGetTickCount();
1151     /* update the global variable too */
1152     KeTickCount.LowPart   = count->u.LowPart;
1153     KeTickCount.High1Time = count->u.HighPart;
1154     KeTickCount.High2Time = count->u.HighPart;
1155 }
1156
1157
1158 /***********************************************************************
1159  *           KeReleaseSemaphore   (NTOSKRNL.EXE.@)
1160  */
1161 LONG WINAPI KeReleaseSemaphore( PRKSEMAPHORE Semaphore, KPRIORITY Increment,
1162                                 LONG Adjustment, BOOLEAN Wait )
1163 {
1164     FIXME("(%p %d %d %d) stub\n", Semaphore, Increment, Adjustment, Wait );
1165     return 0;
1166 }
1167
1168
1169 /***********************************************************************
1170  *           KeQueryTimeIncrement   (NTOSKRNL.EXE.@)
1171  */
1172 ULONG WINAPI KeQueryTimeIncrement(void)
1173 {
1174     return 10000;
1175 }
1176
1177
1178 /***********************************************************************
1179  *           KeResetEvent   (NTOSKRNL.EXE.@)
1180  */
1181 LONG WINAPI KeResetEvent( PRKEVENT Event )
1182 {
1183     FIXME("(%p): stub\n", Event);
1184     return 0;
1185 }
1186
1187
1188 /***********************************************************************
1189  *           KeSetEvent   (NTOSKRNL.EXE.@)
1190  */
1191 LONG WINAPI KeSetEvent( PRKEVENT Event, KPRIORITY Increment, BOOLEAN Wait )
1192 {
1193     FIXME("(%p, %d, %d): stub\n", Event, Increment, Wait);
1194     return 0;
1195 }
1196
1197
1198 /***********************************************************************
1199  *           KeSetPriorityThread   (NTOSKRNL.EXE.@)
1200  */
1201 KPRIORITY WINAPI KeSetPriorityThread( PKTHREAD Thread, KPRIORITY Priority )
1202 {
1203     FIXME("(%p %d)\n", Thread, Priority);
1204     return Priority;
1205 }
1206
1207
1208 /***********************************************************************
1209  *           KeWaitForSingleObject   (NTOSKRNL.EXE.@)
1210  */
1211 NTSTATUS WINAPI KeWaitForSingleObject(PVOID Object,
1212                                       KWAIT_REASON WaitReason,
1213                                       KPROCESSOR_MODE WaitMode,
1214                                       BOOLEAN Alertable,
1215                                       PLARGE_INTEGER Timeout)
1216 {
1217     FIXME( "stub: %p, %d, %d, %d, %p\n", Object, WaitReason, WaitMode, Alertable, Timeout );
1218     return STATUS_NOT_IMPLEMENTED;
1219 }
1220
1221 /***********************************************************************
1222  *           IoRegisterFileSystem   (NTOSKRNL.EXE.@)
1223  */
1224 VOID WINAPI IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject)
1225 {
1226     FIXME("(%p): stub\n", DeviceObject);
1227 }
1228
1229 /***********************************************************************
1230 *           IoUnregisterFileSystem   (NTOSKRNL.EXE.@)
1231 */
1232 VOID WINAPI IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject)
1233 {
1234     FIXME("(%p): stub\n", DeviceObject);
1235 }
1236
1237 /***********************************************************************
1238  *           MmAllocateNonCachedMemory   (NTOSKRNL.EXE.@)
1239  */
1240 PVOID WINAPI MmAllocateNonCachedMemory( SIZE_T size )
1241 {
1242     TRACE( "%lu\n", size );
1243     return VirtualAlloc( NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE|PAGE_NOCACHE );
1244 }
1245
1246 /***********************************************************************
1247  *           MmAllocateContiguousMemory   (NTOSKRNL.EXE.@)
1248  */
1249 PVOID WINAPI MmAllocateContiguousMemory( SIZE_T size, PHYSICAL_ADDRESS highest_valid_address )
1250 {
1251     FIXME( "%lu, %s stub\n", size, wine_dbgstr_longlong(highest_valid_address.QuadPart) );
1252     return NULL;
1253 }
1254
1255 /***********************************************************************
1256  *           MmAllocatePagesForMdl   (NTOSKRNL.EXE.@)
1257  */
1258 PMDL WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress, PHYSICAL_ADDRESS highaddress,
1259                                   PHYSICAL_ADDRESS skipbytes, SIZE_T size)
1260 {
1261     FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress.QuadPart), wine_dbgstr_longlong(highaddress.QuadPart),
1262                                   wine_dbgstr_longlong(skipbytes.QuadPart), size);
1263     return NULL;
1264 }
1265
1266 /***********************************************************************
1267  *           MmFreeNonCachedMemory   (NTOSKRNL.EXE.@)
1268  */
1269 void WINAPI MmFreeNonCachedMemory( void *addr, SIZE_T size )
1270 {
1271     TRACE( "%p %lu\n", addr, size );
1272     VirtualFree( addr, 0, MEM_RELEASE );
1273 }
1274
1275 /***********************************************************************
1276  *           MmIsAddressValid   (NTOSKRNL.EXE.@)
1277  *
1278  * Check if the process can access the virtual address without a pagefault
1279  *
1280  * PARAMS
1281  *  VirtualAddress [I] Address to check
1282  *
1283  * RETURNS
1284  *  Failure: FALSE
1285  *  Success: TRUE  (Accessing the Address works without a Pagefault)
1286  *
1287  */
1288 BOOLEAN WINAPI MmIsAddressValid(PVOID VirtualAddress)
1289 {
1290     TRACE("(%p)\n", VirtualAddress);
1291     return !IsBadWritePtr(VirtualAddress, 1);
1292 }
1293
1294 /***********************************************************************
1295  *           MmPageEntireDriver   (NTOSKRNL.EXE.@)
1296  */
1297 PVOID WINAPI MmPageEntireDriver(PVOID AddrInSection)
1298 {
1299     TRACE("%p\n", AddrInSection);
1300     return AddrInSection;
1301 }
1302
1303 /***********************************************************************
1304  *           MmResetDriverPaging   (NTOSKRNL.EXE.@)
1305  */
1306 void WINAPI MmResetDriverPaging(PVOID AddrInSection)
1307 {
1308     TRACE("%p\n", AddrInSection);
1309 }
1310
1311 /***********************************************************************
1312  *           ObfReferenceObject   (NTOSKRNL.EXE.@)
1313  */
1314 VOID WINAPI ObfReferenceObject(PVOID Object)
1315 {
1316     FIXME("(%p): stub\n", Object);
1317 }
1318
1319  /***********************************************************************
1320  *           ObReferenceObjectByHandle    (NTOSKRNL.EXE.@)
1321  */
1322 NTSTATUS WINAPI ObReferenceObjectByHandle( HANDLE obj, ACCESS_MASK access,
1323                                            POBJECT_TYPE type,
1324                                            KPROCESSOR_MODE mode, PVOID* ptr,
1325                                            POBJECT_HANDLE_INFORMATION info)
1326 {
1327     FIXME( "stub: %p %x %p %d %p %p\n", obj, access, type, mode, ptr, info);
1328     return STATUS_NOT_IMPLEMENTED;
1329 }
1330
1331
1332 /***********************************************************************
1333  *           ObfDereferenceObject   (NTOSKRNL.EXE.@)
1334  */
1335 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1336 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject )
1337 void WINAPI __regs_ObfDereferenceObject( VOID *obj )
1338 #else
1339 void WINAPI ObfDereferenceObject( VOID *obj )
1340 #endif
1341 {
1342     FIXME( "stub: %p\n", obj );
1343 }
1344
1345
1346 /***********************************************************************
1347  *           PsCreateSystemThread   (NTOSKRNL.EXE.@)
1348  */
1349 NTSTATUS WINAPI PsCreateSystemThread(PHANDLE ThreadHandle, ULONG DesiredAccess,
1350                                      POBJECT_ATTRIBUTES ObjectAttributes,
1351                                      HANDLE ProcessHandle, PCLIENT_ID ClientId,
1352                                      PKSTART_ROUTINE StartRoutine, PVOID StartContext)
1353 {
1354     if (!ProcessHandle) ProcessHandle = GetCurrentProcess();
1355     return RtlCreateUserThread(ProcessHandle, 0, FALSE, 0, 0,
1356                                0, StartRoutine, StartContext,
1357                                ThreadHandle, ClientId);
1358 }
1359
1360 /***********************************************************************
1361  *           PsGetCurrentProcessId   (NTOSKRNL.EXE.@)
1362  */
1363 HANDLE WINAPI PsGetCurrentProcessId(void)
1364 {
1365     return UlongToHandle(GetCurrentProcessId());  /* FIXME: not quite right... */
1366 }
1367
1368
1369 /***********************************************************************
1370  *           PsGetCurrentThreadId   (NTOSKRNL.EXE.@)
1371  */
1372 HANDLE WINAPI PsGetCurrentThreadId(void)
1373 {
1374     return UlongToHandle(GetCurrentThreadId());  /* FIXME: not quite right... */
1375 }
1376
1377
1378 /***********************************************************************
1379  *           PsGetVersion   (NTOSKRNL.EXE.@)
1380  */
1381 BOOLEAN WINAPI PsGetVersion(ULONG *major, ULONG *minor, ULONG *build, UNICODE_STRING *version )
1382 {
1383     RTL_OSVERSIONINFOEXW info;
1384
1385     info.dwOSVersionInfoSize = sizeof(info);
1386     RtlGetVersion( &info );
1387     if (major) *major = info.dwMajorVersion;
1388     if (minor) *minor = info.dwMinorVersion;
1389     if (build) *build = info.dwBuildNumber;
1390
1391     if (version)
1392     {
1393 #if 0  /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
1394         size_t len = min( strlenW(info.szCSDVersion)*sizeof(WCHAR), version->MaximumLength );
1395         memcpy( version->Buffer, info.szCSDVersion, len );
1396         if (len < version->MaximumLength) version->Buffer[len / sizeof(WCHAR)] = 0;
1397         version->Length = len;
1398 #endif
1399     }
1400     return TRUE;
1401 }
1402
1403
1404 /***********************************************************************
1405  *           PsSetCreateProcessNotifyRoutine   (NTOSKRNL.EXE.@)
1406  */
1407 NTSTATUS WINAPI PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback, BOOLEAN remove )
1408 {
1409     FIXME( "stub: %p %d\n", callback, remove );
1410     return STATUS_SUCCESS;
1411 }
1412
1413
1414 /***********************************************************************
1415  *           PsSetCreateThreadNotifyRoutine   (NTOSKRNL.EXE.@)
1416  */
1417 NTSTATUS WINAPI PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
1418 {
1419     FIXME( "stub: %p\n", NotifyRoutine );
1420     return STATUS_SUCCESS;
1421 }
1422
1423
1424 /***********************************************************************
1425  *           PsTerminateSystemThread   (NTOSKRNL.EXE.@)
1426  */
1427 NTSTATUS WINAPI PsTerminateSystemThread(NTSTATUS ExitStatus)
1428 {
1429     FIXME( "stub: %u\n", ExitStatus );
1430     return STATUS_NOT_IMPLEMENTED;
1431 }
1432
1433
1434 /***********************************************************************
1435  *           MmGetSystemRoutineAddress   (NTOSKRNL.EXE.@)
1436  */
1437 PVOID WINAPI MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName)
1438 {
1439     HMODULE hMod;
1440     STRING routineNameA;
1441     PVOID pFunc = NULL;
1442
1443     static const WCHAR ntoskrnlW[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
1444     static const WCHAR halW[] = {'h','a','l','.','d','l','l',0};
1445
1446     if (!SystemRoutineName) return NULL;
1447
1448     if (RtlUnicodeStringToAnsiString( &routineNameA, SystemRoutineName, TRUE ) == STATUS_SUCCESS)
1449     {
1450         /* We only support functions exported from ntoskrnl.exe or hal.dll */
1451         hMod = GetModuleHandleW( ntoskrnlW );
1452         pFunc = GetProcAddress( hMod, routineNameA.Buffer );
1453         if (!pFunc)
1454         {
1455            hMod = GetModuleHandleW( halW );
1456            if (hMod) pFunc = GetProcAddress( hMod, routineNameA.Buffer );
1457         }
1458         RtlFreeAnsiString( &routineNameA );
1459     }
1460
1461     TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName), pFunc );
1462     return pFunc;
1463 }
1464
1465
1466 /***********************************************************************
1467  *           MmQuerySystemSize   (NTOSKRNL.EXE.@)
1468  */
1469 MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void)
1470 {
1471     FIXME("stub\n");
1472     return MmLargeSystem;
1473 }
1474
1475
1476 /*****************************************************
1477  *           DllMain
1478  */
1479 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
1480 {
1481     static void *handler;
1482     LARGE_INTEGER count;
1483
1484     switch(reason)
1485     {
1486     case DLL_PROCESS_ATTACH:
1487         DisableThreadLibraryCalls( inst );
1488 #ifdef __i386__
1489         handler = RtlAddVectoredExceptionHandler( TRUE, vectored_handler );
1490 #endif
1491         KeQueryTickCount( &count );  /* initialize the global KeTickCount */
1492         break;
1493     case DLL_PROCESS_DETACH:
1494         RtlRemoveVectoredExceptionHandler( handler );
1495         break;
1496     }
1497     return TRUE;
1498 }