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