bdfc20ef7d748d2109e7d4bd75b3e7bd8d2a1471
[reactos.git] / drivers / network / afd / afd / lock.c
1 /* $Id$
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 #include "afd.h"
11 #include "tdi_proto.h"
12 #include "tdiconn.h"
13 #include "debug.h"
14 #include "pseh/pseh2.h"
15
16 /* Lock a method_neither request so it'll be available from DISPATCH_LEVEL */
17 PVOID LockRequest( PIRP Irp, PIO_STACK_LOCATION IrpSp ) {
18 BOOLEAN LockFailed = FALSE;
19
20 Irp->MdlAddress =
21 IoAllocateMdl( IrpSp->Parameters.DeviceIoControl.Type3InputBuffer,
22 IrpSp->Parameters.DeviceIoControl.InputBufferLength,
23 FALSE,
24 FALSE,
25 NULL );
26 if( Irp->MdlAddress ) {
27 _SEH2_TRY {
28 MmProbeAndLockPages( Irp->MdlAddress, Irp->RequestorMode, IoModifyAccess );
29 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
30 LockFailed = TRUE;
31 } _SEH2_END;
32
33 if( LockFailed ) {
34 IoFreeMdl( Irp->MdlAddress );
35 Irp->MdlAddress = NULL;
36 return NULL;
37 }
38
39 IrpSp->Parameters.DeviceIoControl.Type3InputBuffer =
40 MmGetSystemAddressForMdlSafe( Irp->MdlAddress, NormalPagePriority );
41
42 if( !IrpSp->Parameters.DeviceIoControl.Type3InputBuffer ) {
43 IoFreeMdl( Irp->MdlAddress );
44 Irp->MdlAddress = NULL;
45 return NULL;
46 }
47
48 return IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
49 } else return NULL;
50 }
51
52 VOID UnlockRequest( PIRP Irp, PIO_STACK_LOCATION IrpSp ) {
53 PVOID Buffer = MmGetSystemAddressForMdlSafe( Irp->MdlAddress, NormalPagePriority );
54 if( IrpSp->Parameters.DeviceIoControl.Type3InputBuffer == Buffer || Buffer == NULL ) {
55 MmUnmapLockedPages( IrpSp->Parameters.DeviceIoControl.Type3InputBuffer, Irp->MdlAddress );
56 MmUnlockPages( Irp->MdlAddress );
57 IoFreeMdl( Irp->MdlAddress );
58 }
59
60 Irp->MdlAddress = NULL;
61 }
62
63 /* Note: We add an extra buffer if LockAddress is true. This allows us to
64 * treat the address buffer as an ordinary client buffer. It's only used
65 * for datagrams. */
66
67 PAFD_WSABUF LockBuffers( PAFD_WSABUF Buf, UINT Count,
68 PVOID AddressBuf, PINT AddressLen,
69 BOOLEAN Write, BOOLEAN LockAddress ) {
70 UINT i;
71 /* Copy the buffer array so we don't lose it */
72 UINT Lock = LockAddress ? 2 : 0;
73 UINT Size = sizeof(AFD_WSABUF) * (Count + Lock);
74 PAFD_WSABUF NewBuf = ExAllocatePool( PagedPool, Size * 2 );
75 BOOLEAN LockFailed = FALSE;
76 PAFD_MAPBUF MapBuf;
77
78 AFD_DbgPrint(MID_TRACE,("Called(%08x)\n", NewBuf));
79
80 if( NewBuf ) {
81 RtlZeroMemory(NewBuf, Size * 2);
82
83 MapBuf = (PAFD_MAPBUF)(NewBuf + Count + Lock);
84
85 _SEH2_TRY {
86 RtlCopyMemory( NewBuf, Buf, sizeof(AFD_WSABUF) * Count );
87 if( LockAddress ) {
88 if (AddressBuf && AddressLen) {
89 NewBuf[Count].buf = AddressBuf;
90 NewBuf[Count].len = *AddressLen;
91 NewBuf[Count + 1].buf = (PVOID)AddressLen;
92 NewBuf[Count + 1].len = sizeof(*AddressLen);
93 }
94 Count += 2;
95 }
96 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
97 AFD_DbgPrint(MIN_TRACE,("Access violation copying buffer info "
98 "from userland (%x %x)\n",
99 Buf, AddressLen));
100 ExFreePool( NewBuf );
101 _SEH2_YIELD(return NULL);
102 } _SEH2_END;
103
104 for( i = 0; i < Count; i++ ) {
105 AFD_DbgPrint(MID_TRACE,("Locking buffer %d (%x:%d)\n",
106 i, NewBuf[i].buf, NewBuf[i].len));
107
108 if( NewBuf[i].buf && NewBuf[i].len ) {
109 MapBuf[i].Mdl = IoAllocateMdl( NewBuf[i].buf,
110 NewBuf[i].len,
111 FALSE,
112 FALSE,
113 NULL );
114 } else {
115 MapBuf[i].Mdl = NULL;
116 continue;
117 }
118
119 AFD_DbgPrint(MID_TRACE,("NewMdl @ %x\n", MapBuf[i].Mdl));
120
121 if( MapBuf[i].Mdl ) {
122 AFD_DbgPrint(MID_TRACE,("Probe and lock pages\n"));
123 _SEH2_TRY {
124 MmProbeAndLockPages( MapBuf[i].Mdl, KernelMode,
125 Write ? IoModifyAccess : IoReadAccess );
126 } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
127 LockFailed = TRUE;
128 } _SEH2_END;
129 AFD_DbgPrint(MID_TRACE,("MmProbeAndLock finished\n"));
130
131 if( LockFailed ) {
132 IoFreeMdl( MapBuf[i].Mdl );
133 MapBuf[i].Mdl = NULL;
134 ExFreePool( NewBuf );
135 return NULL;
136 }
137 } else {
138 ExFreePool( NewBuf );
139 return NULL;
140 }
141 }
142 }
143
144 AFD_DbgPrint(MID_TRACE,("Leaving %x\n", NewBuf));
145
146 return NewBuf;
147 }
148
149 VOID UnlockBuffers( PAFD_WSABUF Buf, UINT Count, BOOL Address ) {
150 UINT Lock = Address ? 2 : 0;
151 PAFD_MAPBUF Map = (PAFD_MAPBUF)(Buf + Count + Lock);
152 UINT i;
153
154 if( !Buf ) return;
155
156 for( i = 0; i < Count + Lock; i++ ) {
157 if( Map[i].Mdl ) {
158 MmUnlockPages( Map[i].Mdl );
159 IoFreeMdl( Map[i].Mdl );
160 Map[i].Mdl = NULL;
161 }
162 }
163
164 ExFreePool( Buf );
165 Buf = NULL;
166 }
167
168 /* Produce a kernel-land handle array with handles replaced by object
169 * pointers. This will allow the system to do proper alerting */
170 PAFD_HANDLE LockHandles( PAFD_HANDLE HandleArray, UINT HandleCount ) {
171 UINT i;
172 NTSTATUS Status = STATUS_SUCCESS;
173
174 PAFD_HANDLE FileObjects = ExAllocatePool
175 ( NonPagedPool, HandleCount * sizeof(AFD_HANDLE) );
176
177 for( i = 0; FileObjects && i < HandleCount; i++ ) {
178 FileObjects[i].Status = 0;
179 FileObjects[i].Events = HandleArray[i].Events;
180 FileObjects[i].Handle = 0;
181 if( !HandleArray[i].Handle ) continue;
182 if( NT_SUCCESS(Status) ) {
183 Status = ObReferenceObjectByHandle
184 ( (PVOID)HandleArray[i].Handle,
185 FILE_ALL_ACCESS,
186 NULL,
187 KernelMode,
188 (PVOID*)&FileObjects[i].Handle,
189 NULL );
190 }
191
192 if( !NT_SUCCESS(Status) )
193 FileObjects[i].Handle = 0;
194 }
195
196 if( !NT_SUCCESS(Status) ) {
197 UnlockHandles( FileObjects, HandleCount );
198 return NULL;
199 }
200
201 return FileObjects;
202 }
203
204 VOID UnlockHandles( PAFD_HANDLE HandleArray, UINT HandleCount ) {
205 UINT i;
206
207 for( i = 0; i < HandleCount; i++ ) {
208 if( HandleArray[i].Handle )
209 ObDereferenceObject( (PVOID)HandleArray[i].Handle );
210 }
211
212 ExFreePool( HandleArray );
213 HandleArray = NULL;
214 }
215
216 /* Returns transitioned state or SOCKET_STATE_INVALID_TRANSITION */
217 UINT SocketAcquireStateLock( PAFD_FCB FCB ) {
218 NTSTATUS Status = STATUS_SUCCESS;
219 PVOID CurrentThread = KeGetCurrentThread();
220
221 ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
222
223 AFD_DbgPrint(MAX_TRACE,("Called on %x, attempting to lock\n", FCB));
224
225 /* Wait for the previous user to unlock the FCB state. There might be
226 * multiple waiters waiting to change the state. We need to check each
227 * time we get the event whether somebody still has the state locked */
228
229 if( !FCB ) return FALSE;
230
231 if( CurrentThread == FCB->CurrentThread ) {
232 FCB->LockCount++;
233 AFD_DbgPrint(MID_TRACE,
234 ("Same thread, lock count %d\n", FCB->LockCount));
235 return TRUE;
236 } else {
237 AFD_DbgPrint(MID_TRACE,
238 ("Thread %x opposes lock thread %x\n",
239 CurrentThread, FCB->CurrentThread));
240 }
241
242
243 ExAcquireFastMutex( &FCB->Mutex );
244
245 while( FCB->Locked ) {
246 AFD_DbgPrint
247 (MID_TRACE,("FCB %x is locked, waiting for notification\n",
248 FCB));
249 ExReleaseFastMutex( &FCB->Mutex );
250 Status = KeWaitForSingleObject( &FCB->StateLockedEvent,
251 UserRequest,
252 KernelMode,
253 FALSE,
254 NULL );
255 ExAcquireFastMutex( &FCB->Mutex );
256 }
257 FCB->Locked = TRUE;
258 FCB->CurrentThread = CurrentThread;
259 FCB->LockCount++;
260 ExReleaseFastMutex( &FCB->Mutex );
261
262 AFD_DbgPrint(MAX_TRACE,("Got lock (%d).\n", FCB->LockCount));
263
264 return TRUE;
265 }
266
267 VOID SocketStateUnlock( PAFD_FCB FCB ) {
268 #if DBG
269 PVOID CurrentThread = KeGetCurrentThread();
270 #endif
271 ASSERT(FCB->LockCount > 0);
272 ASSERT(KeGetCurrentIrql() <= APC_LEVEL);
273
274 ExAcquireFastMutex( &FCB->Mutex );
275 FCB->LockCount--;
276
277 if( !FCB->LockCount ) {
278 FCB->CurrentThread = NULL;
279 FCB->Locked = FALSE;
280
281 AFD_DbgPrint(MAX_TRACE,("Unlocked.\n"));
282 KePulseEvent( &FCB->StateLockedEvent, IO_NETWORK_INCREMENT, FALSE );
283 } else {
284 AFD_DbgPrint(MAX_TRACE,("New lock count: %d (Thr: %x)\n",
285 FCB->LockCount, CurrentThread));
286 }
287 ExReleaseFastMutex( &FCB->Mutex );
288 }
289
290 NTSTATUS NTAPI UnlockAndMaybeComplete
291 ( PAFD_FCB FCB, NTSTATUS Status, PIRP Irp,
292 UINT Information ) {
293 Irp->IoStatus.Status = Status;
294 Irp->IoStatus.Information = Information;
295 if ( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
296 (void)IoSetCancelRoutine(Irp, NULL);
297 SocketStateUnlock( FCB );
298 IoCompleteRequest( Irp, IO_NETWORK_INCREMENT );
299 return Status;
300 }
301
302
303 NTSTATUS LostSocket( PIRP Irp ) {
304 NTSTATUS Status = STATUS_FILE_CLOSED;
305 AFD_DbgPrint(MIN_TRACE,("Called.\n"));
306 Irp->IoStatus.Information = 0;
307 Irp->IoStatus.Status = Status;
308 if ( Irp->MdlAddress ) UnlockRequest( Irp, IoGetCurrentIrpStackLocation( Irp ) );
309 IoCompleteRequest( Irp, IO_NO_INCREMENT );
310 return Status;
311 }
312
313 NTSTATUS LeaveIrpUntilLater( PAFD_FCB FCB, PIRP Irp, UINT Function ) {
314 InsertTailList( &FCB->PendingIrpList[Function],
315 &Irp->Tail.Overlay.ListEntry );
316 IoMarkIrpPending(Irp);
317 (void)IoSetCancelRoutine(Irp, AfdCancelHandler);
318 SocketStateUnlock( FCB );
319 return STATUS_PENDING;
320 }