?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmime: Don't set DSBCAPS_CTRLPAN together with DSBCAPS_CTRL3D.
[wine.git] / dlls / ntoskrnl.exe / ntoskrnl.c
blob04f01985eaf730069ccf8a65aaca8d7aeedc9fe0
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 FIXME( "%p %d %u %p %p: stub\n", device, device_property, buffer_length,
1044 property_buffer, result_length );
1045 return STATUS_NOT_IMPLEMENTED;
1046 }
1047
1048
1049 /***********************************************************************
1050 * IoCallDriver (NTOSKRNL.EXE.@)
1051 */
1052 NTSTATUS WINAPI IoCallDriver( DEVICE_OBJECT *device, IRP *irp )
1053 {
1054 PDRIVER_DISPATCH dispatch;
1055 IO_STACK_LOCATION *irpsp;
1056 NTSTATUS status;
1057
1058 --irp->CurrentLocation;
1059 irpsp = --irp->Tail.Overlay.s.u2.CurrentStackLocation;
1060 dispatch = device->DriverObject->MajorFunction[irpsp->MajorFunction];
1061
1062 if (TRACE_ON(relay))
1063 DPRINTF( "%04x:Call driver dispatch %p (device=%p,irp=%p)\n",
1064 GetCurrentThreadId(), dispatch, device, irp );
1065
1066 status = dispatch( device, irp );
1067
1068 if (TRACE_ON(relay))
1069 DPRINTF( "%04x:Ret driver dispatch %p (device=%p,irp=%p) retval=%08x\n",
1070 GetCurrentThreadId(), dispatch, device, irp, status );
1071
1072 return status;
1073 }
1074
1075
1076 /***********************************************************************
1077 * IofCallDriver (NTOSKRNL.EXE.@)
1078 */
1079 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1080 DEFINE_FASTCALL2_ENTRYPOINT( IofCallDriver )
1081 NTSTATUS WINAPI __regs_IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
1082 #else
1083 NTSTATUS WINAPI IofCallDriver( DEVICE_OBJECT *device, IRP *irp )
1084 #endif
1085 {
1086 TRACE( "%p %p\n", device, irp );
1087 return IoCallDriver( device, irp );
1088 }
1089
1090
1091 /***********************************************************************
1092 * IoGetRelatedDeviceObject (NTOSKRNL.EXE.@)
1093 */
1094 PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject( PFILE_OBJECT obj )
1095 {
1096 FIXME( "stub: %p\n", obj );
1097 return NULL;
1098 }
1099
1100 static CONFIGURATION_INFORMATION configuration_information;
1101
1102 /***********************************************************************
1103 * IoGetConfigurationInformation (NTOSKRNL.EXE.@)
1104 */
1105 PCONFIGURATION_INFORMATION WINAPI IoGetConfigurationInformation(void)
1106 {
1107 FIXME( "partial stub\n" );
1108 /* FIXME: return actual devices on system */
1109 return &configuration_information;
1110 }
1111
1112
1113 /***********************************************************************
1114 * IoIsWdmVersionAvailable (NTOSKRNL.EXE.@)
1115 */
1116 NTSTATUS WINAPI IoIsWdmVersionAvailable(UCHAR MajorVersion, UCHAR MinorVersion)
1117 {
1118 DWORD version;
1119 DWORD major;
1120 DWORD minor;
1121
1122 TRACE( "%d, 0x%X\n", MajorVersion, MinorVersion );
1123
1124 version = GetVersion();
1125 major = LOBYTE(version);
1126 minor = HIBYTE(LOWORD(version));
1127
1128 if (MajorVersion == 6 && MinorVersion == 0)
1129 {
1130 /* Windows Vista, Windows Server 2008, Windows 7 */
1131 }
1132 else if (MajorVersion == 1)
1133 {
1134 if (MinorVersion == 0x30)
1135 {
1136 /* Windows server 2003 */
1137 MajorVersion = 6;
1138 MinorVersion = 0;
1139 }
1140 else if (MinorVersion == 0x20)
1141 {
1142 /* Windows XP */
1143 MajorVersion = 5;
1144 MinorVersion = 1;
1145 }
1146 else if (MinorVersion == 0x10)
1147 {
1148 /* Windows 2000 */
1149 MajorVersion = 5;
1150 MinorVersion = 0;
1151 }
1152 else if (MinorVersion == 0x05)
1153 {
1154 /* Windows ME */
1155 MajorVersion = 4;
1156 MinorVersion = 0x5a;
1157 }
1158 else if (MinorVersion == 0x00)
1159 {
1160 /* Windows 98 */
1161 MajorVersion = 4;
1162 MinorVersion = 0x0a;
1163 }
1164 else
1165 {
1166 FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
1167 return FALSE;
1168 }
1169 }
1170 else
1171 {
1172 FIXME( "unknown major %d minor 0x%X\n", MajorVersion, MinorVersion );
1173 return FALSE;
1174 }
1175 return major > MajorVersion || (major == MajorVersion && minor >= MinorVersion);
1176 }
1177
1178
1179 /***********************************************************************
1180 * IoQueryDeviceDescription (NTOSKRNL.EXE.@)
1181 */
1182 NTSTATUS WINAPI IoQueryDeviceDescription(PINTERFACE_TYPE itype, PULONG bus, PCONFIGURATION_TYPE ctype,
1183 PULONG cnum, PCONFIGURATION_TYPE ptype, PULONG pnum,
1184 PIO_QUERY_DEVICE_ROUTINE callout, PVOID context)
1185 {
1186 FIXME( "(%p %p %p %p %p %p %p %p)\n", itype, bus, ctype, cnum, ptype, pnum, callout, context);
1187 return STATUS_NOT_IMPLEMENTED;
1188 }
1189
1190
1191 /***********************************************************************
1192 * IoRegisterDriverReinitialization (NTOSKRNL.EXE.@)
1193 */
1194 void WINAPI IoRegisterDriverReinitialization( PDRIVER_OBJECT obj, PDRIVER_REINITIALIZE reinit, PVOID context )
1195 {
1196 FIXME( "stub: %p %p %p\n", obj, reinit, context );
1197 }
1198
1199
1200 /***********************************************************************
1201 * IoRegisterShutdownNotification (NTOSKRNL.EXE.@)
1202 */
1203 NTSTATUS WINAPI IoRegisterShutdownNotification( PDEVICE_OBJECT obj )
1204 {
1205 FIXME( "stub: %p\n", obj );
1206 return STATUS_SUCCESS;
1207 }
1208
1209
1210 /***********************************************************************
1211 * IoUnregisterShutdownNotification (NTOSKRNL.EXE.@)
1212 */
1213 VOID WINAPI IoUnregisterShutdownNotification( PDEVICE_OBJECT obj )
1214 {
1215 FIXME( "stub: %p\n", obj );
1216 }
1217
1218
1219 /***********************************************************************
1220 * IoReportResourceUsage (NTOSKRNL.EXE.@)
1221 */
1222 NTSTATUS WINAPI IoReportResourceUsage(PUNICODE_STRING name, PDRIVER_OBJECT drv_obj, PCM_RESOURCE_LIST drv_list,
1223 ULONG drv_size, PDRIVER_OBJECT dev_obj, PCM_RESOURCE_LIST dev_list,
1224 ULONG dev_size, BOOLEAN overwrite, PBOOLEAN detected)
1225 {
1226 FIXME("(%s %p %p %u %p %p %u %d %p) stub\n", debugstr_w(name? name->Buffer : NULL),
1227 drv_obj, drv_list, drv_size, dev_obj, dev_list, dev_size, overwrite, detected);
1228 return STATUS_NOT_IMPLEMENTED;
1229 }
1230
1231
1232 /***********************************************************************
1233 * IoCompleteRequest (NTOSKRNL.EXE.@)
1234 */
1235 VOID WINAPI IoCompleteRequest( IRP *irp, UCHAR priority_boost )
1236 {
1237 IO_STACK_LOCATION *irpsp;
1238 PIO_COMPLETION_ROUTINE routine;
1239 NTSTATUS status, stat;
1240 HANDLE handle;
1241 int call_flag = 0;
1242
1243 TRACE( "%p %u\n", irp, priority_boost );
1244
1245 status = irp->IoStatus.u.Status;
1246 while (irp->CurrentLocation <= irp->StackCount)
1247 {
1248 irpsp = irp->Tail.Overlay.s.u2.CurrentStackLocation;
1249 routine = irpsp->CompletionRoutine;
1250 call_flag = 0;
1251 /* FIXME: add SL_INVOKE_ON_CANCEL support */
1252 if (routine)
1253 {
1254 if ((irpsp->Control & SL_INVOKE_ON_SUCCESS) && STATUS_SUCCESS == status)
1255 call_flag = 1;
1256 if ((irpsp->Control & SL_INVOKE_ON_ERROR) && STATUS_SUCCESS != status)
1257 call_flag = 1;
1258 }
1259 ++irp->CurrentLocation;
1260 ++irp->Tail.Overlay.s.u2.CurrentStackLocation;
1261 if (call_flag)
1262 {
1263 TRACE( "calling %p( %p, %p, %p )\n", routine,
1264 irpsp->DeviceObject, irp, irpsp->Context );
1265 stat = routine( irpsp->DeviceObject, irp, irpsp->Context );
1266 TRACE( "CompletionRoutine returned %x\n", stat );
1267 if (STATUS_MORE_PROCESSING_REQUIRED == stat)
1268 return;
1269 }
1270 }
1271
1272 handle = (HANDLE)irp->UserIosb;
1273 if (handle)
1274 {
1275 void *out_buff = irp->UserBuffer;
1276 FILE_OBJECT *file = irp->Tail.Overlay.OriginalFileObject;
1277
1278 SERVER_START_REQ( set_irp_result )
1279 {
1280 req->handle = wine_server_obj_handle( handle );
1281 req->status = irp->IoStatus.u.Status;
1282 req->file_ptr = wine_server_client_ptr( file );
1283 if (irp->IoStatus.u.Status >= 0)
1284 {
1285 req->size = irp->IoStatus.Information;
1286 if (out_buff) wine_server_add_data( req, out_buff, irp->IoStatus.Information );
1287 }
1288 wine_server_call( req );
1289 }
1290 SERVER_END_REQ;
1291 HeapFree( GetProcessHeap(), 0, out_buff );
1292 }
1293
1294 IoFreeIrp( irp );
1295 }
1296
1297
1298 /***********************************************************************
1299 * IofCompleteRequest (NTOSKRNL.EXE.@)
1300 */
1301 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1302 DEFINE_FASTCALL2_ENTRYPOINT( IofCompleteRequest )
1303 void WINAPI __regs_IofCompleteRequest( IRP *irp, UCHAR priority_boost )
1304 #else
1305 void WINAPI IofCompleteRequest( IRP *irp, UCHAR priority_boost )
1306 #endif
1307 {
1308 TRACE( "%p %u\n", irp, priority_boost );
1309 IoCompleteRequest( irp, priority_boost );
1310 }
1311
1312
1313 /***********************************************************************
1314 * InterlockedCompareExchange (NTOSKRNL.EXE.@)
1315 */
1316 #ifdef DEFINE_FASTCALL3_ENTRYPOINT
1317 DEFINE_FASTCALL3_ENTRYPOINT( NTOSKRNL_InterlockedCompareExchange )
1318 LONG WINAPI __regs_NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
1319 #else
1320 LONG WINAPI NTOSKRNL_InterlockedCompareExchange( LONG volatile *dest, LONG xchg, LONG compare )
1321 #endif
1322 {
1323 return InterlockedCompareExchange( dest, xchg, compare );
1324 }
1325
1326
1327 /***********************************************************************
1328 * InterlockedDecrement (NTOSKRNL.EXE.@)
1329 */
1330 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1331 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedDecrement )
1332 LONG WINAPI __regs_NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
1333 #else
1334 LONG WINAPI NTOSKRNL_InterlockedDecrement( LONG volatile *dest )
1335 #endif
1336 {
1337 return InterlockedDecrement( dest );
1338 }
1339
1340
1341 /***********************************************************************
1342 * InterlockedExchange (NTOSKRNL.EXE.@)
1343 */
1344 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1345 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchange )
1346 LONG WINAPI __regs_NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
1347 #else
1348 LONG WINAPI NTOSKRNL_InterlockedExchange( LONG volatile *dest, LONG val )
1349 #endif
1350 {
1351 return InterlockedExchange( dest, val );
1352 }
1353
1354
1355 /***********************************************************************
1356 * InterlockedExchangeAdd (NTOSKRNL.EXE.@)
1357 */
1358 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
1359 DEFINE_FASTCALL2_ENTRYPOINT( NTOSKRNL_InterlockedExchangeAdd )
1360 LONG WINAPI __regs_NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
1361 #else
1362 LONG WINAPI NTOSKRNL_InterlockedExchangeAdd( LONG volatile *dest, LONG incr )
1363 #endif
1364 {
1365 return InterlockedExchangeAdd( dest, incr );
1366 }
1367
1368
1369 /***********************************************************************
1370 * InterlockedIncrement (NTOSKRNL.EXE.@)
1371 */
1372 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1373 DEFINE_FASTCALL1_ENTRYPOINT( NTOSKRNL_InterlockedIncrement )
1374 LONG WINAPI __regs_NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1375 #else
1376 LONG WINAPI NTOSKRNL_InterlockedIncrement( LONG volatile *dest )
1377 #endif
1378 {
1379 return InterlockedIncrement( dest );
1380 }
1381
1382
1383 /***********************************************************************
1384 * ExAllocatePool (NTOSKRNL.EXE.@)
1385 */
1386 PVOID WINAPI ExAllocatePool( POOL_TYPE type, SIZE_T size )
1387 {
1388 return ExAllocatePoolWithTag( type, size, 0 );
1389 }
1390
1391
1392 /***********************************************************************
1393 * ExAllocatePoolWithQuota (NTOSKRNL.EXE.@)
1394 */
1395 PVOID WINAPI ExAllocatePoolWithQuota( POOL_TYPE type, SIZE_T size )
1396 {
1397 return ExAllocatePoolWithTag( type, size, 0 );
1398 }
1399
1400
1401 /***********************************************************************
1402 * ExAllocatePoolWithTag (NTOSKRNL.EXE.@)
1403 */
1404 PVOID WINAPI ExAllocatePoolWithTag( POOL_TYPE type, SIZE_T size, ULONG tag )
1405 {
1406 /* FIXME: handle page alignment constraints */
1407 void *ret = HeapAlloc( GetProcessHeap(), 0, size );
1408 TRACE( "%lu pool %u -> %p\n", size, type, ret );
1409 return ret;
1410 }
1411
1412
1413 /***********************************************************************
1414 * ExAllocatePoolWithQuotaTag (NTOSKRNL.EXE.@)
1415 */
1416 PVOID WINAPI ExAllocatePoolWithQuotaTag( POOL_TYPE type, SIZE_T size, ULONG tag )
1417 {
1418 return ExAllocatePoolWithTag( type, size, tag );
1419 }
1420
1421
1422 /***********************************************************************
1423 * ExCreateCallback (NTOSKRNL.EXE.@)
1424 */
1425 NTSTATUS WINAPI ExCreateCallback(PCALLBACK_OBJECT *obj, POBJECT_ATTRIBUTES attr,
1426 BOOLEAN create, BOOLEAN allow_multiple)
1427 {
1428 FIXME("(%p, %p, %u, %u): stub\n", obj, attr, create, allow_multiple);
1429
1430 return STATUS_NOT_IMPLEMENTED;
1431 }
1432
1433
1434 /***********************************************************************
1435 * ExDeleteNPagedLookasideList (NTOSKRNL.EXE.@)
1436 */
1437 void WINAPI ExDeleteNPagedLookasideList( PNPAGED_LOOKASIDE_LIST lookaside )
1438 {
1439 FIXME("(%p) stub\n", lookaside);
1440 }
1441
1442
1443 /***********************************************************************
1444 * ExDeletePagedLookasideList (NTOSKRNL.EXE.@)
1445 */
1446 void WINAPI ExDeletePagedLookasideList( PPAGED_LOOKASIDE_LIST lookaside )
1447 {
1448 FIXME("(%p) stub\n", lookaside);
1449 }
1450
1451
1452 /***********************************************************************
1453 * ExFreePool (NTOSKRNL.EXE.@)
1454 */
1455 void WINAPI ExFreePool( void *ptr )
1456 {
1457 ExFreePoolWithTag( ptr, 0 );
1458 }
1459
1460
1461 /***********************************************************************
1462 * ExFreePoolWithTag (NTOSKRNL.EXE.@)
1463 */
1464 void WINAPI ExFreePoolWithTag( void *ptr, ULONG tag )
1465 {
1466 TRACE( "%p\n", ptr );
1467 HeapFree( GetProcessHeap(), 0, ptr );
1468 }
1469
1470
1471 /***********************************************************************
1472 * ExInitializeResourceLite (NTOSKRNL.EXE.@)
1473 */
1474 NTSTATUS WINAPI ExInitializeResourceLite(PERESOURCE Resource)
1475 {
1476 FIXME( "stub: %p\n", Resource );
1477 return STATUS_NOT_IMPLEMENTED;
1478 }
1479
1480
1481 /***********************************************************************
1482 * ExInitializeNPagedLookasideList (NTOSKRNL.EXE.@)
1483 */
1484 void WINAPI ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside,
1485 PALLOCATE_FUNCTION Allocate,
1486 PFREE_FUNCTION Free,
1487 ULONG Flags,
1488 SIZE_T Size,
1489 ULONG Tag,
1490 USHORT Depth)
1491 {
1492 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1493 }
1494
1495 /***********************************************************************
1496 * ExInitializePagedLookasideList (NTOSKRNL.EXE.@)
1497 */
1498 void WINAPI ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside,
1499 PALLOCATE_FUNCTION Allocate,
1500 PFREE_FUNCTION Free,
1501 ULONG Flags,
1502 SIZE_T Size,
1503 ULONG Tag,
1504 USHORT Depth)
1505 {
1506 FIXME( "stub: %p, %p, %p, %u, %lu, %u, %u\n", Lookaside, Allocate, Free, Flags, Size, Tag, Depth );
1507 }
1508
1509 /***********************************************************************
1510 * ExInitializeZone (NTOSKRNL.EXE.@)
1511 */
1512 NTSTATUS WINAPI ExInitializeZone(PZONE_HEADER Zone,
1513 ULONG BlockSize,
1514 PVOID InitialSegment,
1515 ULONG InitialSegmentSize)
1516 {
1517 FIXME( "stub: %p, %u, %p, %u\n", Zone, BlockSize, InitialSegment, InitialSegmentSize );
1518 return STATUS_NOT_IMPLEMENTED;
1519 }
1520
1521 /***********************************************************************
1522 * FsRtlRegisterUncProvider (NTOSKRNL.EXE.@)
1523 */
1524 NTSTATUS WINAPI FsRtlRegisterUncProvider(PHANDLE MupHandle, PUNICODE_STRING RedirDevName,
1525 BOOLEAN MailslotsSupported)
1526 {
1527 FIXME("(%p %p %d): stub\n", MupHandle, RedirDevName, MailslotsSupported);
1528 return STATUS_NOT_IMPLEMENTED;
1529 }
1530
1531 /***********************************************************************
1532 * IoGetCurrentProcess / PsGetCurrentProcess (NTOSKRNL.EXE.@)
1533 */
1534 PEPROCESS WINAPI IoGetCurrentProcess(void)
1535 {
1536 FIXME("() stub\n");
1537 return NULL;
1538 }
1539
1540 /***********************************************************************
1541 * KeGetCurrentThread / PsGetCurrentThread (NTOSKRNL.EXE.@)
1542 */
1543 PRKTHREAD WINAPI KeGetCurrentThread(void)
1544 {
1545 FIXME("() stub\n");
1546 return NULL;
1547 }
1548
1549 /***********************************************************************
1550 * KeInitializeEvent (NTOSKRNL.EXE.@)
1551 */
1552 void WINAPI KeInitializeEvent( PRKEVENT Event, EVENT_TYPE Type, BOOLEAN State )
1553 {
1554 FIXME( "stub: %p %d %d\n", Event, Type, State );
1555 }
1556
1557
1558 /***********************************************************************
1559 * KeInitializeMutex (NTOSKRNL.EXE.@)
1560 */
1561 void WINAPI KeInitializeMutex(PRKMUTEX Mutex, ULONG Level)
1562 {
1563 FIXME( "stub: %p, %u\n", Mutex, Level );
1564 }
1565
1566
1567 /***********************************************************************
1568 * KeWaitForMutexObject (NTOSKRNL.EXE.@)
1569 */
1570 NTSTATUS WINAPI KeWaitForMutexObject(PRKMUTEX Mutex, KWAIT_REASON WaitReason, KPROCESSOR_MODE WaitMode,
1571 BOOLEAN Alertable, PLARGE_INTEGER Timeout)
1572 {
1573 FIXME( "stub: %p, %d, %d, %d, %p\n", Mutex, WaitReason, WaitMode, Alertable, Timeout );
1574 return STATUS_NOT_IMPLEMENTED;
1575 }
1576
1577
1578 /***********************************************************************
1579 * KeReleaseMutex (NTOSKRNL.EXE.@)
1580 */
1581 LONG WINAPI KeReleaseMutex(PRKMUTEX Mutex, BOOLEAN Wait)
1582 {
1583 FIXME( "stub: %p, %d\n", Mutex, Wait );
1584 return STATUS_NOT_IMPLEMENTED;
1585 }
1586
1587
1588 /***********************************************************************
1589 * KeInitializeSemaphore (NTOSKRNL.EXE.@)
1590 */
1591 void WINAPI KeInitializeSemaphore( PRKSEMAPHORE Semaphore, LONG Count, LONG Limit )
1592 {
1593 FIXME( "(%p %d %d) stub\n", Semaphore , Count, Limit );
1594 }
1595
1596
1597 /***********************************************************************
1598 * KeInitializeSpinLock (NTOSKRNL.EXE.@)
1599 */
1600 void WINAPI KeInitializeSpinLock( PKSPIN_LOCK SpinLock )
1601 {
1602 FIXME( "stub: %p\n", SpinLock );
1603 }
1604
1605
1606 /***********************************************************************
1607 * KeInitializeTimerEx (NTOSKRNL.EXE.@)
1608 */
1609 void WINAPI KeInitializeTimerEx( PKTIMER Timer, TIMER_TYPE Type )
1610 {
1611 FIXME( "stub: %p %d\n", Timer, Type );
1612 }
1613
1614
1615 /***********************************************************************
1616 * KeInitializeTimer (NTOSKRNL.EXE.@)
1617 */
1618 void WINAPI KeInitializeTimer( PKTIMER Timer )
1619 {
1620 KeInitializeTimerEx(Timer, NotificationTimer);
1621 }
1622
1623 /***********************************************************************
1624 * KeInsertQueue (NTOSKRNL.EXE.@)
1625 */
1626 LONG WINAPI KeInsertQueue(PRKQUEUE Queue, PLIST_ENTRY Entry)
1627 {
1628 FIXME( "stub: %p %p\n", Queue, Entry );
1629 return 0;
1630 }
1631
1632 /**********************************************************************
1633 * KeQueryActiveProcessors (NTOSKRNL.EXE.@)
1634 *
1635 * Return the active Processors as bitmask
1636 *
1637 * RETURNS
1638 * active Processors as bitmask
1639 *
1640 */
1641 KAFFINITY WINAPI KeQueryActiveProcessors( void )
1642 {
1643 DWORD_PTR AffinityMask;
1644
1645 GetProcessAffinityMask( GetCurrentProcess(), &AffinityMask, NULL);
1646 return AffinityMask;
1647 }
1648
1649
1650 /**********************************************************************
1651 * KeQueryInterruptTime (NTOSKRNL.EXE.@)
1652 *
1653 * Return the interrupt time count
1654 *
1655 */
1656 ULONGLONG WINAPI KeQueryInterruptTime( void )
1657 {
1658 LARGE_INTEGER totaltime;
1659
1660 KeQueryTickCount(&totaltime);
1661 return totaltime.QuadPart;
1662 }
1663
1664
1665 /***********************************************************************
1666 * KeQuerySystemTime (NTOSKRNL.EXE.@)
1667 */
1668 void WINAPI KeQuerySystemTime( LARGE_INTEGER *time )
1669 {
1670 NtQuerySystemTime( time );
1671 }
1672
1673
1674 /***********************************************************************
1675 * KeQueryTickCount (NTOSKRNL.EXE.@)
1676 */
1677 void WINAPI KeQueryTickCount( LARGE_INTEGER *count )
1678 {
1679 count->QuadPart = NtGetTickCount();
1680 /* update the global variable too */
1681 KeTickCount.LowPart = count->u.LowPart;
1682 KeTickCount.High1Time = count->u.HighPart;
1683 KeTickCount.High2Time = count->u.HighPart;
1684 }
1685
1686
1687 /***********************************************************************
1688 * KeReleaseSemaphore (NTOSKRNL.EXE.@)
1689 */
1690 LONG WINAPI KeReleaseSemaphore( PRKSEMAPHORE Semaphore, KPRIORITY Increment,
1691 LONG Adjustment, BOOLEAN Wait )
1692 {
1693 FIXME("(%p %d %d %d) stub\n", Semaphore, Increment, Adjustment, Wait );
1694 return 0;
1695 }
1696
1697
1698 /***********************************************************************
1699 * KeQueryTimeIncrement (NTOSKRNL.EXE.@)
1700 */
1701 ULONG WINAPI KeQueryTimeIncrement(void)
1702 {
1703 return 10000;
1704 }
1705
1706
1707 /***********************************************************************
1708 * KeResetEvent (NTOSKRNL.EXE.@)
1709 */
1710 LONG WINAPI KeResetEvent( PRKEVENT Event )
1711 {
1712 FIXME("(%p): stub\n", Event);
1713 return 0;
1714 }
1715
1716
1717 /***********************************************************************
1718 * KeSetEvent (NTOSKRNL.EXE.@)
1719 */
1720 LONG WINAPI KeSetEvent( PRKEVENT Event, KPRIORITY Increment, BOOLEAN Wait )
1721 {
1722 FIXME("(%p, %d, %d): stub\n", Event, Increment, Wait);
1723 return 0;
1724 }
1725
1726
1727 /***********************************************************************
1728 * KeSetPriorityThread (NTOSKRNL.EXE.@)
1729 */
1730 KPRIORITY WINAPI KeSetPriorityThread( PKTHREAD Thread, KPRIORITY Priority )
1731 {
1732 FIXME("(%p %d)\n", Thread, Priority);
1733 return Priority;
1734 }
1735
1736 /***********************************************************************
1737 * KeSetSystemAffinityThread (NTOSKRNL.EXE.@)
1738 */
1739 VOID WINAPI KeSetSystemAffinityThread(KAFFINITY Affinity)
1740 {
1741 FIXME("(%lx) stub\n", Affinity);
1742 }
1743
1744 /***********************************************************************
1745 * KeWaitForSingleObject (NTOSKRNL.EXE.@)
1746 */
1747 NTSTATUS WINAPI KeWaitForSingleObject(PVOID Object,
1748 KWAIT_REASON WaitReason,
1749 KPROCESSOR_MODE WaitMode,
1750 BOOLEAN Alertable,
1751 PLARGE_INTEGER Timeout)
1752 {
1753 FIXME( "stub: %p, %d, %d, %d, %p\n", Object, WaitReason, WaitMode, Alertable, Timeout );
1754 return STATUS_NOT_IMPLEMENTED;
1755 }
1756
1757 /***********************************************************************
1758 * IoRegisterFileSystem (NTOSKRNL.EXE.@)
1759 */
1760 VOID WINAPI IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject)
1761 {
1762 FIXME("(%p): stub\n", DeviceObject);
1763 }
1764
1765 /***********************************************************************
1766 * IoUnregisterFileSystem (NTOSKRNL.EXE.@)
1767 */
1768 VOID WINAPI IoUnregisterFileSystem(PDEVICE_OBJECT DeviceObject)
1769 {
1770 FIXME("(%p): stub\n", DeviceObject);
1771 }
1772
1773 /***********************************************************************
1774 * MmAllocateNonCachedMemory (NTOSKRNL.EXE.@)
1775 */
1776 PVOID WINAPI MmAllocateNonCachedMemory( SIZE_T size )
1777 {
1778 TRACE( "%lu\n", size );
1779 return VirtualAlloc( NULL, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE|PAGE_NOCACHE );
1780 }
1781
1782 /***********************************************************************
1783 * MmAllocateContiguousMemory (NTOSKRNL.EXE.@)
1784 */
1785 PVOID WINAPI MmAllocateContiguousMemory( SIZE_T size, PHYSICAL_ADDRESS highest_valid_address )
1786 {
1787 FIXME( "%lu, %s stub\n", size, wine_dbgstr_longlong(highest_valid_address.QuadPart) );
1788 return NULL;
1789 }
1790
1791 /***********************************************************************
1792 * MmAllocateContiguousMemorySpecifyCache (NTOSKRNL.EXE.@)
1793 */
1794 PVOID WINAPI MmAllocateContiguousMemorySpecifyCache( SIZE_T size,
1795 PHYSICAL_ADDRESS lowest_valid_address,
1796 PHYSICAL_ADDRESS highest_valid_address,
1797 PHYSICAL_ADDRESS BoundaryAddressMultiple,
1798 MEMORY_CACHING_TYPE CacheType )
1799 {
1800 FIXME(": stub\n");
1801 return NULL;
1802 }
1803
1804 /***********************************************************************
1805 * MmAllocatePagesForMdl (NTOSKRNL.EXE.@)
1806 */
1807 PMDL WINAPI MmAllocatePagesForMdl(PHYSICAL_ADDRESS lowaddress, PHYSICAL_ADDRESS highaddress,
1808 PHYSICAL_ADDRESS skipbytes, SIZE_T size)
1809 {
1810 FIXME("%s %s %s %lu: stub\n", wine_dbgstr_longlong(lowaddress.QuadPart), wine_dbgstr_longlong(highaddress.QuadPart),
1811 wine_dbgstr_longlong(skipbytes.QuadPart), size);
1812 return NULL;
1813 }
1814
1815 /***********************************************************************
1816 * MmFreeNonCachedMemory (NTOSKRNL.EXE.@)
1817 */
1818 void WINAPI MmFreeNonCachedMemory( void *addr, SIZE_T size )
1819 {
1820 TRACE( "%p %lu\n", addr, size );
1821 VirtualFree( addr, 0, MEM_RELEASE );
1822 }
1823
1824 /***********************************************************************
1825 * MmIsAddressValid (NTOSKRNL.EXE.@)
1826 *
1827 * Check if the process can access the virtual address without a pagefault
1828 *
1829 * PARAMS
1830 * VirtualAddress [I] Address to check
1831 *
1832 * RETURNS
1833 * Failure: FALSE
1834 * Success: TRUE (Accessing the Address works without a Pagefault)
1835 *
1836 */
1837 BOOLEAN WINAPI MmIsAddressValid(PVOID VirtualAddress)
1838 {
1839 TRACE("(%p)\n", VirtualAddress);
1840 return !IsBadWritePtr(VirtualAddress, 1);
1841 }
1842
1843 /***********************************************************************
1844 * MmMapIoSpace (NTOSKRNL.EXE.@)
1845 */
1846 PVOID WINAPI MmMapIoSpace( PHYSICAL_ADDRESS PhysicalAddress, DWORD NumberOfBytes, DWORD CacheType )
1847 {
1848 FIXME( "stub: 0x%08x%08x, %d, %d\n", PhysicalAddress.u.HighPart, PhysicalAddress.u.LowPart, NumberOfBytes, CacheType );
1849 return NULL;
1850 }
1851
1852
1853 /***********************************************************************
1854 * MmLockPagableSectionByHandle (NTOSKRNL.EXE.@)
1855 */
1856 VOID WINAPI MmLockPagableSectionByHandle(PVOID ImageSectionHandle)
1857 {
1858 FIXME("stub %p\n", ImageSectionHandle);
1859 }
1860
1861 /***********************************************************************
1862 * MmMapLockedPagesSpecifyCache (NTOSKRNL.EXE.@)
1863 */
1864 PVOID WINAPI MmMapLockedPagesSpecifyCache(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, MEMORY_CACHING_TYPE CacheType,
1865 PVOID BaseAddress, ULONG BugCheckOnFailure, MM_PAGE_PRIORITY Priority)
1866 {
1867 FIXME("(%p, %u, %u, %p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, CacheType, BaseAddress, BugCheckOnFailure, Priority);
1868
1869 return NULL;
1870 }
1871
1872 /***********************************************************************
1873 * MmUnlockPagableImageSection (NTOSKRNL.EXE.@)
1874 */
1875 VOID WINAPI MmUnlockPagableImageSection(PVOID ImageSectionHandle)
1876 {
1877 FIXME("stub %p\n", ImageSectionHandle);
1878 }
1879
1880 /***********************************************************************
1881 * MmPageEntireDriver (NTOSKRNL.EXE.@)
1882 */
1883 PVOID WINAPI MmPageEntireDriver(PVOID AddrInSection)
1884 {
1885 TRACE("%p\n", AddrInSection);
1886 return AddrInSection;
1887 }
1888
1889
1890 /***********************************************************************
1891 * MmProbeAndLockPages (NTOSKRNL.EXE.@)
1892 */
1893 void WINAPI MmProbeAndLockPages(PMDLX MemoryDescriptorList, KPROCESSOR_MODE AccessMode, LOCK_OPERATION Operation)
1894 {
1895 FIXME("(%p, %u, %u): stub\n", MemoryDescriptorList, AccessMode, Operation);
1896 }
1897
1898
1899 /***********************************************************************
1900 * MmResetDriverPaging (NTOSKRNL.EXE.@)
1901 */
1902 void WINAPI MmResetDriverPaging(PVOID AddrInSection)
1903 {
1904 TRACE("%p\n", AddrInSection);
1905 }
1906
1907
1908 /***********************************************************************
1909 * MmUnlockPages (NTOSKRNL.EXE.@)
1910 */
1911 void WINAPI MmUnlockPages(PMDLX MemoryDescriptorList)
1912 {
1913 FIXME("(%p): stub\n", MemoryDescriptorList);
1914 }
1915
1916
1917 /***********************************************************************
1918 * MmUnmapIoSpace (NTOSKRNL.EXE.@)
1919 */
1920 VOID WINAPI MmUnmapIoSpace( PVOID BaseAddress, SIZE_T NumberOfBytes )
1921 {
1922 FIXME( "stub: %p, %lu\n", BaseAddress, NumberOfBytes );
1923 }
1924
1925 /***********************************************************************
1926 * ObfReferenceObject (NTOSKRNL.EXE.@)
1927 */
1928 VOID WINAPI ObfReferenceObject(PVOID Object)
1929 {
1930 FIXME("(%p): stub\n", Object);
1931 }
1932
1933 /***********************************************************************
1934 * ObReferenceObjectByHandle (NTOSKRNL.EXE.@)
1935 */
1936 NTSTATUS WINAPI ObReferenceObjectByHandle( HANDLE obj, ACCESS_MASK access,
1937 POBJECT_TYPE type,
1938 KPROCESSOR_MODE mode, PVOID* ptr,
1939 POBJECT_HANDLE_INFORMATION info)
1940 {
1941 FIXME( "stub: %p %x %p %d %p %p\n", obj, access, type, mode, ptr, info);
1942 return STATUS_NOT_IMPLEMENTED;
1943 }
1944
1945 /***********************************************************************
1946 * ObReferenceObjectByName (NTOSKRNL.EXE.@)
1947 */
1948 NTSTATUS WINAPI ObReferenceObjectByName( UNICODE_STRING *ObjectName,
1949 ULONG Attributes,
1950 ACCESS_STATE *AccessState,
1951 ACCESS_MASK DesiredAccess,
1952 POBJECT_TYPE ObjectType,
1953 KPROCESSOR_MODE AccessMode,
1954 void *ParseContext,
1955 void **Object)
1956 {
1957 FIXME("stub\n");
1958 return STATUS_NOT_IMPLEMENTED;
1959 }
1960
1961 /***********************************************************************
1962 * ObfDereferenceObject (NTOSKRNL.EXE.@)
1963 */
1964 #ifdef DEFINE_FASTCALL1_ENTRYPOINT
1965 DEFINE_FASTCALL1_ENTRYPOINT( ObfDereferenceObject )
1966 void WINAPI __regs_ObfDereferenceObject( VOID *obj )
1967 #else
1968 void WINAPI ObfDereferenceObject( VOID *obj )
1969 #endif
1970 {
1971 FIXME( "stub: %p\n", obj );
1972 }
1973
1974
1975 /***********************************************************************
1976 * PsCreateSystemThread (NTOSKRNL.EXE.@)
1977 */
1978 NTSTATUS WINAPI PsCreateSystemThread(PHANDLE ThreadHandle, ULONG DesiredAccess,
1979 POBJECT_ATTRIBUTES ObjectAttributes,
1980 HANDLE ProcessHandle, PCLIENT_ID ClientId,
1981 PKSTART_ROUTINE StartRoutine, PVOID StartContext)
1982 {
1983 if (!ProcessHandle) ProcessHandle = GetCurrentProcess();
1984 return RtlCreateUserThread(ProcessHandle, 0, FALSE, 0, 0,
1985 0, StartRoutine, StartContext,
1986 ThreadHandle, ClientId);
1987 }
1988
1989 /***********************************************************************
1990 * PsGetCurrentProcessId (NTOSKRNL.EXE.@)
1991 */
1992 HANDLE WINAPI PsGetCurrentProcessId(void)
1993 {
1994 if (GetCurrentThreadId() == request_thread)
1995 return UlongToHandle(client_pid);
1996 return UlongToHandle(GetCurrentProcessId());
1997 }
1998
1999
2000 /***********************************************************************
2001 * PsGetCurrentThreadId (NTOSKRNL.EXE.@)
2002 */
2003 HANDLE WINAPI PsGetCurrentThreadId(void)
2004 {
2005 if (GetCurrentThreadId() == request_thread)
2006 return UlongToHandle(client_tid);
2007 return UlongToHandle(GetCurrentThreadId());
2008 }
2009
2010
2011 /***********************************************************************
2012 * PsGetVersion (NTOSKRNL.EXE.@)
2013 */
2014 BOOLEAN WINAPI PsGetVersion(ULONG *major, ULONG *minor, ULONG *build, UNICODE_STRING *version )
2015 {
2016 RTL_OSVERSIONINFOEXW info;
2017
2018 info.dwOSVersionInfoSize = sizeof(info);
2019 RtlGetVersion( &info );
2020 if (major) *major = info.dwMajorVersion;
2021 if (minor) *minor = info.dwMinorVersion;
2022 if (build) *build = info.dwBuildNumber;
2023
2024 if (version)
2025 {
2026 #if 0 /* FIXME: GameGuard passes an uninitialized pointer in version->Buffer */
2027 size_t len = min( strlenW(info.szCSDVersion)*sizeof(WCHAR), version->MaximumLength );
2028 memcpy( version->Buffer, info.szCSDVersion, len );
2029 if (len < version->MaximumLength) version->Buffer[len / sizeof(WCHAR)] = 0;
2030 version->Length = len;
2031 #endif
2032 }
2033 return TRUE;
2034 }
2035
2036
2037 /***********************************************************************
2038 * PsImpersonateClient (NTOSKRNL.EXE.@)
2039 */
2040 NTSTATUS WINAPI PsImpersonateClient(PETHREAD Thread, PACCESS_TOKEN Token, BOOLEAN CopyOnOpen,
2041 BOOLEAN EffectiveOnly, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
2042 {
2043 FIXME("(%p, %p, %u, %u, %u): stub\n", Thread, Token, CopyOnOpen, EffectiveOnly, ImpersonationLevel);
2044
2045 return STATUS_NOT_IMPLEMENTED;
2046 }
2047
2048
2049 /***********************************************************************
2050 * PsSetCreateProcessNotifyRoutine (NTOSKRNL.EXE.@)
2051 */
2052 NTSTATUS WINAPI PsSetCreateProcessNotifyRoutine( PCREATE_PROCESS_NOTIFY_ROUTINE callback, BOOLEAN remove )
2053 {
2054 FIXME( "stub: %p %d\n", callback, remove );
2055 return STATUS_SUCCESS;
2056 }
2057
2058
2059 /***********************************************************************
2060 * PsSetCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
2061 */
2062 NTSTATUS WINAPI PsSetCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
2063 {
2064 FIXME( "stub: %p\n", NotifyRoutine );
2065 return STATUS_SUCCESS;
2066 }
2067
2068
2069 /***********************************************************************
2070 * PsRemoveCreateThreadNotifyRoutine (NTOSKRNL.EXE.@)
2071 */
2072 NTSTATUS WINAPI PsRemoveCreateThreadNotifyRoutine( PCREATE_THREAD_NOTIFY_ROUTINE NotifyRoutine )
2073 {
2074 FIXME( "stub: %p\n", NotifyRoutine );
2075 return STATUS_SUCCESS;
2076 }
2077
2078
2079 /***********************************************************************
2080 * PsTerminateSystemThread (NTOSKRNL.EXE.@)
2081 */
2082 NTSTATUS WINAPI PsTerminateSystemThread(NTSTATUS ExitStatus)
2083 {
2084 FIXME( "stub: %u\n", ExitStatus );
2085 return STATUS_NOT_IMPLEMENTED;
2086 }
2087
2088
2089 /***********************************************************************
2090 * MmGetSystemRoutineAddress (NTOSKRNL.EXE.@)
2091 */
2092 PVOID WINAPI MmGetSystemRoutineAddress(PUNICODE_STRING SystemRoutineName)
2093 {
2094 HMODULE hMod;
2095 STRING routineNameA;
2096 PVOID pFunc = NULL;
2097
2098 static const WCHAR ntoskrnlW[] = {'n','t','o','s','k','r','n','l','.','e','x','e',0};
2099 static const WCHAR halW[] = {'h','a','l','.','d','l','l',0};
2100
2101 if (!SystemRoutineName) return NULL;
2102
2103 if (RtlUnicodeStringToAnsiString( &routineNameA, SystemRoutineName, TRUE ) == STATUS_SUCCESS)
2104 {
2105 /* We only support functions exported from ntoskrnl.exe or hal.dll */
2106 hMod = GetModuleHandleW( ntoskrnlW );
2107 pFunc = GetProcAddress( hMod, routineNameA.Buffer );
2108 if (!pFunc)
2109 {
2110 hMod = GetModuleHandleW( halW );
2111 if (hMod) pFunc = GetProcAddress( hMod, routineNameA.Buffer );
2112 }
2113 RtlFreeAnsiString( &routineNameA );
2114 }
2115
2116 if (pFunc)
2117 TRACE( "%s -> %p\n", debugstr_us(SystemRoutineName), pFunc );
2118 else
2119 FIXME( "%s not found\n", debugstr_us(SystemRoutineName) );
2120 return pFunc;
2121 }
2122
2123
2124 /***********************************************************************
2125 * MmQuerySystemSize (NTOSKRNL.EXE.@)
2126 */
2127 MM_SYSTEMSIZE WINAPI MmQuerySystemSize(void)
2128 {
2129 FIXME("stub\n");
2130 return MmLargeSystem;
2131 }
2132
2133 /***********************************************************************
2134 * KeInitializeDpc (NTOSKRNL.EXE.@)
2135 */
2136 VOID WINAPI KeInitializeDpc(PRKDPC Dpc, PKDEFERRED_ROUTINE DeferredRoutine, PVOID DeferredContext)
2137 {
2138 FIXME("stub\n");
2139 }
2140
2141 /***********************************************************************
2142 * READ_REGISTER_BUFFER_UCHAR (NTOSKRNL.EXE.@)
2143 */
2144 VOID WINAPI READ_REGISTER_BUFFER_UCHAR(PUCHAR Register, PUCHAR Buffer, ULONG Count)
2145 {
2146 FIXME("stub\n");
2147 }
2148
2149 /*****************************************************
2150 * PoSetPowerState (NTOSKRNL.EXE.@)
2151 */
2152 POWER_STATE WINAPI PoSetPowerState(PDEVICE_OBJECT DeviceObject, POWER_STATE_TYPE Type, POWER_STATE State)
2153 {
2154 FIXME("(%p %u %u) stub\n", DeviceObject, Type, State.DeviceState);
2155 return State;
2156 }
2157
2158 /*****************************************************
2159 * IoWMIRegistrationControl (NTOSKRNL.EXE.@)
2160 */
2161 NTSTATUS WINAPI IoWMIRegistrationControl(PDEVICE_OBJECT DeviceObject, ULONG Action)
2162 {
2163 FIXME("(%p %u) stub\n", DeviceObject, Action);
2164 return STATUS_SUCCESS;
2165 }
2166
2167 /*****************************************************
2168 * PsSetLoadImageNotifyRoutine (NTOSKRNL.EXE.@)
2169 */
2170 NTSTATUS WINAPI PsSetLoadImageNotifyRoutine(PLOAD_IMAGE_NOTIFY_ROUTINE routine)
2171 {
2172 FIXME("(%p) stub\n", routine);
2173 return STATUS_SUCCESS;
2174 }
2175
2176 /*****************************************************
2177 * PsLookupProcessByProcessId (NTOSKRNL.EXE.@)
2178 */
2179 NTSTATUS WINAPI PsLookupProcessByProcessId(HANDLE processid, PEPROCESS *process)
2180 {
2181 static int once;
2182 if (!once++) FIXME("(%p %p) stub\n", processid, process);
2183 return STATUS_NOT_IMPLEMENTED;
2184 }
2185
2186
2187 /*****************************************************
2188 * IoSetThreadHardErrorMode (NTOSKRNL.EXE.@)
2189 */
2190 BOOLEAN WINAPI IoSetThreadHardErrorMode(BOOLEAN EnableHardErrors)
2191 {
2192 FIXME("stub\n");
2193 return FALSE;
2194 }
2195
2196
2197 /*****************************************************
2198 * IoInitializeRemoveLockEx (NTOSKRNL.EXE.@)
2199 */
2200 VOID WINAPI IoInitializeRemoveLockEx(PIO_REMOVE_LOCK lock, ULONG tag,
2201 ULONG maxmin, ULONG high, ULONG size)
2202 {
2203 FIXME("(%p %u %u %u %u) stub\n", lock, tag, maxmin, high, size);
2204 }
2205
2206
2207 /*****************************************************
2208 * IoAcquireRemoveLockEx (NTOSKRNL.EXE.@)
2209 */
2210
2211 NTSTATUS WINAPI IoAcquireRemoveLockEx(PIO_REMOVE_LOCK lock, PVOID tag,
2212 LPCSTR file, ULONG line, ULONG lock_size)
2213 {
2214 FIXME("(%p, %p, %s, %u, %u): stub\n", lock, tag, debugstr_a(file), line, lock_size);
2215
2216 return STATUS_NOT_IMPLEMENTED;
2217 }
2218
2219
2220 /*****************************************************
2221 * DllMain
2222 */
2223 BOOL WINAPI DllMain( HINSTANCE inst, DWORD reason, LPVOID reserved )
2224 {
2225 static void *handler;
2226 LARGE_INTEGER count;
2227
2228 switch(reason)
2229 {
2230 case DLL_PROCESS_ATTACH:
2231 DisableThreadLibraryCalls( inst );
2232 #if defined(__i386__) || defined(__x86_64__)
2233 handler = RtlAddVectoredExceptionHandler( TRUE, vectored_handler );
2234 #endif
2235 KeQueryTickCount( &count ); /* initialize the global KeTickCount */
2236 break;
2237 case DLL_PROCESS_DETACH:
2238 if (reserved) break;
2239 RtlRemoveVectoredExceptionHandler( handler );
2240 break;
2241 }
2242 return TRUE;
2243 }
2244
2245 /*****************************************************
2246 * Ke386IoSetAccessProcess (NTOSKRNL.EXE.@)
2247 */
2248 BOOLEAN WINAPI Ke386IoSetAccessProcess(PEPROCESS *process, ULONG flag)
2249 {
2250 FIXME("(%p %d) stub\n", process, flag);
2251 return FALSE;
2252 }
2253
2254 /*****************************************************
2255 * Ke386SetIoAccessMap (NTOSKRNL.EXE.@)
2256 */
2257 BOOLEAN WINAPI Ke386SetIoAccessMap(ULONG flag, PVOID buffer)
2258 {
2259 FIXME("(%d %p) stub\n", flag, buffer);
2260 return FALSE;
2261 }
2262
2263 /*****************************************************
2264 * IoCreateSynchronizationEvent (NTOSKRNL.EXE.@)
2265 */
2266 PKEVENT WINAPI IoCreateSynchronizationEvent(PUNICODE_STRING name, PHANDLE handle)
2267 {
2268 FIXME("(%p %p) stub\n", name, handle);
2269 return NULL;
2270 }
2271
2272 /*****************************************************
2273 * IoStartNextPacket (NTOSKRNL.EXE.@)
2274 */
2275 VOID WINAPI IoStartNextPacket(PDEVICE_OBJECT deviceobject, BOOLEAN cancelable)
2276 {
2277 FIXME("(%p %d) stub\n", deviceobject, cancelable);
2278 }
2279
2280 /*****************************************************
2281 * ObQueryNameString (NTOSKRNL.EXE.@)
2282 */
2283 NTSTATUS WINAPI ObQueryNameString(PVOID object, POBJECT_NAME_INFORMATION name, ULONG maxlength, PULONG returnlength)
2284 {
2285 FIXME("(%p %p %u %p) stub\n", object, name, maxlength, returnlength);
2286 return STATUS_NOT_IMPLEMENTED;
2287 }
2288
2289 /*****************************************************
2290 * IoRegisterPlugPlayNotification (NTOSKRNL.EXE.@)
2291 */
2292 NTSTATUS WINAPI IoRegisterPlugPlayNotification(IO_NOTIFICATION_EVENT_CATEGORY category, ULONG flags, PVOID data,
2293 PDRIVER_OBJECT driver, PDRIVER_NOTIFICATION_CALLBACK_ROUTINE callback,
2294 PVOID context, PVOID *notification)
2295 {
2296 FIXME("(%u %u %p %p %p %p %p) stub\n", category, flags, data, driver, callback, context, notification);
2297 return STATUS_SUCCESS;
2298 }
2299
2300 /*****************************************************
2301 * IoCsqInitialize (NTOSKRNL.EXE.@)
2302 */
2303 NTSTATUS WINAPI IoCsqInitialize(PIO_CSQ csq, PIO_CSQ_INSERT_IRP insert_irp, PIO_CSQ_REMOVE_IRP remove_irp,
2304 PIO_CSQ_PEEK_NEXT_IRP peek_irp, PIO_CSQ_ACQUIRE_LOCK acquire_lock,
2305 PIO_CSQ_RELEASE_LOCK release_lock, PIO_CSQ_COMPLETE_CANCELED_IRP complete_irp)
2306 {
2307 FIXME("(%p %p %p %p %p %p %p) stub\n",
2308 csq, insert_irp, remove_irp, peek_irp, acquire_lock, release_lock, complete_irp);
2309 return STATUS_SUCCESS;
2310 }
2311
2312 /***********************************************************************
2313 * ExAcquireResourceExclusiveLite (NTOSKRNL.EXE.@)
2314 */
2315 BOOLEAN WINAPI ExAcquireResourceExclusiveLite( PERESOURCE resource, BOOLEAN wait )
2316 {
2317 FIXME( ":%p %u stub\n", resource, wait );
2318 return TRUE;
2319 }
2320
2321 /***********************************************************************
2322 * ExDeleteResourceLite (NTOSKRNL.EXE.@)
2323 */
2324 NTSTATUS WINAPI ExDeleteResourceLite(PERESOURCE resource)
2325 {
2326 FIXME("(%p): stub\n", resource);
2327 return STATUS_NOT_IMPLEMENTED;
2328 }
2329
2330 /*****************************************************
2331 * ExInterlockedRemoveHeadList (NTOSKRNL.EXE.@)
2332 */
2333 PLIST_ENTRY WINAPI ExInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2334 {
2335 FIXME("(%p %p) stub\n", head, lock);
2336 return NULL;
2337 }
2338
2339 /***********************************************************************
2340 * ExfInterlockedRemoveHeadList (NTOSKRNL.EXE.@)
2341 */
2342 #ifdef DEFINE_FASTCALL2_ENTRYPOINT
2343 DEFINE_FASTCALL2_ENTRYPOINT( ExfInterlockedRemoveHeadList )
2344 PLIST_ENTRY WINAPI __regs_ExfInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2345 #else
2346 PLIST_ENTRY WINAPI ExfInterlockedRemoveHeadList(PLIST_ENTRY head, PKSPIN_LOCK lock)
2347 #endif
2348 {
2349 FIXME("(%p %p) stub\n", head, lock);
2350 return ExInterlockedRemoveHeadList( head, lock );
2351 }
2352
2353 /***********************************************************************
2354 * ExReleaseResourceForThreadLite (NTOSKRNL.EXE.@)
2355 */
2356 void WINAPI ExReleaseResourceForThreadLite( PERESOURCE resource, ERESOURCE_THREAD tid )
2357 {
2358 FIXME( "stub: %p %lu\n", resource, tid );
2359 }
2360
2361 /***********************************************************************
2362 * KeEnterCriticalRegion (NTOSKRNL.EXE.@)
2363 */
2364 void WINAPI KeEnterCriticalRegion(void)
2365 {
2366 FIXME(": stub\n");
2367 }
2368
2369 /***********************************************************************
2370 * KeLeaveCriticalRegion (NTOSKRNL.EXE.@)
2371 */
2372 void WINAPI KeLeaveCriticalRegion(void)
2373 {
2374 FIXME(": stub\n");
2375 }
2376
2377 /***********************************************************************
2378 * ProbeForRead (NTOSKRNL.EXE.@)
2379 */
2380 void WINAPI ProbeForRead(void *address, SIZE_T length, ULONG alignment)
2381 {
2382 FIXME("(%p %lu %u) stub\n", address, length, alignment);
2383 }
2384
2385 /***********************************************************************
2386 * ProbeForWrite (NTOSKRNL.EXE.@)
2387 */
2388 void WINAPI ProbeForWrite(void *address, SIZE_T length, ULONG alignment)
2389 {
2390 FIXME("(%p %lu %u) stub\n", address, length, alignment);
2391 }
2392
2393 /***********************************************************************
2394 * CmRegisterCallback (NTOSKRNL.EXE.@)
2395 */
2396 NTSTATUS WINAPI CmRegisterCallback(EX_CALLBACK_FUNCTION *function, void *context, LARGE_INTEGER *cookie)
2397 {
2398 FIXME("(%p %p %p): stub\n", function, context, cookie);
2399 return STATUS_NOT_IMPLEMENTED;
2400 }
2401
2402 /***********************************************************************
2403 * CmUnRegisterCallback (NTOSKRNL.EXE.@)
2404 */
2405 NTSTATUS WINAPI CmUnRegisterCallback(LARGE_INTEGER cookie)
2406 {
2407 FIXME("(%s): stub\n", wine_dbgstr_longlong(cookie.QuadPart));
2408 return STATUS_NOT_IMPLEMENTED;
2409 }
Windows API implementation