ReactOS 0.4.15-dev-7907-g95bf896
lock.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: drivers/net/afd/afd/lock.c
5 * PURPOSE: Ancillary functions driver
6 * PROGRAMMER: Art Yerkes (ayerkes@speakeasy.net)
7 * UPDATE HISTORY:
8 * 20040708 Created
9 */
10
11#include "afd.h"
12
14{
15 ASSERT(Irp->MdlAddress);
16 ASSERT(Irp->Tail.Overlay.DriverContext[0]);
17
19
20 return Irp->Tail.Overlay.DriverContext[0];
21}
22
23/* Lock a method_neither request so it'll be available from DISPATCH_LEVEL */
28 BOOLEAN LockFailed = FALSE;
29
30 ASSERT(!Irp->MdlAddress);
31
32 switch (IrpSp->MajorFunction)
33 {
36 ASSERT(IrpSp->Parameters.DeviceIoControl.Type3InputBuffer);
37 ASSERT(IrpSp->Parameters.DeviceIoControl.InputBufferLength);
38
39
40 Irp->MdlAddress =
42 IrpSp->Parameters.DeviceIoControl.InputBufferLength,
43 FALSE,
44 FALSE,
45 NULL );
46 if( Irp->MdlAddress ) {
47 _SEH2_TRY {
48 MmProbeAndLockPages( Irp->MdlAddress, Irp->RequestorMode, IoModifyAccess );
50 LockFailed = TRUE;
51 } _SEH2_END;
52
53 if( LockFailed ) {
54 AFD_DbgPrint(MIN_TRACE,("Failed to lock pages\n"));
55 IoFreeMdl( Irp->MdlAddress );
56 Irp->MdlAddress = NULL;
57 return NULL;
58 }
59
60 /* The mapped address goes in index 1 */
61 Irp->Tail.Overlay.DriverContext[1] = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
62 if (!Irp->Tail.Overlay.DriverContext[1])
63 {
64 AFD_DbgPrint(MIN_TRACE,("Failed to get mapped address\n"));
65 MmUnlockPages(Irp->MdlAddress);
66 IoFreeMdl( Irp->MdlAddress );
67 Irp->MdlAddress = NULL;
68 return NULL;
69 }
70
71 /* The allocated address goes in index 0 */
72 Irp->Tail.Overlay.DriverContext[0] = ExAllocatePoolWithTag(NonPagedPool,
73 MmGetMdlByteCount(Irp->MdlAddress),
75
76 if (!Irp->Tail.Overlay.DriverContext[0])
77 {
78 AFD_DbgPrint(MIN_TRACE,("Failed to allocate memory\n"));
79 MmUnlockPages(Irp->MdlAddress);
80 IoFreeMdl( Irp->MdlAddress );
81 Irp->MdlAddress = NULL;
82 return NULL;
83 }
84
85 RtlCopyMemory(Irp->Tail.Overlay.DriverContext[0],
86 Irp->Tail.Overlay.DriverContext[1],
87 MmGetMdlByteCount(Irp->MdlAddress));
88
89 /* If we don't want a copy back, we zero the mapped address pointer */
90 if (!Output)
91 {
92 Irp->Tail.Overlay.DriverContext[1] = NULL;
93 }
94
95 /* We're using a user-mode buffer directly */
96 if (LockMode != NULL)
97 {
99 }
100 }
101 else return NULL;
102 break;
103
104 case IRP_MJ_READ:
105 case IRP_MJ_WRITE:
106 ASSERT(Irp->UserBuffer);
107
108 Irp->MdlAddress =
109 IoAllocateMdl(Irp->UserBuffer,
111 IrpSp->Parameters.Read.Length : IrpSp->Parameters.Write.Length,
112 FALSE,
113 FALSE,
114 NULL );
115 if( Irp->MdlAddress ) {
116 PAFD_RECV_INFO AfdInfo;
117
118 _SEH2_TRY {
119 MmProbeAndLockPages( Irp->MdlAddress, Irp->RequestorMode, IoModifyAccess );
121 LockFailed = TRUE;
122 } _SEH2_END;
123
124 if( LockFailed ) {
125 AFD_DbgPrint(MIN_TRACE,("Failed to lock pages\n"));
126 IoFreeMdl( Irp->MdlAddress );
127 Irp->MdlAddress = NULL;
128 return NULL;
129 }
130
131 /* We need to create the info struct that AFD expects for all send/recv requests */
133 sizeof(AFD_RECV_INFO) + sizeof(AFD_WSABUF),
135
136 if (!AfdInfo)
137 {
138 AFD_DbgPrint(MIN_TRACE,("Failed to allocate memory\n"));
139 MmUnlockPages(Irp->MdlAddress);
140 IoFreeMdl( Irp->MdlAddress );
141 Irp->MdlAddress = NULL;
142 return NULL;
143 }
144
145 /* We'll append the buffer array to this struct */
146 AfdInfo->BufferArray = (PAFD_WSABUF)(AfdInfo + 1);
147 AfdInfo->BufferCount = 1;
148
149 /* Setup the default flags values */
150 AfdInfo->AfdFlags = 0;
151 AfdInfo->TdiFlags = 0;
152
153 /* Now build the buffer array */
154 AfdInfo->BufferArray[0].buf = MmGetSystemAddressForMdl(Irp->MdlAddress);
155 AfdInfo->BufferArray[0].len = MmGetMdlByteCount(Irp->MdlAddress);
156
157 /* Store the struct where AFD expects */
158 Irp->Tail.Overlay.DriverContext[0] = AfdInfo;
159
160 /* Don't copy anything out */
161 Irp->Tail.Overlay.DriverContext[1] = NULL;
162
163 /* We're using a placeholder buffer that we allocated */
164 if (LockMode != NULL)
165 {
167 }
168 }
169 else return NULL;
170 break;
171
172 default:
173 ASSERT(FALSE);
174 return NULL;
175 }
176
177 return GetLockedData(Irp, IrpSp);
178}
179
181{
182 ASSERT(Irp->MdlAddress);
183 ASSERT(Irp->Tail.Overlay.DriverContext[0]);
184
186
187 /* Check if we need to copy stuff back */
188 if (Irp->Tail.Overlay.DriverContext[1] != NULL)
189 {
190 RtlCopyMemory(Irp->Tail.Overlay.DriverContext[1],
191 Irp->Tail.Overlay.DriverContext[0],
192 MmGetMdlByteCount(Irp->MdlAddress));
193 }
194
195 ExFreePoolWithTag(Irp->Tail.Overlay.DriverContext[0], TAG_AFD_DATA_BUFFER);
196 MmUnlockPages( Irp->MdlAddress );
197 IoFreeMdl( Irp->MdlAddress );
198 Irp->MdlAddress = NULL;
199}
200
201/* Note: We add an extra buffer if LockAddress is true. This allows us to
202 * treat the address buffer as an ordinary client buffer. It's only used
203 * for datagrams. */
204
206 PVOID AddressBuf, PINT AddressLen,
207 BOOLEAN Write, BOOLEAN LockAddress,
209 UINT i;
210 /* Copy the buffer array so we don't lose it */
211 UINT Lock = LockAddress ? 2 : 0;
212 UINT Size = (sizeof(AFD_WSABUF) + sizeof(AFD_MAPBUF)) * (Count + Lock);
214 BOOLEAN LockFailed = FALSE;
215 PAFD_MAPBUF MapBuf;
216
217 AFD_DbgPrint(MID_TRACE,("Called(%p)\n", NewBuf));
218
219 if( NewBuf ) {
220 RtlZeroMemory(NewBuf, Size);
221
222 MapBuf = (PAFD_MAPBUF)(NewBuf + Count + Lock);
223
224 _SEH2_TRY {
225 RtlCopyMemory( NewBuf, Buf, sizeof(AFD_WSABUF) * Count );
226 if( LockAddress ) {
227 if (AddressBuf && AddressLen) {
228 NewBuf[Count].buf = AddressBuf;
229 NewBuf[Count].len = *AddressLen;
230 NewBuf[Count + 1].buf = (PVOID)AddressLen;
231 NewBuf[Count + 1].len = sizeof(*AddressLen);
232 }
233 Count += 2;
234 }
236 AFD_DbgPrint(MIN_TRACE,("Access violation copying buffer info "
237 "from userland (%p %p)\n",
238 Buf, AddressLen));
240 _SEH2_YIELD(return NULL);
241 } _SEH2_END;
242
243 for( i = 0; i < Count; i++ ) {
244 AFD_DbgPrint(MID_TRACE,("Locking buffer %u (%p:%u)\n",
245 i, NewBuf[i].buf, NewBuf[i].len));
246
247 if( NewBuf[i].buf && NewBuf[i].len ) {
248 MapBuf[i].Mdl = IoAllocateMdl( NewBuf[i].buf,
249 NewBuf[i].len,
250 FALSE,
251 FALSE,
252 NULL );
253 } else {
254 MapBuf[i].Mdl = NULL;
255 continue;
256 }
257
258 AFD_DbgPrint(MID_TRACE,("NewMdl @ %p\n", MapBuf[i].Mdl));
259
260 if( MapBuf[i].Mdl ) {
261 AFD_DbgPrint(MID_TRACE,("Probe and lock pages\n"));
262 _SEH2_TRY {
266 LockFailed = TRUE;
267 } _SEH2_END;
268 AFD_DbgPrint(MID_TRACE,("MmProbeAndLock finished\n"));
269
270 if( LockFailed ) {
271 AFD_DbgPrint(MIN_TRACE,("Failed to lock pages\n"));
272 IoFreeMdl( MapBuf[i].Mdl );
273 MapBuf[i].Mdl = NULL;
275 return NULL;
276 }
277 } else {
279 return NULL;
280 }
281 }
282 }
283
284 AFD_DbgPrint(MID_TRACE,("Leaving %p\n", NewBuf));
285
286 return NewBuf;
287}
288
290 UINT Lock = Address ? 2 : 0;
291 PAFD_MAPBUF Map = (PAFD_MAPBUF)(Buf + Count + Lock);
292 UINT i;
293
294 if( !Buf ) return;
295
296 for( i = 0; i < Count + Lock; i++ ) {
297 if( Map[i].Mdl ) {
298 MmUnlockPages( Map[i].Mdl );
299 IoFreeMdl( Map[i].Mdl );
300 Map[i].Mdl = NULL;
301 }
302 }
303
305 Buf = NULL;
306}
307
308/* Produce a kernel-land handle array with handles replaced by object
309 * pointers. This will allow the system to do proper alerting */
310PAFD_HANDLE LockHandles( PAFD_HANDLE HandleArray, UINT HandleCount ) {
311 UINT i;
313
315 HandleCount * sizeof(AFD_HANDLE),
317
318 for( i = 0; FileObjects && i < HandleCount; i++ ) {
319 FileObjects[i].Status = 0;
320 FileObjects[i].Events = HandleArray[i].Events;
321 FileObjects[i].Handle = 0;
322 if( !HandleArray[i].Handle ) continue;
323 if( NT_SUCCESS(Status) ) {
325 ( (PVOID)HandleArray[i].Handle,
327 NULL,
329 (PVOID*)&FileObjects[i].Handle,
330 NULL );
331 }
332
333 if( !NT_SUCCESS(Status) )
334 {
335 AFD_DbgPrint(MIN_TRACE,("Failed to reference handles (0x%x)\n", Status));
336 FileObjects[i].Handle = 0;
337 }
338 }
339
340 if( !NT_SUCCESS(Status) ) {
341 UnlockHandles( FileObjects, HandleCount );
342 return NULL;
343 }
344
345 return FileObjects;
346}
347
348VOID UnlockHandles( PAFD_HANDLE HandleArray, UINT HandleCount ) {
349 UINT i;
350
351 for( i = 0; i < HandleCount; i++ ) {
352 if( HandleArray[i].Handle )
353 ObDereferenceObject( (PVOID)HandleArray[i].Handle );
354 }
355
357 HandleArray = NULL;
358}
359
361 if( !FCB ) return FALSE;
362
363 return !KeWaitForMutexObject(&FCB->Mutex,
364 Executive,
366 FALSE,
367 NULL);
368}
369
371 KeReleaseMutex(&FCB->Mutex, FALSE);
372}
373
376 UINT Information ) {
377 Irp->IoStatus.Status = Status;
378 Irp->IoStatus.Information = Information;
379 if ( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
383 return Status;
384}
385
386
389 AFD_DbgPrint(MIN_TRACE,("Called.\n"));
390 Irp->IoStatus.Information = 0;
391 Irp->IoStatus.Status = Status;
392 if ( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
394 return Status;
395}
396
398{
400
401 /* Add the IRP to the queue in all cases (so AfdCancelHandler will work properly) */
402 InsertTailList( &FCB->PendingIrpList[Function],
403 &Irp->Tail.Overlay.ListEntry );
404
405 /* Acquire the cancel spin lock and check the cancel bit */
406 IoAcquireCancelSpinLock(&Irp->CancelIrql);
407 if (!Irp->Cancel)
408 {
409 /* We are not cancelled; we're good to go so
410 * set the cancel routine, release the cancel spin lock,
411 * mark the IRP as pending, and
412 * return STATUS_PENDING to the caller
413 */
415 IoReleaseCancelSpinLock(Irp->CancelIrql);
418 }
419 else
420 {
421 /* We were already cancelled before we were able to register our cancel routine
422 * so we are to call the cancel routine ourselves right here to cancel the IRP
423 * (which handles all the stuff we do above) and return STATUS_CANCELLED to the caller
424 */
426 Irp);
428 }
429
430 return Status;
431}
432
435
437
439
440 return Status;
441}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
unsigned char BOOLEAN
struct _AFD_MAPBUF * PAFD_MAPBUF
#define TAG_AFD_POLL_HANDLE
Definition: afd.h:47
DRIVER_CANCEL AfdCancelHandler
Definition: afd.h:302
#define TAG_AFD_WSA_BUFFER
Definition: afd.h:54
#define TAG_AFD_DATA_BUFFER
Definition: afd.h:38
LONG NTSTATUS
Definition: precomp.h:26
#define MIN_TRACE
Definition: debug.h:14
#define MID_TRACE
Definition: debug.h:15
_In_ CDROM_SCAN_FOR_SPECIAL_INFO _In_ PCDROM_SCAN_FOR_SPECIAL_HANDLER Function
Definition: cdrom.h:1156
_In_ PIRP Irp
Definition: csq.h:116
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4137
PVOID LockRequest(PIRP Irp, PIO_STACK_LOCATION IrpSp, BOOLEAN Output, KPROCESSOR_MODE *LockMode)
Definition: lock.c:24
VOID UnlockBuffers(PAFD_WSABUF Buf, UINT Count, BOOL Address)
Definition: lock.c:289
VOID UnlockHandles(PAFD_HANDLE HandleArray, UINT HandleCount)
Definition: lock.c:348
VOID UnlockRequest(PIRP Irp, PIO_STACK_LOCATION IrpSp)
Definition: lock.c:180
NTSTATUS QueueUserModeIrp(PAFD_FCB FCB, PIRP Irp, UINT Function)
Definition: lock.c:397
NTSTATUS LostSocket(PIRP Irp)
Definition: lock.c:387
NTSTATUS NTAPI UnlockAndMaybeComplete(PAFD_FCB FCB, NTSTATUS Status, PIRP Irp, UINT Information)
Definition: lock.c:375
PAFD_WSABUF LockBuffers(PAFD_WSABUF Buf, UINT Count, PVOID AddressBuf, PINT AddressLen, BOOLEAN Write, BOOLEAN LockAddress, KPROCESSOR_MODE LockMode)
Definition: lock.c:205
VOID SocketStateUnlock(PAFD_FCB FCB)
Definition: lock.c:370
NTSTATUS LeaveIrpUntilLater(PAFD_FCB FCB, PIRP Irp, UINT Function)
Definition: lock.c:433
BOOLEAN SocketAcquireStateLock(PAFD_FCB FCB)
Definition: lock.c:360
PVOID GetLockedData(PIRP Irp, PIO_STACK_LOCATION IrpSp)
Definition: lock.c:13
PAFD_HANDLE LockHandles(PAFD_HANDLE HandleArray, UINT HandleCount)
Definition: lock.c:310
#define AFD_DbgPrint(_t_, _x_)
Definition: debug.h:60
#define IO_NETWORK_INCREMENT
Definition: tcpip.h:43
ULONG LockMode
Definition: env_spec_w32.cpp:8
#define InsertTailList(ListHead, Entry)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define NonPagedPool
Definition: env_spec_w32.h:307
#define PagedPool
Definition: env_spec_w32.h:308
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
unsigned int BOOL
Definition: ntddk_ex.h:94
#define IoFreeMdl
Definition: fxmdl.h:89
#define IoAllocateMdl
Definition: fxmdl.h:88
ULONG Handle
Definition: gdb_input.c:15
Status
Definition: gdiplustypes.h:25
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
IoMarkIrpPending(Irp)
IoSetCancelRoutine(Irp, CancelRoutine)
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:931
VOID NTAPI MmUnlockPages(IN PMDL Mdl)
Definition: mdlsup.c:1435
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
@ NormalPagePriority
Definition: imports.h:56
unsigned int UINT
Definition: ndis.h:50
#define KernelMode
Definition: asm.h:34
#define UserMode
Definition: asm.h:35
int Count
Definition: noreturn.cpp:7
#define FILE_ALL_ACCESS
Definition: nt_native.h:651
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
#define IoCompleteRequest
Definition: irp.c:1240
VOID NTAPI IoReleaseCancelSpinLock(IN KIRQL Irql)
Definition: util.c:150
VOID NTAPI IoAcquireCancelSpinLock(OUT PKIRQL Irql)
Definition: util.c:56
LONG NTAPI KeReleaseMutex(IN PKMUTEX Mutex, IN BOOLEAN Wait)
Definition: mutex.c:189
#define STATUS_FILE_CLOSED
Definition: ntstatus.h:532
#define STATUS_PENDING
Definition: ntstatus.h:82
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
static WCHAR Address[46]
Definition: ping.c:68
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:162
#define IRP_MJ_READ
Definition: rdpdr.c:46
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
#define IRP_MJ_WRITE
Definition: rdpdr.c:47
@ Output
Definition: arc.h:85
struct _AFD_WSABUF AFD_WSABUF
struct _AFD_WSABUF * PAFD_WSABUF
#define STATUS_SUCCESS
Definition: shellext.h:65
Definition: afd.h:159
SOCKET Handle
Definition: shared.h:50
ULONG Events
Definition: shared.h:51
NTSTATUS Status
Definition: shared.h:52
PMDL Mdl
Definition: afd.h:105
ULONG BufferCount
Definition: shared.h:86
ULONG TdiFlags
Definition: shared.h:88
ULONG AfdFlags
Definition: shared.h:87
PAFD_WSABUF BufferArray
Definition: shared.h:85
PCHAR buf
Definition: shared.h:18
UINT len
Definition: shared.h:17
Definition: cdstruc.h:902
struct _IO_STACK_LOCATION::@1564::@1565 DeviceIoControl
union _IO_STACK_LOCATION::@1564 Parameters
struct _IO_STACK_LOCATION::@3978::@3983 Write
struct _IO_STACK_LOCATION::@3978::@3982 Read
#define NTAPI
Definition: typedefs.h:36
void * PVOID
Definition: typedefs.h:50
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define STATUS_CANCELLED
Definition: udferr_usr.h:170
static BOOL Write(PBYTE Address, PBYTE Data, SIZE_T Size)
Definition: vmhorizon.c:15
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_In_ WDFDEVICE _In_ PVOID _In_opt_ PMDL Mdl
_In_ WDFREQUEST _In_ NTSTATUS _In_ ULONG_PTR Information
Definition: wdfrequest.h:1049
_Must_inspect_result_ _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFWAITLOCK * Lock
Definition: wdfsync.h:127
int * PINT
Definition: windef.h:177
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define IRP_MJ_INTERNAL_DEVICE_CONTROL
#define KeWaitForMutexObject
Definition: kefuncs.h:543
@ Executive
Definition: ketypes.h:415
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
@ IoReadAccess
Definition: ketypes.h:863
@ IoModifyAccess
Definition: ketypes.h:865
#define MmGetMdlByteCount(_Mdl)
#define MmGetSystemAddressForMdl(Mdl)
#define MmGetSystemAddressForMdlSafe(_Mdl, _Priority)
#define ObDereferenceObject
Definition: obfuncs.h:203