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