convert DefaultSetInfoBufferCheck and DefaultQueryInfoBufferCheck to inlined functions
[reactos.git] / reactos / ntoskrnl / io / iocomp.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: ntoskrnl/io/iocomp.c
5 * PURPOSE: No purpose listed.
6 *
7 * PROGRAMMERS: David Welch (welch@mcmail.com)
8 */
9
10 /* INCLUDES *****************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <internal/debug.h>
15
16 POBJECT_TYPE IoCompletionType;
17
18 NPAGED_LOOKASIDE_LIST IoCompletionPacketLookaside;
19
20 static GENERIC_MAPPING IopCompletionMapping =
21 {
22 STANDARD_RIGHTS_READ | IO_COMPLETION_QUERY_STATE,
23 STANDARD_RIGHTS_WRITE | IO_COMPLETION_MODIFY_STATE,
24 STANDARD_RIGHTS_EXECUTE | SYNCHRONIZE | IO_COMPLETION_QUERY_STATE,
25 IO_COMPLETION_ALL_ACCESS
26 };
27
28 static const INFORMATION_CLASS_INFO IoCompletionInfoClass[] = {
29
30 /* IoCompletionBasicInformation */
31 ICI_SQ_SAME( sizeof(IO_COMPLETION_BASIC_INFORMATION), sizeof(ULONG), ICIF_QUERY ),
32 };
33
34 /* FUNCTIONS *****************************************************************/
35
36 VOID
37 STDCALL
38 IopFreeIoCompletionPacket(PIO_COMPLETION_PACKET Packet)
39 {
40 PKPRCB Prcb = KeGetCurrentPrcb();
41 PNPAGED_LOOKASIDE_LIST List;
42
43 /* Use the P List */
44 List = (PNPAGED_LOOKASIDE_LIST)Prcb->PPLookasideList[LookasideCompletionList].P;
45 List->L.TotalFrees++;
46
47 /* Check if the Free was within the Depth or not */
48 if (ExQueryDepthSList(&List->L.ListHead) >= List->L.Depth)
49 {
50 /* Let the balancer know */
51 List->L.FreeMisses++;
52
53 /* Use the L List */
54 List = (PNPAGED_LOOKASIDE_LIST)Prcb->PPLookasideList[LookasideCompletionList].L;
55 List->L.TotalFrees++;
56
57 /* Check if the Free was within the Depth or not */
58 if (ExQueryDepthSList(&List->L.ListHead) >= List->L.Depth)
59 {
60 /* All lists failed, use the pool */
61 List->L.FreeMisses++;
62 ExFreePool(Packet);
63 }
64 }
65
66 /* The free was within dhe Depth */
67 InterlockedPushEntrySList(&List->L.ListHead, (PSINGLE_LIST_ENTRY)Packet);
68 }
69
70 VOID
71 STDCALL
72 IopDeleteIoCompletion(PVOID ObjectBody)
73 {
74 PKQUEUE Queue = ObjectBody;
75 PLIST_ENTRY FirstEntry;
76 PLIST_ENTRY CurrentEntry;
77 PIRP Irp;
78 PIO_COMPLETION_PACKET Packet;
79
80 DPRINT("IopDeleteIoCompletion()\n");
81
82 /* Rundown the Queue */
83 FirstEntry = KeRundownQueue(Queue);
84
85 /* Clean up the IRPs */
86 if (FirstEntry) {
87
88 CurrentEntry = FirstEntry;
89 do {
90
91 /* Get the Packet */
92 Packet = CONTAINING_RECORD(CurrentEntry, IO_COMPLETION_PACKET, ListEntry);
93
94 /* Go to next Entry */
95 CurrentEntry = CurrentEntry->Flink;
96
97 /* Check if it's part of an IRP, or a separate packet */
98 if (Packet->PacketType == IrpCompletionPacket)
99 {
100 /* Get the IRP and free it */
101 Irp = CONTAINING_RECORD(Packet, IRP, Tail.Overlay.ListEntry);
102 IoFreeIrp(Irp);
103 }
104 else
105 {
106 /* Use common routine */
107 IopFreeIoCompletionPacket(Packet);
108 }
109 } while (FirstEntry != CurrentEntry);
110 }
111 }
112
113 /*
114 * @implemented
115 */
116 NTSTATUS
117 STDCALL
118 IoSetIoCompletion(IN PVOID IoCompletion,
119 IN PVOID KeyContext,
120 IN PVOID ApcContext,
121 IN NTSTATUS IoStatus,
122 IN ULONG_PTR IoStatusInformation,
123 IN BOOLEAN Quota)
124 {
125 PKQUEUE Queue = (PKQUEUE)IoCompletion;
126 PNPAGED_LOOKASIDE_LIST List;
127 PKPRCB Prcb = KeGetCurrentPrcb();
128 PIO_COMPLETION_PACKET Packet;
129
130 /* Get the P List */
131 List = (PNPAGED_LOOKASIDE_LIST)Prcb->PPLookasideList[LookasideCompletionList].P;
132
133 /* Try to allocate the Packet */
134 List->L.TotalAllocates++;
135 Packet = (PVOID)InterlockedPopEntrySList(&List->L.ListHead);
136
137 /* Check if that failed, use the L list if it did */
138 if (!Packet)
139 {
140 /* Let the balancer know */
141 List->L.AllocateMisses++;
142
143 /* Get L List */
144 List = (PNPAGED_LOOKASIDE_LIST)Prcb->PPLookasideList[LookasideCompletionList].L;
145
146 /* Try to allocate the Packet */
147 List->L.TotalAllocates++;
148 Packet = (PVOID)InterlockedPopEntrySList(&List->L.ListHead);
149 }
150
151 /* Still failed, use pool */
152 if (!Packet)
153 {
154 /* Let the balancer know */
155 List->L.AllocateMisses++;
156
157 /* Allocate from Nonpaged Pool */
158 Packet = ExAllocatePoolWithTag(NonPagedPool, sizeof(*Packet), IOC_TAG);
159 }
160
161 /* Make sure we have one by now... */
162 if (Packet)
163 {
164 /* Set up the Packet */
165 Packet->PacketType = IrpMiniCompletionPacket;
166 Packet->Key = KeyContext;
167 Packet->Context = ApcContext;
168 Packet->IoStatus.Status = IoStatus;
169 Packet->IoStatus.Information = IoStatusInformation;
170
171 /* Insert the Queue */
172 KeInsertQueue(Queue, &Packet->ListEntry);
173 }
174 else
175 {
176 return STATUS_INSUFFICIENT_RESOURCES;
177 }
178
179 /* Return Success */
180 return STATUS_SUCCESS;
181 }
182
183 /*
184 * @unimplemented
185 */
186 NTSTATUS
187 STDCALL
188 IoSetCompletionRoutineEx(IN PDEVICE_OBJECT DeviceObject,
189 IN PIRP Irp,
190 IN PIO_COMPLETION_ROUTINE CompletionRoutine,
191 IN PVOID Context,
192 IN BOOLEAN InvokeOnSuccess,
193 IN BOOLEAN InvokeOnError,
194 IN BOOLEAN InvokeOnCancel)
195 {
196 UNIMPLEMENTED;
197 return STATUS_NOT_IMPLEMENTED;
198 }
199
200 VOID
201 FASTCALL
202 IopInitIoCompletionImplementation(VOID)
203 {
204 OBJECT_TYPE_INITIALIZER ObjectTypeInitializer;
205 UNICODE_STRING Name;
206
207 DPRINT("Creating IoCompletion Object Type\n");
208
209 /* Initialize the Driver object type */
210 RtlZeroMemory(&ObjectTypeInitializer, sizeof(ObjectTypeInitializer));
211 RtlInitUnicodeString(&Name, L"IoCompletion");
212 ObjectTypeInitializer.Length = sizeof(ObjectTypeInitializer);
213 ObjectTypeInitializer.DefaultNonPagedPoolCharge = sizeof(KQUEUE);
214 ObjectTypeInitializer.PoolType = NonPagedPool;
215 ObjectTypeInitializer.ValidAccessMask = IO_COMPLETION_ALL_ACCESS;
216 ObjectTypeInitializer.UseDefaultObject = TRUE;
217 ObjectTypeInitializer.GenericMapping = IopCompletionMapping;
218 ObjectTypeInitializer.DeleteProcedure = IopDeleteIoCompletion;
219 ObpCreateTypeObject(&ObjectTypeInitializer, &Name, &IoCompletionType);
220 }
221
222 NTSTATUS
223 STDCALL
224 NtCreateIoCompletion(OUT PHANDLE IoCompletionHandle,
225 IN ACCESS_MASK DesiredAccess,
226 IN POBJECT_ATTRIBUTES ObjectAttributes,
227 IN ULONG NumberOfConcurrentThreads)
228 {
229 PKQUEUE Queue;
230 HANDLE hIoCompletionHandle;
231 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
232 NTSTATUS Status = STATUS_SUCCESS;
233
234 PAGED_CODE();
235
236 if (PreviousMode != KernelMode) {
237
238 _SEH_TRY {
239
240 ProbeForWriteHandle(IoCompletionHandle);
241 } _SEH_HANDLE {
242
243 Status = _SEH_GetExceptionCode();
244 } _SEH_END;
245
246 if (!NT_SUCCESS(Status)) {
247
248 return Status;
249 }
250 }
251
252 /* Create the Object */
253 Status = ObCreateObject(PreviousMode,
254 IoCompletionType,
255 ObjectAttributes,
256 PreviousMode,
257 NULL,
258 sizeof(KQUEUE),
259 0,
260 0,
261 (PVOID*)&Queue);
262
263 /* Check for success */
264 if (NT_SUCCESS(Status)) {
265
266 /* Initialize the Queue */
267 KeInitializeQueue(Queue, NumberOfConcurrentThreads);
268
269 /* Insert it */
270 Status = ObInsertObject(Queue,
271 NULL,
272 DesiredAccess,
273 0,
274 NULL,
275 &hIoCompletionHandle);
276 ObDereferenceObject(Queue);
277
278 if (NT_SUCCESS(Status)) {
279
280 _SEH_TRY {
281
282 *IoCompletionHandle = hIoCompletionHandle;
283 } _SEH_HANDLE {
284
285 Status = _SEH_GetExceptionCode();
286 } _SEH_END;
287 }
288 }
289
290 /* Return Status */
291 return Status;
292 }
293
294 NTSTATUS
295 STDCALL
296 NtOpenIoCompletion(OUT PHANDLE IoCompletionHandle,
297 IN ACCESS_MASK DesiredAccess,
298 IN POBJECT_ATTRIBUTES ObjectAttributes)
299 {
300 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
301 HANDLE hIoCompletionHandle;
302 NTSTATUS Status = STATUS_SUCCESS;
303
304 PAGED_CODE();
305
306 if(PreviousMode != KernelMode) {
307
308 _SEH_TRY {
309
310 ProbeForWriteHandle(IoCompletionHandle);
311 } _SEH_HANDLE {
312
313 Status = _SEH_GetExceptionCode();
314 } _SEH_END;
315
316 if(!NT_SUCCESS(Status)) {
317
318 return Status;
319 }
320 }
321
322 /* Open the Object */
323 Status = ObOpenObjectByName(ObjectAttributes,
324 IoCompletionType,
325 NULL,
326 PreviousMode,
327 DesiredAccess,
328 NULL,
329 &hIoCompletionHandle);
330
331 if (NT_SUCCESS(Status)) {
332
333 _SEH_TRY {
334
335 *IoCompletionHandle = hIoCompletionHandle;
336 } _SEH_HANDLE {
337
338 Status = _SEH_GetExceptionCode();
339 } _SEH_END;
340 }
341
342 /* Return Status */
343 return Status;
344 }
345
346
347 NTSTATUS
348 STDCALL
349 NtQueryIoCompletion(IN HANDLE IoCompletionHandle,
350 IN IO_COMPLETION_INFORMATION_CLASS IoCompletionInformationClass,
351 OUT PVOID IoCompletionInformation,
352 IN ULONG IoCompletionInformationLength,
353 OUT PULONG ResultLength OPTIONAL)
354 {
355 PKQUEUE Queue;
356 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
357 NTSTATUS Status = STATUS_SUCCESS;
358
359 PAGED_CODE();
360
361 /* Check buffers and parameters */
362 Status = DefaultQueryInfoBufferCheck(IoCompletionInformationClass,
363 IoCompletionInfoClass,
364 sizeof(IoCompletionInfoClass) / sizeof(IoCompletionInfoClass[0]),
365 IoCompletionInformation,
366 IoCompletionInformationLength,
367 ResultLength,
368 PreviousMode);
369 if(!NT_SUCCESS(Status)) {
370
371 DPRINT1("NtQueryMutant() failed, Status: 0x%x\n", Status);
372 return Status;
373 }
374
375 /* Get the Object */
376 Status = ObReferenceObjectByHandle(IoCompletionHandle,
377 IO_COMPLETION_QUERY_STATE,
378 IoCompletionType,
379 PreviousMode,
380 (PVOID*)&Queue,
381 NULL);
382
383 /* Check for Success */
384 if (NT_SUCCESS(Status)) {
385
386 _SEH_TRY {
387
388 /* Return Info */
389 ((PIO_COMPLETION_BASIC_INFORMATION)IoCompletionInformation)->Depth = KeReadStateQueue(Queue);
390 ObDereferenceObject(Queue);
391
392 /* Return Result Length if needed */
393 if (ResultLength) {
394
395 *ResultLength = sizeof(IO_COMPLETION_BASIC_INFORMATION);
396 }
397 } _SEH_HANDLE {
398
399 Status = _SEH_GetExceptionCode();
400 } _SEH_END;
401 }
402
403 /* Return Status */
404 return Status;
405 }
406
407 /*
408 * Dequeues an I/O completion message from an I/O completion object
409 */
410 NTSTATUS
411 STDCALL
412 NtRemoveIoCompletion(IN HANDLE IoCompletionHandle,
413 OUT PVOID *CompletionKey,
414 OUT PVOID *CompletionContext,
415 OUT PIO_STATUS_BLOCK IoStatusBlock,
416 IN PLARGE_INTEGER Timeout OPTIONAL)
417 {
418 LARGE_INTEGER SafeTimeout;
419 PKQUEUE Queue;
420 PIO_COMPLETION_PACKET Packet;
421 PLIST_ENTRY ListEntry;
422 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
423 NTSTATUS Status = STATUS_SUCCESS;
424
425 PAGED_CODE();
426
427 if (PreviousMode != KernelMode) {
428
429 _SEH_TRY {
430
431 ProbeForWritePointer(CompletionKey);
432 ProbeForWritePointer(CompletionContext);
433 ProbeForWrite(IoStatusBlock,
434 sizeof(IO_STATUS_BLOCK),
435 sizeof(ULONG));
436 if (Timeout != NULL) {
437
438 SafeTimeout = ProbeForReadLargeInteger(Timeout);
439 Timeout = &SafeTimeout;
440 }
441 } _SEH_HANDLE {
442
443 Status = _SEH_GetExceptionCode();
444 } _SEH_END;
445
446 if (!NT_SUCCESS(Status)) {
447
448 return Status;
449 }
450 }
451
452 /* Open the Object */
453 Status = ObReferenceObjectByHandle(IoCompletionHandle,
454 IO_COMPLETION_MODIFY_STATE,
455 IoCompletionType,
456 PreviousMode,
457 (PVOID*)&Queue,
458 NULL);
459
460 /* Check for success */
461 if (NT_SUCCESS(Status)) {
462
463 /* Remove queue */
464 ListEntry = KeRemoveQueue(Queue, PreviousMode, Timeout);
465
466 /* If we got a timeout or user_apc back, return the status */
467 if ((NTSTATUS)ListEntry == STATUS_TIMEOUT || (NTSTATUS)ListEntry == STATUS_USER_APC) {
468
469 Status = (NTSTATUS)ListEntry;
470
471 } else {
472
473 /* Get the Packet Data */
474 Packet = CONTAINING_RECORD(ListEntry, IO_COMPLETION_PACKET, ListEntry);
475
476 _SEH_TRY {
477
478 /* Check if this is piggybacked on an IRP */
479 if (Packet->PacketType == IrpCompletionPacket)
480 {
481 /* Get the IRP */
482 PIRP Irp = NULL;
483 Irp = CONTAINING_RECORD(ListEntry, IRP, Tail.Overlay.ListEntry);
484
485 /* Return values to user */
486 *CompletionKey = Irp->Tail.CompletionKey;
487 *CompletionContext = Irp->Overlay.AsynchronousParameters.UserApcContext;
488 *IoStatusBlock = Packet->IoStatus;
489 IoFreeIrp(Irp);
490 }
491 else
492 {
493 /* This is a user-mode generated or API generated mini-packet */
494 *CompletionKey = Packet->Key;
495 *CompletionContext = Packet->Context;
496 *IoStatusBlock = Packet->IoStatus;
497 IopFreeIoCompletionPacket(Packet);
498 }
499
500 } _SEH_HANDLE {
501
502 Status = _SEH_GetExceptionCode();
503 } _SEH_END;
504 }
505
506 /* Dereference the Object */
507 ObDereferenceObject(Queue);
508 }
509
510 /* Return status */
511 return Status;
512 }
513
514 /*
515 * Queues an I/O completion message to an I/O completion object
516 */
517 NTSTATUS
518 STDCALL
519 NtSetIoCompletion(IN HANDLE IoCompletionPortHandle,
520 IN PVOID CompletionKey,
521 IN PVOID CompletionContext,
522 IN NTSTATUS CompletionStatus,
523 IN ULONG CompletionInformation)
524 {
525 NTSTATUS Status;
526 PKQUEUE Queue;
527
528 PAGED_CODE();
529
530 /* Get the Object */
531 Status = ObReferenceObjectByHandle(IoCompletionPortHandle,
532 IO_COMPLETION_MODIFY_STATE,
533 IoCompletionType,
534 ExGetPreviousMode(),
535 (PVOID*)&Queue,
536 NULL);
537
538 /* Check for Success */
539 if (NT_SUCCESS(Status)) {
540
541 /* Set the Completion */
542 Status = IoSetIoCompletion(Queue,
543 CompletionKey,
544 CompletionContext,
545 CompletionStatus,
546 CompletionInformation,
547 TRUE);
548 ObDereferenceObject(Queue);
549 }
550
551 /* Return status */
552 return Status;
553 }