bc80ebb955f0c81510295e5f2e8d4e995de4dd85
[reactos.git] / drivers / filesystems / npfs / waitsup.c
1 /*
2 * PROJECT: ReactOS Named Pipe FileSystem
3 * LICENSE: BSD - See COPYING.ARM in the top level directory
4 * FILE: drivers/filesystems/npfs/waitsup.c
5 * PURPOSE: Pipes Waiting Support
6 * PROGRAMMERS: ReactOS Portable Systems Group
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #include "npfs.h"
12
13 // File ID number for NPFS bugchecking support
14 #define NPFS_BUGCHECK_FILE_ID (NPFS_BUGCHECK_WAITSUP)
15
16 /* FUNCTIONS ******************************************************************/
17
18 VOID
19 NTAPI
20 NpCancelWaitQueueIrp(IN PDEVICE_OBJECT DeviceObject,
21 IN PIRP Irp)
22 {
23 KIRQL OldIrql;
24 PNP_WAIT_QUEUE_ENTRY WaitEntry;
25 PNP_WAIT_QUEUE WaitQueue;
26
27 IoReleaseCancelSpinLock(Irp->CancelIrql);
28
29 WaitQueue = (PNP_WAIT_QUEUE)Irp->Tail.Overlay.DriverContext[0];
30
31 KeAcquireSpinLock(&WaitQueue->WaitLock, &OldIrql);
32
33 WaitEntry = (PNP_WAIT_QUEUE_ENTRY)Irp->Tail.Overlay.DriverContext[1];
34 if (WaitEntry)
35 {
36 RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
37 if (!KeCancelTimer(&WaitEntry->Timer))
38 {
39 WaitEntry->Irp = NULL;
40 WaitEntry = NULL;
41 }
42 }
43
44 KeReleaseSpinLock(&WaitQueue->WaitLock, OldIrql);
45
46 if (WaitEntry)
47 {
48 ObDereferenceObject(WaitEntry->FileObject);
49 ExFreePool(WaitEntry);
50 }
51
52 Irp->IoStatus.Information = 0;
53 Irp->IoStatus.Status = STATUS_CANCELLED;
54 IoCompleteRequest(Irp, IO_NAMED_PIPE_INCREMENT);
55 }
56
57 VOID
58 NTAPI
59 NpTimerDispatch(IN PKDPC Dpc,
60 IN PVOID Context,
61 IN PVOID Argument1,
62 IN PVOID Argument2)
63 {
64 PIRP Irp;
65 KIRQL OldIrql;
66 PNP_WAIT_QUEUE_ENTRY WaitEntry = Context;
67
68 KeAcquireSpinLock(&WaitEntry->WaitQueue->WaitLock, &OldIrql);
69
70 Irp = WaitEntry->Irp;
71 if (Irp)
72 {
73 RemoveEntryList(&Irp->Tail.Overlay.ListEntry);
74
75 if (!IoSetCancelRoutine(Irp, NULL))
76 {
77 Irp->Tail.Overlay.DriverContext[1] = NULL;
78 Irp = NULL;
79 }
80 }
81
82 KeReleaseSpinLock(&WaitEntry->WaitQueue->WaitLock, OldIrql);
83
84 if (Irp)
85 {
86 Irp->IoStatus.Status = STATUS_IO_TIMEOUT;
87 IoCompleteRequest(Irp, IO_NAMED_PIPE_INCREMENT);
88 }
89
90 ObDereferenceObject(WaitEntry->FileObject);
91 ExFreePool(WaitEntry);
92 }
93
94 VOID
95 NTAPI
96 NpInitializeWaitQueue(IN PNP_WAIT_QUEUE WaitQueue)
97 {
98 InitializeListHead(&WaitQueue->WaitList);
99 KeInitializeSpinLock(&WaitQueue->WaitLock);
100 }
101
102 NTSTATUS
103 NTAPI
104 NpCancelWaiter(IN PNP_WAIT_QUEUE WaitQueue,
105 IN PUNICODE_STRING PipeName,
106 IN NTSTATUS Status,
107 IN PLIST_ENTRY List)
108 {
109 UNICODE_STRING DestinationString;
110 KIRQL OldIrql;
111 PWCHAR Buffer;
112 PLIST_ENTRY NextEntry;
113 PNP_WAIT_QUEUE_ENTRY WaitEntry, Linkage;
114 PIRP WaitIrp;
115 PFILE_PIPE_WAIT_FOR_BUFFER WaitBuffer;
116 ULONG i, NameLength;
117
118 Linkage = NULL;
119
120 Buffer = ExAllocatePoolWithTag(NonPagedPool,
121 PipeName->Length,
122 NPFS_WAIT_BLOCK_TAG);
123 if (!Buffer) return STATUS_INSUFFICIENT_RESOURCES;
124
125 RtlInitEmptyUnicodeString(&DestinationString, Buffer, PipeName->Length);
126 RtlUpcaseUnicodeString(&DestinationString, PipeName, FALSE);
127
128 KeAcquireSpinLock(&WaitQueue->WaitLock, &OldIrql);
129
130 for (NextEntry = WaitQueue->WaitList.Flink;
131 NextEntry != &WaitQueue->WaitList;
132 NextEntry = NextEntry->Flink)
133 {
134 WaitIrp = CONTAINING_RECORD(NextEntry, IRP, Tail.Overlay.ListEntry);
135 WaitEntry = WaitIrp->Tail.Overlay.DriverContext[1];
136
137 if (WaitEntry->AliasName.Length)
138 {
139 ASSERT(FALSE);
140 if (DestinationString.Length == WaitEntry->AliasName.Length)
141 {
142 if (RtlCompareMemory(WaitEntry->AliasName.Buffer,
143 DestinationString.Buffer,
144 DestinationString.Length) ==
145 DestinationString.Length)
146 {
147 CancelWait:
148 RemoveEntryList(&WaitIrp->Tail.Overlay.ListEntry);
149 if (KeCancelTimer(&WaitEntry->Timer))
150 {
151 WaitEntry->WaitQueue = (PNP_WAIT_QUEUE)Linkage;
152 Linkage = WaitEntry;
153 }
154 else
155 {
156 WaitEntry->Irp = NULL;
157 WaitIrp->Tail.Overlay.DriverContext[1] = NULL;
158 }
159
160 if (IoSetCancelRoutine(WaitIrp, NULL))
161 {
162 WaitIrp->IoStatus.Information = 0;
163 WaitIrp->IoStatus.Status = Status;
164 InsertTailList(List, &WaitIrp->Tail.Overlay.ListEntry);
165 }
166 else
167 {
168 WaitIrp->Tail.Overlay.DriverContext[1] = NULL;
169 }
170 }
171 }
172 }
173 else
174 {
175 WaitBuffer = WaitIrp->AssociatedIrp.SystemBuffer;
176
177 if (WaitBuffer->NameLength + sizeof(WCHAR) == DestinationString.Length)
178 {
179 NameLength = WaitBuffer->NameLength / sizeof(WCHAR);
180 for (i = 0; i < NameLength; i++)
181 {
182 if (WaitBuffer->Name[i] != DestinationString.Buffer[i + 1]) break;
183 }
184
185 if (i >= NameLength) goto CancelWait;
186 }
187 }
188 }
189
190 KeReleaseSpinLock(&WaitQueue->WaitLock, OldIrql);
191
192 ExFreePool(DestinationString.Buffer);
193
194 while (Linkage)
195 {
196 WaitEntry = Linkage;
197 Linkage = (PNP_WAIT_QUEUE_ENTRY)Linkage->WaitQueue;
198 ObDereferenceObject(WaitEntry->FileObject);
199 ExFreePool(WaitEntry);
200 }
201
202 return STATUS_SUCCESS;
203 }
204
205 NTSTATUS
206 NTAPI
207 NpAddWaiter(IN PNP_WAIT_QUEUE WaitQueue,
208 IN LARGE_INTEGER WaitTime,
209 IN PIRP Irp,
210 IN PUNICODE_STRING AliasName)
211 {
212 PIO_STACK_LOCATION IoStack;
213 KIRQL OldIrql;
214 NTSTATUS Status;
215 PNP_WAIT_QUEUE_ENTRY WaitEntry;
216 PFILE_PIPE_WAIT_FOR_BUFFER WaitBuffer;
217 LARGE_INTEGER DueTime;
218 ULONG i;
219
220 IoStack = IoGetCurrentIrpStackLocation(Irp);
221
222 WaitEntry = ExAllocatePoolWithQuotaTag(NonPagedPool | POOL_QUOTA_FAIL_INSTEAD_OF_RAISE,
223 sizeof(*WaitEntry),
224 NPFS_WRITE_BLOCK_TAG);
225 if (!WaitEntry)
226 {
227 return STATUS_INSUFFICIENT_RESOURCES;
228 }
229
230 KeInitializeDpc(&WaitEntry->Dpc, NpTimerDispatch, WaitEntry);
231 KeInitializeTimer(&WaitEntry->Timer);
232
233 if (AliasName)
234 {
235 WaitEntry->AliasName = *AliasName;
236 }
237 else
238 {
239 WaitEntry->AliasName.Length = 0;
240 WaitEntry->AliasName.Buffer = NULL;
241 }
242
243 WaitEntry->WaitQueue = WaitQueue;
244 WaitEntry->Irp = Irp;
245
246 WaitBuffer = Irp->AssociatedIrp.SystemBuffer;
247 if (WaitBuffer->TimeoutSpecified)
248 {
249 DueTime = WaitBuffer->Timeout;
250 }
251 else
252 {
253 DueTime = WaitTime;
254 }
255
256 for (i = 0; i < WaitBuffer->NameLength / sizeof(WCHAR); i++)
257 {
258 WaitBuffer->Name[i] = RtlUpcaseUnicodeChar(WaitBuffer->Name[i]);
259 }
260
261 Irp->Tail.Overlay.DriverContext[0] = WaitQueue;
262 Irp->Tail.Overlay.DriverContext[1] = WaitEntry;
263
264 KeAcquireSpinLock(&WaitQueue->WaitLock, &OldIrql);
265
266 IoSetCancelRoutine(Irp, NpCancelWaitQueueIrp);
267
268 if (Irp->Cancel && IoSetCancelRoutine(Irp, NULL))
269 {
270 Status = STATUS_CANCELLED;
271 }
272 else
273 {
274 InsertTailList(&WaitQueue->WaitList, &Irp->Tail.Overlay.ListEntry);
275
276 IoMarkIrpPending(Irp);
277 Status = STATUS_PENDING;
278
279 WaitEntry->FileObject = IoStack->FileObject;
280 ObReferenceObject(WaitEntry->FileObject);
281
282 KeSetTimer(&WaitEntry->Timer, DueTime, &WaitEntry->Dpc);
283 WaitEntry = NULL;
284 }
285
286 KeReleaseSpinLock(&WaitQueue->WaitLock, OldIrql);
287 if (WaitEntry) ExFreePool(WaitEntry);
288
289 return Status;
290 }
291
292 /* EOF */