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