1 /*++
2
3 Copyright (c) Microsoft Corporation
4
5 ModuleName:
6
7 MxGeneralUm.h
8
9 Abstract:
10
11 User mode implementation for general OS
12 functions defined in MxGeneral.h
13
14 Author:
15
16
17
18 Revision History:
19
20
21
22 --*/
23
24 #pragma once
25
26 #define MAKE_MX_FUNC_NAME(x) x
27
28
29
30
31
32
33
34
35 #define REMOVE_LOCK_RELEASE_TIMEOUT_IN_SECONDS 45
36
37 typedef VOID THREADPOOL_WAIT_CALLBACK (
38 __inout PTP_CALLBACK_INSTANCE Instance,
39 __inout_opt PVOID Context,
40 __inout PTP_WAIT Wait,
41 __in TP_WAIT_RESULT WaitResult
42 );
43
44 typedef THREADPOOL_WAIT_CALLBACK MdInterruptServiceRoutineType, *MdInterruptServiceRoutine;
45
46 typedef
47 BOOLEAN
48 InterruptSynchronizeRoutine (
49 __in PVOID SynchronizeContext
50 );
51
52 typedef InterruptSynchronizeRoutine MdInterruptSynchronizeRoutineType, *MdInterruptSynchronizeRoutine;
53
54 typedef struct _CALLBACK_OBJECT *PCALLBACK_OBJECT;
55
56 typedef
57 VOID
58 CALLBACK_FUNCTION(
59 __in PVOID CallbackContext,
60 __in_opt PVOID Argument1,
61 __in_opt PVOID Argument2
62 );
63
64 typedef CALLBACK_FUNCTION MdCallbackFunctionType, *MdCallbackFunction;
65
66 //
67 // Define PnP notification event categories
68 //
69
70 typedef enum _IO_NOTIFICATION_EVENT_CATEGORY {
71 EventCategoryReserved,
72 EventCategoryHardwareProfileChange,
73 EventCategoryDeviceInterfaceChange,
74 EventCategoryTargetDeviceChange
75 } IO_NOTIFICATION_EVENT_CATEGORY;
76
77 #include "MxGeneral.h"
78
79 __inline
80 BOOLEAN
IsUM()81 Mx::IsUM(
82 )
83 {
84 return TRUE;
85 }
86
87 __inline
88 BOOLEAN
IsKM()89 Mx::IsKM(
90 )
91 {
92 return FALSE;
93 }
94
95 __inline
96 MxThread
MxGetCurrentThread()97 Mx::MxGetCurrentThread(
98 )
99 {
100 //
101 // We can't use GetCurrentThread as it returns a pseudo handle
102 // which would have same numeric value for different threads
103 // We could use DuplicateHandle to get real handle but that has the
104 // following problems:
105 // 1) It returns different handle values for the same thread
106 // if called again without closing handle.
107 // 2) Makes the caller call CloseHandle making it inconvenient to
108 // call this function just to get an identifier for the thread
109 // 3) More expensive than GetCurrentThreadId
110 //
111 // Since framework uses the thread only for comparison, logging
112 // purposes GetCurrentThreadId works well.
113 // It is cast to PVOID to match the pointer type PKTHREAD otherwise
114 // trace functions complain of data type mismatch
115 //
116
117 return (PVOID) ::GetCurrentThreadId();
118 }
119
120 __inline
121 MdEThread
GetCurrentEThread()122 Mx::GetCurrentEThread(
123 )
124 {
125 //
126 // See comments in MxGetCurrentThread.
127 //
128 return (PVOID) MxGetCurrentThread();
129 }
130
131 __inline
132 NTSTATUS
MxTerminateCurrentThread(__in NTSTATUS Status)133 Mx::MxTerminateCurrentThread(
134 __in NTSTATUS Status
135 )
136 {
137 #pragma prefast(suppress:__WARNING_USINGTERMINATETHREAD, "TerminateThread is the intent.");
138 if (!TerminateThread(::GetCurrentThread(), HRESULT_FROM_NT(Status))) {
139 DWORD err = GetLastError();
140 return WinErrorToNtStatus(err);
141 }
142 return STATUS_SUCCESS;
143 }
144
145 __inline
146 KIRQL
MxGetCurrentIrql()147 Mx::MxGetCurrentIrql(
148 )
149 {
150 return PASSIVE_LEVEL;
151 }
152
153 __inline
154 VOID
155 #pragma prefast(suppress:__WARNING_UNMATCHED_DECL_ANNO, "Can't apply kernel mode annotations.");
MxRaiseIrql(__in KIRQL NewIrql,__out PKIRQL OldIrql)156 Mx::MxRaiseIrql(
157 __in KIRQL NewIrql,
158 __out PKIRQL OldIrql
159 )
160 {
161 UNREFERENCED_PARAMETER(NewIrql);
162 UNREFERENCED_PARAMETER(OldIrql);
163
164 DO_NOTHING();
165 }
166
167 __inline
168 VOID
169 #pragma prefast(suppress:__WARNING_UNMATCHED_DECL_ANNO, "Can't apply kernel mode annotations.");
MxLowerIrql(__in KIRQL NewIrql)170 Mx::MxLowerIrql(
171 __in KIRQL NewIrql
172 )
173 {
174 UNREFERENCED_PARAMETER(NewIrql);
175
176 DO_NOTHING();
177 }
178
179 __inline
180 VOID
MxQueryTickCount(__out PLARGE_INTEGER TickCount)181 Mx::MxQueryTickCount(
182 __out PLARGE_INTEGER TickCount
183 )
184 {
185 TickCount->QuadPart = GetTickCount();
186 }
187
188 __inline
189 ULONG
MxQueryTimeIncrement()190 Mx::MxQueryTimeIncrement(
191 )
192 {
193 //
194 // The way to get absolute time is TickCount * TimeIncrement.
195 // In UM, TickCount is expressed in miliseconds, so this
196 // conversion ensures that absolute time is expressed
197 // in 100ns units as it is in KM.
198 //
199 return 1000 * 10;
200 }
201
202 __inline
203 VOID
MxDbgBreakPoint()204 Mx::MxDbgBreakPoint(
205 )
206 {
207 DebugBreak();
208 }
209
210 __inline
211 VOID
MxAssert(__in BOOLEAN Condition)212 Mx::MxAssert(
213 __in BOOLEAN Condition
214 )
215 {
216 if (!Condition)
217 {
218
219
220
221 DebugBreak();
222 }
223 }
224
225 __inline
226 VOID
MxAssertMsg(__in LPSTR Message,__in BOOLEAN Condition)227 Mx::MxAssertMsg(
228 __in LPSTR Message,
229 __in BOOLEAN Condition
230 )
231 {
232 UNREFERENCED_PARAMETER(Message);
233
234 if (!Condition)
235 {
236
237
238
239 DebugBreak();
240 }
241 }
242
243 __inline
244 VOID
245 #pragma prefast(suppress:__WARNING_UNMATCHED_DEFN, "Can't apply kernel mode annotations.");
MxEnterCriticalRegion()246 Mx::MxEnterCriticalRegion(
247 )
248 {
249
250
251
252
253
254 // DO_NOTHING();
255 }
256
257 __inline
258 VOID
259 #pragma prefast(suppress:__WARNING_UNMATCHED_DEFN, "Can't apply kernel mode annotations.");
MxLeaveCriticalRegion()260 Mx::MxLeaveCriticalRegion(
261 )
262 {
263
264
265
266
267
268 // DO_NOTHING();
269 }
270
271 __inline
272 VOID
MxDelayExecutionThread(__in KPROCESSOR_MODE WaitMode,__in BOOLEAN Alertable,__in PLARGE_INTEGER Interval)273 Mx::MxDelayExecutionThread(
274 __in KPROCESSOR_MODE WaitMode,
275 __in BOOLEAN Alertable,
276 __in PLARGE_INTEGER Interval
277 )
278 {
279 UNREFERENCED_PARAMETER(WaitMode);
280 ASSERTMSG("Interval must be relative\n", Interval->QuadPart <= 0);
281
282 LARGE_INTEGER intervalMillisecond;
283
284 //
285 // This function uses KeDelayExecutionThread's contract, where relative
286 // intervals are negative numbers expressed in 100ns units. We must
287 // flip the sign and convert to ms units before calling SleepEx.
288 //
289 intervalMillisecond.QuadPart = -1 * Interval->QuadPart;
290 intervalMillisecond.QuadPart /= 10 * 1000;
291
292 SleepEx((DWORD)intervalMillisecond.QuadPart, Alertable);
293 }
294
295 __inline
296 PVOID
MxGetSystemRoutineAddress(__in MxFuncName FuncName)297 Mx::MxGetSystemRoutineAddress(
298 __in MxFuncName FuncName
299 )
300 /*++
301 Description:
302
303 This function is meant to be called only by mode agnostic code
304 System routine is assumed to be in ntdll.dll.
305
306 This is because system routines (Rtl*) that can be used both
307 in kernel mode as well as user mode reside in ntdll.dll.
308 Kernel32.dll contains the user mode only Win32 API.
309
310 Arguments:
311
312 MxFuncName FuncName -
313
314 Return Value:
315
316 NTSTATUS Status code.
317 --*/
318 {
319 HMODULE hMod;
320
321 hMod = GetModuleHandleW(L"ntdll.dll");
322
323 return GetProcAddress(hMod, FuncName);
324 }
325
326 __inline
327 VOID
MxReferenceObject(__in PVOID Object)328 Mx::MxReferenceObject(
329 __in PVOID Object
330 )
331 {
332 UNREFERENCED_PARAMETER(Object);
333
334
335
336
337
338
339 // DO_NOTHING();
340 }
341
342 __inline
343 VOID
MxDereferenceObject(__in PVOID Object)344 Mx::MxDereferenceObject(
345 __in PVOID Object
346 )
347 {
348 UNREFERENCED_PARAMETER(Object);
349
350
351
352
353
354
355 // DO_NOTHING();
356 }
357
358 __inline
359 VOID
MxInitializeRemoveLock(__in MdRemoveLock Lock,__in ULONG AllocateTag,__in ULONG MaxLockedMinutes,__in ULONG HighWatermark)360 Mx::MxInitializeRemoveLock(
361 __in MdRemoveLock Lock,
362 __in ULONG AllocateTag,
363 __in ULONG MaxLockedMinutes,
364 __in ULONG HighWatermark
365 )
366 {
367 UNREFERENCED_PARAMETER(AllocateTag);
368 UNREFERENCED_PARAMETER(MaxLockedMinutes);
369 UNREFERENCED_PARAMETER(HighWatermark);
370
371 ZeroMemory(Lock, sizeof(*Lock));
372 Lock->IoCount = 1;
373 Lock->Removed = FALSE;
374 Lock->RemoveEvent = NULL;
375 Lock->ReleaseRemLockAndWaitStatus = (DWORD)-1;
376 }
377
378 __inline
379 NTSTATUS
MxAcquireRemoveLock(__in MdRemoveLock RemoveLock,__in_opt PVOID Tag)380 Mx::MxAcquireRemoveLock(
381 __in MdRemoveLock RemoveLock,
382 __in_opt PVOID Tag
383 )
384 {
385 UNREFERENCED_PARAMETER(Tag);
386 LONG lockValue;
387 NTSTATUS status;
388
389 lockValue = InterlockedIncrement(&RemoveLock->IoCount);
390
391 ASSERT(lockValue > 0);
392
393 if (! RemoveLock->Removed) {
394 return STATUS_SUCCESS;
395 }
396 else {
397 if (0 == InterlockedDecrement(&RemoveLock->IoCount)) {
398 if (! SetEvent(RemoveLock->RemoveEvent)) {
399 Mx::MxBugCheckEx(WDF_VIOLATION,
400 0, 0, 0, 0);
401 }
402 }
403 status = STATUS_DELETE_PENDING;
404 }
405
406 return status;
407 }
408
409 __inline
410 VOID
MxReleaseRemoveLock(__in MdRemoveLock RemoveLock,__in PVOID Tag)411 Mx::MxReleaseRemoveLock(
412 __in MdRemoveLock RemoveLock,
413 __in PVOID Tag
414 )
415 {
416 UNREFERENCED_PARAMETER(Tag);
417 LONG lockValue;
418
419 lockValue = InterlockedDecrement(&RemoveLock->IoCount);
420
421 ASSERT(0 <= lockValue);
422
423 if (0 == lockValue) {
424 ASSERT (RemoveLock->Removed);
425
426 //
427 // The device needs to be removed. Signal the remove event
428 // that it's safe to go ahead.
429 //
430 if (! SetEvent(RemoveLock->RemoveEvent)) {
431 Mx::MxBugCheckEx(WDF_VIOLATION,
432 0, 0, 0, 0);
433 }
434 }
435 }
436
437 __inline
438 VOID
MxReleaseRemoveLockAndWait(__in MdRemoveLock RemoveLock,__in PVOID Tag)439 Mx::MxReleaseRemoveLockAndWait(
440 __in MdRemoveLock RemoveLock,
441 __in PVOID Tag
442 )
443 {
444 UNREFERENCED_PARAMETER(Tag);
445 LONG ioCount;
446 DWORD retVal = ERROR_SUCCESS;
447
448 RemoveLock->Removed = TRUE;
449
450 ioCount = InterlockedDecrement (&RemoveLock->IoCount);
451 ASSERT(0 < ioCount);
452
453 if (0 < InterlockedDecrement (&RemoveLock->IoCount)) {
454 retVal = WaitForSingleObject(RemoveLock->RemoveEvent,
455 REMOVE_LOCK_RELEASE_TIMEOUT_IN_SECONDS*1000);
456 ASSERT(retVal == WAIT_OBJECT_0);
457 }
458
459 // This only serves as a debugging aid.
460 RemoveLock->ReleaseRemLockAndWaitStatus = retVal;
461 }
462
463 __inline
464 BOOLEAN
MxHasEnoughRemainingThreadStack(VOID)465 Mx::MxHasEnoughRemainingThreadStack(
466 VOID
467 )
468 {
469
470
471
472
473 //
474 // Thread stack is not so scarce in UM so return TRUE always
475 //
476 return TRUE;
477 }
478
479 __inline
480 VOID
481 #pragma prefast(suppress:__WARNING_UNMATCHED_DECL_ANNO, "Can't apply kernel mode annotations.");
ReleaseCancelSpinLock(__in KIRQL Irql)482 Mx::ReleaseCancelSpinLock(
483 __in KIRQL Irql
484 )
485 {
486 UNREFERENCED_PARAMETER(Irql);
487
488 //
489 // UMDF Host doesn't have cancel spinlock equivalent concept so do nothing.
490 //
491 DO_NOTHING();
492 }
493
494 __inline
495 NTSTATUS
CreateCallback(__out PCALLBACK_OBJECT * CallbackObject,__in POBJECT_ATTRIBUTES ObjectAttributes,__in BOOLEAN Create,__in BOOLEAN AllowMultipleCallbacks)496 Mx::CreateCallback(
497 __out PCALLBACK_OBJECT *CallbackObject,
498 __in POBJECT_ATTRIBUTES ObjectAttributes,
499 __in BOOLEAN Create,
500 __in BOOLEAN AllowMultipleCallbacks
501 )
502 {
503 UNREFERENCED_PARAMETER(CallbackObject);
504 UNREFERENCED_PARAMETER(ObjectAttributes);
505 UNREFERENCED_PARAMETER(Create);
506 UNREFERENCED_PARAMETER(AllowMultipleCallbacks);
507
508 return STATUS_UNSUCCESSFUL;
509 }
510
511 __inline
512 PVOID
RegisterCallback(__in PCALLBACK_OBJECT CallbackObject,__in MdCallbackFunction CallbackFunction,__in PVOID CallbackContext)513 Mx::RegisterCallback(
514 __in PCALLBACK_OBJECT CallbackObject,
515 __in MdCallbackFunction CallbackFunction,
516 __in PVOID CallbackContext
517 )
518 {
519 UNREFERENCED_PARAMETER(CallbackObject);
520 UNREFERENCED_PARAMETER(CallbackFunction);
521 UNREFERENCED_PARAMETER(CallbackContext);
522
523 ASSERTMSG("Not implemented for UMDF\n", FALSE);
524
525 return NULL;
526 }
527
528 __inline
529 VOID
UnregisterCallback(__in PVOID CbRegistration)530 Mx::UnregisterCallback(
531 __in PVOID CbRegistration
532 )
533 {
534 UNREFERENCED_PARAMETER(CbRegistration);
535
536 ASSERTMSG("Not implemented for UMDF\n", FALSE);
537 }
538
539 __inline
540 VOID
MxUnlockPages(__in PMDL Mdl)541 Mx::MxUnlockPages(
542 __in PMDL Mdl
543 )
544 {
545 UNREFERENCED_PARAMETER(Mdl);
546
547 ASSERTMSG("Not implemented for UMDF\n", FALSE);
548 }
549
550 __inline
551 PVOID
MxGetSystemAddressForMdlSafe(__inout PMDL Mdl,__in ULONG Priority)552 Mx::MxGetSystemAddressForMdlSafe(
553 __inout PMDL Mdl,
554 __in ULONG Priority
555 )
556 {
557 UNREFERENCED_PARAMETER(Mdl);
558 UNREFERENCED_PARAMETER(Priority);
559
560 ASSERTMSG("Not implemented for UMDF\n", FALSE);
561
562 return NULL;
563 }
564
565 __inline
566 VOID
MxBuildMdlForNonPagedPool(__inout PMDL Mdl)567 Mx::MxBuildMdlForNonPagedPool(
568 __inout PMDL Mdl
569 )
570 {
571 UNREFERENCED_PARAMETER(Mdl);
572
573 ASSERTMSG("Not implemented for UMDF\n", FALSE);
574 }
575
576 __inline
577 PVOID
MxGetDriverObjectExtension(__in MdDriverObject DriverObject,__in PVOID ClientIdentificationAddress)578 Mx::MxGetDriverObjectExtension(
579 __in MdDriverObject DriverObject,
580 __in PVOID ClientIdentificationAddress
581 )
582 {
583 UNREFERENCED_PARAMETER(DriverObject);
584 UNREFERENCED_PARAMETER(ClientIdentificationAddress);
585
586 ASSERTMSG("Not implemented for UMDF\n", FALSE);
587
588 return NULL;
589 }
590
591 __inline
592 NTSTATUS
593 Mx::MxAllocateDriverObjectExtension(
594 _In_ MdDriverObject DriverObject,
595 _In_ PVOID ClientIdentificationAddress,
596 _In_ ULONG DriverObjectExtensionSize,
597 // When successful, this always allocates already-aliased memory.
598 _Post_ _At_(*DriverObjectExtension, _When_(return==0,
599 __drv_aliasesMem __drv_allocatesMem(Mem) _Post_notnull_))
600 _When_(return == 0, _Outptr_result_bytebuffer_(DriverObjectExtensionSize))
601 PVOID *DriverObjectExtension
602 )
603 {
604 UNREFERENCED_PARAMETER(DriverObject);
605 UNREFERENCED_PARAMETER(ClientIdentificationAddress);
606 UNREFERENCED_PARAMETER(DriverObjectExtensionSize);
607 UNREFERENCED_PARAMETER(DriverObjectExtension);
608
609 ASSERTMSG("Not implemented for UMDF\n", FALSE);
610
611 return STATUS_UNSUCCESSFUL;
612 }
613
614 __inline
615 MdDeviceObject
MxGetAttachedDeviceReference(__in MdDeviceObject DriverObject)616 Mx::MxGetAttachedDeviceReference(
617 __in MdDeviceObject DriverObject
618 )
619 {
620 UNREFERENCED_PARAMETER(DriverObject);
621
622 ASSERTMSG("Not implemented for UMDF\n", FALSE);
623
624 return NULL;
625 }
626
627 __inline
628 VOID
MxDeleteSymbolicLink(__in PUNICODE_STRING Value)629 Mx::MxDeleteSymbolicLink(
630 __in PUNICODE_STRING Value
631 )
632 {
633 UNREFERENCED_PARAMETER(Value);
634
635 ASSERTMSG("Not implemented for UMDF\n", FALSE);
636 }
637
638 __inline
639 VOID
MxDeleteNPagedLookasideList(_In_ PNPAGED_LOOKASIDE_LIST LookasideList)640 Mx::MxDeleteNPagedLookasideList(
641 _In_ PNPAGED_LOOKASIDE_LIST LookasideList
642 )
643 {
644 UNREFERENCED_PARAMETER(LookasideList);
645 }
646
647 __inline
648 VOID
MxDeletePagedLookasideList(_In_ PPAGED_LOOKASIDE_LIST LookasideList)649 Mx::MxDeletePagedLookasideList(
650 _In_ PPAGED_LOOKASIDE_LIST LookasideList
651 )
652 {
653 UNREFERENCED_PARAMETER(LookasideList);
654
655 ASSERTMSG("Not implemented for UMDF\n", FALSE);
656 }
657
658 __inline
659 VOID
MxInitializeNPagedLookasideList(_Out_ PNPAGED_LOOKASIDE_LIST Lookaside,_In_opt_ PALLOCATE_FUNCTION Allocate,_In_opt_ PFREE_FUNCTION Free,_In_ ULONG Flags,_In_ SIZE_T Size,_In_ ULONG Tag,_In_ USHORT Depth)660 Mx::MxInitializeNPagedLookasideList(
661 _Out_ PNPAGED_LOOKASIDE_LIST Lookaside,
662 _In_opt_ PALLOCATE_FUNCTION Allocate,
663 _In_opt_ PFREE_FUNCTION Free,
664 _In_ ULONG Flags,
665 _In_ SIZE_T Size,
666 _In_ ULONG Tag,
667 _In_ USHORT Depth
668 )
669 {
670
671 UNREFERENCED_PARAMETER(Lookaside);
672 UNREFERENCED_PARAMETER(Allocate);
673 UNREFERENCED_PARAMETER(Free);
674 UNREFERENCED_PARAMETER(Flags);
675 UNREFERENCED_PARAMETER(Size);
676 UNREFERENCED_PARAMETER(Tag);
677 UNREFERENCED_PARAMETER(Depth);
678
679 //ASSERTMSG("Not implemented for UMDF\n", FALSE);
680
681 }
682
683 __inline
684 VOID
MxInitializePagedLookasideList(_Out_ PPAGED_LOOKASIDE_LIST Lookaside,_In_opt_ PALLOCATE_FUNCTION Allocate,_In_opt_ PFREE_FUNCTION Free,_In_ ULONG Flags,_In_ SIZE_T Size,_In_ ULONG Tag,_In_ USHORT Depth)685 Mx::MxInitializePagedLookasideList(
686 _Out_ PPAGED_LOOKASIDE_LIST Lookaside,
687 _In_opt_ PALLOCATE_FUNCTION Allocate,
688 _In_opt_ PFREE_FUNCTION Free,
689 _In_ ULONG Flags,
690 _In_ SIZE_T Size,
691 _In_ ULONG Tag,
692 _In_ USHORT Depth
693 )
694 {
695
696 UNREFERENCED_PARAMETER(Lookaside);
697 UNREFERENCED_PARAMETER(Allocate);
698 UNREFERENCED_PARAMETER(Free);
699 UNREFERENCED_PARAMETER(Flags);
700 UNREFERENCED_PARAMETER(Size);
701 UNREFERENCED_PARAMETER(Tag);
702 UNREFERENCED_PARAMETER(Depth);
703
704 //ASSERTMSG("Not implemented for UMDF\n", FALSE);
705
706 }
707
708 __inline
709 VOID
MxDeleteDevice(_In_ MdDeviceObject Device)710 Mx::MxDeleteDevice(
711 _In_ MdDeviceObject Device
712 )
713 {
714 UNREFERENCED_PARAMETER(Device);
715
716
717
718
719 //
720 // Host's device stack object holds the only reference to the host devices.
721 // The infrastructure controls the device object's lifetime.
722 //
723 DO_NOTHING();
724 }
725
726 __inline
727 NTSTATUS
MxCreateDeviceSecure(_In_ MdDriverObject DriverObject,_In_ ULONG DeviceExtensionSize,_In_opt_ PUNICODE_STRING DeviceName,_In_ DEVICE_TYPE DeviceType,_In_ ULONG DeviceCharacteristics,_In_ BOOLEAN Exclusive,_In_ PCUNICODE_STRING DefaultSDDLString,_In_opt_ LPCGUID DeviceClassGuid,_Out_opt_ MdDeviceObject * DeviceObject)728 Mx::MxCreateDeviceSecure(
729 _In_ MdDriverObject DriverObject,
730 _In_ ULONG DeviceExtensionSize,
731 _In_opt_ PUNICODE_STRING DeviceName,
732 _In_ DEVICE_TYPE DeviceType,
733 _In_ ULONG DeviceCharacteristics,
734 _In_ BOOLEAN Exclusive,
735 _In_ PCUNICODE_STRING DefaultSDDLString,
736 _In_opt_ LPCGUID DeviceClassGuid,
737 _Out_opt_ MdDeviceObject *DeviceObject
738 )
739 {
740 UNREFERENCED_PARAMETER(DriverObject);
741 UNREFERENCED_PARAMETER(DeviceExtensionSize);
742 UNREFERENCED_PARAMETER(DeviceName);
743 UNREFERENCED_PARAMETER(DeviceType);
744 UNREFERENCED_PARAMETER(Exclusive);
745 UNREFERENCED_PARAMETER(DeviceCharacteristics);
746 UNREFERENCED_PARAMETER(DefaultSDDLString);
747 UNREFERENCED_PARAMETER(DeviceClassGuid);
748 UNREFERENCED_PARAMETER(DeviceObject);
749
750 ASSERTMSG("Not implemented for UMDF\n", FALSE);
751
752 return STATUS_SUCCESS;
753 }
754
755 __inline
756 MdDeviceObject
MxAttachDeviceToDeviceStack(_In_ MdDeviceObject SourceDevice,_In_ MdDeviceObject TargetDevice)757 Mx::MxAttachDeviceToDeviceStack(
758 _In_ MdDeviceObject SourceDevice,
759 _In_ MdDeviceObject TargetDevice
760 )
761 {
762
763 UNREFERENCED_PARAMETER(SourceDevice);
764 UNREFERENCED_PARAMETER(TargetDevice);
765
766 ASSERTMSG("Not implemented for UMDF\n", FALSE);
767
768 return NULL;
769 }
770
771 __inline
772 NTSTATUS
MxCreateDevice(_In_ MdDriverObject DriverObject,_In_ ULONG DeviceExtensionSize,_In_opt_ PUNICODE_STRING DeviceName,_In_ DEVICE_TYPE DeviceType,_In_ ULONG DeviceCharacteristics,_In_ BOOLEAN Exclusive,_Out_opt_ MdDeviceObject * DeviceObject)773 Mx::MxCreateDevice(
774 _In_ MdDriverObject DriverObject,
775 _In_ ULONG DeviceExtensionSize,
776 _In_opt_ PUNICODE_STRING DeviceName,
777 _In_ DEVICE_TYPE DeviceType,
778 _In_ ULONG DeviceCharacteristics,
779 _In_ BOOLEAN Exclusive,
780 _Out_opt_ MdDeviceObject *DeviceObject
781 )
782 {
783 UNREFERENCED_PARAMETER(DriverObject);
784 UNREFERENCED_PARAMETER(DeviceExtensionSize);
785 UNREFERENCED_PARAMETER(DeviceName);
786 UNREFERENCED_PARAMETER(DeviceType);
787 UNREFERENCED_PARAMETER(DeviceCharacteristics);
788 UNREFERENCED_PARAMETER(Exclusive);
789 UNREFERENCED_PARAMETER(DeviceObject);
790
791 ASSERTMSG("Not implemented for UMDF\n", FALSE);
792
793 return STATUS_SUCCESS;
794
795 }
796
797 __inline
798 NTSTATUS
MxCreateSymbolicLink(_In_ PUNICODE_STRING SymbolicLinkName,_In_ PUNICODE_STRING DeviceName)799 Mx::MxCreateSymbolicLink(
800 _In_ PUNICODE_STRING SymbolicLinkName,
801 _In_ PUNICODE_STRING DeviceName
802 )
803 {
804 UNREFERENCED_PARAMETER(SymbolicLinkName);
805 UNREFERENCED_PARAMETER(DeviceName);
806
807 ASSERTMSG("Not implemented for UMDF\n", FALSE);
808
809 return STATUS_NOT_IMPLEMENTED;
810 }
811
812 __inline
813 VOID
MxFlushQueuedDpcs()814 Mx::MxFlushQueuedDpcs(
815 )
816 {
817 //
818 // Not supported for UMDF
819 //
820 }
821
822 __inline
823 NTSTATUS
MxOpenKey(_In_ PHANDLE KeyHandle,_In_ ACCESS_MASK DesiredAccess,_In_ POBJECT_ATTRIBUTES ObjectAttributes)824 Mx::MxOpenKey(
825 _In_ PHANDLE KeyHandle,
826 _In_ ACCESS_MASK DesiredAccess,
827 _In_ POBJECT_ATTRIBUTES ObjectAttributes
828 )
829 {
830 UNREFERENCED_PARAMETER(KeyHandle);
831 UNREFERENCED_PARAMETER(DesiredAccess);
832 UNREFERENCED_PARAMETER(ObjectAttributes);
833
834 ASSERTMSG("Not implemented for UMDF\n", FALSE);
835
836 return STATUS_NOT_IMPLEMENTED;
837 }
838
839 __inline
840 NTSTATUS
MxSetDeviceInterfaceState(_In_ PUNICODE_STRING SymbolicLinkName,_In_ BOOLEAN Enable)841 Mx::MxSetDeviceInterfaceState(
842 _In_ PUNICODE_STRING SymbolicLinkName,
843 _In_ BOOLEAN Enable
844 )
845 {
846 UNREFERENCED_PARAMETER(SymbolicLinkName);
847 UNREFERENCED_PARAMETER(Enable);
848
849 ASSERTMSG("Not implemented for UMDF\n", FALSE);
850
851 return STATUS_NOT_IMPLEMENTED;
852 }
853
854
855 __inline
856 NTSTATUS
MxRegisterDeviceInterface(_In_ PDEVICE_OBJECT PhysicalDeviceObject,_In_ const GUID * InterfaceClassGuid,_In_opt_ PUNICODE_STRING ReferenceString,_Out_ PUNICODE_STRING SymbolicLinkName)857 Mx::MxRegisterDeviceInterface(
858 _In_ PDEVICE_OBJECT PhysicalDeviceObject,
859 _In_ const GUID *InterfaceClassGuid,
860 _In_opt_ PUNICODE_STRING ReferenceString,
861 _Out_ PUNICODE_STRING SymbolicLinkName
862 )
863 {
864 UNREFERENCED_PARAMETER(PhysicalDeviceObject);
865 UNREFERENCED_PARAMETER(InterfaceClassGuid);
866 UNREFERENCED_PARAMETER(ReferenceString);
867 UNREFERENCED_PARAMETER(SymbolicLinkName);
868
869 ASSERTMSG("Not implemented for UMDF\n", FALSE);
870
871 return STATUS_NOT_IMPLEMENTED;
872 }
873
874 __inline
875 NTSTATUS
MxDeleteKey(_In_ HANDLE KeyHandle)876 Mx::MxDeleteKey(
877 _In_ HANDLE KeyHandle
878 )
879
880 {
881 UNREFERENCED_PARAMETER(KeyHandle);
882
883 ASSERTMSG("Not implemented for UMDF\n", FALSE);
884
885 return STATUS_NOT_IMPLEMENTED;
886 }
887
888 __inline
889 VOID
MxInitializeMdl(_In_ PMDL MemoryDescriptorList,_In_ PVOID BaseVa,_In_ SIZE_T Length)890 Mx::MxInitializeMdl(
891 _In_ PMDL MemoryDescriptorList,
892 _In_ PVOID BaseVa,
893 _In_ SIZE_T Length
894 )
895 {
896 UNREFERENCED_PARAMETER(MemoryDescriptorList);
897 UNREFERENCED_PARAMETER(BaseVa);
898 UNREFERENCED_PARAMETER(Length);
899
900 ASSERTMSG("Not implemented for UMDF\n", FALSE);
901
902 }
903
904 __inline
905 PVOID
MxGetMdlVirtualAddress(_In_ PMDL Mdl)906 Mx::MxGetMdlVirtualAddress(
907 _In_ PMDL Mdl
908 )
909 {
910 UNREFERENCED_PARAMETER(Mdl);
911
912 ASSERTMSG("Not implemented for UMDF\n", FALSE);
913
914 return NULL;
915 }
916
917 __inline
918 VOID
MxBuildPartialMdl(_In_ PMDL SourceMdl,_Inout_ PMDL TargetMdl,_In_ PVOID VirtualAddress,_In_ ULONG Length)919 Mx::MxBuildPartialMdl(
920 _In_ PMDL SourceMdl,
921 _Inout_ PMDL TargetMdl,
922 _In_ PVOID VirtualAddress,
923 _In_ ULONG Length
924 )
925 {
926 UNREFERENCED_PARAMETER(SourceMdl);
927 UNREFERENCED_PARAMETER(TargetMdl);
928 UNREFERENCED_PARAMETER(VirtualAddress);
929 UNREFERENCED_PARAMETER(Length);
930
931 ASSERTMSG("Not implemented for UMDF\n", FALSE);
932 }
933
934 __inline
935 VOID
MxQuerySystemTime(_Out_ PLARGE_INTEGER CurrentTime)936 Mx::MxQuerySystemTime(
937 _Out_ PLARGE_INTEGER CurrentTime
938 )
939 {
940 UNREFERENCED_PARAMETER(CurrentTime);
941
942 ASSERTMSG("Not implemented for UMDF\n", FALSE);
943 }
944
945 __inline
946 NTSTATUS
MxSetValueKey(_In_ HANDLE KeyHandle,_In_ PUNICODE_STRING ValueName,_In_opt_ ULONG TitleIndex,_In_ ULONG Type,_In_opt_ PVOID Data,_In_ ULONG DataSize)947 Mx::MxSetValueKey(
948 _In_ HANDLE KeyHandle,
949 _In_ PUNICODE_STRING ValueName,
950 _In_opt_ ULONG TitleIndex,
951 _In_ ULONG Type,
952 _In_opt_ PVOID Data,
953 _In_ ULONG DataSize
954 )
955 {
956 UNREFERENCED_PARAMETER(KeyHandle);
957 UNREFERENCED_PARAMETER(ValueName);
958 UNREFERENCED_PARAMETER(TitleIndex);
959 UNREFERENCED_PARAMETER(Type);
960 UNREFERENCED_PARAMETER(Data);
961 UNREFERENCED_PARAMETER(DataSize);
962
963 ASSERTMSG("Not implemented for UMDF\n", FALSE);
964
965 return STATUS_NOT_IMPLEMENTED;
966 }
967
968 __inline
969 NTSTATUS
MxQueryValueKey(_In_ HANDLE KeyHandle,_In_ PUNICODE_STRING ValueName,_In_ KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,_Out_opt_ PVOID KeyValueInformation,_In_ ULONG Length,_Out_ PULONG ResultLength)970 Mx::MxQueryValueKey(
971 _In_ HANDLE KeyHandle,
972 _In_ PUNICODE_STRING ValueName,
973 _In_ KEY_VALUE_INFORMATION_CLASS KeyValueInformationClass,
974 _Out_opt_ PVOID KeyValueInformation,
975 _In_ ULONG Length,
976 _Out_ PULONG ResultLength
977 )
978 {
979 UNREFERENCED_PARAMETER(KeyHandle);
980 UNREFERENCED_PARAMETER(ValueName);
981 UNREFERENCED_PARAMETER(KeyValueInformationClass);
982 UNREFERENCED_PARAMETER(KeyValueInformation);
983 UNREFERENCED_PARAMETER(Length);
984 UNREFERENCED_PARAMETER(ResultLength);
985
986 ASSERTMSG("Not implemented for UMDF\n", FALSE);
987
988 return STATUS_NOT_IMPLEMENTED;
989 }
990
991 __inline
992 NTSTATUS
MxUnRegisterPlugPlayNotification(__in __drv_freesMem (Pool)PVOID NotificationEntry)993 Mx::MxUnRegisterPlugPlayNotification(
994 __in __drv_freesMem(Pool) PVOID NotificationEntry
995 )
996 {
997 UNREFERENCED_PARAMETER(NotificationEntry);
998
999 ASSERTMSG("Not implemented for UMDF\n", FALSE);
1000
1001 return STATUS_NOT_IMPLEMENTED;
1002 }
1003
1004 __inline
1005 NTSTATUS
MxReferenceObjectByHandle(__in HANDLE Handle,__in ACCESS_MASK DesiredAccess,__in_opt POBJECT_TYPE ObjectType,__in KPROCESSOR_MODE AccessMode,__out PVOID * Object,__out_opt POBJECT_HANDLE_INFORMATION HandleInformation)1006 Mx::MxReferenceObjectByHandle(
1007 __in HANDLE Handle,
1008 __in ACCESS_MASK DesiredAccess,
1009 __in_opt POBJECT_TYPE ObjectType,
1010 __in KPROCESSOR_MODE AccessMode,
1011 __out PVOID *Object,
1012 __out_opt POBJECT_HANDLE_INFORMATION HandleInformation
1013 )
1014 {
1015 UNREFERENCED_PARAMETER(Handle);
1016 UNREFERENCED_PARAMETER(DesiredAccess);
1017 UNREFERENCED_PARAMETER(ObjectType);
1018 UNREFERENCED_PARAMETER(AccessMode);
1019 UNREFERENCED_PARAMETER(Object);
1020 UNREFERENCED_PARAMETER(HandleInformation);
1021
1022 ASSERTMSG("Not implemented for UMDF\n", FALSE);
1023
1024 return STATUS_NOT_IMPLEMENTED;
1025 }
1026
1027 __inline
1028 NTSTATUS
MxClose(__in HANDLE Handle)1029 Mx::MxClose(
1030 __in HANDLE Handle
1031 )
1032 {
1033 CloseHandle(Handle);
1034
1035 return STATUS_SUCCESS;
1036 }
1037
1038 __inline
1039 KIRQL
MxAcquireInterruptSpinLock(_Inout_ PKINTERRUPT Interrupt)1040 Mx::MxAcquireInterruptSpinLock(
1041 _Inout_ PKINTERRUPT Interrupt
1042 )
1043 {
1044 UNREFERENCED_PARAMETER(Interrupt);
1045
1046 ASSERTMSG("Not implemented for UMDF\n", FALSE);
1047 return PASSIVE_LEVEL;
1048 }
1049
1050 __inline
1051 VOID
MxReleaseInterruptSpinLock(_Inout_ PKINTERRUPT Interrupt,_In_ KIRQL OldIrql)1052 Mx::MxReleaseInterruptSpinLock(
1053 _Inout_ PKINTERRUPT Interrupt,
1054 _In_ KIRQL OldIrql
1055 )
1056 {
1057 UNREFERENCED_PARAMETER(Interrupt);
1058 UNREFERENCED_PARAMETER(OldIrql);
1059
1060 ASSERTMSG("Not implemented for UMDF\n", FALSE);
1061 }
1062
1063 __inline
1064 BOOLEAN
MxInsertQueueDpc(__inout PRKDPC Dpc,__in_opt PVOID SystemArgument1,__in_opt PVOID SystemArgument2)1065 Mx::MxInsertQueueDpc(
1066 __inout PRKDPC Dpc,
1067 __in_opt PVOID SystemArgument1,
1068 __in_opt PVOID SystemArgument2
1069 )
1070 {
1071 UNREFERENCED_PARAMETER(Dpc);
1072 UNREFERENCED_PARAMETER(SystemArgument1);
1073 UNREFERENCED_PARAMETER(SystemArgument2);
1074
1075 ASSERTMSG("Not implemented for UMDF\n", FALSE);
1076 return FALSE;
1077 }
1078
1079