ReactOS  0.4.15-dev-3173-g40ee59d
fxiotargetapi.cpp
Go to the documentation of this file.
1 /*++
2 
3 Copyright (c) Microsoft Corporation
4 
5 Module Name:
6 
7  FxIoTargetAPI.cpp
8 
9 Abstract:
10 
11  This module implements the IO Target APIs
12 
13 Author:
14 
15 Environment:
16 
17  kernel mode only
18 
19 Revision History:
20 
21 --*/
22 
23 #include "../fxtargetsshared.hpp"
24 
25 extern "C" {
26 // #include "FxIoTargetAPI.tmh"
27 }
28 
29 //
30 // Extern the entire file
31 //
32 extern "C" {
33 
37 STDCALL
38 WDFEXPORT(WdfIoTargetStart)(
39  __in
41  __in
42  WDFIOTARGET IoTarget
43  )
44 /*++
45 
46 Routine Description:
47  Changes the target's state to started. In the started state, the target
48  can send I/O.
49 
50 Arguments:
51  IoTarget - the target whose state will change
52 
53 Return Value:
54  NTSTATUS
55 
56  --*/
57 {
58  DDI_ENTRY();
59 
61 
63  IoTarget,
65  (PVOID*) &pTarget);
66 
67  return pTarget->Start();
68 }
69 
72 VOID
73 STDCALL
74 WDFEXPORT(WdfIoTargetStop)(
75  __in
77  __in
78  WDFIOTARGET IoTarget,
79  __in
80  __drv_strictTypeMatch(__drv_typeConst)
82  )
83 /*++
84 
85 Routine Description:
86  This function puts the target into the stopped state. Depending on the value
87  of Action, this function may not return until sent I/O has been canceled and/or
88  completed.
89 
90 Arguments:
91  IoTarget - the target whose state is being changed
92 
93  Action - what to do with the I/O that is pending in the target already
94 
95 Return Value:
96  None
97 
98  --*/
99 {
100  DDI_ENTRY();
101 
105 
107  IoTarget,
109  (PVOID*) &pTarget,
111 
115  "Action %d undefined or out of range", Action);
116  return;
117  }
118 
122  if (!NT_SUCCESS(status)) {
123  return;
124  }
125  }
126 
127  pTarget->Stop(Action);
128 }
129 
132 VOID
133 STDCALL
134 WDFEXPORT(WdfIoTargetPurge)(
135  __in
137  __in
138  WDFIOTARGET IoTarget,
139  __in
140  __drv_strictTypeMatch(__drv_typeConst)
142  )
143 /*++
144 
145 Routine Description:
146  This function puts the target into the purged state. Depending on the value
147  of Action, this function may not return until pending and sent I/O has been
148  canceled and completed.
149 
150 Arguments:
151  IoTarget - the target whose state is being changed
152 
153  Action - purge action: wait or not for I/O to complete after doing the purge.
154 
155 Return Value:
156  None
157 
158  --*/
159 {
160  DDI_ENTRY();
161 
165 
167  IoTarget,
169  (PVOID*) &pTarget,
171 
175  "Action %d undefined or out of range", Action);
176  return;
177  }
178 
181  if (!NT_SUCCESS(status)) {
182  return;
183  }
184  }
185 
186  pTarget->Purge(Action);
187 }
188 
191 STDCALL
192 WDFEXPORT(WdfIoTargetGetState)(
193  __in
195  __in
196  WDFIOTARGET IoTarget
197  )
198 /*++
199 
200 Routine Description:
201  Returns the current state of the target
202 
203 Arguments:
204  IoTarget - target whose state is being returned
205 
206 Return Value:
207  current target state
208 
209  --*/
210 {
211  DDI_ENTRY();
212 
214 
216  IoTarget,
218  (PVOID*) &pTarget);
219 
220  return pTarget->GetState();
221 }
222 
224 NTSTATUS
226  __in PFX_DRIVER_GLOBALS FxDriverGlobals,
228  )
229 /*++
230 
231 Routine Description:
232  Validates the target open parameters structure.
233 
234 Arguments:
235  FxDriverGlobals - driver globals
236 
237  OpenParams - the structure to validate
238 
239 Return Value:
240  NTSTATUS
241 
242  --*/
243 
244 {
246 
247  //
248  // Check specific fields based on Type
249  //
250  switch (OpenParams->Type) {
252  if (OpenParams->TargetDeviceObject == NULL) {
255  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
256  "Expected non NULL TargetDeviceObject in OpenParams, %!STATUS!",
257  status);
258  return status;
259  }
260 
261  //
262  // This type is supported only in KMDF.
263  //
264  if (FxDriverGlobals->IsUserModeDriver) {
267  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
268  "The open type WdfIoTargetOpenUseExistingDevice is not "
269  "supported in UMDF drivers. It is supported in KMDF "
270  "drivers only, %!STATUS!",
271  status);
272  return status;
273  }
274 
275  if (OpenParams->TargetFileObject == NULL &&
276  (OpenParams->EvtIoTargetQueryRemove != NULL ||
277  OpenParams->EvtIoTargetRemoveCanceled != NULL ||
278  OpenParams->EvtIoTargetRemoveComplete != NULL)) {
280 
282  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
283  "OpenParams %p TargetFileObject is NULL but a state callback "
284  "(query remove %p, remove canceled %p, remove complete %p)"
285  " was specified, %!STATUS!",
286  OpenParams, OpenParams->EvtIoTargetQueryRemove,
287  OpenParams->EvtIoTargetRemoveCanceled,
288  OpenParams->EvtIoTargetRemoveComplete, status);
289 
290  return status;
291  }
292  break;
293 
295  if (OpenParams->TargetDeviceName.Buffer == NULL ||
296  OpenParams->TargetDeviceName.Length == 0 ||
297  OpenParams->TargetDeviceName.MaximumLength == 0) {
300  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
301  "Expected valid OpenParams TargetDeviceName string, %!STATUS!",
302  status);
303  return status;
304  }
305  break;
306 
308  //
309  // This type is supported only in UMDF.
310  //
311  if (FxDriverGlobals->IsUserModeDriver == FALSE) {
314  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
315  "The open type WdfIoTargetOpenLocalTargetByFile is not "
316  "supported in KMDF drivers. It is supported in UMDF "
317  "drivers only, %!STATUS!",
318  status);
319  return status;
320  }
321 
322  if ((OpenParams->EvtIoTargetQueryRemove != NULL ||
323  OpenParams->EvtIoTargetRemoveCanceled != NULL ||
324  OpenParams->EvtIoTargetRemoveComplete != NULL)) {
326 
328  FxDriverGlobals, TRACE_LEVEL_ERROR, TRACINGIOTARGET,
329  "The open type is WdfIoTargetOpenLocalTargetByFile but a state"
330  " callback (query remove %p, remove canceled %p, remove"
331  " complete %p) was specified, %!STATUS!",
332  OpenParams->EvtIoTargetQueryRemove,
333  OpenParams->EvtIoTargetRemoveCanceled,
334  OpenParams->EvtIoTargetRemoveComplete, status);
335 
336  return status;
337  }
338 
339  if (OpenParams->FileName.Buffer != NULL ||
340  OpenParams->FileName.Length != 0 ||
341  OpenParams->FileName.MaximumLength != 0) {
342  status = FxValidateUnicodeString(FxDriverGlobals,
343  &OpenParams->FileName);
344  if (!NT_SUCCESS(status)) {
345  return status;
346  }
347  }
348 
349 
350  break;
351 
353  break;
354 
355  default:
358  "OpenParams Type (%d) incorrect, %!STATUS!",
359  OpenParams->Type, status);
360 
361  return status;
362  }
363 
364  return STATUS_SUCCESS;
365 }
366 
367 
370 NTSTATUS
371 STDCALL
372 WDFEXPORT(WdfIoTargetCreate)(
373  __in
375  __in
376  WDFDEVICE Device,
377  __in_opt
379  __out
380  WDFIOTARGET* IoTarget
381  )
382 /*++
383 
384 Routine Description:
385  Creates a WDFIOTARGET which can be opened upon success.
386 
387 Arguments:
388  Device - the device which will own the target. The target will be parented
389  by the owning device
390 
391  IoTargetAttributes - optional attributes to apply to the target
392 
393  IoTarget - pointer which will receive the created target handle
394 
395 Return Value:
396  NTSTATUS
397 
398  --*/
399 {
400  DDI_ENTRY();
401 
406 
408  Device,
410  (PWDFOBJECT) &pDevice,
412 
414 
416  "WDFDEVICE 0x%p", Device);
417 
420  return status;
421  }
422 
423  //
424  // Since the target is auto parented to the Device, we don't allow the client
425  // to specify a parent.
426  //
428  if (!NT_SUCCESS(status)) {
429  return status;
430  }
431 
434 
436  *IoTarget = pTarget->GetHandle();
437  }
438 
439  return status;
440 }
441 
444 NTSTATUS
445 STDCALL
446 WDFEXPORT(WdfIoTargetOpen)(
447  __in
449  __in
450  WDFIOTARGET IoTarget,
451  __in
453  )
454 /*++
455 
456 Routine Description:
457  Opens a target. The target must be in the closed state for an open to
458  succeed. Open is either wrapping an existing PDEVICE_OBJECT + PFILE_OBJECT
459  that the client provides or opening a PDEVICE_OBJECT by name.
460 
461 Arguments:
462  IoTarget - Target to be opened
463 
464  OpenParams - structure which describes how to open the target
465 
466 Return Value:
467  NTSTATUS
468 
469  --*/
470 {
471  //
472  // UMDF only, noop for KMDF.
473  // It's ok to be impersonated here, because it can be required in order for
474  // the CreateFile() call to succeed.
475  //
477 
483 
485  IoTarget,
487  (PVOID*) &pTarget,
489 
491  "enter WDFIOTARGET 0x%p", IoTarget);
492 
494 
496  if (!NT_SUCCESS(status)) {
497  return status;
498  }
499 
501  sizeof(WDF_IO_TARGET_OPEN_PARAMS) :
503 
504  //
505  // Check Size
506  //
507  if (OpenParams->Size != sizeof(WDF_IO_TARGET_OPEN_PARAMS) &&
508  OpenParams->Size != sizeof(WDF_IO_TARGET_OPEN_PARAMS_V1_11)) {
511  "OpenParams size (%d) incorrect, expected %d, %!STATUS!",
513  return status;
514  }
515 
516  //
517  // Normalize WDF_IO_TARGET_OPEN_PARAMS structure.
518  //
519  if (OpenParams->Size < sizeof(WDF_IO_TARGET_OPEN_PARAMS)) {
521 
522  //
523  // Copy over existing fields and readjust the struct size.
524  //
526  openParams.Size = sizeof(openParams);
527 
528  //
529  // Use new open params structure from now on.
530  //
532  }
533 
535  if (!NT_SUCCESS(status)) {
536  //
537  // FxIoTargetValidateCreateParams traces the error
538  //
539  return status;
540  }
541 
542  status = pTarget->Open(OpenParams);
543 
545  "exit WDFIOTARGET 0x%p, %!STATUS!", IoTarget, status);
546 
547  return status;
548 }
549 
551 VOID
552 STDCALL
553 WDFEXPORT(WdfIoTargetCloseForQueryRemove)(
554  __in
556  __in
557  WDFIOTARGET IoTarget
558  )
559 /*++
560 
561 Routine Description:
562  Closes a target in response to a query remove notification callback. This
563  will pend all i/o sent after the call returns.
564 
565 Arguments:
566  IoTarget - Target to be closed
567 
568 Return Value:
569  None
570 
571  --*/
572 {
573  DDI_ENTRY();
574 
578 
580  IoTarget,
582  (PVOID*) &pTarget,
584 
586 
589  "enter WDFIOTARGET 0x%p", IoTarget);
590 
592  if (!NT_SUCCESS(status)) {
593  return;
594  }
595 
597 }
598 
600 VOID
601 STDCALL
602 WDFEXPORT(WdfIoTargetClose)(
603  __in
605  __in
606  WDFIOTARGET IoTarget
607  )
608 /*++
609 
610 Routine Description:
611  Closes the target for good. The target can be in either a query removed or
612  opened state.
613 
614 Arguments:
615  IoTarget - target to close
616 
617 Return Value:
618  None
619 
620  --*/
621 {
622  DDI_ENTRY();
623 
627 
629  IoTarget,
631  (PVOID*) &pTarget,
633 
635  "enter WDFIOTARGET 0x%p", IoTarget);
636 
638  if (!NT_SUCCESS(status)) {
639  return;
640  }
641 
643 }
644 
646 WDFDEVICE
647 STDCALL
648 WDFEXPORT(WdfIoTargetGetDevice)(
649  __in
651  __in
652  WDFIOTARGET IoTarget
653  )
654 /*++
655 
656 Routine Description:
657  Returns the owning WDFDEVICE for the WDFIOTARGET, this is not necessarily
658  the PDEVICE_OBJECT of the target itself.
659 
660 Arguments:
661  IoTarget - the target being retrieved
662 
663 Return Value:
664  a valid WDFDEVICE handle , NULL if there are any problems
665 
666  --*/
667 
668 {
669  DDI_ENTRY();
670 
673  WDFDEVICE device;
674 
676  IoTarget,
678  (PVOID*) &pTarget,
680 
682  "enter WDFIOTARGET 0x%p", IoTarget);
683 
685 
687  "exit WDFIOTARGET 0x%p, WDFDEVICE 0x%p", IoTarget, device);
688 
689  return device;
690 }
691 
692 static
694 NTSTATUS
696  __in
697  PFX_DRIVER_GLOBALS FxDriverGlobals,
698  __in
699  WDFIOTARGET IoTarget,
701  WDFREQUEST Request,
702  __in
703  UCHAR MajorCode,
705  PWDF_MEMORY_DESCRIPTOR IoBuffer,
706  __in_opt
708  __in_opt
710  __out_opt
712  )
713 /*++
714 
715 Routine Description:
716  This routine sends a read or write synchronously to the target. If Request
717  is not NULL, the PIRP it contains will be used to send the IO.
718 
719 Arguments:
720  IoTarget - target to where the IO is going to be sent
721 
722  Request - optional. If specified, the PIRP it contains will be used
723  to send the I/O
724 
725  MajorCode - read or write major code
726 
727  IoBuffer - Buffer which will be used in the I/O. The buffer can be a PMDL,
728  buffer, or WDFMEMORY
729 
730  DeviceOffset - offset into the target (and not the memory) in which the I/O
731  will start
732 
733  RequestOptions - optional. If specified, the timeout value is used to cancel
734  the sent i/o if the timeout is exceeded
735 
736  BytesReturned - upon success, the number of bytes transferred in the I/O
737  request
738 
739 Return Value:
740  NTSTATUS
741 
742  --*/
743 
744 {
746  FxRequestBuffer ioBuf;
748 
749  FxObjectHandleGetPtrAndGlobals(FxDriverGlobals,
750  IoTarget,
752  (PVOID*) &pTarget,
753  &FxDriverGlobals);
754 
755  //
756  // Minimize the points of failure by using the stack instead of allocating
757  // out of pool. For UMDF, request initialization can fail so we still need
758  // to call initialize for FxSyncRequest. Initialization always succeeds for
759  // KM.
760  //
762  FxSyncRequest request(FxDriverGlobals, &context, Request);
763 
764  status = request.Initialize();
765  if (!NT_SUCCESS(status)) {
767  "Failed to initialize FxSyncRequest for WDFIOTARGET "
768  "0x%p", IoTarget);
769  return status;
770  }
771 
773  "enter: WDFIOTARGET 0x%p, WDFREQUEST 0x%p, MJ code 0x%x",
774  IoTarget, Request, MajorCode);
775 
776  //
777  // Since we are synchronously waiting, we must be at passive level
778  //
779  status = FxVerifierCheckIrqlLevel(FxDriverGlobals, PASSIVE_LEVEL);
780  if (!NT_SUCCESS(status)) {
781  return status;
782  }
783 
784  status = FxValidateRequestOptions(FxDriverGlobals, RequestOptions);
785  if (!NT_SUCCESS(status)) {
787  "invalid options, %!STATUS!", status);
788  return status;
789  }
790 
791  if (IoBuffer != NULL) {
792  //
793  // This transcribes the client union into a local structure which we
794  // can change w/out altering the client's buffer.
795  //
796  status = ioBuf.ValidateMemoryDescriptor(FxDriverGlobals, IoBuffer);
797  if (!NT_SUCCESS(status)) {
799  "invalid input buffer descriptor 0x%p, %!STATUS!",
800  IoBuffer, status);
801  return status;
802  }
803  }
804 
805  //
806  // Format the next stack location in the PIRP
807  //
809  request.m_TrueRequest, MajorCode, &ioBuf, DeviceOffset, NULL);
810 
811  if (NT_SUCCESS(status)) {
812  //
813  // And send it
814  //
816  "WDFIOTARGET 0x%p, WDFREQUEST 0x%p being submitted",
817  IoTarget, request.m_TrueRequest->GetTraceObjectHandle());
818 
819  status = pTarget->SubmitSync(request.m_TrueRequest, RequestOptions);
820 
821  if (BytesReturned != NULL) {
822  *BytesReturned = request.m_TrueRequest->GetSubmitFxIrp()->GetInformation();
823 
824  }
825  }
826  else {
828  "could not format MJ 0x%x request, %!STATUS!",
829  MajorCode, status);
830  }
831 
832  return status;
833 }
834 
835 static
837 NTSTATUS
839  __in
840  PFX_DRIVER_GLOBALS FxDriverGlobals,
841  __in
842  WDFIOTARGET IoTarget,
843  __inout
844  WDFREQUEST Request,
845  __in
846  UCHAR MajorCode,
848  WDFMEMORY IoBuffer,
849  __in_opt
850  PWDFMEMORY_OFFSET IoBufferOffsets,
851  __in_opt
853  )
854 /*++
855 
856 Routine Description:
857  Formats a Request for a read or write. The request can later be sent to the
858  target using WdfRequestSend. Upon success, this will take a reference on the
859  Iobuffer handle if it is not NULL. This reference will be released when
860  one of the following occurs:
861  1) the request is completed through WdfRequestComplete
862  2) the request is reused through WdfRequestReuse
863  3) the request is reformatted through any target format DDI
864 
865 Arguments:
866  IoTarget - the request that the read or write will later be sent to
867 
868  Request - the request that will be formatted
869 
870  MajorCode - read or write major code
871 
872  IoBuffer - optional reference counted memory handle
873 
874  IoBufferOffset - optional offset into the IoBuffer. This can specify the
875  starting offset and/or length of the transfer
876 
877  DeviceOffset - offset into the target in which the i/o will start
878 
879 Return Value:
880  NTSTATUS
881 
882  --*/
883 {
886  IFxMemory* pIoMemory;
887  FxRequestBuffer ioBuf;
889 
890  FxObjectHandleGetPtrAndGlobals(FxDriverGlobals,
891  IoTarget,
893  (PVOID*) &pTarget,
894  &FxDriverGlobals);
895 
896  DoTraceLevelMessage(FxDriverGlobals,
898  "enter: WDFIOTARGET 0x%p, WDFREQUEST 0x%p, MJ code 0x%x, WDFMEMORY 0x%p",
899  IoTarget, Request, MajorCode, IoBuffer);
900 
901  FxObjectHandleGetPtr(FxDriverGlobals,
902  Request,
904  (PVOID*) &pRequest);
905 
906  if (IoBuffer != NULL) {
907  FxObjectHandleGetPtr(FxDriverGlobals,
908  IoBuffer,
910  (PVOID*) &pIoMemory);
911 
912  status = pIoMemory->ValidateMemoryOffsets(IoBufferOffsets);
913  if (!NT_SUCCESS(status)) {
915  "invalid memory offsets, %!STATUS!",
916  status);
917  return status;
918  }
919 
920  //
921  // This transcribes the client union into a local structure which we
922  // can change w/out altering the client's buffer.
923  //
924  ioBuf.SetMemory(pIoMemory, IoBufferOffsets);
925  }
926  else {
927  pIoMemory = NULL;
928  }
929 
930  //
931  // Format the next stack locaiton in the PIRP
932  //
934  pRequest, MajorCode, &ioBuf, DeviceOffset, NULL);
935 
936  if (NT_SUCCESS(status)) {
937  if (MajorCode == IRP_MJ_WRITE) {
938  pRequest->GetContext()->FormatWriteParams(pIoMemory, IoBufferOffsets);
939  }
940  else if (MajorCode == IRP_MJ_READ) {
941  pRequest->GetContext()->FormatReadParams(pIoMemory, IoBufferOffsets);
942  }
943  }
944 
946  "exit WDFIOTARGET 0x%p, WDFREQUEST 0x%p, %!STATUS!",
948 
949  return status;
950 }
951 
954 NTSTATUS
955 STDCALL
956 WDFEXPORT(WdfIoTargetSendReadSynchronously)(
957  __in
959  __in
960  WDFIOTARGET IoTarget,
961  __in_opt
962  WDFREQUEST Request,
963  __in_opt
965  __in_opt
967  __in_opt
969  __out_opt
971  )
972 {
973  DDI_ENTRY();
974 
976  IoTarget,
977  Request,
978  IRP_MJ_READ,
979  OutputBuffer,
980  DeviceOffset,
982  BytesRead);
983 }
984 
987 NTSTATUS
988 STDCALL
989 WDFEXPORT(WdfIoTargetFormatRequestForRead)(
990  __in
992  __in
993  WDFIOTARGET IoTarget,
994  __in
995  WDFREQUEST Request,
996  __in_opt
997  WDFMEMORY OutputBuffer,
998  __in_opt
1000  __in_opt
1002  )
1003 {
1004  DDI_ENTRY();
1005 
1007  IoTarget,
1008  Request,
1009  IRP_MJ_READ,
1010  OutputBuffer,
1012  DeviceOffset);
1013 }
1014 
1015 
1018 NTSTATUS
1019 STDCALL
1020 WDFEXPORT(WdfIoTargetSendWriteSynchronously)(
1021  __in
1023  __in
1024  WDFIOTARGET IoTarget,
1025  __in_opt
1026  WDFREQUEST Request,
1027  __in_opt
1029  __in_opt
1031  __in_opt
1033  __out_opt
1035  )
1037  DDI_ENTRY();
1038 
1040  IoTarget,
1041  Request,
1042  IRP_MJ_WRITE,
1043  InputBuffer,
1044  DeviceOffset,
1046  BytesWritten);
1047 }
1048 
1051 NTSTATUS
1052 STDCALL
1053 WDFEXPORT(WdfIoTargetFormatRequestForWrite)(
1054  __in
1056  __in
1057  WDFIOTARGET IoTarget,
1058  __in
1059  WDFREQUEST Request,
1060  __in_opt
1061  WDFMEMORY InputBuffer,
1062  __in_opt
1064  __in_opt
1066  )
1067 {
1068  DDI_ENTRY();
1069 
1071  IoTarget,
1072  Request,
1073  IRP_MJ_WRITE,
1074  InputBuffer,
1076  DeviceOffset);
1077 }
1078 
1080 NTSTATUS
1082  __in
1083  PFX_DRIVER_GLOBALS FxDriverGlobals,
1084  __in
1085  WDFIOTARGET IoTarget,
1086  __in_opt
1087  WDFREQUEST Request,
1088  __in
1089  ULONG Ioctl,
1090  __in
1091  BOOLEAN Internal,
1092  __in_opt
1094  __in_opt
1096  __in_opt
1098  __out_opt
1100  )
1101 /*++
1102 
1103 Routine Description:
1104  Sends an external or internal IOCTL to the target. If the optional request
1105  is specified, this function will use it's PIRP to send the request to the
1106  target. Both buffers are optional.
1107 
1108 Arguments:
1109  IoTarget - the target to which the IOCTL is being sent
1110 
1111  IOCTL - the device io control value
1112 
1113  Internal - if TRUE, an internal IOCTL, if FALSE, a normal IOCTL
1114 
1115  InputBuffer - optional. Can be one of the following: PMDL, PVOID, or WDFMEMORY
1116 
1117  OutputBuffer - optional. Can be one of the following: PMDL, PVOID, or WDFMEMORY
1118 
1119  RequestOptions - optional. Specifies a timeout to be used if the sent IO
1120  does not return within the time specified.
1121 
1122  BytesReturned - number of bytes transfered
1123 
1124 Return Value:
1125  NTSTATUS
1126 
1127  --*/
1128 {
1130  FxRequestBuffer inputBuf, outputBuf;
1131  NTSTATUS status;
1132 
1133  FxObjectHandleGetPtrAndGlobals(FxDriverGlobals,
1134  IoTarget,
1136  (PVOID*) &pTarget,
1137  &FxDriverGlobals);
1138 
1139  //
1140  // Minimize the points of failure by using the stack instead of allocating
1141  // out of pool. For UMDF, request initialization can fail so we still need
1142  // to call initialize for FxSyncRequest. Initialization always succeeds for
1143  // KM.
1144  //
1146  FxSyncRequest request(FxDriverGlobals, &context, Request);
1147 
1148  status = request.Initialize();
1149  if (!NT_SUCCESS(status)) {
1151  "Failed to initialize FxSyncRequest for WDFIOTARGET "
1152  "0x%p", IoTarget);
1153  return status;
1154  }
1155 
1157  "enter: WDFIOTARGET 0x%p, WDFREQUEST 0x%p, IOCTL 0x%x, "
1158  "internal %d", IoTarget, Request, Ioctl, Internal);
1159 
1160  //
1161  // Since we are synchronously waiting, we must be at passive
1162  //
1163  status = FxVerifierCheckIrqlLevel(FxDriverGlobals, PASSIVE_LEVEL);
1164  if (!NT_SUCCESS(status)) {
1165  return status;
1166  }
1167 
1168  status = FxValidateRequestOptions(FxDriverGlobals, RequestOptions);
1169  if (!NT_SUCCESS(status)) {
1171  "invalid options, %!STATUS!", status);
1172  return status;
1173  }
1174 
1175  if (InputBuffer != NULL) {
1176  //
1177  // This transcribes the client union into a local structure which we
1178  // can change w/out altering the client's buffer.
1179  //
1180  status = inputBuf.ValidateMemoryDescriptor(FxDriverGlobals, InputBuffer);
1181  if (!NT_SUCCESS(status)) {
1183  "invalid input buffer descriptor 0x%p, %!STATUS!",
1184  InputBuffer, status);
1185  return status;
1186  }
1187  }
1188 
1189  if (OutputBuffer != NULL) {
1190  //
1191  // This transcribes the client union into a local structure which we
1192  // can change w/out altering the client's buffer.
1193  //
1194  status = outputBuf.ValidateMemoryDescriptor(FxDriverGlobals, OutputBuffer);
1195  if (!NT_SUCCESS(status)) {
1197  "invalid output buffer descriptor 0x%p, %!STATUS!",
1198  OutputBuffer, status);
1199  return status;
1200  }
1201  }
1202 
1203  //
1204  // Format the next stack location
1205  //
1207  request.m_TrueRequest, Ioctl, Internal, &inputBuf, &outputBuf, NULL);
1208 
1209  if (NT_SUCCESS(status)) {
1211  "WDFIOTARGET 0x%p, WDFREQUEST 0x%p being submitted",
1212  IoTarget,
1213  request.m_TrueRequest->GetTraceObjectHandle());
1214 
1215  status = pTarget->SubmitSync(request.m_TrueRequest, RequestOptions);
1216 
1217  if (BytesReturned != NULL) {
1218  *BytesReturned = request.m_TrueRequest->GetSubmitFxIrp()->GetInformation();
1219  }
1220  }
1221  else {
1223  "could not format IOCTL 0x%x request, %!STATUS!",
1224  Ioctl, status);
1225  }
1226 
1227  return status;
1228 }
1229 
1230 static
1232 NTSTATUS
1234  __in
1235  PFX_DRIVER_GLOBALS FxDriverGlobals,
1236  __in
1237  WDFIOTARGET IoTarget,
1238  __in
1239  WDFREQUEST Request,
1240  __in
1241  ULONG Ioctl,
1242  __in
1243  BOOLEAN Internal,
1244  __in_opt
1245  WDFMEMORY InputBuffer,
1246  __in_opt
1248  __in_opt
1249  WDFMEMORY OutputBuffer,
1250  __in_opt
1252  )
1253 /*++
1254 
1255 Routine Description:
1256  Formats a request as an IOCTL to be sent to the specified target. Upon
1257  success, this will take a reference on each of the WDFMEMORY handles that
1258  are passed in. This reference will be released when one of the following
1259  occurs:
1260  1) the request is completed through WdfRequestComplete
1261  2) the request is reused through WdfRequestReuse
1262  3) the request is reformatted through any target format DDI
1263 
1264 Arguments:
1265  IoTarget - the target to which the IOCTL will be formatted for
1266 
1267  Request - the request which will be formatted
1268 
1269  IOCTL - the device IO control itself to be used
1270 
1271  Internal - if TRUE, an internal IOCTL, if FALSE, a normal IOCTL
1272 
1273  InputBuffer - optional. If specified, a reference counted memory handle to
1274  be placed in the next stack location.
1275 
1276  InputBufferOffsets - optional. If specified, it can override the starting
1277  offset of the buffer and the length of the buffer used
1278 
1279  OutputBuffer - optional. If specified, a reference counted memory handle to
1280  be placed in the next stack location.
1281 
1282  OutputBufferOffsets - optional. If specified, it can override the starting
1283  offset of the buffer and the length of the buffer used
1284 
1285 Return Value:
1286  NTSTATUS
1287 
1288  --*/
1289 {
1292  IFxMemory *pInputMemory, *pOutputMemory;
1293  FxRequestBuffer inputBuf, outputBuf;
1294  NTSTATUS status;
1295 
1296  FxObjectHandleGetPtrAndGlobals(FxDriverGlobals,
1297  IoTarget,
1299  (PVOID*) &pTarget,
1300  &FxDriverGlobals);
1301 
1303  FxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET,
1304  "enter: WDFIOTARGET 0x%p, WDFREQUEST 0x%p, IOCTL 0x%x, internal %d, input "
1305  "WDFMEMORY 0x%p, output WDFMEMORY 0x%p",
1307 
1308  FxObjectHandleGetPtr(FxDriverGlobals,
1309  Request,
1311  (PVOID*) &pRequest);
1312 
1313  if (InputBuffer != NULL) {
1314  FxObjectHandleGetPtr(FxDriverGlobals,
1315  InputBuffer,
1317  (PVOID*) &pInputMemory);
1318 
1319  status = pInputMemory->ValidateMemoryOffsets(InputBufferOffsets);
1320  if (!NT_SUCCESS(status)) {
1322  "Invalid input memory offsets, %!STATUS!",
1323  status);
1324  return status;
1325  }
1326 
1327  //
1328  // This transcribes the client union into a local structure which we
1329  // can change w/out altering the client's buffer.
1330  //
1331  inputBuf.SetMemory(pInputMemory, InputBufferOffsets);
1332  }
1333 
1334  if (OutputBuffer != NULL) {
1335  FxObjectHandleGetPtr(FxDriverGlobals,
1336  OutputBuffer,
1338  (PVOID*) &pOutputMemory);
1339 
1340  status = pOutputMemory->ValidateMemoryOffsets(OutputBufferOffsets);
1341  if (!NT_SUCCESS(status)) {
1343  "Invalid output memory offsets, %!STATUS!",
1344  status);
1345  return status;
1346  }
1347 
1348  //
1349  // This transcribes the client union into a local structure which we
1350  // can change w/out altering the client's buffer.
1351  //
1352  outputBuf.SetMemory(pOutputMemory, OutputBufferOffsets);
1353  }
1354 
1355  //
1356  // format the next stack location
1357  //
1359  pRequest, Ioctl, Internal, &inputBuf, &outputBuf, NULL);
1360 
1361  if (NT_SUCCESS(status)) {
1362  FxRequestContext* pContext;
1363 
1364  //
1365  // Upon a successful format, a FxRequestContext will have been
1366  // associated with the FxRequest
1367  //
1368  pContext = pRequest->GetContext();
1369 
1370  pContext->m_CompletionParams.Parameters.Ioctl.IoControlCode = Ioctl;
1371 
1372  if (Internal) {
1374  }
1375  else {
1377  }
1378 
1379  pContext->m_CompletionParams.Parameters.Ioctl.Input.Buffer = InputBuffer;
1380  if (InputBufferOffsets != NULL) {
1381  pContext->m_CompletionParams.Parameters.Ioctl.Input.Offset =
1383  }
1384 
1385  pContext->m_CompletionParams.Parameters.Ioctl.Output.Buffer = OutputBuffer;
1386  if (OutputBufferOffsets != NULL) {
1387  pContext->m_CompletionParams.Parameters.Ioctl.Output.Offset =
1389  }
1390  }
1391 
1393  "Exit WDFIOTARGET 0x%p, WDFREQUEST 0x%p, %!STATUS!",
1394  IoTarget, Request, status);
1395 
1396  return status;
1397 }
1398 
1401 NTSTATUS
1402 STDCALL
1403 WDFEXPORT(WdfIoTargetSendIoctlSynchronously)(
1404  __in
1406  __in
1407  WDFIOTARGET IoTarget,
1408  __in_opt
1409  WDFREQUEST Request,
1410  __in
1411  ULONG Ioctl,
1412  __in_opt
1414  __in_opt
1416  __in_opt
1418  __out_opt
1420  )
1422  DDI_ENTRY();
1423 
1424  return FxIoTargetSendIoctl(
1426  IoTarget,
1427  Request,
1428  Ioctl,
1429  FALSE,
1430  InputBuffer,
1431  OutputBuffer,
1434  );
1435 }
1436 
1439 NTSTATUS
1440 STDCALL
1441 WDFEXPORT(WdfIoTargetFormatRequestForIoctl)(
1442  __in
1444  __in
1445  WDFIOTARGET IoTarget,
1446  __in
1447  WDFREQUEST Request,
1448  __in
1449  ULONG Ioctl,
1450  __in_opt
1451  WDFMEMORY InputBuffer,
1452  __in_opt
1454  __in_opt
1455  WDFMEMORY OutputBuffer,
1456  __in_opt
1458  )
1459 {
1460  DDI_ENTRY();
1461 
1463  IoTarget,
1464  Request,
1465  Ioctl,
1466  FALSE,
1467  InputBuffer,
1469  OutputBuffer,
1471 }
1472 
1475 NTSTATUS
1476 STDCALL
1477 WDFEXPORT(WdfIoTargetSendInternalIoctlSynchronously)(
1478  __in
1480  __in
1481  WDFIOTARGET IoTarget,
1482  __in_opt
1483  WDFREQUEST Request,
1484  __in
1485  ULONG Ioctl,
1486  __in_opt
1488  __in_opt
1490  __in_opt
1492  __out_opt
1494  )
1495 {
1496  DDI_ENTRY();
1497 
1498  return FxIoTargetSendIoctl(
1500  IoTarget,
1501  Request,
1502  Ioctl,
1503  TRUE,
1504  InputBuffer,
1505  OutputBuffer,
1508  );
1509 }
1510 
1513 NTSTATUS
1514 STDCALL
1515 WDFEXPORT(WdfIoTargetFormatRequestForInternalIoctl)(
1516  __in
1518  __in
1519  WDFIOTARGET IoTarget,
1520  __in
1521  WDFREQUEST Request,
1522  __in
1523  ULONG Ioctl,
1524  __in_opt
1525  WDFMEMORY InputBuffer,
1526  __in_opt
1528  __in_opt
1529  WDFMEMORY OutputBuffer,
1530  __in_opt
1532  )
1533 {
1534  DDI_ENTRY();
1535 
1537  IoTarget,
1538  Request,
1539  Ioctl,
1540  TRUE,
1541  InputBuffer,
1543  OutputBuffer,
1545 }
1546 
1549 NTSTATUS
1550 STDCALL
1551 WDFEXPORT(WdfIoTargetSendInternalIoctlOthersSynchronously)(
1552  __in
1554  __in
1555  WDFIOTARGET IoTarget,
1556  __in_opt
1557  WDFREQUEST Request,
1558  __in
1559  ULONG Ioctl,
1560  __in_opt
1562  __in_opt
1564  __in_opt
1566  __in_opt
1568  __out_opt
1570  )
1571 /*++
1572 
1573 Routine Description:
1574  Sends an internal IOCTL to the target synchronously. Since all 3 buffers can
1575  be used, we cannot overload WdfIoTargetSendInternalIoctlSynchronously since
1576  it can only take 2 buffers.
1577 
1578 Arguments:
1579  IoTarget - the target to which the request will be sent
1580 
1581  Request - optional. If specified, the request's PIRP will be used to send
1582  the i/o to the target.
1583 
1584  Ioctl - internal ioctl value to send
1585 
1586  OtherArg1
1587  OtherArg2
1588  OtherArg4 - arguments to use in the stack locations's Others field. There
1589  is no OtherArg3 because 3 is where the IOCTL value is written.
1590  All buffers are optional.
1591 
1592  RequestOptions - optional. If specified, the timeout indicated will be used
1593  if the request exceeds the timeout.
1594 
1595  BytesReturned - the number of bytes returned by the target
1596 
1597 Return Value:
1598  NTSTATUS
1599 
1600  --*/
1601 {
1602  DDI_ENTRY();
1603 
1607  NTSTATUS status;
1608 
1610  IoTarget,
1612  (PVOID*) &pTarget,
1613  &pFxDriverGlobals);
1614 
1615  //
1616  // Minimize the points of failure by using the stack instead of allocating
1617  // out of pool. For UMDF, request initialization can fail so we still need
1618  // to call initialize for FxSyncRequest. Initialization always succeeds for
1619  // KM.
1620  //
1622  FxSyncRequest request(pFxDriverGlobals, &context, Request);
1623 
1624  status = request.Initialize();
1625  if (!NT_SUCCESS(status)) {
1627  "Failed to initialize FxSyncRequest for WDFIOTARGET "
1628  "0x%p", IoTarget);
1629  return status;
1630  }
1631 
1633  "enter: WDFIOTARGET 0x%p, WDFREQUEST 0x%p, IOCTL 0x%x, Args %p %p %p",
1635 
1636  //
1637  // Since we are waiting synchronously, we must be at pasisve
1638  //
1640  if (!NT_SUCCESS(status)) {
1641  return status;
1642  }
1643 
1645  if (!NT_SUCCESS(status)) {
1647  "Invalid options, %!STATUS!", status);
1648  return status;
1649  }
1650 
1652 
1653  i = 0;
1654  if (OtherArg1 != NULL) {
1655  //
1656  // This transcribes the client union into a local structure which we
1657  // can change w/out altering the client's buffer.
1658  //
1659  status = args[i].ValidateMemoryDescriptor(pFxDriverGlobals, OtherArg1);
1660  if (!NT_SUCCESS(status)) {
1662  "invalid OtherArg1 buffer descriptor 0x%p, %!STATUS!",
1663  OtherArg1, status);
1664  return status;
1665  }
1666  }
1667 
1668  i++;
1669  if (OtherArg2 != NULL) {
1670  //
1671  // This transcribes the client union into a local structure which we
1672  // can change w/out altering the client's buffer.
1673  //
1674  status = args[i].ValidateMemoryDescriptor(pFxDriverGlobals, OtherArg2);
1675  if (!NT_SUCCESS(status)) {
1677  "invalid OtherArg2 buffer descriptor 0x%p, %!STATUS!",
1678  OtherArg2, status);
1679  return status;
1680  }
1681  }
1682 
1683  i++;
1684  if (OtherArg4 != NULL) {
1685  //
1686  // This transcribes the client union into a local structure which we
1687  // can change w/out altering the client's buffer.
1688  //
1689  status = args[i].ValidateMemoryDescriptor(pFxDriverGlobals, OtherArg4);
1690  if (!NT_SUCCESS(status)) {
1692  "invalid OtherArg4 buffer descriptor 0x%p, %!STATUS!",
1693  OtherArg4, status);
1694  return status;
1695  }
1696  }
1697 
1698  //
1699  // Format the next stack location
1700  //
1702  Ioctl,
1703  args);
1704 
1705  if (NT_SUCCESS(status)) {
1707  "WDFIOTARGET 0x%p, WDFREQUEST 0x%p being submitted",
1708  IoTarget,
1709  request.m_TrueRequest->GetTraceObjectHandle());
1710 
1711  status = pTarget->SubmitSync(request.m_TrueRequest, RequestOptions);
1712 
1713  if (BytesReturned != NULL) {
1714  *BytesReturned = request.m_TrueRequest->GetSubmitFxIrp()->GetInformation();
1715  }
1716  }
1717  else {
1719  "Could not format IOCTL 0x%x request, %!STATUS!",
1720  Ioctl, status);
1721  }
1722 
1723  return status;
1724 }
1725 
1728 NTSTATUS
1729 STDCALL
1730 WDFEXPORT(WdfIoTargetFormatRequestForInternalIoctlOthers)(
1731  __in
1733  __in
1734  WDFIOTARGET IoTarget,
1735  __in
1736  WDFREQUEST Request,
1737  __in
1738  ULONG Ioctl,
1739  __in_opt
1740  WDFMEMORY OtherArg1,
1741  __in_opt
1743  __in_opt
1744  WDFMEMORY OtherArg2,
1745  __in_opt
1747  __in_opt
1748  WDFMEMORY OtherArg4,
1749  __in_opt
1751  )
1752 /*++
1753 
1754 Routine Description:
1755  Formats an internal IOCTL so that it can sent to the target. Since all 3
1756  buffers can be used, we cannot overload
1757  WdfIoTargetFormatRequestForInternalIoctlOthers since it can only take 2 buffers.
1758 
1759  Upon success, this will take a reference on each of the WDFMEMORY handles that
1760  are passed in. This reference will be released when one of the following
1761  occurs:
1762  1) the request is completed through WdfRequestComplete
1763  2) the request is reused through WdfRequestReuse
1764  3) the request is reformatted through any target format DDI
1765 
1766 Arguments:
1767  IoTarget - the target to which the request will be sent
1768 
1769  Request - the request to be formatted
1770 
1771  Ioctl - internal ioctl value to send
1772 
1773  OtherArg1
1774  OtherArg2
1775  OtherArg4 - arguments to use in the stack locations's Others field. There
1776  is no OtherArg3 because 3 is where the IOCTL value is written.
1777  All buffers are optional
1778 
1779  OterhArgXOffsets - offset into each buffer which can override the starting
1780  offset of the buffer. Length does not matter since
1781  there is no way of generically describing the length of
1782  each of the 3 buffers in the PIRP
1783 
1784 Return Value:
1785  NTSTATUS
1786 
1787  --*/
1789  DDI_ENTRY();
1790 
1798  NTSTATUS status;
1799  ULONG i;
1801 
1803  IoTarget,
1805  (PVOID*) &pTarget,
1806  &pFxDriverGlobals);
1807 
1809  "Enter: WDFIOTARGET 0x%p, WDFREQUEST 0x%p, IOCTL 0x%x, "
1810  "WDFMEMORY 1 0x%p, 2 0x%p, 3 0x%p",
1812  OtherArg4);
1813 
1815  Request,
1817  (PVOID*) &pRequest);
1818 
1819  i = 0;
1822 
1825 
1828 
1829  for (i = 0; i < FX_REQUEST_NUM_OTHER_PARAMS; i++) {
1830  if (memoryHandles[i] != NULL) {
1831 
1833  memoryHandles[i],
1835  (PVOID*) &pMemory[i]);
1836 
1838  if (!NT_SUCCESS(status)) {
1840  "Invalid OtherArg%d memory offsets, %!STATUS!",
1841  i+1, status);
1842  return status;
1843  }
1844 
1845  //
1846  // This transcribes the client union into a local structure which we
1847  // can change w/out altering the client's buffer.
1848  //
1849  args[i].SetMemory(pMemory[i], offsets[i]);
1850  }
1851  }
1852 
1854  if (NT_SUCCESS(status)) {
1856  }
1858  "Exit: WDFIOTARGET %p, WDFREQUEST %p, IOCTL 0x%x, "
1859  "Arg Handles %p %p %p, status %!STATUS!",
1861  OtherArg4, status);
1862 
1863  return status;
1864 }
1865 
1868 NTSTATUS
1869 STDCALL
1870 WDFEXPORT(WdfIoTargetSelfAssignDefaultIoQueue)(
1871  _In_
1873  _In_
1874  WDFIOTARGET IoTarget,
1875  _In_
1876  WDFQUEUE Queue
1877  )
1878 
1879 /*++
1880 
1881 Routine Description:
1882 
1883  Assigns a default queue for the Self IO Target.
1884 
1885  By default the IO sent to the Self IO Target is dispatched ot the
1886  client's default / top level queue.
1887 
1888  This routine assigns a default queue for the Intenral I/O target.
1889  If a client calls this API, all the I/O directed to the Self IO target
1890  is dispatched to the queue specified.
1891 
1892 Arguments:
1893 
1894  IoTarget - Handle to the Self Io Target.
1895 
1896  Queue - Handle to a queue that is being assigned as the default queue for
1897  the Self io target.
1898 
1899 Returns:
1900 
1901  NTSTATUS
1902 
1903 --*/
1904 
1906  DDI_ENTRY();
1907 
1909  NTSTATUS status;
1911  FxDevice* pDevice;
1913 
1914  pDevice = NULL;
1915  pFxIoQueue = NULL;
1916 
1918  IoTarget,
1920  (PVOID *) &pTargetSelf,
1921  &pGlobals);
1922 
1924 
1925  //
1926  // Validate the Queue handle
1927  //
1929  Queue,
1930  FX_TYPE_QUEUE,
1931  (PVOID*)&pFxIoQueue);
1932 
1935 
1938  "Input WDFQUEUE 0x%p belongs to WDFDEVICE 0x%p, but "
1939  "Self Io Target 0x%p corresponds to the WDFDEVICE 0x%p, %!STATUS!",
1941  pDevice->GetHandle(), status);
1942 
1943  return status;
1944  }
1945 
1946  if (pDevice->IsLegacy()) {
1947  //
1948  // This is a controldevice. Make sure the create is called after the device
1949  // is initialized and ready to accept I/O.
1950  //
1953 
1957  "Queue cannot be configured for automatic dispatching"
1958  " after WdfControlDeviceFinishInitializing"
1959  "is called on the WDFDEVICE %p is called %!STATUS!",
1960  pDevice->GetHandle(),
1961  status);
1962  return status;
1963  }
1964  }
1965  else {
1966  //
1967  // This is either FDO or PDO. Make sure it's not started yet.
1968  //
1969  if (pDevice->GetDevicePnpState() != WdfDevStatePnpInit) {
1973  "Queue cannot be configured for automatic dispatching"
1974  "after the WDFDEVICE %p is started, %!STATUS!",
1975  pDevice->GetHandle(), status);
1976  return status;
1977  }
1978  }
1979 
1981 
1983 }
1984 
1986 HANDLE
1987 STDCALL
1988 WDFEXPORT(WdfIoTargetWdmGetTargetFileHandle)(
1989  __in
1991  __in
1992  WDFIOTARGET IoTarget
1993  )
1994 /*++
1995 
1996 Routine Description:
1997  Returns the file handle that the target represents. For KMDF, the handle is a kernel
1998  handle, so it is not tied to any process context. For UMDF it is a Win32 handle opened
1999  in the host process context. Not all targets have a file handle associated with them,
2000  so NULL is a valid return value that does not indicate error.
2001 
2002 Arguments:
2003  IoTarget - target whose file handle is being returned
2004 
2005 Return Value:
2006  A valid kernel/win32 handle or NULL
2007 
2008  --*/
2009 {
2013 
2015  IoTarget,
2017  (PVOID*) &pTarget,
2018  &pFxDriverGlobals);
2019 
2021  "enter WDFIOTARGET 0x%p", IoTarget);
2022 
2023  handle = pTarget->GetTargetHandle();
2024 
2026  "exit WDFIOTARGET 0x%p, WDM file handle 0x%p",
2027  IoTarget, handle);
2028 
2029  return handle;
2030 }
2031 
2032 
2033 } // extern "C"
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PLONGLONG _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_opt_ PULONG_PTR BytesWritten
Definition: wdfiotarget.h:949
#define DDI_ENTRY()
Definition: fxglobalskm.h:56
enum _WDF_IO_TARGET_PURGE_IO_ACTION WDF_IO_TARGET_PURGE_IO_ACTION
_Must_inspect_result_ __in WDFIOTARGET __in WDFREQUEST __in_opt WDFMEMORY __in_opt PWDFMEMORY_OFFSET InputBufferOffsets
_Must_inspect_result_ NTSTATUS ValidateMemoryOffsets(__in_opt PWDFMEMORY_OFFSET Offsets)
Definition: ifxmemory.hpp:105
VOID SetMemory(__in IFxMemory *Memory, __in PWDFMEMORY_OFFSET Offsets)
__inline WDFDEVICE GetDeviceHandle(VOID)
Definition: fxiotarget.hpp:299
#define STATUS_INFO_LENGTH_MISMATCH
Definition: udferr_usr.h:133
MdDeviceObject __inline GetDeviceObject(VOID)
Definition: fxdevice.hpp:174
GLint x0
Definition: linetemp.h:95
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_ ULONG _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PWDF_MEMORY_DESCRIPTOR OtherArg2
Definition: wdfiotarget.h:1243
Definition: http.c:7251
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in_opt PWDF_MEMORY_DESCRIPTOR __in_opt PLONGLONG __in_opt PWDF_REQUEST_SEND_OPTIONS RequestOptions
IFxMemory * pMemory[FX_REQUEST_NUM_OTHER_PARAMS]
#define __in_opt
Definition: dbghelp.h:38
#define TRUE
Definition: types.h:120
WDFDEVICE __inline GetHandle(VOID)
Definition: fxdevice.hpp:237
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
WDFMEMORY memoryHandles[FX_REQUEST_NUM_OTHER_PARAMS]
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in_opt PWDF_MEMORY_DESCRIPTOR InputBuffer
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PLONGLONG DeviceOffset
Definition: wdfiotarget.h:859
_Must_inspect_result_ _In_ WDFDEVICE _In_ PIRP _In_ WDFQUEUE Queue
Definition: wdfdevice.h:2221
_Must_inspect_result_ __in WDFIOTARGET IoTarget
_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ PWDF_OBJECT_ATTRIBUTES IoTargetAttributes
Definition: wdfiotarget.h:363
_Must_inspect_result_ _In_ WDFIOTARGET _In_ WDFQUEUE Queue
_Must_inspect_result_ NTSTATUS FormatInternalIoctlOthersRequest(__in FxRequestBase *Request, __in ULONG Ioctl, __in FxRequestBuffer *Buffers)
NTSTATUS status
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in ULONG __in_opt PWDF_MEMORY_DESCRIPTOR __in_opt PWDF_MEMORY_DESCRIPTOR __in_opt PWDF_MEMORY_DESCRIPTOR OtherArg4
LONG NTSTATUS
Definition: precomp.h:26
__inline WDF_IO_TARGET_STATE GetState(VOID)
Definition: fxiotarget.hpp:263
#define FX_REQUEST_NUM_OTHER_PARAMS
ULONG i
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
_Must_inspect_result_ NTSTATUS FxIoTargetValidateOpenParams(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_IO_TARGET_OPEN_PARAMS OpenParams)
FxIoTargetSelf * pTargetSelf
static _Must_inspect_result_ NTSTATUS FxIoTargetFormatIo(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFIOTARGET IoTarget, __inout WDFREQUEST Request, __in UCHAR MajorCode, __inout_opt WDFMEMORY IoBuffer, __in_opt PWDFMEMORY_OFFSET IoBufferOffsets, __in_opt PLONGLONG DeviceOffset)
_In_ WDFREQUEST Request
Definition: wdfdevice.h:547
static _Must_inspect_result_ NTSTATUS FxIoTargetSendIo(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFIOTARGET IoTarget, __inout_opt WDFREQUEST Request, __in UCHAR MajorCode, __inout_opt PWDF_MEMORY_DESCRIPTOR IoBuffer, __in_opt PLONGLONG DeviceOffset, __in_opt PWDF_REQUEST_SEND_OPTIONS RequestOptions, __out_opt PULONG_PTR BytesReturned)
_Must_inspect_result_ __in WDFIOTARGET __in WDFREQUEST __in ULONG __in_opt WDFMEMORY __in_opt PWDFMEMORY_OFFSET __in_opt WDFMEMORY __in_opt PWDFMEMORY_OFFSET OtherArg2Offsets
_Must_inspect_result_ NTSTATUS SubmitSync(__in FxRequestBase *Request, __in_opt PWDF_REQUEST_SEND_OPTIONS Options=NULL, __out_opt PULONG Action=NULL)
DriverGlobals
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in_opt PWDF_MEMORY_DESCRIPTOR __in_opt PLONGLONG __in_opt PWDF_REQUEST_SEND_OPTIONS __out_opt PULONG_PTR BytesWritten
struct _WDF_REQUEST_COMPLETION_PARAMS::@3639::@3642 Ioctl
#define __inout_opt
Definition: dbghelp.h:53
VOID FormatWriteParams(__in_opt IFxMemory *WriteMemory, __in_opt PWDFMEMORY_OFFSET WriteOffsets)
Definition: match.c:390
return STATUS_SUCCESS
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_ ULONG _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_opt_ PULONG_PTR BytesReturned
Definition: wdfiotarget.h:1039
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PLONGLONG _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_opt_ PULONG_PTR BytesRead
Definition: wdfiotarget.h:859
NTSTATUS __inline FxValidateRequestOptions(_In_ PFX_DRIVER_GLOBALS FxDriverGlobals, _In_ PWDF_REQUEST_SEND_OPTIONS Options, _In_opt_ FxRequestBase *Request=NULL)
#define STATUS_INVALID_DEVICE_STATE
Definition: udferr_usr.h:178
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in ULONG Ioctl
enum _WDF_IO_TARGET_SENT_IO_ACTION WDF_IO_TARGET_SENT_IO_ACTION
__GNU_EXTENSION typedef __int64 * PLONGLONG
Definition: ntbasedef.h:382
WDFIOTARGET GetHandle(VOID)
Definition: fxiotarget.hpp:307
#define __out_opt
Definition: dbghelp.h:65
#define FALSE
Definition: types.h:117
FxObjectHandleGetPtr(GetFxDriverGlobals(DriverGlobals), IoTarget, FX_TYPE_IO_TARGET,(PVOID *) &pTarget)
#define TRACE_LEVEL_VERBOSE
Definition: storswtr.h:30
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST Request
Definition: devices.h:37
#define WDFEXPORT(a)
Definition: fxmacros.hpp:157
size_t BufferOffset
Definition: wdfmemory.h:65
WDF_IO_TARGET_OPEN_PARAMS openParams
_Must_inspect_result_ NTSTATUS FormatIoRequest(__inout FxRequestBase *Request, __in UCHAR MajorCode, __in FxRequestBuffer *IoBuffer, __in_opt PLONGLONG StartingOffset, __in_opt FxFileObject *FileObject=NULL)
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_ ULONG _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PWDF_MEMORY_DESCRIPTOR OtherArg4
Definition: wdfiotarget.h:1243
#define __out
Definition: dbghelp.h:62
FxDeviceBase * pDevice
unsigned char BOOLEAN
_Must_inspect_result_ BOOLEAN IsVersionGreaterThanOrEqualTo(__in ULONG Major, __in ULONG Minor)
Definition: globalskm.cpp:92
VOID SetDispatchQueue(_In_ FxIoQueue *DispatchQueue)
#define _In_
Definition: ms_sal.h:308
VOID FormatReadParams(__in_opt IFxMemory *ReadMemory, __in_opt PWDFMEMORY_OFFSET ReadOffsets)
VOID FormatOtherParams(__in FxInternalIoctlParams *InternalIoctlParams)
FxObjectHandleGetPtrAndGlobals(GetFxDriverGlobals(DriverGlobals), Device, FX_TYPE_DEVICE_BASE,(PWDFOBJECT) &pDevice, &pFxDriverGlobals)
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR OutputBuffer
Definition: wdfiotarget.h:859
__in WDFIOTARGET __in __drv_strictTypeMatch(__drv_typeConst) WDF_IO_TARGET_SENT_IO_ACTION Action)
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR InputBuffer
Definition: wdfiotarget.h:949
__inline NTSTATUS FxVerifierCheckIrqlLevel(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in KIRQL Irql)
Definition: fxverifier.h:158
_Must_inspect_result_ NTSTATUS FxIoTargetSendIoctl(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFIOTARGET IoTarget, __in_opt WDFREQUEST Request, __in ULONG Ioctl, __in BOOLEAN Internal, __in_opt PWDF_MEMORY_DESCRIPTOR InputBuffer, __in_opt PWDF_MEMORY_DESCRIPTOR OutputBuffer, __in_opt PWDF_REQUEST_SEND_OPTIONS RequestOptions, __out_opt PULONG_PTR BytesReturned)
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in ULONG __in_opt PWDF_MEMORY_DESCRIPTOR __in_opt PWDF_MEMORY_DESCRIPTOR __in_opt PWDF_REQUEST_SEND_OPTIONS __out_opt PULONG_PTR BytesReturned
struct _WDF_IO_TARGET_OPEN_PARAMS WDF_IO_TARGET_OPEN_PARAMS
#define STDCALL
Definition: wdf.h:45
WDF_EXTERN_C_START enum _WDF_IO_TARGET_STATE WDF_IO_TARGET_STATE
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
__drv_when(Action==3, __drv_maxIRQL(DISPATCH_LEVEL)) __drv_when(Action
_Must_inspect_result_ __in WDFIOTARGET __in WDFREQUEST __in ULONG __in_opt WDFMEMORY __in_opt PWDFMEMORY_OFFSET __in_opt WDFMEMORY __in_opt PWDFMEMORY_OFFSET __in_opt WDFMEMORY __in_opt PWDFMEMORY_OFFSET OtherArg4Offsets
_Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) NTSTATUS STDCALL WDFEXPORT(WdfIoTargetSelfAssignDefaultIoQueue)(_In_ PWDF_DRIVER_GLOBALS DriverGlobals
Definition: hardware.c:1705
_Must_inspect_result_ __in WDFIOTARGET __in WDFREQUEST __in_opt WDFMEMORY __in_opt PWDFMEMORY_OFFSET OutputBufferOffsets
PWDFMEMORY_OFFSET offsets[FX_REQUEST_NUM_OTHER_PARAMS]
PVOID handle
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in ULONG __in_opt PWDF_MEMORY_DESCRIPTOR __in_opt PWDF_MEMORY_DESCRIPTOR OtherArg2
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_ ULONG _In_opt_ PWDF_MEMORY_DESCRIPTOR OtherArg1
Definition: wdfiotarget.h:1243
_Must_inspect_result_ _In_ WDFIOTARGET _In_ PWDF_IO_TARGET_OPEN_PARAMS OpenParams
Definition: wdfiotarget.h:398
unsigned char UCHAR
Definition: xmlstorage.h:181
_Must_inspect_result_ NTSTATUS FxValidateObjectAttributes(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_OBJECT_ATTRIBUTES Attributes, __in ULONG Flags=FX_VALIDATE_OPTION_NONE_SPECIFIED)
ULONG expectedConfigSize
_Must_inspect_result_ NTSTATUS FormatIoctlRequest(__in FxRequestBase *Request, __in ULONG Ioctl, __in BOOLEAN Internal, __in FxRequestBuffer *InputBuffer, __in FxRequestBuffer *OutputBuffer, __in_opt FxFileObject *FileObject=NULL)
WDFDEVICE device
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in_opt PWDF_MEMORY_DESCRIPTOR __in_opt PLONGLONG DeviceOffset
static _Must_inspect_result_ NTSTATUS _Create(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_OBJECT_ATTRIBUTES Attributes, __in FxDeviceBase *Device, __out FxIoTargetRemote **Target)
virtual VOID Purge(__in WDF_IO_TARGET_PURGE_IO_ACTION Action)
Definition: fxiotarget.cpp:918
virtual _Must_inspect_result_ NTSTATUS Start(VOID)
Definition: fxiotarget.cpp:282
#define __inout
Definition: dbghelp.h:50
_Must_inspect_result_ NTSTATUS __inline FxValidateUnicodeString(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PCUNICODE_STRING String)
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in_opt PWDF_MEMORY_DESCRIPTOR OutputBuffer
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
#define _Must_inspect_result_
Definition: ms_sal.h:558
_Must_inspect_result_ _In_ WDFDEVICE Device
Definition: wdfchildlist.h:474
FxPointerNotNull(pFxDriverGlobals, IoTarget)
PFX_DRIVER_GLOBALS pGlobals
MxDeviceObject deviceObject
CfxDevice * GetDevice(VOID)
Definition: fxobject.hpp:781
#define TRACE_LEVEL_ERROR
Definition: storswtr.h:27
_Must_inspect_result_ __in WDFIOTARGET __in PWDF_IO_TARGET_OPEN_PARAMS OpenParams
FxInternalIoctlParams InternalIoctlParams
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
#define TRACINGPNP
Definition: dbgtrace.h:67
NTSTATUS ValidateMemoryDescriptor(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in PWDF_MEMORY_DESCRIPTOR Descriptor, __in ULONG Flags=0x0)
_Must_inspect_result_ __in WDFIOTARGET __in WDFREQUEST __in ULONG __in_opt WDFMEMORY __in_opt PWDFMEMORY_OFFSET OtherArg1Offsets
struct _WDF_IO_TARGET_OPEN_PARAMS_V1_11 WDF_IO_TARGET_OPEN_PARAMS_V1_11
_In_ WDFIOTARGET _In_ _Strict_type_match_ WDF_IO_TARGET_SENT_IO_ACTION Action
Definition: wdfiotarget.h:506
FxRequest * pRequest
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in_opt PWDF_MEMORY_DESCRIPTOR __in_opt PLONGLONG __in_opt PWDF_REQUEST_SEND_OPTIONS __out_opt PULONG_PTR BytesRead
WDF_REQUEST_COMPLETION_PARAMS m_CompletionParams
__inline FxRequestContext * GetContext(VOID)
FxIoQueue * pFxIoQueue
#define NULL
Definition: types.h:112
DoTraceLevelMessage(pFxDriverGlobals, TRACE_LEVEL_VERBOSE, TRACINGIOTARGET, "WDFDEVICE 0x%p", Device)
Definition: tftpd.h:85
_Must_inspect_result_ __in WDFIOTARGET __in_opt WDFREQUEST __in ULONG __in_opt PWDF_MEMORY_DESCRIPTOR OtherArg1
#define IRP_MJ_READ
Definition: rdpdr.c:46
__inline CfxDevice * GetDevice(VOID)
Definition: fxioqueue.hpp:773
FxSyncRequest request(pFxDriverGlobals, &context, Request)
PFX_DRIVER_GLOBALS pFxDriverGlobals
#define DDI_ENTRY_IMPERSONATION_OK()
Definition: fxglobalskm.h:55
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PLONGLONG _In_opt_ PWDF_REQUEST_SEND_OPTIONS RequestOptions
Definition: wdfiotarget.h:859
unsigned int ULONG
Definition: retypes.h:1
_Must_inspect_result_ _In_ WDFDEVICE _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFIOTARGET * IoTarget
Definition: wdfiotarget.h:363
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
uint32_t * PULONG_PTR
Definition: typedefs.h:65
static _Must_inspect_result_ NTSTATUS FxIoTargetFormatIoctl(__in PFX_DRIVER_GLOBALS FxDriverGlobals, __in WDFIOTARGET IoTarget, __in WDFREQUEST Request, __in ULONG Ioctl, __in BOOLEAN Internal, __in_opt WDFMEMORY InputBuffer, __in_opt PWDFMEMORY_OFFSET InputBufferOffsets, __in_opt WDFMEMORY OutputBuffer, __in_opt PWDFMEMORY_OFFSET OutputBufferOffsets)
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
_Must_inspect_result_ __in WDFDEVICE Device
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
#define TRACINGIO
Definition: dbgtrace.h:66
ULONG GetFlags(VOID)
__inline PFX_DRIVER_GLOBALS GetFxDriverGlobals(__in PWDF_DRIVER_GLOBALS DriverGlobals)
Definition: fxglobals.h:597
FxIoTarget * pTarget
#define __in
Definition: dbghelp.h:35
_Must_inspect_result_ __in WDFDEVICE __in_opt PWDF_OBJECT_ATTRIBUTES IoTargetAttributes
FxInternalIoctlOthersContext context
#define TRACINGIOTARGET
Definition: dbgtrace.h:72
_Must_inspect_result_ __drv_maxIRQL(DISPATCH_LEVEL) NTSTATUS STDCALL WDFEXPORT(WdfIoTargetStart)(__in PWDF_DRIVER_GLOBALS DriverGlobals
virtual VOID Stop(__in WDF_IO_TARGET_SENT_IO_ACTION Action)
Definition: fxiotarget.cpp:748
union _WDF_REQUEST_COMPLETION_PARAMS::@3639 Parameters
Definition: ps.c:97