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_tid;
247 client_pid = reply->client_pid;
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 * IoUnregisterShutdownNotification (NTOSKRNL.EXE.@)
842 */
843 VOID WINAPI IoUnregisterShutdownNotification( PDEVICE_OBJECT obj )
844 {
845 FIXME( "stub: %p\n", obj );
846 }
847
848
849 /***********************************************************************
850 * IoReportResourceUsage (NTOSKRNL.EXE.@)
851 */
852 NTSTATUS WINAPI IoReportResourceUsage(PUNICODE_STRING name, PDRIVER_OBJECT drv_obj, PCM_RESOURCE_LIST drv_list,
853 ULONG drv_size, PDRIVER_OBJECT dev_obj, PCM_RESOURCE_LIST dev_list,
854 ULONG dev_size, BOOLEAN overwrite, PBOOLEAN detected)
855 {
856 FIXME("(%s %p %p %u %p %p %u %d %p) stub\n", debugstr_w(name? name->Buffer : NULL),
857 drv_obj, drv_list, drv_size, dev_obj, dev_list, dev_size, overwrite, detected);
858 return STATUS_NOT_IMPLEMENTED;
859 }
860
861
862 /***********************************************************************
863 * IoCompleteRequest (NTOSKRNL.EXE.@)
864 */
865 VOID WINAPI IoCompleteRequest( IRP *irp, UCHAR priority_boost )
866 {
867 IO_STACK_LOCATION *irpsp;
868 PIO_COMPLETION_ROUTINE routine;
869 IO_STATUS_BLOCK *iosb;
870 struct IrpInstance *instance;
871 NTSTATUS status, stat;
872 int call_flag = 0;
873
874 TRACE( "%p %u\n", irp, priority_boost );
875
876 iosb = irp->UserIosb;
877 status = irp->IoStatus.u.Status;
878 while (irp->CurrentLocation <= irp->StackCount)
879 {
880 irpsp = irp->Tail.Overlay.s.u2.CurrentStackLocation;
881 routine = irpsp->CompletionRoutine;
882 call_flag = 0;
883 /* FIXME: add SL_INVOKE_ON_CANCEL support */
884 if (routine)
885 {
886 if ((irpsp->Control & SL_INVOKE_ON_SUCCESS) && STATUS_SUCCESS == status)
887 call_flag = 1;
888 if ((irpsp->Control & SL_INVOKE_ON_ERROR) && STATUS_SUCCESS != status)
889 call_flag = 1;
890 }
891 ++irp->CurrentLocation;
892 ++irp->Tail.Overlay.s.u2.CurrentStackLocation;
893 if (call_flag)
894 {
895 TRACE( "calling %p( %p, %p, %p )\n", routine,
896 irpsp->DeviceObject, irp, irpsp->Context );
897 stat = routine( irpsp->DeviceObject, irp, irpsp->Context );
898 TRACE( "CompletionRoutine returned %x\n", stat );
899 if (STATUS_MORE_PROCESSING_REQUIRED == stat)
900 return;
901 }
902 }
903 if (iosb && STATUS_SUCCESS == status)
904 {
905 iosb->u.Status = irp->IoStatus.u.Status;
906 iosb->Information = irp->IoStatus.Information;
907 }
908 LIST_FOR_EACH_ENTRY( instance, &Irps, struct IrpInstance, entry )
909 {
910 if (instance->irp == irp)
911 {
912 list_remove( &instance->entry );
913 HeapFree( GetProcessHeap(), 0, instance );
914 IoFreeIrp( irp );
915 break;
916 }
917 }
918 }
919
920
921 /***********************************************************************
922 * IofCompleteRequest (NTOSKRNL.EXE.@)
923 */
924 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
925 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest )
926 void WINAPI __regs_IofCompleteRequest( IRP *irp, UCHAR priority_boost )
927 #else
928 void WINAPI IofCompleteRequest( IRP *irp, UCHAR priority_boost )
929 #endif
930 {
931 TRACE( "%p %u\n", irp, priority_boost );
932 IoCompleteRequest( irp, priority_boost );
933 }
934
935
936 /***********************************************************************
937 * InterlockedCompareExchange (NTOSKRNL.EXE.@)
938 */
939 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
940 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange )
941 LONG WINAPI __regs_NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
942 #else
943 LONG WINAPI NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
944 #endif
945 {
946 return InterlockedCompareExchange( dest, xchg, compare );
947 }
948
949
950 /***********************************************************************
951 * InterlockedDecrement (NTOSKRNL.EXE.@)
952 */
953 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
954 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement )
955 LONG WINAPI __regs_NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
956 #else
957 LONG WINAPI NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
958 #endif
959 {
960 return InterlockedDecrement( dest );
961 }
962
963
964 /***********************************************************************
965 * InterlockedExchange (NTOSKRNL.EXE.@)
966 */
967 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
968 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange )
969 LONG WINAPI __regs_NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
970 #else
971 LONG WINAPI NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
972 #endif
973 {
974 return InterlockedExchange( dest, val );
975 }
976
977
978 /***********************************************************************
979 * InterlockedExchangeAdd (NTOSKRNL.EXE.@)
980 */
981 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
982 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd )
983 LONG WINAPI __regs_NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
984 #else
985 LONG WINAPI NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
986 #endif
987 {
988 return InterlockedExchangeAdd( dest, incr );
989 }
990
991
992 /***********************************************************************
993 * InterlockedIncrement (NTOSKRNL.EXE.@)
994 */
995 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
996 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement )
997 LONG WINAPI __regs_NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
998 #else
999 LONG WINAPI NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1000 #endif
1001 {
1002 return InterlockedIncrement( dest );
1003 }
1004
1005
1006 /***********************************************************************
1007 * ExAllocatePool (NTOSKRNL.EXE.@)
1008 */
1009 PVOID WINAPI ExAllocatePool( POOL_TYPE type, SIZE_T size )
1010 {
1011 return ExAllocatePoolWithTag( type, size, 0 );
1012 }
1013
1014
1015 /***********************************************************************
1016 * ExAllocatePoolWithQuota (NTOSKRNL.EXE.@)
1017 */
1018 PVOID WINAPI ExAllocatePoolWithQuota( POOL_TYPE type, SIZE_T size )
1019 {
1020 return ExAllocatePoolWithTag( type, size, 0 );
1021 }
1022
1023
1024 /***********************************************************************
1025 * ExAllocatePoolWithTag (NTOSKRNL.EXE.@)
1026 */
1027 PVOID WINAPI ExAllocatePoolWithTag( POOL_TYPE type, SIZE_T size, ULONG tag )
1028 {
1029 /* FIXME: handle page alignment constraints */
1030 void *ret = HeapAlloc( GetProcessHeap(), 0, size );
1031 TRACE( "%lu pool %u -> %p\n", size, type, ret );
1032 return ret;
1033 }
1034
1035
1036 /***********************************************************************
1037 * ExAllocatePoolWithQuotaTag (NTOSKRNL.EXE.@)
1038 */
1039 PVOID WINAPI ExAllocatePoolWithQuotaTag( POOL_TYPE type, SIZE_T size, ULONG tag )
1040 {
1041 return ExAllocatePoolWithTag( type, size, tag );
1042 }
1043
1044
1045 /***********************************************************************
1046 * ExFreePool (NTOSKRNL.EXE.@)
1047 */
1048 void WINAPI ExFreePool( void *ptr )
1049 {
1050 ExFreePoolWithTag( ptr, 0 );
1051 }
1052
1053
1054 /***********************************************************************
1055 * ExFreePoolWithTag (NTOSKRNL.EXE.@)
1056 */
1057 void WINAPI ExFreePoolWithTag( void *ptr, ULONG tag )
1058 {
1059 TRACE( "%p\n", ptr );
1060 HeapFree( GetProcessHeap(), 0, ptr );
1061 }
1062
1063
1064 /***********************************************************************
1065 * ExInitializeResourceLite (NTOSKRNL.EXE.@)
1066 */
1067 NTSTATUS WINAPI ExInitializeResourceLite(PERESOURCE Resource)
1068 {
1069 FIXME( "stub: %p\n", Resource );
1070 return STATUS_NOT_IMPLEMENTED;
1071 }
1072
1073
1074 /***********************************************************************
1075 * ExInitializeNPagedLookasideList (NTOSKRNL.EXE.@)
1076 */
1077 void WINAPI ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
1078 PALLOCATE_FUNCTION Allocate,
1079 PFREE_FUNCTION Free,
1080 ULONG Flags,
1081 SIZE_T Size,
1082 ULONG Tag,
1083 USHORT Depth)
1084 {
1085 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1086 }
1087
1088 /***********************************************************************
1089 * ExInitializePagedLookasideList (NTOSKRNL.EXE.@)
1090 */
1091 void WINAPI ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside,
1092 PALLOCATE_FUNCTION Allocate,
1093 PFREE_FUNCTION Free,
1094 ULONG Flags,
1095 SIZE_T Size,
1096 ULONG Tag,
1097 USHORT Depth)
1098 {
1099 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1100 }
1101
1102 /***********************************************************************
1103 * ExInitializeZone (NTOSKRNL.EXE.@)
1104 */
1105 NTSTATUS WINAPI ExInitializeZone(PZONE_HEADER Zone,
1106 ULONG BlockSize,
1107 PVOID InitialSegment,
1108 ULONG InitialSegmentSize)
1109 {
1110 FIXME( "stub: %p, %u, %p, %u\n", Zone, BlockSize, InitialSegment, InitialSegmentSize );
1111 return STATUS_NOT_IMPLEMENTED;
1112 }
1113
1114 /***********************************************************************
1115 * FsRtlRegisterUncProvider (NTOSKRNL.EXE.@)
1116 */
1117 NTSTATUS WINAPI FsRtlRegisterUncProvider(PHANDLE MupHandle, PUNICODE_STRING RedirDevName,
1118 BOOLEAN MailslotsSupported)
1119 {
1120 FIXME("(%p %p %d): stub\n", MupHandle, RedirDevName, MailslotsSupported);
1121 return STATUS_NOT_IMPLEMENTED;
1122 }
1123
1124 /***********************************************************************
1125 * IoGetCurrentProcess / PsGetCurrentProcess (NTOSKRNL.EXE.@)
1126 */
1127 PEPROCESS WINAPI IoGetCurrentProcess(void)
1128 {
1129 FIXME("() stub\n");
1130 return NULL;
1131 }
1132
1133 /***********************************************************************
1134 * KeGetCurrentThread / PsGetCurrentThread (NTOSKRNL.EXE.@)
1135 */
1136 PRKTHREAD WINAPI KeGetCurrentThread(void)
1137 {
1138 FIXME("() stub\n");
1139 return NULL;
1140 }
1141
1142 /***********************************************************************
1143 * KeInitializeEvent (NTOSKRNL.EXE.@)
1144 */
1145 void WINAPI KeInitializeEvent( PRKEVENT Event, EVENT_TYPE Type, BOOLEAN State )
1146 {
1147 FIXME( "stub: %p %d %d\n", Event, Type, State );
1148 }
1149
1150
1151 /***********************************************************************
1152 * KeInitializeMutex (NTOSKRNL.EXE.@)
1153 */
1154 void WINAPI KeInitializeMutex(PRKMUTEX Mutex, ULONG Level)
1155 {
1156 FIXME( "stub: %p, %u\n", Mutex, Level );
1157 }
1158
1159
1160 /***********************************************************************
1161 * KeWaitForMutexObject (NTOSKRNL.EXE.@)
1162 */
1163 NTSTATUS WINAPI KeWaitForMutexObject(PRKMUTEX Mutex, KWAIT_REASON WaitReason, KPROCESSOR_MODE WaitMode,
1164 BOOLEAN Alertable, PLARGE_INTEGER Timeout)
1165 {
1166 FIXME( "stub: %p, %d, %d, %d, %p\n", Mutex, WaitReason, WaitMode, Alertable, Timeout );
1167 return STATUS_NOT_IMPLEMENTED;
1168 }
1169
1170
1171 /***********************************************************************
1172 * KeReleaseMutex (NTOSKRNL.EXE.@)
1173 */
1174 LONG WINAPI KeReleaseMutex(PRKMUTEX Mutex, BOOLEAN Wait)
1175 {
1176 FIXME( "stub: %p, %d\n", Mutex, Wait );
1177 return STATUS_NOT_IMPLEMENTED;
1178 }
1179
1180
1181 /***********************************************************************
1182 * KeInitializeSemaphore (NTOSKRNL.EXE.@)
1183 */
1184 void WINAPI KeInitializeSemaphore( PRKSEMAPHORE Semaphore, LONG Count, LONG Limit )
1185 {
1186 FIXME( "(%p %d %d) stub\n", Semaphore , Count, Limit );
1187 }
1188
1189
1190 /***********************************************************************
1191 * KeInitializeSpinLock (NTOSKRNL.EXE.@)
1192 */
1193 void WINAPI KeInitializeSpinLock( PKSPIN_LOCK SpinLock )
1194 {
1195 FIXME( "stub: %p\n", SpinLock );
1196 }
1197
1198
1199 /***********************************************************************
1200 * KeInitializeTimerEx (NTOSKRNL.EXE.@)
1201 */
1202 void WINAPI KeInitializeTimerEx( PKTIMER Timer, TIMER_TYPE Type )
1203 {
1204 FIXME( "stub: %p %d\n", Timer, Type );
1205 }
1206
1207
1208 /***********************************************************************
1209 * KeInitializeTimer (NTOSKRNL.EXE.@)
1210 */
1211 void WINAPI KeInitializeTimer( PKTIMER Timer )
1212 {
1213 KeInitializeTimerEx(Timer, NotificationTimer);
1214 }
1215
1216
1217 /**********************************************************************
1218 * KeQueryActiveProcessors (NTOSKRNL.EXE.@)
1219 *
1220 * Return the active Processors as bitmask
1221 *
1222 * RETURNS
1223 * active Processors as bitmask
1224 *
1225 */
1226 KAFFINITY WINAPI KeQueryActiveProcessors( void )
1227 {
1228 DWORD_PTR AffinityMask;
1229
1230 GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask, NULL);
1231 return AffinityMask;
1232 }
1233
1234
1235 /**********************************************************************
1236 * KeQueryInterruptTime (NTOSKRNL.EXE.@)
1237 *
1238 * Return the interrupt time count
1239 *
1240 */
1241 ULONGLONG WINAPI KeQueryInterruptTime( void )
1242 {
1243 LARGE_INTEGER totaltime;
1244
1245 KeQueryTickCount(&totaltime);
1246 return totaltime.QuadPart;
1247 }
1248
1249
1250 /***********************************************************************
1251 * KeQuerySystemTime (NTOSKRNL.EXE.@)
1252 */
1253 void WINAPI KeQuerySystemTime( LARGE_INTEGER *time )
1254 {
1255 NtQuerySystemTime( time );
1256 }
1257
1258
1259 /***********************************************************************
1260 * KeQueryTickCount (NTOSKRNL.EXE.@)
1261 */
1262 void WINAPI KeQueryTickCount( LARGE_INTEGER *count )
1263 {
1264 count->QuadPart = NtGetTickCount();
1265 /* update the global variable too */
1266 KeTickCount.LowPart = count->u.LowPart;
1267 KeTickCount.High1Time = count->u.HighPart;
1268 KeTickCount.High2Time = count->u.HighPart;
1269 }
1270
1271
1272 /***********************************************************************
1273 * KeReleaseSemaphore (NTOSKRNL.EXE.@)
1274 */
1275 LONG WINAPI KeReleaseSemaphore( PRKSEMAPHORE Semaphore, KPRIORITY Increment,
1276 LONG Adjustment, BOOLEAN Wait )
1277 {
1278 FIXME("(%p %d %d %d) stub\n", Semaphore, Increment, Adjustment, Wait );
1279 return 0;
1280 }
1281
1282
1283 /***********************************************************************
1284 * KeQueryTimeIncrement (NTOSKRNL.EXE.@)
1285 */
1286 ULONG WINAPI KeQueryTimeIncrement(void)
1287 {
1288 return 10000;
1289 }
1290
1291
1292 /***********************************************************************
1293 * KeResetEvent (NTOSKRNL.EXE.@)
1294 */
1295 LONG WINAPI KeResetEvent( PRKEVENT Event )
1296 {
1297 FIXME("(%p): stub\n", Event);
1298 return 0;
1299 }
1300
1301
1302 /***********************************************************************
1303 * KeSetEvent (NTOSKRNL.EXE.@)
1304 */
1305 LONG WINAPI KeSetEvent( PRKEVENT Event, KPRIORITY Increment, BOOLEAN Wait )
1306 {
1307 FIXME("(%p, %d, %d): stub\n", Event, Increment, Wait);
1308 return 0;
1309 }
1310
1311
1312 /***********************************************************************
1313 * KeSetPriorityThread (NTOSKRNL.EXE.@)
1314 */
1315 KPRIORITY WINAPI KeSetPriorityThread( PKTHREAD Thread, KPRIORITY Priority )
1316 {
1317 FIXME("(%p %d)\n", Thread, Priority);
1318 return Priority;
1319 }
1320
1321
1322 /***********************************************************************
1323 * KeWaitForSingleObject (NTOSKRNL.EXE.@)
1324 */
1325 NTSTATUS WINAPI KeWaitForSingleObject(PVOID Object,
1326 KWAIT_REASON WaitReason,
1327 KPROCESSOR_MODE WaitMode,
1328 BOOLEAN Alertable,
1329 PLARGE_INTEGER Timeout)
1330 {
1331 FIXME( "stub: %p, %d, %d, %d, %p\n", Object, WaitReason, WaitMode, Alertable, Timeout );
1332 return STATUS_NOT_IMPLEMENTED;
1333 }
1334
1335 /***********************************************************************
1336 * IoRegisterFileSystem (NTOSKRNL.EXE.@)
1337 */
1338 VOID WINAPI IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject)
1339 {
1340 FIXME("(%p): stub\n", DeviceObject);
1341 }
1342
1343 /***********************************************************************
1344 * IoUnregisterFileSystem (NTOSKRNL.EXE.@)
1345 */
1346 VOID WINAPI IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject)
1347 {
1348 FIXME("(%p): stub\n", DeviceObject);
1349 }
1350
1351 /***********************************************************************
1352 * MmAllocateNonCachedMemory (NTOSKRNL.EXE.@)
1353 */
1354 PVOID WINAPI MmAllocateNonCachedMemory( SIZE_T size )
1355 {
1356 TRACE( "%lu\n", size );
1357 return VirtualAlloc( NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE|PAGE_NOCACHE );
1358 }
1359
1360 /***********************************************************************
1361 * MmAllocateContiguousMemory (NTOSKRNL.EXE.@)
1362 */
1363 PVOID WINAPI MmAllocateContiguousMemory( SIZE_T size, PHYSICAL_ADDRESS highest_valid_address )
1364 {
1365 FIXME( "%lu, %s stub\n", size, wine_dbgstr_longlong(highest_valid_address.QuadPart) );
1366 return NULL;
1367 }
1368
1369 /***********************************************************************
1370 * MmAllocateContiguousMemorySpecifyCache (NTOSKRNL.EXE.@)
1371 */
1372 PVOID WINAPI MmAllocateContiguousMemorySpecifyCache( SIZE_T size,
1373 PHYSICAL_ADDRESS lowest_valid_address,
1374 PHYSICAL_ADDRESS highest_valid_address,
1375 PHYSICAL_ADDRESS BoundaryAddressMultiple,
1376 MEMORY_CACHING_TYPE CacheType )
1377 {
1378 FIXME(": stub\n");
1379 return NULL;
1380 }
1381
1382 /***********************************************************************
1383 * MmAllocatePagesForMdl (NTOSKRNL.EXE.@)
1384 */
1385 PMDL WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress, PHYSICAL_ADDRESS highaddress,
1386 PHYSICAL_ADDRESS skipbytes, SIZE_T size)
1387 {
1388 FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress.QuadPart), wine_dbgstr_longlong(highaddress.QuadPart),
1389 wine_dbgstr_longlong(skipbytes.QuadPart), size);
1390 return NULL;
1391 }
1392
1393 /***********************************************************************
1394 * MmFreeNonCachedMemory (NTOSKRNL.EXE.@)
1395 */
1396 void WINAPI MmFreeNonCachedMemory( void *addr, SIZE_T size )
1397 {
1398 TRACE( "%p %lu\n", addr, size );
1399 VirtualFree( addr, 0, MEM_RELEASE );
1400 }
1401
1402 /***********************************************************************
1403 * MmIsAddressValid (NTOSKRNL.EXE.@)
1404 *
1405 * Check if the process can access the virtual address without a pagefault
1406 *
1407 * PARAMS
1408 * VirtualAddress [I] Address to check
1409 *
1410 * RETURNS
1411 * Failure: FALSE
1412 * Success: TRUE (Accessing the Address works without a Pagefault)
1413 *
1414 */
1415 BOOLEAN WINAPI MmIsAddressValid(PVOID VirtualAddress)
1416 {
1417 TRACE("(%p)\n", VirtualAddress);
1418 return !IsBadWritePtr(VirtualAddress, 1);
1419 }
1420
1421 /***********************************************************************
1422 * MmMapIoSpace (NTOSKRNL.EXE.@)
1423 */
1424 PVOID WINAPI MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress, DWORD NumberOfBytes, DWORD CacheType )
1425 {
1426 FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress.u.HighPart, PhysicalAddress.u.LowPart, NumberOfBytes, CacheType );
1427 return NULL;
1428 }
1429
1430 /***********************************************************************
1431 * MmPageEntireDriver (NTOSKRNL.EXE.@)
1432 */
1433 PVOID WINAPI MmPageEntireDriver(PVOID AddrInSection)
1434 {
1435 TRACE("%p\n", AddrInSection);
1436 return AddrInSection;
1437 }
1438
1439 /***********************************************************************
1440 * MmResetDriverPaging (NTOSKRNL.EXE.@)
1441 */
1442 void WINAPI MmResetDriverPaging(PVOID AddrInSection)
1443 {
1444 TRACE("%p\n", AddrInSection);
1445 }
1446
1447 /***********************************************************************
1448 * MmUnmapIoSpace (NTOSKRNL.EXE.@)
1449 */
1450 VOID WINAPI MmUnmapIoSpace( PVOID BaseAddress, SIZE_T NumberOfBytes )
1451 {
1452 FIXME( "stub: %p, %lu\n", BaseAddress, NumberOfBytes );
1453 }
1454
1455 /***********************************************************************
1456 * ObfReferenceObject (NTOSKRNL.EXE.@)
1457 */
1458 VOID WINAPI ObfReferenceObject(PVOID Object)
1459 {
1460 FIXME("(%p): stub\n", Object);
1461 }
1462
1463 /***********************************************************************
1464 * ObReferenceObjectByHandle (NTOSKRNL.EXE.@)
1465 */
1466 NTSTATUS WINAPI ObReferenceObjectByHandle( HANDLE obj, ACCESS_MASK access,
1467 POBJECT_TYPE type,
1468 KPROCESSOR_MODE mode, PVOID* ptr,
1469 POBJECT_HANDLE_INFORMATION info)
1470 {
1471 FIXME( "stub: %p %x %p %d %p %p\n", obj, access, type, mode, ptr, info);
1472 return STATUS_NOT_IMPLEMENTED;
1473 }
1474
1475 /***********************************************************************
1476 * ObReferenceObjectByName (NTOSKRNL.EXE.@)
1477 */
1478 NTSTATUS WINAPI ObReferenceObjectByName( UNICODE_STRING *ObjectName,
1479 ULONG Attributes,
1480 ACCESS_STATE *AccessState,
1481 ACCESS_MASK DesiredAccess,
1482 POBJECT_TYPE ObjectType,
1483 KPROCESSOR_MODE AccessMode,
1484 void *ParseContext,
1485 void **Object)
1486 {
1487 FIXME("stub\n");
1488 return STATUS_NOT_IMPLEMENTED;
1489 }
1490
1491 /***********************************************************************
1492 * ObfDereferenceObject (NTOSKRNL.EXE.@)
1493 */
1494 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1495 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject )
1496 void WINAPI __regs_ObfDereferenceObject( VOID *obj )
1497 #else
1498 void WINAPI ObfDereferenceObject( VOID *obj )
1499 #endif
1500 {
1501 FIXME( "stub: %p\n", obj );
1502 }
1503
1504
1505 /***********************************************************************
1506 * PsCreateSystemThread (NTOSKRNL.EXE.@)
1507 */
1508 NTSTATUS WINAPI PsCreateSystemThread(PHANDLE ThreadHandle, ULONG DesiredAccess,
1509 POBJECT_ATTRIBUTES ObjectAttributes,
1510 HANDLE ProcessHandle, PCLIENT_ID ClientId,
1511 PKSTART_ROUTINE StartRoutine, PVOID StartContext)
1512 {
1513 if (!ProcessHandle) ProcessHandle = GetCurrentProcess();
1514 return RtlCreateUserThread(ProcessHandle, 0, FALSE, 0, 0,
1515 0, StartRoutine, StartContext,
1516 ThreadHandle, ClientId);
1517 }
1518
1519 /***********************************************************************
1520 * PsGetCurrentProcessId (NTOSKRNL.EXE.@)
1521 */
1522 HANDLE WINAPI PsGetCurrentProcessId(void)
1523 {
1524 if (GetCurrentThreadId() == request_thread)
1525 return UlongToHandle(client_pid);
1526 return UlongToHandle(GetCurrentProcessId());
1527 }
1528
1529
1530 /***********************************************************************
1531 * PsGetCurrentThreadId (NTOSKRNL.EXE.@)
1532 */
1533 HANDLE WINAPI PsGetCurrentThreadId(void)
1534 {
1535 if (GetCurrentThreadId() == request_thread)
1536 return UlongToHandle(client_tid);
1537 return UlongToHandle(GetCurrentThreadId());
1538 }
1539
1540
1541 /***********************************************************************
1542 * PsGetVersion (NTOSKRNL.EXE.@)
1543 */
1544 BOOLEAN WINAPI PsGetVersion(ULONG *major, ULONG *minor, ULONG *build, UNICODE_STRING *version )
1545 {
1546 RTL_OSVERSIONINFOEXW info;
1547
1548 info.dwOSVersionInfoSize = sizeof(info);
1549 RtlGetVersion( &info );
1550 if (major) *major = info.dwMajorVersion;
1551 if (minor) *minor = info.dwMinorVersion;
1552 if (build) *build = info.dwBuildNumber;
1553
1554 if (version)
1555 {
1556 #if 0 /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
1557 size_t len = min( strlenW(info.szCSDVersion)*sizeof(WCHAR), version->MaximumLength );
1558 memcpy( version->Buffer, info.szCSDVersion, len );
1559 if (len < version->MaximumLength) version->Buffer[len / sizeof(WCHAR)] = 0;
1560 version->Length = len;
1561 #endif
1562 }
1563 return TRUE;
1564 }
1565
1566
1567 /***********************************************************************
1568 * PsSetCreateProcessNotifyRoutine (NTOSKRNL.EXE.@)
1569 */
1570 NTSTATUS WINAPI PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback, BOOLEAN remove )
1571 {
1572 FIXME( "stub: %p %d\n", callback, remove );
1573 return STATUS_SUCCESS;
1574 }
1575
1576
1577 /***********************************************************************
1578 * PsSetCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
1579 */
1580 NTSTATUS WINAPI PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
1581 {
1582 FIXME( "stub: %p\n", NotifyRoutine );
1583 return STATUS_SUCCESS;
1584 }
1585
1586
1587 /***********************************************************************
1588 * PsTerminateSystemThread (NTOSKRNL.EXE.@)
1589 */
1590 NTSTATUS WINAPI PsTerminateSystemThread(NTSTATUS ExitStatus)
1591 {
1592 FIXME( "stub: %u\n", ExitStatus );
1593 return STATUS_NOT_IMPLEMENTED;
1594 }
1595
1596
1597 /***********************************************************************
1598 * MmGetSystemRoutineAddress (NTOSKRNL.EXE.@)
1599 */
1600 PVOID WINAPI MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName)
1601 {
1602 HMODULE hMod;
1603 STRING routineNameA;
1604 PVOID pFunc = NULL;
1605
1606 static const WCHAR ntoskrnlW[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
1607 static const WCHAR halW[] = {'h','a','l','.','d','l','l',0};
1608
1609 if (!SystemRoutineName) return NULL;
1610
1611 if (RtlUnicodeStringToAnsiString( &routineNameA, SystemRoutineName, TRUE ) == STATUS_SUCCESS)
1612 {
1613 /* We only support functions exported from ntoskrnl.exe or hal.dll */
1614 hMod = GetModuleHandleW( ntoskrnlW );
1615 pFunc = GetProcAddress( hMod, routineNameA.Buffer );
1616 if (!pFunc)
1617 {
1618 hMod = GetModuleHandleW( halW );
1619 if (hMod) pFunc = GetProcAddress( hMod, routineNameA.Buffer );
1620 }
1621 RtlFreeAnsiString( &routineNameA );
1622 }
1623
1624 if (pFunc)
1625 TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName), pFunc );
1626 else
1627 FIXME( "%s not found\n", debugstr_us(SystemRoutineName) );
1628 return pFunc;
1629 }
1630
1631
1632 /***********************************************************************
1633 * MmQuerySystemSize (NTOSKRNL.EXE.@)
1634 */
1635 MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void)
1636 {
1637 FIXME("stub\n");
1638 return MmLargeSystem;
1639 }
1640
1641 /***********************************************************************
1642 * KeInitializeDpc (NTOSKRNL.EXE.@)
1643 */
1644 VOID WINAPI KeInitializeDpc(PRKDPC Dpc, PKDEFERRED_ROUTINE DeferredRoutine, PVOID DeferredContext)
1645 {
1646 FIXME("stub\n");
1647 }
1648
1649 /***********************************************************************
1650 * READ_REGISTER_BUFFER_UCHAR (NTOSKRNL.EXE.@)
1651 */
1652 VOID WINAPI READ_REGISTER_BUFFER_UCHAR(PUCHAR Register, PUCHAR Buffer, ULONG Count)
1653 {
1654 FIXME("stub\n");
1655 }
1656
1657 /*****************************************************
1658 * PoSetPowerState (NTOSKRNL.EXE.@)
1659 */
1660 POWER_STATE WINAPI PoSetPowerState(PDEVICE_OBJECT DeviceObject, POWER_STATE_TYPE Type, POWER_STATE State)
1661 {
1662 FIXME("(%p %u %u) stub\n", DeviceObject, Type, State.DeviceState);
1663 return State;
1664 }
1665
1666 /*****************************************************
1667 * IoWMIRegistrationControl (NTOSKRNL.EXE.@)
1668 */
1669 NTSTATUS WINAPI IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject, ULONG Action)
1670 {
1671 FIXME("(%p %u ) stub\n", DeviceObject, Action);
1672 return STATUS_SUCCESS;
1673 }
1674
1675 /*****************************************************
1676 * PsSetLoadImageNotifyRoutine (NTOSKRNL.EXE.@)
1677 */
1678 NTSTATUS WINAPI PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine)
1679 {
1680 FIXME("(%p) stub\n", routine);
1681 return STATUS_SUCCESS;
1682 }
1683
1684 /*****************************************************
1685 * PsLookupProcessByProcessId (NTOSKRNL.EXE.@)
1686 */
1687 NTSTATUS WINAPI PsLookupProcessByProcessId(HANDLE processid, PEPROCESS *process)
1688 {
1689 FIXME("(%p %p) stub\n", processid, process);
1690 return STATUS_NOT_IMPLEMENTED;
1691 }
1692
1693
1694 /*****************************************************
1695 * IoSetThreadHardErrorMode (NTOSKRNL.EXE.@)
1696 */
1697 BOOLEAN WINAPI IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors)
1698 {
1699 FIXME("stub\n");
1700 return FALSE;
1701 }
1702
1703
1704 /*****************************************************
1705 * IoInitializeRemoveLockEx (NTOSKRNL.EXE.@)
1706 */
1707 VOID WINAPI IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock, ULONG tag,
1708 ULONG maxmin, ULONG high, ULONG size)
1709 {
1710 FIXME("(%p %u %u %u %u) stub\n", lock, tag, maxmin, high, size);
1711 }
1712
1713 /*****************************************************
1714 * DllMain
1715 */
1716 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
1717 {
1718 static void *handler;
1719 LARGE_INTEGER count;
1720
1721 switch(reason)
1722 {
1723 case DLL_PROCESS_ATTACH:
1724 DisableThreadLibraryCalls( inst );
1725 #ifdef __i386__
1726 handler = RtlAddVectoredExceptionHandler( TRUE, vectored_handler );
1727 #endif
1728 KeQueryTickCount( &count ); /* initialize the global KeTickCount */
1729 break;
1730 case DLL_PROCESS_DETACH:
1731 RtlRemoveVectoredExceptionHandler( handler );
1732 break;
1733 }
1734 return TRUE;
1735 }
1736
1737 /*****************************************************
1738 * Ke386IoSetAccessProcess (NTOSKRNL.EXE.@)
1739 */
1740 BOOLEAN WINAPI Ke386IoSetAccessProcess(PEPROCESS *process, ULONG flag)
1741 {
1742 FIXME("(%p %d) stub\n", process, flag);
1743 return FALSE;
1744 }
1745
1746 /*****************************************************
1747 * Ke386SetIoAccessMap (NTOSKRNL.EXE.@)
1748 */
1749 BOOLEAN WINAPI Ke386SetIoAccessMap(ULONG flag, PVOID buffer)
1750 {
1751 FIXME("(%d %p) stub\n", flag, buffer);
1752 return FALSE;
1753 }
1754
1755 /*****************************************************
1756 * IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
1757 */
1758 PKEVENT WINAPI IoCreateSynchronizationEvent(PUNICODE_STRING name, PHANDLE handle)
1759 {
1760 FIXME("(%p %p) stub\n", name, handle);
1761 return NULL;
1762 }
1763
1764 /*****************************************************
1765 * IoStartNextPacket (NTOSKRNL.EXE.@)
1766 */
1767 VOID WINAPI IoStartNextPacket(PDEVICE_OBJECT deviceobject, BOOLEAN cancelable)
1768 {
1769 FIXME("(%p %d) stub\n", deviceobject, cancelable);
1770 }
1771
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.