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