ReactOS  0.4.15-dev-2700-g4b4ffa9
fxiotargetremote.cpp
Go to the documentation of this file.
1 /*++
2 
3 Copyright (c) Microsoft Corporation
4 
5 Module Name:
6 
7  FxIoTargetRemote.cpp
8 
9 Abstract:
10 
11 Author:
12 
13 Environment:
14 
15  Both kernel and user mode
16 
17 Revision History:
18 
19 --*/
20 
21 #include "../fxtargetsshared.hpp"
22 
23 extern "C" {
24 // #include "FxIoTargetRemote.tmh"
25 }
26 
27 #include <initguid.h>
28 #include "wdmguid.h"
29 
30 
32  __in PFX_DRIVER_GLOBALS FxDriverGlobals
33  ) :
34  FxIoTarget(FxDriverGlobals, sizeof(FxIoTargetRemote)),
35  m_EvtQueryRemove(FxDriverGlobals),
36  m_EvtRemoveCanceled(FxDriverGlobals),
37  m_EvtRemoveComplete(FxDriverGlobals)
38 {
39 
40  //
41  // No automatic state changes based on the pnp state changes of our own
42  // device stack. The one exception is remove where we need to shut
43  // everything down.
44  //
45  m_InStack = FALSE;
46 
49 
51 
55 
56 #if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
58 #elif (FX_CORE_MODE == FX_CORE_USER_MODE)
59  m_TargetNotifyHandle = WUDF_TARGET_CONTEXT_INVALID;
60 
61  m_pIoDispatcher = NULL;
62  m_pRemoteDispatcher = NULL;
63  m_NotificationCallback = NULL;
64 #endif
65 }
66 
68 {
69 }
70 
74  __in PFX_DRIVER_GLOBALS FxDriverGlobals,
78  )
79 {
82  WDFOBJECT hTarget;
84 
85  *Target = NULL;
86 
87  if (Attributes == NULL || Attributes->ParentObject == NULL) {
88  pParent = Device;
89  }
90  else {
91  CfxDeviceBase* pSearchDevice;
92 
93  FxObjectHandleGetPtr(FxDriverGlobals,
94  Attributes->ParentObject,
96  (PVOID*) &pParent);
97 
99 
100  if (pSearchDevice == NULL) {
102 
104  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
105  "Attributes->ParentObject 0x%p must have WDFDEVICE as an "
106  "eventual ancestor, %!STATUS!",
107  Attributes->ParentObject, status);
108 
109  return status;
110  }
111  else if (pSearchDevice != Device) {
113 
115  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
116  "Attributes->ParentObject 0x%p ancestor is WDFDEVICE %p, but "
117  "not the same WDFDEVICE 0x%p passed to WdfIoTargetCreate, "
118  "%!STATUS!",
119  Attributes->ParentObject, pSearchDevice->GetHandle(),
120  Device->GetHandle(), status);
121 
122  return status;
123  }
124  }
125 
126  pTarget = new (FxDriverGlobals, Attributes)
127  FxIoTargetRemote(FxDriverGlobals);
128 
129  if (pTarget == NULL) {
132  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
133  "Could not allocate memory for target, %!STATUS!", status);
134  return status;
135  }
136 
137  //
138  // initialize the new target
139  //
140  status = pTarget->InitRemote(Device);
141  if (!NT_SUCCESS(status)) {
142  return status;
143  }
144 
145  //
146  // Commit and apply the attributes
147  //
148  status = pTarget->Commit(Attributes, &hTarget, pParent);
149 
150  if (NT_SUCCESS(status)) {
151  *Target = pTarget;
152  }
153  else {
154  //
155  // This will properly clean up the target's state and free it
156  //
158  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
159  "Commit failed for target, %!STATUS!", status);
161  }
162 
163  return status;
164 }
165 
166 NTSTATUS
169  )
170 {
172 
173  //
174  // do the base class mode-specific initialization
175  //
176  status = FxIoTarget::InitModeSpecific(Device); // __super call
177  if (!NT_SUCCESS(status)) {
178  return status;
179  }
180 
181  //
182  // Do mode-specific initilialization
183  //
185  if (!NT_SUCCESS(status)) {
186  return status;
187  }
188 
189  m_Driver = Device->GetDriver();
190 
192  m_InStackDevice = Device->GetDeviceObject();
193 
194  (void) Device->AddIoTarget(this);
195 
196  return STATUS_SUCCESS;
197 }
198 
200 NTSTATUS
203  )
204 {
207  LIST_ENTRY pended;
210  BOOLEAN close, reopen;
211  PVOID pEa;
212  ULONG eaLength;
213  KIRQL irql;
214 
215  RtlZeroMemory(&name, sizeof(name));
216  close = FALSE;
217  reopen = OpenParams->Type == WdfIoTargetOpenReopen ? TRUE : FALSE;
218 
219  pEa = NULL;
220  eaLength = 0;
221 
222  //
223  // We only support reopening using stored settings when we open by name
224  //
225  if (reopen && m_OpenParams.OpenType != WdfIoTargetOpenByName) {
229  "Reopen only supported if the open type is WdfIoTargetOpenByName WDFIOTARGET %p %!STATUS!",
231  return status;
232  }
233 
234  //
235  // Must preallocate all settings now
236  //
237  if (reopen) {
238  //
239  // convert the type into the type used for the previous open
240  //
242  pParams = &m_OpenParams;
243  }
244  else {
245  type = OpenParams->Type;
246  pParams = &params;
247 
248  if (OpenParams->Type == WdfIoTargetOpenByName) {
249 
251  &OpenParams->TargetDeviceName,
252  &name);
253  if (!NT_SUCCESS(status)) {
256  "Could not allocate memory for target name for WDFIOTARGET %p",
257  GetObjectHandle());
258  goto Done;
259  }
260  if (OpenParams->EaBuffer != NULL && OpenParams->EaBufferLength > 0) {
261 
262  pEa = FxPoolAllocate(GetDriverGlobals(),
263  PagedPool,
264  OpenParams->EaBufferLength);
265 
266  if (pEa == NULL) {
269  "Could not allocate memory for target name "
270  "for WDFIOTARGET %p", GetObjectHandle());
272  goto Done;
273  }
274  else {
275  eaLength = OpenParams->EaBufferLength;
276  RtlCopyMemory(pEa, OpenParams->EaBuffer, eaLength);
277  }
278  }
279  }
280  }
281 
282  Lock(&irql);
283 
284  if (m_State == WdfIoTargetDeleted) {
287  "Opening WDFIOTARGET %p which is removed, state %d",
290  }
292  //
293  // We are either open or are opening
294  //
297  "Opening an already open WDFIOTARGET %p, open state %d",
300  }
301  else {
304  "Opening WDFIOTARGET %p", GetObjectHandle());
305 
306  //
307  // Clear the event so that if something is waiting on the state
308  // transition, they will block until we are done.
309  //
311 
314  }
315  Unlock(irql);
316 
317  if (!NT_SUCCESS(status)) {
318  goto Done;
319  }
320 
323  ASSERT(m_TargetPdo == NULL);
325 
326  //
327  // m_TargetNotifyHandle can be a valid value if the caller has previously
328  // opened the target, received a query remove, then a cancel remove, and
329  // is now reopening the target.
330  //
333 
334  //
335  // Only clear the open parameters if we are not attempting a reopen.
336  //
337  if (reopen == FALSE) {
339  }
340 
341  switch (type) {
344 
345  //
346  // OpenParams must be non NULL b/c we can't reopen a target with a
347  // previous device object.
348  //
350 
351  m_TargetDevice = (MdDeviceObject) OpenParams->TargetDeviceObject;
352  m_TargetFileObject = (MdFileObject) OpenParams->TargetFileObject;
354 
355  //
356  // By taking a manual reference here, we simplify the code in
357  // FxIoTargetRemote::Close where we can assume there is an outstanding
358  // reference on the PFILE_OBJECT at all times as long as we have a non
359  // NULL pointer.
360  //
361  if (m_TargetFileObject != NULL) {
363  }
364 
366 
367  break;
368 
371 
373  break;
374 
376  //
377  // Only capture the open parameters if we are not reopening.
378  //
379  if (reopen == FALSE) {
380  pParams->Set(OpenParams, &name, pEa, eaLength);
381  }
382 
383  status = OpenTargetHandle(OpenParams, pParams);
384  if (NT_SUCCESS(status)) {
385  if (reopen == FALSE) {
386  m_OpenParams.Set(OpenParams, &name, pEa, eaLength);
387 
388  //
389  // Setting pEa to NULL stops it from being freed later.
390  // Zeroing out name stops it from being freed later.
391  //
392  pEa = NULL;
393  RtlZeroMemory(&name, sizeof(name));
394  }
395  }
396  else {
397  close = TRUE;
398  }
399  break;
400  }
401 
402  InitializeListHead(&pended);
403 
404  //
405  // Get Target file object for KMDF. Noop for UMDF.
406  //
407  if (NT_SUCCESS(status)) {
409  }
410 
412  if (reopen == FALSE) {
413  //
414  // Set the values before the register so that if a notification
415  // comes in before the register returns, we have a function to call.
416  //
417  m_EvtQueryRemove.m_Method = OpenParams->EvtIoTargetQueryRemove;
418  m_EvtRemoveCanceled.m_Method = OpenParams->EvtIoTargetRemoveCanceled;
419  m_EvtRemoveComplete.m_Method = OpenParams->EvtIoTargetRemoveComplete;
420  }
421 
423 
424  //
425  // Even if we can't register, we still are successful in opening
426  // up the device and we will proceed from there.
427  //
428  if (!NT_SUCCESS(status)) {
431  "WDFIOTARGET %p, could not register pnp notification, %!STATUS! not "
432  "treated as an error", GetObjectHandle(), status);
433 
437 
439  }
440  }
441 
442  //
443  // UMDF only. Bind handle to remote dispatcher.
444  //
445 #if (FX_CORE_MODE == FX_CORE_USER_MODE)
447  status = BindToHandle();
448  if (!NT_SUCCESS(status)) {
449  close = TRUE;
450  }
451  }
452 #endif
453 
454  Lock(&irql);
455 
456  if (NT_SUCCESS(status)) {
457 
458 #if (FX_CORE_MODE == FX_CORE_KERNEL_MODE)
461 #endif
462 
464 
465  //
466  // Set our state to started. This will also resend any pended requests
467  // due to a query remove.
468  //
469  status = GotoStartState(&pended, FALSE);
470 
471  //
472  // We could not successfully start, close back down
473  //
474  if (!NT_SUCCESS(status)) {
477  "WDFIOTARGET %p could not transition to started state, %!STATUS!",
479 
480  close = TRUE;
481  }
482  }
483  else {
485  }
486 
487  //
488  // No matter what, indicate to any waiters that our state change has
489  // completed.
490  //
491  m_OpenedEvent.Set();
492 
493  Unlock(irql);
494 
495 Done:
496  //
497  // Resubmit any reads that were pended until now.
498  //
499  if (NT_SUCCESS(status)) {
500  SubmitPendedRequests(&pended);
501  }
502  else if (close) {
504  }
505 
506  if (name.Buffer != NULL) {
507  FxPoolFree(name.Buffer);
508  }
509 
510  if (pEa != NULL) {
511  FxPoolFree(pEa);
512  }
513 
514  return status;
515 }
516 
517 
518 VOID
521  )
522 {
523  FxIoTargetClearedPointers pointers;
524  MdTargetNotifyHandle pNotifyHandle;
526  LIST_ENTRY pended;
527  WDF_IO_TARGET_STATE removeState;
528  KIRQL irql;
529  BOOLEAN wait;
531 
534  "enter: WDFIOTARGET %p, reason %d", GetObjectHandle(), Reason);
535 
536  RtlZeroMemory(&pointers, sizeof(pointers));
537  pNotifyHandle = NULL;
538 
539  sent.Next = NULL;
540  InitializeListHead(&pended);
541 
542  wait = FALSE;
543 
544  //
545  // Pick a value that is not used anywhere in the function and make sure that
546  // we have changed it, before we go to the Remove state
547  //
548 #pragma prefast(suppress: __WARNING_UNUSED_SCALAR_ASSIGNMENT, "PFD is warning that the following assignement is unused. Suppress it to prevent changing any logic.")
549  removeState = WdfIoTargetStarted;
550 
551 CheckState:
552  Lock(&irql);
553 
554  //
555  // If we are in the process of opening the target, wait for that to finish.
556  //
558  Unlock(irql);
559 
562  "Closing WDFIOTARGET %p which is opening, waiting on event %p",
564 
566 
567  //
568  // Jump back to the top and recheck
569  //
570  goto CheckState;
571  }
572 
576  "Closing WDFIOTARGET %p, reason: delete", GetObjectHandle());
577 
578  removeState = WdfIoTargetDeleted;
579  }
584  "Closing WDFIOTARGET %p, reason: query remove",
585  GetObjectHandle());
586  //
587  // Not really being removed, but that is what the API name is...
588  //
589  removeState = WdfIoTargetClosedForQueryRemove;
590  }
591  else {
592 
595  "Closing WDFIOTARGET %p, reason: close", GetObjectHandle());
596 
598  removeState = WdfIoTargetClosed;
599  }
600  else {
601  removeState = WdfIoTargetClosedForQueryRemove;
602  }
603  }
604 
605  //
606  // Either way, we are no longer open for business
607  //
609  }
610  else {
613  "Closing WDFIOTARGET %p which is not open", GetObjectHandle());
614 
615  //
616  // We are not opened, so treat this as a cleanup
617  //
618  removeState = WdfIoTargetClosed;
619  }
620 
623  "WDFIOTARGET %p: fileobj %p, devobj %p, handle %p, notify handle %I64d",
626 
628  //
629  // If we are closing for a query remove, we want to keep the handle
630  // around so that we can be notified of the final close or if the close
631  // was canceled.
632  //
633  pNotifyHandle = m_TargetNotifyHandle;
635  }
636 
637  ASSERT(removeState != WdfIoTargetStarted);
638  m_ClearedPointers = &pointers;
639  GotoRemoveState(removeState, &pended, &sent, FALSE, &wait);
640 
641  Unlock(irql);
642 
643  UnregisterForPnpNotification(pNotifyHandle);
644 
645  //
646  // Complete any requests we might have pulled off of our lists
647  //
648  CompletePendedRequestList(&pended);
650 
651  //
652  // We were just removed, wait for any I/O to complete back if necessary.
653  //
654  if (wait) {
657  "WDFIOTARGET %p, waiting for stop to complete", GetObjectHandle());
658 
660  }
661 
662  switch (Reason) {
664  //
665  // m_OpenParams is needed for reopen on canceled query remove
666  //
667  DO_NOTHING();
668  break;
669 
672  break;
673 
674  default:
675  //
676  // If this object is not about to be deleted, we need to revert some
677  // of the state that just changed.
678  //
680  break;
681  }
682 
683  if (removeState == WdfIoTargetDeleted) {
685  }
686 
687  //
688  // Finally, close down our handle and pointers
689  //
690  if (pointers.TargetPdo != NULL) {
693  "WDFIOTARGET %p derefing PDO %p on close",
694  GetObjectHandle(), pointers.TargetPdo);
695 
697  }
698 
699  if (pointers.TargetFileObject != NULL) {
702  "WDFIOTARGET %p derefing FileObj %p on close",
703  GetObjectHandle(), pointers.TargetFileObject);
705 
706 #if (FX_CORE_MODE == FX_CORE_USER_MODE)
707  CloseWdfFileObject(pointers.TargetFileObject);
708 #endif
709  }
710 
711 #if (FX_CORE_MODE == FX_CORE_USER_MODE)
712  UnbindHandle(&pointers);
713 #endif
714 
715  if (pointers.TargetHandle != NULL) {
718  "WDFIOTARGET %p closing handle %p on close",
719  GetObjectHandle(), pointers.TargetHandle);
720  Mx::MxClose(pointers.TargetHandle);
721  }
722 }
723 
724 VOID
726  VOID
727  )
728 {
731  "WDFIOTARGET %p cleared pointers %p state %!WDF_IO_TARGET_STATE!,"
732  " open state %d, pdo %p, fileobj %p, handle %p",
735 
736  //
737  // Check to see if the caller who is changing state wants these pointer
738  // values before they being cleared out.
739  //
740  if (m_ClearedPointers != NULL) {
745  }
746 
747  //
748  // m_TargetHandle is only an FxIoTargetRemote field, clear it now
749  //
751 
752  //
753  // m_TargetPdo and m_TargetFileObject will be cleared in the following call.
754  //
755  // m_TargetNotifyHandle is not cleared in the following call and is left
756  // valid because we want to receive the notification about query remove being
757  // canceled or completing. When we receive either of those notifications,
758  // m_TargetNotifyHandle will be freed then.
759  //
760  FxIoTarget::ClearTargetPointers(); // __super call
761 }
762 
763 VOID
765  VOID
766  )
767 {
768  //
769  // Close is the same as remove in this object
770  //
772 
773  //
774  // Do mode-specific work
775  //
777 
778  return ;
779 }
780 
781 VOID
783  VOID
784  )
785 {
786  if (EaBuffer != NULL) {
788  }
789 
790  if (TargetDeviceName.Buffer != NULL) {
792  }
793 
795 }
796 
797 VOID
801  __in PVOID Ea,
803  )
804 {
806 
807  EaBuffer = Ea;
809 
811 
812  DesiredAccess = OpenParams->DesiredAccess;
813  FileAttributes = OpenParams->FileAttributes;
814  ShareAccess = OpenParams->ShareAccess;
815  CreateDisposition = OpenParams->CreateDisposition;
816  CreateOptions = OpenParams->CreateOptions;
817 
818  if (OpenParams->AllocationSize != NULL) {
819  AllocationSize.QuadPart = *(OpenParams->AllocationSize);
821  }
822  else {
824  }
825 }
FxIoTarget * pTarget
Definition: fxdeviceapi.cpp:97
__drv_restoresIRQL KIRQL __in BOOLEAN Unlock
Definition: fxobject.hpp:1474
MdDeviceObject m_TargetDevice
Definition: fxiotarget.hpp:910
return
Definition: dirsup.c:529
_Must_inspect_result_ _In_ WDFDEVICE _In_ ULONG _In_ ACCESS_MASK DesiredAccess
Definition: wdfdevice.h:2654
#define _Must_inspect_result_
Definition: no_sal2.h:62
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
VOID CompletePendedRequestList(__in PLIST_ENTRY RequestListHead)
Definition: fxiotarget.cpp:520
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
VOID UnregisterForPnpNotification(_In_ MdTargetNotifyHandle Handle)
FxIoTargetRemoteCloseReason
_Must_inspect_result_ NTSTATUS Commit(__in_opt PWDF_OBJECT_ATTRIBUTES Attributes, __out_opt WDFOBJECT *ObjectHandle, __in_opt FxObject *Parent=NULL, __in BOOLEAN AssignDriverAsDefaultParent=TRUE)
Definition: fxobject.cpp:904
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
Definition: ntbasedef.h:628
PVOID GetEvent(VOID)
Definition: fxwaitlock.hpp:172
#define TRUE
Definition: types.h:120
WDFDEVICE __inline GetHandle(VOID)
Definition: fxdevice.hpp:237
#define CheckState(OldState, NewState)
_In_ ACCESS_MASK _In_ POBJECT_ATTRIBUTES _Out_ PIO_STATUS_BLOCK _In_opt_ PLARGE_INTEGER _In_ ULONG _In_ ULONG _In_ ULONG _In_ ULONG _In_opt_ PVOID EaBuffer
Definition: iofuncs.h:837
LONG NTSTATUS
Definition: precomp.h:26
PDEVICE_OBJECT MdDeviceObject
Definition: mxgeneralkm.h:30
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
KIRQL irql
Definition: wave.h:1
VOID SetDeviceBase(__in CfxDeviceBase *DeviceBase)
Definition: fxobject.hpp:797
FxObjectHandleGetPtr(GetFxDriverGlobals(DriverGlobals), Fdo, FX_TYPE_DEVICE,(PVOID *)&pFdo)
PFN_WDF_IO_TARGET_QUERY_REMOVE m_Method
PFILE_OBJECT MdFileObject
Definition: mxgeneralkm.h:32
virtual VOID ClearTargetPointers(VOID)
VOID Set(VOID)
Definition: fxwaitlock.hpp:144
#define TRACE_LEVEL_INFORMATION
Definition: storswtr.h:29
VOID ResetTargetNotifyHandle(VOID)
_Must_inspect_result_ NTSTATUS InitModeSpecific(__in CfxDeviceBase *Device)
FxCREvent m_SentIoEvent
Definition: fxiotarget.hpp:878
WDF_IO_TARGET_STATE m_State
Definition: fxiotarget.hpp:928
#define UMDF_ONLY_CODE_PATH_ASSERT()
Definition: fxmin.hpp:132
enum _WDF_IO_TARGET_OPEN_TYPE WDF_IO_TARGET_OPEN_TYPE
MdDeviceObject m_InStackDevice
Definition: fxiotarget.hpp:905
#define STATUS_INVALID_DEVICE_STATE
Definition: udferr_usr.h:178
static FxDeviceBase * _SearchForDevice(__in FxObject *Object, __out_opt IFxHasCallbacks **Callbacks)
_Must_inspect_result_ NTSTATUS OpenLocalTargetByFile(_In_ PWDF_IO_TARGET_OPEN_PARAMS OpenParams)
FxDriver * m_Driver
Definition: fxiotarget.hpp:900
UCHAR KIRQL
Definition: env_spec_w32.h:591
FxIoTargetRemoveComplete m_EvtRemoveComplete
FxIoTargetQueryRemove m_EvtQueryRemove
#define FALSE
Definition: types.h:117
GLenum const GLfloat * params
Definition: glext.h:5645
#define TRACE_LEVEL_VERBOSE
Definition: storswtr.h:30
static __inline VOID MxReferenceObject(__in PVOID Object)
Definition: mxgeneralkm.h:238
PVOID __inline GetObjectHandle(VOID)
Definition: fxobject.hpp:603
#define __out
Definition: dbghelp.h:62
static __inline NTSTATUS MxClose(__in HANDLE Handle)
Definition: mxgeneralkm.h:758
NTSTATUS EnterCRAndWaitAndLeave(VOID)
Definition: fxwaitlock.hpp:87
unsigned char BOOLEAN
_Must_inspect_result_ BOOLEAN IsVersionGreaterThanOrEqualTo(__in ULONG Major, __in ULONG Minor)
Definition: globalskm.cpp:92
MdFileObject m_TargetFileObject
Definition: fxiotarget.hpp:923
MdDeviceObject m_TargetPdo
Definition: fxiotarget.hpp:918
virtual VOID Remove(VOID)
NTSTATUS GetTargetDeviceRelations(_Out_ BOOLEAN *Close)
UCHAR GetTargetIoType(VOID)
Definition: fxiotarget.hpp:631
_Must_inspect_result_ _In_opt_ WDFKEY _In_ PCUNICODE_STRING _In_ ACCESS_MASK _In_ ULONG _Out_opt_ PULONG CreateDisposition
Definition: wdfregistry.h:112
PFX_DRIVER_GLOBALS pFxDriverGlobals
VOID RemoveModeSpecific(VOID)
BOOLEAN m_InStack
Definition: fxiotarget.hpp:855
#define ASSERT(a)
Definition: mode.c:44
IN PVCB IN PDIRENT OUT PULONG EaLength
Definition: fatprocs.h:875
FxIoTargetClearedPointers * m_ClearedPointers
WDF_EXTERN_C_START enum _WDF_IO_TARGET_STATE WDF_IO_TARGET_STATE
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
VOID Clear(VOID)
Definition: fxwaitlock.hpp:152
VOID Close(__in FxIoTargetRemoteCloseReason Reason)
_Must_inspect_result_ _In_ WDFIOTARGET _In_ PWDF_IO_TARGET_OPEN_PARAMS OpenParams
Definition: wdfiotarget.h:398
Definition: msg.h:34
_Must_inspect_result_ NTSTATUS FxDuplicateUnicodeString(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in const UNICODE_STRING *Source, __out PUNICODE_STRING Destination)
Definition: stringutil.cpp:180
UCHAR m_TargetIoType
Definition: fxiotarget.hpp:947
static _Must_inspect_result_ NTSTATUS _Create(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_OBJECT_ATTRIBUTES Attributes, __in FxDeviceBase *Device, __out FxIoTargetRemote **Target)
Definition: typedefs.h:119
#define close
Definition: acwin.h:98
_Must_inspect_result_ _In_ WDFDEVICE Device
Definition: wdfchildlist.h:474
virtual VOID ClearTargetPointers(VOID)
Definition: fxiotarget.hpp:618
#define KMDF_ONLY_CODE_PATH_ASSERT()
Definition: fx.hpp:55
virtual VOID WaitForSentIoToComplete(VOID)
Definition: fxiotarget.hpp:676
_Must_inspect_result_ _In_opt_ WDFKEY _In_ PCUNICODE_STRING _In_ ACCESS_MASK _In_ ULONG CreateOptions
Definition: wdfregistry.h:112
FxIoTargetRemote(__in PFX_DRIVER_GLOBALS FxDriverGlobals)
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
virtual _Must_inspect_result_ NTSTATUS GotoStartState(__in PLIST_ENTRY RequestListHead, __in BOOLEAN Lock=TRUE)
Definition: fxiotarget.cpp:306
FxIoTargetRemoveOpenParams m_OpenParams
__inline PFX_DRIVER_GLOBALS GetDriverGlobals(VOID)
Definition: fxobject.hpp:734
MdTargetNotifyHandle m_TargetNotifyHandle
PFN_WDF_IO_TARGET_REMOVE_CANCELED m_Method
CCHAR m_TargetStackSize
Definition: fxiotarget.hpp:941
FxIoTargetRemoveCanceled m_EvtRemoveCanceled
virtual VOID WaitForDisposeEvent(VOID)
Definition: fxiotarget.cpp:124
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGPNP, "Enter, WDFDEVICE %p", Device)
_Must_inspect_result_ NTSTATUS Open(__in PWDF_IO_TARGET_OPEN_PARAMS OpenParams)
NTSTATUS InitRemote(__in FxDeviceBase *Device)
#define NULL
Definition: types.h:112
virtual VOID GotoRemoveState(__in WDF_IO_TARGET_STATE NewState, __in PLIST_ENTRY PendedRequestListHead, __in PSINGLE_LIST_ENTRY SentRequestListHead, __in BOOLEAN Lock, __out PBOOLEAN Wait)
Definition: fxiotarget.cpp:964
VOID Set(__in PWDF_IO_TARGET_OPEN_PARAMS OpenParams, __in PUNICODE_STRING Name, __in PVOID Ea, __in ULONG EaLength)
static VOID _CancelSentRequests(__in PSINGLE_LIST_ENTRY RequestListHead)
Definition: fxiotarget.cpp:550
_In_ WDFIOTARGET Target
Definition: wdfrequest.h:306
VOID DeleteFromFailedCreate(VOID)
Definition: fxobject.cpp:391
Definition: name.c:38
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:124
unsigned int ULONG
Definition: retypes.h:1
FxObject * pParent
Definition: fxdpcapi.cpp:86
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
BOOLEAN CanRegisterForPnpNotification(VOID)
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
NTSTATUS RegisterForPnpNotification(VOID)
#define STATUS_SUCCESS
Definition: shellext.h:65
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
NTSTATUS InitRemoteModeSpecific(__in FxDeviceBase *Device)
unsigned long long UINT64
void FxPoolFree(__in_xcount(ptr is at an offset from AllocationStart) PVOID ptr)
Definition: wdfpool.cpp:361
WDF_IO_TARGET_OPEN_TYPE OpenType
PVOID PVOID PWCHAR PVOID USHORT PULONG Reason
Definition: env.c:47
static __inline VOID MxDereferenceObject(__in PVOID Object)
Definition: mxgeneralkm.h:247
#define __in
Definition: dbghelp.h:35
static SERVICE_STATUS status
Definition: service.c:31
VOID SubmitPendedRequests(__in PLIST_ENTRY RequestListHeadHead)
Definition: fxiotarget.cpp:268
#define TRACINGIOTARGET
Definition: dbgtrace.h:72
NTSTATUS OpenTargetHandle(_In_ PWDF_IO_TARGET_OPEN_PARAMS OpenParams, _Inout_ FxIoTargetRemoveOpenParams *pParams)
LONGLONG QuadPart
Definition: typedefs.h:114
PFN_WDF_IO_TARGET_REMOVE_COMPLETE m_Method
_Must_inspect_result_ _In_ WDFDMAENABLER _In_ _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes
#define DO_NOTHING()
Definition: mxgeneral.h:32
Definition: ps.c:97
GLuint const GLchar * name
Definition: glext.h:6031