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