- use inlined probing macros for basic types
[reactos.git] / reactos / ntoskrnl / ke / apc.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * FILE: ntoskrnl/ke/apc.c
5 * PURPOSE: NT Implementation of APCs
6 *
7 * PROGRAMMERS: Alex Ionescu (alex@relsoft.net)
8 * Phillip Susi
9 */
10
11 /* INCLUDES *****************************************************************/
12
13 #include <ntoskrnl.h>
14 #define NDEBUG
15 #include <internal/debug.h>
16
17 /* FUNCTIONS *****************************************************************/
18
19 /*++
20 * KiKernelApcDeliveryCheck
21 * @implemented NT 5.2
22 *
23 * The KiKernelApcDeliveryCheck routine is called whenever APCs have just
24 * been re-enabled in Kernel Mode, such as after leaving a Critical or
25 * Guarded Region. It delivers APCs if the environment is right.
26 *
27 * Params:
28 * None.
29 *
30 * Returns:
31 * None.
32 *
33 * Remarks:
34 * This routine allows KeLeave/EnterCritical/GuardedRegion to be used as a
35 * macro from inside WIN32K or other Drivers, which will then only have to
36 * do an Import API call in the case where APCs are enabled again.
37 *
38 *--*/
39 VOID
40 STDCALL
41 KiKernelApcDeliveryCheck(VOID)
42 {
43 /* We should only deliver at passive */
44 if (KeGetCurrentIrql() == PASSIVE_LEVEL)
45 {
46 /* Raise to APC and Deliver APCs, then lower back to Passive */
47 KfRaiseIrql(APC_LEVEL);
48 KiDeliverApc(KernelMode, 0, 0);
49 KfLowerIrql(PASSIVE_LEVEL);
50 }
51 else
52 {
53 /*
54 * If we're not at passive level it means someone raised IRQL
55 * to APC level before the a critical or guarded section was entered
56 * (e.g) by a fast mutex). This implies that the APCs shouldn't
57 * be delivered now, but after the IRQL is lowered to passive
58 * level again.
59 */
60 HalRequestSoftwareInterrupt(APC_LEVEL);
61 }
62 }
63
64 /*++
65 * KeEnterCriticalRegion
66 * @implemented NT4
67 *
68 * The KeEnterCriticalRegion routine temporarily disables the delivery of
69 * normal kernel APCs; special kernel-mode APCs are still delivered.
70 *
71 * Params:
72 * None.
73 *
74 * Returns:
75 * None.
76 *
77 * Remarks:
78 * Highest-level drivers can call this routine while running in the context
79 * of the thread that requested the current I/O operation. Any caller of
80 * this routine should call KeLeaveCriticalRegion as quickly as possible.
81 *
82 * Callers of KeEnterCriticalRegion must be running at IRQL <= APC_LEVEL.
83 *
84 *--*/
85 #undef KeEnterCriticalRegion
86 VOID
87 STDCALL
88 KeEnterCriticalRegion(VOID)
89 {
90 /* Disable Kernel APCs */
91 PKTHREAD Thread = KeGetCurrentThread();
92 if (Thread) Thread->KernelApcDisable--;
93 }
94
95 /*++
96 * KeLeaveCriticalRegion
97 * @implemented NT4
98 *
99 * The KeLeaveCriticalRegion routine reenables the delivery of normal
100 * kernel-mode APCs that were disabled by a call to KeEnterCriticalRegion.
101 *
102 * Params:
103 * None.
104 *
105 * Returns:
106 * None.
107 *
108 * Remarks:
109 * Highest-level drivers can call this routine while running in the context
110 * of the thread that requested the current I/O operation.
111 *
112 * Callers of KeLeaveCriticalRegion must be running at IRQL <= DISPATCH_LEVEL.
113 *
114 *--*/
115 #undef KeLeaveCriticalRegion
116 VOID
117 STDCALL
118 KeLeaveCriticalRegion (VOID)
119 {
120 PKTHREAD Thread = KeGetCurrentThread();
121
122 /* Check if Kernel APCs are now enabled */
123 if((Thread) && (++Thread->KernelApcDisable == 0))
124 {
125 /* Check if we need to request an APC Delivery */
126 if (!IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode]))
127 {
128 /* Check for the right environment */
129 KiKernelApcDeliveryCheck();
130 }
131 }
132 }
133
134 /*++
135 * KeInitializeApc
136 * @implemented NT4
137 *
138 * The The KeInitializeApc routine initializes an APC object, and registers
139 * the Kernel, Rundown and Normal routines for that object.
140 *
141 * Params:
142 * Apc - Pointer to a KAPC structure that represents the APC object to
143 * initialize. The caller must allocate storage for the structure
144 * from resident memory.
145 *
146 * Thread - Thread to which to deliver the APC.
147 *
148 * TargetEnvironment - APC Environment to be used.
149 *
150 * KernelRoutine - Points to the KernelRoutine to associate with the APC.
151 * This routine is executed for all APCs.
152 *
153 * RundownRoutine - Points to the RundownRoutine to associate with the APC.
154 * This routine is executed when the Thread exists with
155 * the APC executing.
156 *
157 * NormalRoutine - Points to the NormalRoutine to associate with the APC.
158 * This routine is executed at PASSIVE_LEVEL. If this is
159 * not specifed, the APC becomes a Special APC and the
160 * Mode and Context parameters are ignored.
161 *
162 * Mode - Specifies the processor mode at which to run the Normal Routine.
163 *
164 * Context - Specifices the value to pass as Context parameter to the
165 * registered routines.
166 *
167 * Returns:
168 * None.
169 *
170 * Remarks:
171 * The caller can queue an initialized APC with KeInsertQueueApc.
172 *
173 * Storage for the APC object must be resident, such as nonpaged pool
174 * allocated by the caller.
175 *
176 * Callers of this routine must be running at IRQL = PASSIVE_LEVEL.
177 *
178 *--*/
179 VOID
180 STDCALL
181 KeInitializeApc(IN PKAPC Apc,
182 IN PKTHREAD Thread,
183 IN KAPC_ENVIRONMENT TargetEnvironment,
184 IN PKKERNEL_ROUTINE KernelRoutine,
185 IN PKRUNDOWN_ROUTINE RundownRoutine OPTIONAL,
186 IN PKNORMAL_ROUTINE NormalRoutine,
187 IN KPROCESSOR_MODE Mode,
188 IN PVOID Context)
189 {
190 DPRINT("KeInitializeApc(Apc %x, Thread %x, Environment %d, "
191 "KernelRoutine %x, RundownRoutine %x, NormalRoutine %x, Mode %d, "
192 "Context %x)\n",Apc,Thread,TargetEnvironment,KernelRoutine,RundownRoutine,
193 NormalRoutine,Mode,Context);
194
195 /* Set up the basic APC Structure Data */
196 RtlZeroMemory(Apc, sizeof(KAPC));
197 Apc->Type = ApcObject;
198 Apc->Size = sizeof(KAPC);
199
200 /* Set the Environment */
201 if (TargetEnvironment == CurrentApcEnvironment) {
202
203 Apc->ApcStateIndex = Thread->ApcStateIndex;
204
205 } else {
206
207 Apc->ApcStateIndex = TargetEnvironment;
208 }
209
210 /* Set the Thread and Routines */
211 Apc->Thread = Thread;
212 Apc->KernelRoutine = KernelRoutine;
213 Apc->RundownRoutine = RundownRoutine;
214 Apc->NormalRoutine = NormalRoutine;
215
216 /* Check if this is a Special APC, in which case we use KernelMode and no Context */
217 if (ARGUMENT_PRESENT(NormalRoutine)) {
218
219 Apc->ApcMode = Mode;
220 Apc->NormalContext = Context;
221
222 } else {
223
224 Apc->ApcMode = KernelMode;
225 }
226 }
227
228 /*++
229 * KiInsertQueueApc
230 *
231 * The KiInsertQueueApc routine queues a APC for execution when the right
232 * scheduler environment exists.
233 *
234 * Params:
235 * Apc - Pointer to an initialized control object of type DPC for which the
236 * caller provides the storage.
237 *
238 * PriorityBoost - Priority Boost to apply to the Thread.
239 *
240 * Returns:
241 * If the APC is already inserted or APC queueing is disabled, FALSE.
242 * Otherwise, TRUE.
243 *
244 * Remarks:
245 * The APC will execute at APC_LEVEL for the KernelRoutine registered, and
246 * at PASSIVE_LEVEL for the NormalRoutine registered.
247 *
248 * Callers of this routine must have locked the dipatcher database.
249 *
250 *--*/
251 BOOLEAN
252 STDCALL
253 KiInsertQueueApc(PKAPC Apc,
254 KPRIORITY PriorityBoost)
255 {
256 PKTHREAD Thread = Apc->Thread;
257 PLIST_ENTRY ApcListEntry;
258 PKAPC QueuedApc;
259
260 KeAcquireSpinLockAtDpcLevel(&Thread->ApcQueueLock);
261
262 /* Don't do anything if the APC is already inserted */
263 if (Apc->Inserted) {
264
265 KeReleaseSpinLockFromDpcLevel(&Thread->ApcQueueLock);
266 return FALSE;
267 }
268
269 /* Three scenarios:
270 1) Kernel APC with Normal Routine or User APC = Put it at the end of the List
271 2) User APC which is PsExitSpecialApc = Put it at the front of the List
272 3) Kernel APC without Normal Routine = Put it at the end of the No-Normal Routine Kernel APC list
273 */
274 if ((Apc->ApcMode != KernelMode) && (Apc->KernelRoutine == (PKKERNEL_ROUTINE)PsExitSpecialApc)) {
275
276 DPRINT1("Inserting the Thread Exit APC for '%.16s' into the Queue\n", ((PETHREAD)Thread)->ThreadsProcess->ImageFileName);
277 Thread->ApcStatePointer[(int)Apc->ApcStateIndex]->UserApcPending = TRUE;
278 InsertHeadList(&Thread->ApcStatePointer[(int)Apc->ApcStateIndex]->ApcListHead[(int)Apc->ApcMode],
279 &Apc->ApcListEntry);
280
281 } else if (Apc->NormalRoutine == NULL) {
282
283 DPRINT("Inserting Special APC %x for '%.16s' into the Queue\n", Apc, ((PETHREAD)Thread)->ThreadsProcess->ImageFileName);
284
285 for (ApcListEntry = Thread->ApcStatePointer[(int)Apc->ApcStateIndex]->ApcListHead[(int)Apc->ApcMode].Flink;
286 ApcListEntry != &Thread->ApcStatePointer[(int)Apc->ApcStateIndex]->ApcListHead[(int)Apc->ApcMode];
287 ApcListEntry = ApcListEntry->Flink) {
288
289 QueuedApc = CONTAINING_RECORD(ApcListEntry, KAPC, ApcListEntry);
290 if (Apc->NormalRoutine != NULL) break;
291 }
292
293 /* We found the first "Normal" APC, so write right before it */
294 ApcListEntry = ApcListEntry->Blink;
295 InsertHeadList(ApcListEntry, &Apc->ApcListEntry);
296
297 } else {
298
299 DPRINT("Inserting Normal APC %x for '%.16s' into the %x Queue\n", Apc, ((PETHREAD)Thread)->ThreadsProcess->ImageFileName, Apc->ApcMode);
300 InsertTailList(&Thread->ApcStatePointer[(int)Apc->ApcStateIndex]->ApcListHead[(int)Apc->ApcMode],
301 &Apc->ApcListEntry);
302 }
303
304 /* Confirm Insertion */
305 Apc->Inserted = TRUE;
306
307 KeReleaseSpinLockFromDpcLevel(&Thread->ApcQueueLock);
308
309 /*
310 * Three possibilites here again:
311 * 1) Kernel APC, The thread is Running: Request an Interrupt
312 * 2) Kernel APC, The Thread is Waiting at PASSIVE_LEVEL and APCs are enabled and not in progress: Unwait the Thread
313 * 3) User APC, Unwait the Thread if it is alertable
314 */
315 if (Apc->ApcMode == KernelMode) {
316
317 /* Set Kernel APC pending */
318 Thread->ApcState.KernelApcPending = TRUE;
319
320 /* Check the Thread State */
321 if (Thread->State == Running) {
322
323 #ifdef CONFIG_SMP
324 PKPRCB Prcb, CurrentPrcb;
325 LONG i;
326 #endif
327
328 DPRINT ("Requesting APC Interrupt for Running Thread \n");
329
330 #ifdef CONFIG_SMP
331 CurrentPrcb = KeGetCurrentPrcb();
332 if (CurrentPrcb->CurrentThread == Thread)
333 {
334 HalRequestSoftwareInterrupt(APC_LEVEL);
335 }
336 else
337 {
338 for (i = 0; i < KeNumberProcessors; i++)
339 {
340 Prcb = ((PKPCR)(KPCR_BASE + i * PAGE_SIZE))->Prcb;
341 if (Prcb->CurrentThread == Thread)
342 {
343 ASSERT (CurrentPrcb != Prcb);
344 KiIpiSendRequest(Prcb->SetMember, IPI_REQUEST_APC);
345 break;
346 }
347 }
348 ASSERT (i < KeNumberProcessors);
349 }
350 #else
351 HalRequestSoftwareInterrupt(APC_LEVEL);
352 #endif
353
354 } else if ((Thread->State == Waiting) && (Thread->WaitIrql == PASSIVE_LEVEL) &&
355 ((Apc->NormalRoutine == NULL) ||
356 ((!Thread->KernelApcDisable) && (!Thread->ApcState.KernelApcInProgress)))) {
357
358 DPRINT("Waking up Thread for Kernel-Mode APC Delivery \n");
359 KiAbortWaitThread(Thread, STATUS_KERNEL_APC, PriorityBoost);
360 }
361
362 } else if ((Thread->State == Waiting) &&
363 (Thread->WaitMode != KernelMode) &&
364 (Thread->Alertable)) {
365
366 DPRINT("Waking up Thread for User-Mode APC Delivery \n");
367 Thread->ApcState.UserApcPending = TRUE;
368 KiAbortWaitThread(Thread, STATUS_USER_APC, PriorityBoost);
369 }
370
371 return TRUE;
372 }
373
374 /*++
375 * KeInsertQueueApc
376 * @implemented NT4
377 *
378 * The KeInsertQueueApc routine queues a APC for execution when the right
379 * scheduler environment exists.
380 *
381 * Params:
382 * Apc - Pointer to an initialized control object of type DPC for which the
383 * caller provides the storage.
384 *
385 * SystemArgument[1,2] - Pointer to a set of two parameters that contain
386 * untyped data.
387 *
388 * PriorityBoost - Priority Boost to apply to the Thread.
389 *
390 * Returns:
391 * If the APC is already inserted or APC queueing is disabled, FALSE.
392 * Otherwise, TRUE.
393 *
394 * Remarks:
395 * The APC will execute at APC_LEVEL for the KernelRoutine registered, and
396 * at PASSIVE_LEVEL for the NormalRoutine registered.
397 *
398 * Callers of this routine must be running at IRQL = PASSIVE_LEVEL.
399 *
400 *--*/
401 BOOLEAN
402 STDCALL
403 KeInsertQueueApc(PKAPC Apc,
404 PVOID SystemArgument1,
405 PVOID SystemArgument2,
406 KPRIORITY PriorityBoost)
407
408 {
409 KIRQL OldIrql;
410 PKTHREAD Thread;
411 BOOLEAN Inserted;
412
413 ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
414 DPRINT("KeInsertQueueApc(Apc %x, SystemArgument1 %x, "
415 "SystemArgument2 %x)\n",Apc,SystemArgument1,
416 SystemArgument2);
417
418 /* Lock the Dispatcher Database */
419 OldIrql = KeAcquireDispatcherDatabaseLock();
420
421 /* Get the Thread specified in the APC */
422 Thread = Apc->Thread;
423
424 /* Make sure the thread allows APC Queues.
425 * The thread is not apc queueable, for instance, when it's (about to be) terminated.
426 */
427 if (Thread->ApcQueueable == FALSE) {
428 DPRINT("Thread doesn't allow APC Queues\n");
429 KeReleaseDispatcherDatabaseLock(OldIrql);
430 return FALSE;
431 }
432
433 /* Set the System Arguments */
434 Apc->SystemArgument1 = SystemArgument1;
435 Apc->SystemArgument2 = SystemArgument2;
436
437 /* Call the Internal Function */
438 Inserted = KiInsertQueueApc(Apc, PriorityBoost);
439
440 /* Return Sucess if we are here */
441 KeReleaseDispatcherDatabaseLock(OldIrql);
442 return Inserted;
443 }
444
445 /*++
446 * KeFlushQueueApc
447 *
448 * The KeFlushQueueApc routine flushes all APCs of the given processor mode
449 * from the specified Thread's APC queue.
450 *
451 * Params:
452 * Thread - Pointer to the thread whose APC queue will be flushed.
453 *
454 * PreviousMode - Specifies which APC Queue to flush.
455 *
456 * Returns:
457 * A pointer to the first entry in the flushed APC queue.
458 *
459 * Remarks:
460 * If the routine returns NULL, it means that no APCs were to be flushed.
461 *
462 * Callers of KeFlushQueueApc must be running at DISPATCH_LEVEL or lower.
463 *
464 *--*/
465 PLIST_ENTRY
466 STDCALL
467 KeFlushQueueApc(IN PKTHREAD Thread,
468 IN KPROCESSOR_MODE PreviousMode)
469 {
470 KIRQL OldIrql;
471 PKAPC Apc;
472 PLIST_ENTRY FirstEntry, CurrentEntry;
473
474 /* Lock the Dispatcher Database and APC Queue */
475 OldIrql = KeAcquireDispatcherDatabaseLock();
476 KeAcquireSpinLockAtDpcLevel(&Thread->ApcQueueLock);
477
478 if (IsListEmpty(&Thread->ApcState.ApcListHead[PreviousMode])) {
479 FirstEntry = NULL;
480 } else {
481 FirstEntry = Thread->ApcState.ApcListHead[PreviousMode].Flink;
482 RemoveEntryList(&Thread->ApcState.ApcListHead[PreviousMode]);
483 CurrentEntry = FirstEntry;
484 do {
485 Apc = CONTAINING_RECORD(CurrentEntry, KAPC, ApcListEntry);
486 Apc->Inserted = FALSE;
487 CurrentEntry = CurrentEntry->Flink;
488 } while (CurrentEntry != FirstEntry);
489 }
490
491 /* Release the locks */
492 KeReleaseSpinLockFromDpcLevel(&Thread->ApcQueueLock);
493 KeReleaseDispatcherDatabaseLock(OldIrql);
494
495 /* Return the first entry */
496 return FirstEntry;
497 }
498
499 /*++
500 * KeRemoveQueueApc
501 *
502 * The KeRemoveQueueApc routine removes a given APC object from the system
503 * APC queue.
504 *
505 * Params:
506 * APC - Pointer to an initialized APC object that was queued by calling
507 * KeInsertQueueApc.
508 *
509 * Returns:
510 * TRUE if the APC Object is in the APC Queue. If it isn't, no operation is
511 * performed and FALSE is returned.
512 *
513 * Remarks:
514 * If the given APC Object is currently queued, it is removed from the queue
515 * and any calls to the registered routines are cancelled.
516 *
517 * Callers of KeLeaveCriticalRegion can be running at any IRQL.
518 *
519 *--*/
520 BOOLEAN
521 STDCALL
522 KeRemoveQueueApc(PKAPC Apc)
523 {
524 KIRQL OldIrql;
525 PKTHREAD Thread = Apc->Thread;
526
527 ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
528 DPRINT("KeRemoveQueueApc called for APC: %x \n", Apc);
529
530 OldIrql = KeAcquireDispatcherDatabaseLock();
531 KeAcquireSpinLockAtDpcLevel(&Thread->ApcQueueLock);
532
533 /* Check if it's inserted */
534 if (Apc->Inserted) {
535
536 /* Remove it from the Queue*/
537 RemoveEntryList(&Apc->ApcListEntry);
538 Apc->Inserted = FALSE;
539
540 /* If the Queue is completely empty, then no more APCs are pending */
541 if (IsListEmpty(&Thread->ApcStatePointer[(int)Apc->ApcStateIndex]->ApcListHead[(int)Apc->ApcMode])) {
542
543 /* Set the correct State based on the Apc Mode */
544 if (Apc->ApcMode == KernelMode) {
545
546 Thread->ApcStatePointer[(int)Apc->ApcStateIndex]->KernelApcPending = FALSE;
547
548 } else {
549
550 Thread->ApcStatePointer[(int)Apc->ApcStateIndex]->UserApcPending = FALSE;
551 }
552 }
553
554 } else {
555
556 /* It's not inserted, fail */
557 KeReleaseSpinLockFromDpcLevel(&Thread->ApcQueueLock);
558 KeReleaseDispatcherDatabaseLock(OldIrql);
559 return(FALSE);
560 }
561
562 /* Restore IRQL and Return */
563 KeReleaseSpinLockFromDpcLevel(&Thread->ApcQueueLock);
564 KeReleaseDispatcherDatabaseLock(OldIrql);
565 return(TRUE);
566 }
567
568 /*++
569 * KiDeliverApc
570 * @implemented @NT4
571 *
572 * The KiDeliverApc routine is called from IRQL switching code if the
573 * thread is returning from an IRQL >= APC_LEVEL and Kernel-Mode APCs are
574 * pending.
575 *
576 * Params:
577 * DeliveryMode - Specifies the current processor mode.
578 *
579 * Reserved - Pointer to the Exception Frame on non-i386 builds.
580 *
581 * TrapFrame - Pointer to the Trap Frame.
582 *
583 * Returns:
584 * None.
585 *
586 * Remarks:
587 * First, Special APCs are delivered, followed by Kernel-Mode APCs and
588 * User-Mode APCs. Note that the TrapFrame is only valid if the previous
589 * mode is User.
590 *
591 * Upon entry, this routine executes at APC_LEVEL.
592 *
593 *--*/
594 VOID
595 STDCALL
596 KiDeliverApc(KPROCESSOR_MODE DeliveryMode,
597 PVOID Reserved,
598 PKTRAP_FRAME TrapFrame)
599 {
600 PKTHREAD Thread = KeGetCurrentThread();
601 PLIST_ENTRY ApcListEntry;
602 PKAPC Apc;
603 KIRQL OldIrql;
604 PKKERNEL_ROUTINE KernelRoutine;
605 PVOID NormalContext;
606 PKNORMAL_ROUTINE NormalRoutine;
607 PVOID SystemArgument1;
608 PVOID SystemArgument2;
609
610 ASSERT_IRQL_EQUAL(APC_LEVEL);
611
612 /* Lock the APC Queue and Raise IRQL to Synch */
613 KeAcquireSpinLock(&Thread->ApcQueueLock, &OldIrql);
614
615 /* Clear APC Pending */
616 Thread->ApcState.KernelApcPending = FALSE;
617
618 /* Do the Kernel APCs first */
619 while (!IsListEmpty(&Thread->ApcState.ApcListHead[KernelMode])) {
620
621 /* Get the next Entry */
622 ApcListEntry = Thread->ApcState.ApcListHead[KernelMode].Flink;
623 Apc = CONTAINING_RECORD(ApcListEntry, KAPC, ApcListEntry);
624
625 /* Save Parameters so that it's safe to free the Object in Kernel Routine*/
626 NormalRoutine = Apc->NormalRoutine;
627 KernelRoutine = Apc->KernelRoutine;
628 NormalContext = Apc->NormalContext;
629 SystemArgument1 = Apc->SystemArgument1;
630 SystemArgument2 = Apc->SystemArgument2;
631
632 /* Special APC */
633 if (NormalRoutine == NULL) {
634
635 /* Remove the APC from the list */
636 RemoveEntryList(ApcListEntry);
637 Apc->Inserted = FALSE;
638
639 /* Go back to APC_LEVEL */
640 KeReleaseSpinLock(&Thread->ApcQueueLock, OldIrql);
641
642 /* Call the Special APC */
643 DPRINT("Delivering a Special APC: %x\n", Apc);
644 KernelRoutine(Apc,
645 &NormalRoutine,
646 &NormalContext,
647 &SystemArgument1,
648 &SystemArgument2);
649
650 /* Raise IRQL and Lock again */
651 KeAcquireSpinLock(&Thread->ApcQueueLock, &OldIrql);
652
653 } else {
654
655 /* Normal Kernel APC */
656 if (Thread->ApcState.KernelApcInProgress || Thread->KernelApcDisable) {
657
658 /*
659 * DeliveryMode must be KernelMode in this case, since one may not
660 * return to umode while being inside a critical section or while
661 * a regular kmode apc is running (the latter should be impossible btw).
662 * -Gunnar
663 */
664 ASSERT(DeliveryMode == KernelMode);
665
666 KeReleaseSpinLock(&Thread->ApcQueueLock, OldIrql);
667 return;
668 }
669
670 /* Dequeue the APC */
671 RemoveEntryList(ApcListEntry);
672 Apc->Inserted = FALSE;
673
674 /* Go back to APC_LEVEL */
675 KeReleaseSpinLock(&Thread->ApcQueueLock, OldIrql);
676
677 /* Call the Kernel APC */
678 DPRINT("Delivering a Normal APC: %x\n", Apc);
679 KernelRoutine(Apc,
680 &NormalRoutine,
681 &NormalContext,
682 &SystemArgument1,
683 &SystemArgument2);
684
685 /* If There still is a Normal Routine, then we need to call this at PASSIVE_LEVEL */
686 if (NormalRoutine != NULL) {
687
688 /* At Passive Level, this APC can be prempted by a Special APC */
689 Thread->ApcState.KernelApcInProgress = TRUE;
690 KeLowerIrql(PASSIVE_LEVEL);
691
692 /* Call and Raise IRQ back to APC_LEVEL */
693 DPRINT("Calling the Normal Routine for a Normal APC: %x\n", Apc);
694 NormalRoutine(NormalContext, SystemArgument1, SystemArgument2);
695 KeRaiseIrql(APC_LEVEL, &OldIrql);
696 }
697
698 /* Raise IRQL and Lock again */
699 KeAcquireSpinLock(&Thread->ApcQueueLock, &OldIrql);
700 Thread->ApcState.KernelApcInProgress = FALSE;
701 }
702 }
703
704 /* Now we do the User APCs */
705 if ((!IsListEmpty(&Thread->ApcState.ApcListHead[UserMode])) &&
706 (DeliveryMode != KernelMode) && (Thread->ApcState.UserApcPending == TRUE)) {
707
708 /* It's not pending anymore */
709 Thread->ApcState.UserApcPending = FALSE;
710
711 /* Get the APC Object */
712 ApcListEntry = Thread->ApcState.ApcListHead[UserMode].Flink;
713 Apc = CONTAINING_RECORD(ApcListEntry, KAPC, ApcListEntry);
714
715 /* Save Parameters so that it's safe to free the Object in Kernel Routine*/
716 NormalRoutine = Apc->NormalRoutine;
717 KernelRoutine = Apc->KernelRoutine;
718 NormalContext = Apc->NormalContext;
719 SystemArgument1 = Apc->SystemArgument1;
720 SystemArgument2 = Apc->SystemArgument2;
721
722 /* Remove the APC from Queue, restore IRQL and call the APC */
723 RemoveEntryList(ApcListEntry);
724 Apc->Inserted = FALSE;
725 KeReleaseSpinLock(&Thread->ApcQueueLock, OldIrql);
726
727 DPRINT("Calling the Kernel Routine for for a User APC: %x\n", Apc);
728 KernelRoutine(Apc,
729 &NormalRoutine,
730 &NormalContext,
731 &SystemArgument1,
732 &SystemArgument2);
733
734 if (NormalRoutine == NULL) {
735
736 /* Check if more User APCs are Pending */
737 KeTestAlertThread(UserMode);
738
739 } else {
740
741 /* Set up the Trap Frame and prepare for Execution in NTDLL.DLL */
742 DPRINT("Delivering a User APC: %x\n", Apc);
743 KiInitializeUserApc(Reserved,
744 TrapFrame,
745 NormalRoutine,
746 NormalContext,
747 SystemArgument1,
748 SystemArgument2);
749 }
750
751 } else {
752
753 /* Go back to APC_LEVEL */
754 KeReleaseSpinLock(&Thread->ApcQueueLock, OldIrql);
755 }
756 }
757
758 VOID
759 STDCALL
760 KiFreeApcRoutine(PKAPC Apc,
761 PKNORMAL_ROUTINE* NormalRoutine,
762 PVOID* NormalContext,
763 PVOID* SystemArgument1,
764 PVOID* SystemArgument2)
765 {
766 /* Free the APC and do nothing else */
767 ExFreePool(Apc);
768 }
769
770 /*++
771 * KiInitializeUserApc
772 *
773 * Prepares the Context for a User-Mode APC called through NTDLL.DLL
774 *
775 * Params:
776 * Reserved - Pointer to the Exception Frame on non-i386 builds.
777 *
778 * TrapFrame - Pointer to the Trap Frame.
779 *
780 * NormalRoutine - Pointer to the NormalRoutine to call.
781 *
782 * NormalContext - Pointer to the context to send to the Normal Routine.
783 *
784 * SystemArgument[1-2] - Pointer to a set of two parameters that contain
785 * untyped data.
786 *
787 * Returns:
788 * None.
789 *
790 * Remarks:
791 * None.
792 *
793 *--*/
794 VOID
795 STDCALL
796 KiInitializeUserApc(IN PVOID Reserved,
797 IN PKTRAP_FRAME TrapFrame,
798 IN PKNORMAL_ROUTINE NormalRoutine,
799 IN PVOID NormalContext,
800 IN PVOID SystemArgument1,
801 IN PVOID SystemArgument2)
802 {
803 PCONTEXT Context;
804 PULONG Esp;
805
806 DPRINT("KiInitializeUserApc(TrapFrame %x/%x)\n", TrapFrame, KeGetCurrentThread()->TrapFrame);
807
808 /*
809 * Save the thread's current context (in other words the registers
810 * that will be restored when it returns to user mode) so the
811 * APC dispatcher can restore them later
812 */
813 Context = (PCONTEXT)(((PUCHAR)TrapFrame->Esp) - sizeof(CONTEXT));
814 RtlZeroMemory(Context, sizeof(CONTEXT));
815 Context->ContextFlags = CONTEXT_FULL;
816 Context->SegGs = TrapFrame->Gs;
817 Context->SegFs = TrapFrame->Fs;
818 Context->SegEs = TrapFrame->Es;
819 Context->SegDs = TrapFrame->Ds;
820 Context->Edi = TrapFrame->Edi;
821 Context->Esi = TrapFrame->Esi;
822 Context->Ebx = TrapFrame->Ebx;
823 Context->Edx = TrapFrame->Edx;
824 Context->Ecx = TrapFrame->Ecx;
825 Context->Eax = TrapFrame->Eax;
826 Context->Ebp = TrapFrame->Ebp;
827 Context->Eip = TrapFrame->Eip;
828 Context->SegCs = TrapFrame->Cs;
829 Context->EFlags = TrapFrame->Eflags;
830 Context->Esp = TrapFrame->Esp;
831 Context->SegSs = TrapFrame->Ss;
832
833 /*
834 * Setup the trap frame so the thread will start executing at the
835 * APC Dispatcher when it returns to user-mode
836 */
837 Esp = (PULONG)(((PUCHAR)TrapFrame->Esp) - (sizeof(CONTEXT) + (6 * sizeof(ULONG))));
838 Esp[0] = 0xdeadbeef;
839 Esp[1] = (ULONG)NormalRoutine;
840 Esp[2] = (ULONG)NormalContext;
841 Esp[3] = (ULONG)SystemArgument1;
842 Esp[4] = (ULONG)SystemArgument2;
843 Esp[5] = (ULONG)Context;
844 TrapFrame->Eip = (ULONG)KeUserApcDispatcher;
845 DPRINT("TrapFrame->Eip: %x\n", TrapFrame->Eip);
846 TrapFrame->Esp = (ULONG)Esp;
847 }
848
849 /*++
850 * KeAreApcsDisabled
851 * @implemented NT4
852 *
853 * Prepares the Context for a User-Mode APC called through NTDLL.DLL
854 *
855 * Params:
856 * None.
857 *
858 * Returns:
859 * KeAreApcsDisabled returns TRUE if the thread is within a critical region
860 * or a guarded region, and FALSE otherwise.
861 *
862 * Remarks:
863 * A thread running at IRQL = PASSIVE_LEVEL can use KeAreApcsDisabled to
864 * determine if normal kernel APCs are disabled. A thread that is inside a
865 * critical region has both user APCs and normal kernel APCs disabled, but
866 * not special kernel APCs. A thread that is inside a guarded region has
867 * all APCs disabled, including special kernel APCs.
868 *
869 * Callers of this routine must be running at IRQL <= APC_LEVEL.
870 *
871 *--*/
872 BOOLEAN
873 STDCALL
874 KeAreApcsDisabled(VOID)
875 {
876 /* Return the Kernel APC State */
877 return KeGetCurrentThread()->KernelApcDisable ? TRUE : FALSE;
878 }
879
880 /*++
881 * NtQueueApcThread
882 * NT4
883 *
884 * This routine is used to queue an APC from user-mode for the specified
885 * thread.
886 *
887 * Params:
888 * Thread Handle - Handle to the Thread. This handle must have THREAD_SET_CONTEXT privileges.
889 *
890 * ApcRoutine - Pointer to the APC Routine to call when the APC executes.
891 *
892 * NormalContext - Pointer to the context to send to the Normal Routine.
893 *
894 * SystemArgument[1-2] - Pointer to a set of two parameters that contain
895 * untyped data.
896 *
897 * Returns:
898 * STATUS_SUCCESS or failure cute from associated calls.
899 *
900 * Remarks:
901 * The thread must enter an alertable wait before the APC will be
902 * delivered.
903 *
904 *--*/
905 NTSTATUS
906 STDCALL
907 NtQueueApcThread(HANDLE ThreadHandle,
908 PKNORMAL_ROUTINE ApcRoutine,
909 PVOID NormalContext,
910 PVOID SystemArgument1,
911 PVOID SystemArgument2)
912 {
913 PKAPC Apc;
914 PETHREAD Thread;
915 KPROCESSOR_MODE PreviousMode = ExGetPreviousMode();
916 NTSTATUS Status;
917
918 /* Get ETHREAD from Handle */
919 Status = ObReferenceObjectByHandle(ThreadHandle,
920 THREAD_SET_CONTEXT,
921 PsThreadType,
922 PreviousMode,
923 (PVOID)&Thread,
924 NULL);
925
926 /* Fail if the Handle is invalid for some reason */
927 if (!NT_SUCCESS(Status)) {
928
929 return(Status);
930 }
931
932 /* If this is a Kernel or System Thread, then fail */
933 if (Thread->Tcb.Teb == NULL) {
934
935 ObDereferenceObject(Thread);
936 return STATUS_INVALID_HANDLE;
937 }
938
939 /* Allocate an APC */
940 Apc = ExAllocatePoolWithTag(NonPagedPool, sizeof(KAPC), TAG('P', 's', 'a', 'p'));
941 if (Apc == NULL) {
942
943 ObDereferenceObject(Thread);
944 return(STATUS_NO_MEMORY);
945 }
946
947 /* Initialize and Queue a user mode apc (always!) */
948 KeInitializeApc(Apc,
949 &Thread->Tcb,
950 OriginalApcEnvironment,
951 KiFreeApcRoutine,
952 NULL,
953 ApcRoutine,
954 UserMode,
955 NormalContext);
956
957 if (!KeInsertQueueApc(Apc, SystemArgument1, SystemArgument2, IO_NO_INCREMENT)) {
958
959 Status = STATUS_UNSUCCESSFUL;
960
961 } else {
962
963 Status = STATUS_SUCCESS;
964 }
965
966 /* Dereference Thread and Return */
967 ObDereferenceObject(Thread);
968 return Status;
969 }
970
971 static inline
972 VOID RepairList(PLIST_ENTRY Original,
973 PLIST_ENTRY Copy,
974 KPROCESSOR_MODE Mode)
975 {
976 /* Copy Source to Desination */
977 if (IsListEmpty(&Original[(int)Mode])) {
978
979 InitializeListHead(&Copy[(int)Mode]);
980
981 } else {
982
983 Copy[(int)Mode].Flink = Original[(int)Mode].Flink;
984 Copy[(int)Mode].Blink = Original[(int)Mode].Blink;
985 Original[(int)Mode].Flink->Blink = &Copy[(int)Mode];
986 Original[(int)Mode].Blink->Flink = &Copy[(int)Mode];
987 }
988 }
989
990 VOID
991 STDCALL
992 KiMoveApcState(PKAPC_STATE OldState,
993 PKAPC_STATE NewState)
994 {
995 /* Restore backup of Original Environment */
996 *NewState = *OldState;
997
998 /* Repair Lists */
999 RepairList(NewState->ApcListHead, OldState->ApcListHead, KernelMode);
1000 RepairList(NewState->ApcListHead, OldState->ApcListHead, UserMode);
1001 }
1002