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