[NTOS:MM] Quick fix: use SIZE_T instead of ULONG, because ULONG is 32-bit and on...
[reactos.git] / ntoskrnl / ke / dpc.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/ke/dpc.c
5 * PURPOSE: Deferred Procedure Call (DPC) Support
6 * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
7 * Philip Susi (phreak@iag.net)
8 * Eric Kohl
9 */
10
11 /* INCLUDES ******************************************************************/
12
13 #include <ntoskrnl.h>
14 #define NDEBUG
15 #include <debug.h>
16
17 /* GLOBALS *******************************************************************/
18
19 ULONG KiMaximumDpcQueueDepth = 4;
20 ULONG KiMinimumDpcRate = 3;
21 ULONG KiAdjustDpcThreshold = 20;
22 ULONG KiIdealDpcRate = 20;
23 BOOLEAN KeThreadDpcEnable;
24 FAST_MUTEX KiGenericCallDpcMutex;
25 KDPC KiTimerExpireDpc;
26 ULONG KiTimeLimitIsrMicroseconds;
27 ULONG KiDPCTimeout = 110;
28
29 /* PRIVATE FUNCTIONS *********************************************************/
30
31 VOID
32 NTAPI
33 KiCheckTimerTable(IN ULARGE_INTEGER CurrentTime)
34 {
35 #if DBG
36 ULONG i = 0;
37 PLIST_ENTRY ListHead, NextEntry;
38 KIRQL OldIrql;
39 PKTIMER Timer;
40
41 /* Raise IRQL to high and loop timers */
42 KeRaiseIrql(HIGH_LEVEL, &OldIrql);
43 do
44 {
45 /* Loop the current list */
46 ListHead = &KiTimerTableListHead[i].Entry;
47 NextEntry = ListHead->Flink;
48 while (NextEntry != ListHead)
49 {
50 /* Get the timer and move to the next one */
51 Timer = CONTAINING_RECORD(NextEntry, KTIMER, TimerListEntry);
52 NextEntry = NextEntry->Flink;
53
54 /* Check if it expired */
55 if (Timer->DueTime.QuadPart <= CurrentTime.QuadPart)
56 {
57 /* Check if the DPC was queued, but didn't run */
58 if (!(KeGetCurrentPrcb()->TimerRequest) &&
59 !(*((volatile PULONG*)(&KiTimerExpireDpc.DpcData))))
60 {
61 /* This is bad, breakpoint! */
62 DPRINT1("Invalid timer state!\n");
63 DbgBreakPoint();
64 }
65 }
66 }
67
68 /* Move to the next timer */
69 i++;
70 } while(i < TIMER_TABLE_SIZE);
71
72 /* Lower IRQL and return */
73 KeLowerIrql(OldIrql);
74 #endif
75 }
76
77 VOID
78 NTAPI
79 KiTimerExpiration(IN PKDPC Dpc,
80 IN PVOID DeferredContext,
81 IN PVOID SystemArgument1,
82 IN PVOID SystemArgument2)
83 {
84 ULARGE_INTEGER SystemTime, InterruptTime;
85 LARGE_INTEGER Interval;
86 LONG Limit, Index, i;
87 ULONG Timers, ActiveTimers, DpcCalls;
88 PLIST_ENTRY ListHead, NextEntry;
89 KIRQL OldIrql;
90 PKTIMER Timer;
91 PKDPC TimerDpc;
92 ULONG Period;
93 DPC_QUEUE_ENTRY DpcEntry[MAX_TIMER_DPCS];
94 PKSPIN_LOCK_QUEUE LockQueue;
95 PKPRCB Prcb = KeGetCurrentPrcb();
96
97 /* Disable interrupts */
98 _disable();
99
100 /* Query system and interrupt time */
101 KeQuerySystemTime((PLARGE_INTEGER)&SystemTime);
102 InterruptTime.QuadPart = KeQueryInterruptTime();
103 Limit = KeTickCount.LowPart;
104
105 /* Bring interrupts back */
106 _enable();
107
108 /* Get the index of the timer and normalize it */
109 Index = PtrToLong(SystemArgument1);
110 if ((Limit - Index) >= TIMER_TABLE_SIZE)
111 {
112 /* Normalize it */
113 Limit = Index + TIMER_TABLE_SIZE - 1;
114 }
115
116 /* Setup index and actual limit */
117 Index--;
118 Limit &= (TIMER_TABLE_SIZE - 1);
119
120 /* Setup accounting data */
121 DpcCalls = 0;
122 Timers = 24;
123 ActiveTimers = 4;
124
125 /* Lock the Database and Raise IRQL */
126 OldIrql = KiAcquireDispatcherLock();
127
128 /* Start expiration loop */
129 do
130 {
131 /* Get the current index */
132 Index = (Index + 1) & (TIMER_TABLE_SIZE - 1);
133
134 /* Get list pointers and loop the list */
135 ListHead = &KiTimerTableListHead[Index].Entry;
136 while (ListHead != ListHead->Flink)
137 {
138 /* Lock the timer and go to the next entry */
139 LockQueue = KiAcquireTimerLock(Index);
140 NextEntry = ListHead->Flink;
141
142 /* Get the current timer and check its due time */
143 Timers--;
144 Timer = CONTAINING_RECORD(NextEntry, KTIMER, TimerListEntry);
145 if ((NextEntry != ListHead) &&
146 (Timer->DueTime.QuadPart <= InterruptTime.QuadPart))
147 {
148 /* It's expired, remove it */
149 ActiveTimers--;
150 KiRemoveEntryTimer(Timer);
151
152 /* Make it non-inserted, unlock it, and signal it */
153 Timer->Header.Inserted = FALSE;
154 KiReleaseTimerLock(LockQueue);
155 Timer->Header.SignalState = 1;
156
157 /* Get the DPC and period */
158 TimerDpc = Timer->Dpc;
159 Period = Timer->Period;
160
161 /* Check if there's any waiters */
162 if (!IsListEmpty(&Timer->Header.WaitListHead))
163 {
164 /* Check the type of event */
165 if (Timer->Header.Type == TimerNotificationObject)
166 {
167 /* Unwait the thread */
168 KxUnwaitThread(&Timer->Header, IO_NO_INCREMENT);
169 }
170 else
171 {
172 /* Otherwise unwait the thread and signal the timer */
173 KxUnwaitThreadForEvent((PKEVENT)Timer, IO_NO_INCREMENT);
174 }
175 }
176
177 /* Check if we have a period */
178 if (Period)
179 {
180 /* Calculate the interval and insert the timer */
181 Interval.QuadPart = Int32x32To64(Period, -10000);
182 while (!KiInsertTreeTimer(Timer, Interval));
183 }
184
185 /* Check if we have a DPC */
186 if (TimerDpc)
187 {
188 #ifdef CONFIG_SMP
189 /*
190 * If the DPC is targeted to another processor,
191 * then insert it into that processor's DPC queue
192 * instead of delivering it now.
193 * If the DPC is a threaded DPC, and the current CPU
194 * has threaded DPCs enabled (KiExecuteDpc is actively parsing DPCs),
195 * then also insert it into the DPC queue for threaded delivery,
196 * instead of doing it here.
197 */
198 if (((TimerDpc->Number >= MAXIMUM_PROCESSORS) &&
199 ((TimerDpc->Number - MAXIMUM_PROCESSORS) != Prcb->Number)) ||
200 ((TimerDpc->Type == ThreadedDpcObject) && (Prcb->ThreadDpcEnable)))
201 {
202 /* Queue it */
203 KeInsertQueueDpc(TimerDpc,
204 UlongToPtr(SystemTime.LowPart),
205 UlongToPtr(SystemTime.HighPart));
206 }
207 else
208 #endif
209 {
210 /* Setup the DPC Entry */
211 DpcEntry[DpcCalls].Dpc = TimerDpc;
212 DpcEntry[DpcCalls].Routine = TimerDpc->DeferredRoutine;
213 DpcEntry[DpcCalls].Context = TimerDpc->DeferredContext;
214 DpcCalls++;
215 ASSERT(DpcCalls < MAX_TIMER_DPCS);
216 }
217 }
218
219 /* Check if we're done processing */
220 if (!(ActiveTimers) || !(Timers))
221 {
222 /* Release the dispatcher while doing DPCs */
223 KiReleaseDispatcherLock(DISPATCH_LEVEL);
224
225 /* Start looping all DPC Entries */
226 for (i = 0; DpcCalls; DpcCalls--, i++)
227 {
228 #if DBG
229 /* Clear DPC Time */
230 Prcb->DebugDpcTime = 0;
231 #endif
232
233 /* Call the DPC */
234 DpcEntry[i].Routine(DpcEntry[i].Dpc,
235 DpcEntry[i].Context,
236 UlongToPtr(SystemTime.LowPart),
237 UlongToPtr(SystemTime.HighPart));
238 }
239
240 /* Reset accounting */
241 Timers = 24;
242 ActiveTimers = 4;
243
244 /* Lock the dispatcher database */
245 KiAcquireDispatcherLock();
246 }
247 }
248 else
249 {
250 /* Check if the timer list is empty */
251 if (NextEntry != ListHead)
252 {
253 /* Sanity check */
254 ASSERT(KiTimerTableListHead[Index].Time.QuadPart <=
255 Timer->DueTime.QuadPart);
256
257 /* Update the time */
258 _disable();
259 KiTimerTableListHead[Index].Time.QuadPart =
260 Timer->DueTime.QuadPart;
261 _enable();
262 }
263
264 /* Release the lock */
265 KiReleaseTimerLock(LockQueue);
266
267 /* Check if we've scanned all the timers we could */
268 if (!Timers)
269 {
270 /* Release the dispatcher while doing DPCs */
271 KiReleaseDispatcherLock(DISPATCH_LEVEL);
272
273 /* Start looping all DPC Entries */
274 for (i = 0; DpcCalls; DpcCalls--, i++)
275 {
276 #if DBG
277 /* Clear DPC Time */
278 Prcb->DebugDpcTime = 0;
279 #endif
280
281 /* Call the DPC */
282 DpcEntry[i].Routine(DpcEntry[i].Dpc,
283 DpcEntry[i].Context,
284 UlongToPtr(SystemTime.LowPart),
285 UlongToPtr(SystemTime.HighPart));
286 }
287
288 /* Reset accounting */
289 Timers = 24;
290 ActiveTimers = 4;
291
292 /* Lock the dispatcher database */
293 KiAcquireDispatcherLock();
294 }
295
296 /* Done looping */
297 break;
298 }
299 }
300 } while (Index != Limit);
301
302 /* Verify the timer table, on debug builds */
303 if (KeNumberProcessors == 1) KiCheckTimerTable(InterruptTime);
304
305 /* Check if we still have DPC entries */
306 if (DpcCalls)
307 {
308 /* Release the dispatcher while doing DPCs */
309 KiReleaseDispatcherLock(DISPATCH_LEVEL);
310
311 /* Start looping all DPC Entries */
312 for (i = 0; DpcCalls; DpcCalls--, i++)
313 {
314 #if DBG
315 /* Clear DPC Time */
316 Prcb->DebugDpcTime = 0;
317 #endif
318
319 /* Call the DPC */
320 DpcEntry[i].Routine(DpcEntry[i].Dpc,
321 DpcEntry[i].Context,
322 UlongToPtr(SystemTime.LowPart),
323 UlongToPtr(SystemTime.HighPart));
324 }
325
326 /* Lower IRQL if we need to */
327 if (OldIrql != DISPATCH_LEVEL) KeLowerIrql(OldIrql);
328 }
329 else
330 {
331 /* Unlock the dispatcher */
332 KiReleaseDispatcherLock(OldIrql);
333 }
334 }
335
336 VOID
337 FASTCALL
338 KiTimerListExpire(IN PLIST_ENTRY ExpiredListHead,
339 IN KIRQL OldIrql)
340 {
341 ULARGE_INTEGER SystemTime;
342 LARGE_INTEGER Interval;
343 LONG i;
344 ULONG DpcCalls = 0;
345 PKTIMER Timer;
346 PKDPC TimerDpc;
347 ULONG Period;
348 DPC_QUEUE_ENTRY DpcEntry[MAX_TIMER_DPCS];
349 PKPRCB Prcb = KeGetCurrentPrcb();
350
351 /* Query system */
352 KeQuerySystemTime((PLARGE_INTEGER)&SystemTime);
353
354 /* Loop expired list */
355 while (ExpiredListHead->Flink != ExpiredListHead)
356 {
357 /* Get the current timer */
358 Timer = CONTAINING_RECORD(ExpiredListHead->Flink, KTIMER, TimerListEntry);
359
360 /* Remove it */
361 RemoveEntryList(&Timer->TimerListEntry);
362
363 /* Not inserted */
364 Timer->Header.Inserted = FALSE;
365
366 /* Signal it */
367 Timer->Header.SignalState = 1;
368
369 /* Get the DPC and period */
370 TimerDpc = Timer->Dpc;
371 Period = Timer->Period;
372
373 /* Check if there's any waiters */
374 if (!IsListEmpty(&Timer->Header.WaitListHead))
375 {
376 /* Check the type of event */
377 if (Timer->Header.Type == TimerNotificationObject)
378 {
379 /* Unwait the thread */
380 KxUnwaitThread(&Timer->Header, IO_NO_INCREMENT);
381 }
382 else
383 {
384 /* Otherwise unwait the thread and signal the timer */
385 KxUnwaitThreadForEvent((PKEVENT)Timer, IO_NO_INCREMENT);
386 }
387 }
388
389 /* Check if we have a period */
390 if (Period)
391 {
392 /* Calculate the interval and insert the timer */
393 Interval.QuadPart = Int32x32To64(Period, -10000);
394 while (!KiInsertTreeTimer(Timer, Interval));
395 }
396
397 /* Check if we have a DPC */
398 if (TimerDpc)
399 {
400 #ifdef CONFIG_SMP
401 /*
402 * If the DPC is targeted to another processor,
403 * then insert it into that processor's DPC queue
404 * instead of delivering it now.
405 * If the DPC is a threaded DPC, and the current CPU
406 * has threaded DPCs enabled (KiExecuteDpc is actively parsing DPCs),
407 * then also insert it into the DPC queue for threaded delivery,
408 * instead of doing it here.
409 */
410 if (((TimerDpc->Number >= MAXIMUM_PROCESSORS) &&
411 ((TimerDpc->Number - MAXIMUM_PROCESSORS) != Prcb->Number)) ||
412 ((TimerDpc->Type == ThreadedDpcObject) && (Prcb->ThreadDpcEnable)))
413 {
414 /* Queue it */
415 KeInsertQueueDpc(TimerDpc,
416 UlongToPtr(SystemTime.LowPart),
417 UlongToPtr(SystemTime.HighPart));
418 }
419 else
420 #endif
421 {
422 /* Setup the DPC Entry */
423 DpcEntry[DpcCalls].Dpc = TimerDpc;
424 DpcEntry[DpcCalls].Routine = TimerDpc->DeferredRoutine;
425 DpcEntry[DpcCalls].Context = TimerDpc->DeferredContext;
426 DpcCalls++;
427 ASSERT(DpcCalls < MAX_TIMER_DPCS);
428 }
429 }
430 }
431
432 /* Check if we still have DPC entries */
433 if (DpcCalls)
434 {
435 /* Release the dispatcher while doing DPCs */
436 KiReleaseDispatcherLock(DISPATCH_LEVEL);
437
438 /* Start looping all DPC Entries */
439 for (i = 0; DpcCalls; DpcCalls--, i++)
440 {
441 #if DBG
442 /* Clear DPC Time */
443 Prcb->DebugDpcTime = 0;
444 #endif
445
446 /* Call the DPC */
447 DpcEntry[i].Routine(DpcEntry[i].Dpc,
448 DpcEntry[i].Context,
449 UlongToPtr(SystemTime.LowPart),
450 UlongToPtr(SystemTime.HighPart));
451 }
452
453 /* Lower IRQL */
454 KeLowerIrql(OldIrql);
455 }
456 else
457 {
458 /* Unlock the dispatcher */
459 KiReleaseDispatcherLock(OldIrql);
460 }
461 }
462
463 VOID
464 NTAPI
465 KiQuantumEnd(VOID)
466 {
467 PKPRCB Prcb = KeGetCurrentPrcb();
468 PKTHREAD NextThread, Thread = Prcb->CurrentThread;
469
470 /* Check if a DPC Event was requested to be signaled */
471 if (InterlockedExchange(&Prcb->DpcSetEventRequest, 0))
472 {
473 /* Signal it */
474 KeSetEvent(&Prcb->DpcEvent, 0, 0);
475 }
476
477 /* Raise to synchronization level and lock the PRCB and thread */
478 KeRaiseIrqlToSynchLevel();
479 KiAcquireThreadLock(Thread);
480 KiAcquirePrcbLock(Prcb);
481
482 /* Check if Quantum expired */
483 if (Thread->Quantum <= 0)
484 {
485 /* Check if we're real-time and with quantums disabled */
486 if ((Thread->Priority >= LOW_REALTIME_PRIORITY) &&
487 (Thread->ApcState.Process->DisableQuantum))
488 {
489 /* Otherwise, set maximum quantum */
490 Thread->Quantum = MAX_QUANTUM;
491 }
492 else
493 {
494 /* Reset the new Quantum */
495 Thread->Quantum = Thread->QuantumReset;
496
497 /* Calculate new priority */
498 Thread->Priority = KiComputeNewPriority(Thread, 1);
499
500 /* Check if a new thread is scheduled */
501 if (!Prcb->NextThread)
502 {
503 /* Get a new ready thread */
504 NextThread = KiSelectReadyThread(Thread->Priority, Prcb);
505 if (NextThread)
506 {
507 /* Found one, set it on standby */
508 NextThread->State = Standby;
509 Prcb->NextThread = NextThread;
510 }
511 }
512 else
513 {
514 /* Otherwise, make sure that this thread doesn't get preempted */
515 Thread->Preempted = FALSE;
516 }
517 }
518 }
519
520 /* Release the thread lock */
521 KiReleaseThreadLock(Thread);
522
523 /* Check if there's no thread scheduled */
524 if (!Prcb->NextThread)
525 {
526 /* Just leave now */
527 KiReleasePrcbLock(Prcb);
528 KeLowerIrql(DISPATCH_LEVEL);
529 return;
530 }
531
532 /* Get the next thread now */
533 NextThread = Prcb->NextThread;
534
535 /* Set current thread's swap busy to true */
536 KiSetThreadSwapBusy(Thread);
537
538 /* Switch threads in PRCB */
539 Prcb->NextThread = NULL;
540 Prcb->CurrentThread = NextThread;
541
542 /* Set thread to running and the switch reason to Quantum End */
543 NextThread->State = Running;
544 Thread->WaitReason = WrQuantumEnd;
545
546 /* Queue it on the ready lists */
547 KxQueueReadyThread(Thread, Prcb);
548
549 /* Set wait IRQL to APC_LEVEL */
550 Thread->WaitIrql = APC_LEVEL;
551
552 /* Swap threads */
553 KiSwapContext(APC_LEVEL, Thread);
554
555 /* Lower IRQL back to DISPATCH_LEVEL */
556 KeLowerIrql(DISPATCH_LEVEL);
557 }
558
559 VOID
560 FASTCALL
561 KiRetireDpcList(IN PKPRCB Prcb)
562 {
563 PKDPC_DATA DpcData;
564 PLIST_ENTRY ListHead, DpcEntry;
565 PKDPC Dpc;
566 PKDEFERRED_ROUTINE DeferredRoutine;
567 PVOID DeferredContext, SystemArgument1, SystemArgument2;
568 ULONG_PTR TimerHand;
569 #ifdef CONFIG_SMP
570 KIRQL OldIrql;
571 #endif
572
573 /* Get data and list variables before starting anything else */
574 DpcData = &Prcb->DpcData[DPC_NORMAL];
575 ListHead = &DpcData->DpcListHead;
576
577 /* Main outer loop */
578 do
579 {
580 /* Set us as active */
581 Prcb->DpcRoutineActive = TRUE;
582
583 /* Check if this is a timer expiration request */
584 if (Prcb->TimerRequest)
585 {
586 /* It is, get the timer hand and disable timer request */
587 TimerHand = Prcb->TimerHand;
588 Prcb->TimerRequest = 0;
589
590 /* Expire timers with interrups enabled */
591 _enable();
592 KiTimerExpiration(NULL, NULL, (PVOID)TimerHand, NULL);
593 _disable();
594 }
595
596 /* Loop while we have entries in the queue */
597 while (DpcData->DpcQueueDepth != 0)
598 {
599 /* Lock the DPC data and get the DPC entry*/
600 KeAcquireSpinLockAtDpcLevel(&DpcData->DpcLock);
601 DpcEntry = ListHead->Flink;
602
603 /* Make sure we have an entry */
604 if (DpcEntry != ListHead)
605 {
606 /* Remove the DPC from the list */
607 RemoveEntryList(DpcEntry);
608 Dpc = CONTAINING_RECORD(DpcEntry, KDPC, DpcListEntry);
609
610 /* Clear its DPC data and save its parameters */
611 Dpc->DpcData = NULL;
612 DeferredRoutine = Dpc->DeferredRoutine;
613 DeferredContext = Dpc->DeferredContext;
614 SystemArgument1 = Dpc->SystemArgument1;
615 SystemArgument2 = Dpc->SystemArgument2;
616
617 /* Decrease the queue depth */
618 DpcData->DpcQueueDepth--;
619
620 #if DBG
621 /* Clear DPC Time */
622 Prcb->DebugDpcTime = 0;
623 #endif
624
625 /* Release the lock */
626 KeReleaseSpinLockFromDpcLevel(&DpcData->DpcLock);
627
628 /* Re-enable interrupts */
629 _enable();
630
631 /* Call the DPC */
632 DeferredRoutine(Dpc,
633 DeferredContext,
634 SystemArgument1,
635 SystemArgument2);
636 ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
637
638 /* Disable interrupts and keep looping */
639 _disable();
640 }
641 else
642 {
643 /* The queue should be flushed now */
644 ASSERT(DpcData->DpcQueueDepth == 0);
645
646 /* Release DPC Lock */
647 KeReleaseSpinLockFromDpcLevel(&DpcData->DpcLock);
648 }
649 }
650
651 /* Clear DPC Flags */
652 Prcb->DpcRoutineActive = FALSE;
653 Prcb->DpcInterruptRequested = FALSE;
654
655 #ifdef CONFIG_SMP
656 /* Check if we have deferred threads */
657 if (Prcb->DeferredReadyListHead.Next)
658 {
659
660 /* Re-enable interrupts and raise to synch */
661 _enable();
662 OldIrql = KeRaiseIrqlToSynchLevel();
663
664 /* Process deferred threads */
665 KiProcessDeferredReadyList(Prcb);
666
667 /* Lower IRQL back and disable interrupts */
668 KeLowerIrql(OldIrql);
669 _disable();
670 }
671 #endif
672 } while (DpcData->DpcQueueDepth != 0);
673 }
674
675 VOID
676 NTAPI
677 KiInitializeDpc(IN PKDPC Dpc,
678 IN PKDEFERRED_ROUTINE DeferredRoutine,
679 IN PVOID DeferredContext,
680 IN KOBJECTS Type)
681 {
682 /* Setup the DPC Object */
683 Dpc->Type = Type;
684 Dpc->Number = 0;
685 Dpc->Importance= MediumImportance;
686 Dpc->DeferredRoutine = DeferredRoutine;
687 Dpc->DeferredContext = DeferredContext;
688 Dpc->DpcData = NULL;
689 }
690
691 /* PUBLIC FUNCTIONS **********************************************************/
692
693 /*
694 * @implemented
695 */
696 VOID
697 NTAPI
698 KeInitializeThreadedDpc(IN PKDPC Dpc,
699 IN PKDEFERRED_ROUTINE DeferredRoutine,
700 IN PVOID DeferredContext)
701 {
702 /* Call the internal routine */
703 KiInitializeDpc(Dpc, DeferredRoutine, DeferredContext, ThreadedDpcObject);
704 }
705
706 /*
707 * @implemented
708 */
709 VOID
710 NTAPI
711 KeInitializeDpc(IN PKDPC Dpc,
712 IN PKDEFERRED_ROUTINE DeferredRoutine,
713 IN PVOID DeferredContext)
714 {
715 /* Call the internal routine */
716 KiInitializeDpc(Dpc, DeferredRoutine, DeferredContext, DpcObject);
717 }
718
719 /*
720 * @implemented
721 */
722 BOOLEAN
723 NTAPI
724 KeInsertQueueDpc(IN PKDPC Dpc,
725 IN PVOID SystemArgument1,
726 IN PVOID SystemArgument2)
727 {
728 KIRQL OldIrql;
729 PKPRCB Prcb, CurrentPrcb;
730 ULONG Cpu;
731 PKDPC_DATA DpcData;
732 BOOLEAN DpcConfigured = FALSE, DpcInserted = FALSE;
733 ASSERT_DPC(Dpc);
734
735 /* Check IRQL and Raise it to HIGH_LEVEL */
736 KeRaiseIrql(HIGH_LEVEL, &OldIrql);
737 CurrentPrcb = KeGetCurrentPrcb();
738
739 /* Check if the DPC has more then the maximum number of CPUs */
740 if (Dpc->Number >= MAXIMUM_PROCESSORS)
741 {
742 /* Then substract the maximum and get that PRCB. */
743 Cpu = Dpc->Number - MAXIMUM_PROCESSORS;
744 Prcb = KiProcessorBlock[Cpu];
745 }
746 else
747 {
748 /* Use the current one */
749 Prcb = CurrentPrcb;
750 Cpu = Prcb->Number;
751 }
752
753 /* ROS Sanity Check */
754 ASSERT(Prcb == CurrentPrcb);
755
756 /* Check if this is a threaded DPC and threaded DPCs are enabled */
757 if ((Dpc->Type == ThreadedDpcObject) && (Prcb->ThreadDpcEnable))
758 {
759 /* Then use the threaded data */
760 DpcData = &Prcb->DpcData[DPC_THREADED];
761 }
762 else
763 {
764 /* Otherwise, use the regular data */
765 DpcData = &Prcb->DpcData[DPC_NORMAL];
766 }
767
768 /* Acquire the DPC lock */
769 KiAcquireSpinLock(&DpcData->DpcLock);
770
771 /* Get the DPC Data */
772 if (!InterlockedCompareExchangePointer(&Dpc->DpcData, DpcData, NULL))
773 {
774 /* Now we can play with the DPC safely */
775 Dpc->SystemArgument1 = SystemArgument1;
776 Dpc->SystemArgument2 = SystemArgument2;
777 DpcData->DpcQueueDepth++;
778 DpcData->DpcCount++;
779 DpcConfigured = TRUE;
780
781 /* Check if this is a high importance DPC */
782 if (Dpc->Importance == HighImportance)
783 {
784 /* Pre-empty other DPCs */
785 InsertHeadList(&DpcData->DpcListHead, &Dpc->DpcListEntry);
786 }
787 else
788 {
789 /* Add it at the end */
790 InsertTailList(&DpcData->DpcListHead, &Dpc->DpcListEntry);
791 }
792
793 /* Check if this is the DPC on the threaded list */
794 if (&Prcb->DpcData[DPC_THREADED] == DpcData)
795 {
796 /* Make sure a threaded DPC isn't already active */
797 if (!(Prcb->DpcThreadActive) && !(Prcb->DpcThreadRequested))
798 {
799 /* FIXME: Setup Threaded DPC */
800 UNIMPLEMENTED_FATAL("Threaded DPC not supported\n");
801 }
802 }
803 else
804 {
805 /* Make sure a DPC isn't executing already */
806 if (!(Prcb->DpcRoutineActive) && !(Prcb->DpcInterruptRequested))
807 {
808 /* Check if this is the same CPU */
809 if (Prcb != CurrentPrcb)
810 {
811 /*
812 * Check if the DPC is of high importance or above the
813 * maximum depth. If it is, then make sure that the CPU
814 * isn't idle, or that it's sleeping.
815 */
816 if (((Dpc->Importance == HighImportance) ||
817 (DpcData->DpcQueueDepth >=
818 Prcb->MaximumDpcQueueDepth)) &&
819 (!(AFFINITY_MASK(Cpu) & KiIdleSummary) ||
820 (Prcb->Sleeping)))
821 {
822 /* Set interrupt requested */
823 Prcb->DpcInterruptRequested = TRUE;
824
825 /* Set DPC inserted */
826 DpcInserted = TRUE;
827 }
828 }
829 else
830 {
831 /* Check if the DPC is of anything but low importance */
832 if ((Dpc->Importance != LowImportance) ||
833 (DpcData->DpcQueueDepth >=
834 Prcb->MaximumDpcQueueDepth) ||
835 (Prcb->DpcRequestRate < Prcb->MinimumDpcRate))
836 {
837 /* Set interrupt requested */
838 Prcb->DpcInterruptRequested = TRUE;
839
840 /* Set DPC inserted */
841 DpcInserted = TRUE;
842 }
843 }
844 }
845 }
846 }
847
848 /* Release the lock */
849 KiReleaseSpinLock(&DpcData->DpcLock);
850
851 /* Check if the DPC was inserted */
852 if (DpcInserted)
853 {
854 /* Check if this was SMP */
855 if (Prcb != CurrentPrcb)
856 {
857 /* It was, request and IPI */
858 KiIpiSend(AFFINITY_MASK(Cpu), IPI_DPC);
859 }
860 else
861 {
862 /* It wasn't, request an interrupt from HAL */
863 HalRequestSoftwareInterrupt(DISPATCH_LEVEL);
864 }
865 }
866
867 /* Lower IRQL */
868 KeLowerIrql(OldIrql);
869 return DpcConfigured;
870 }
871
872 /*
873 * @implemented
874 */
875 BOOLEAN
876 NTAPI
877 KeRemoveQueueDpc(IN PKDPC Dpc)
878 {
879 PKDPC_DATA DpcData;
880 BOOLEAN Enable;
881 ASSERT_DPC(Dpc);
882
883 /* Disable interrupts */
884 Enable = KeDisableInterrupts();
885
886 /* Get DPC data */
887 DpcData = Dpc->DpcData;
888 if (DpcData)
889 {
890 /* Acquire the DPC lock */
891 KiAcquireSpinLock(&DpcData->DpcLock);
892
893 /* Make sure that the data didn't change */
894 if (DpcData == Dpc->DpcData)
895 {
896 /* Remove the DPC */
897 DpcData->DpcQueueDepth--;
898 RemoveEntryList(&Dpc->DpcListEntry);
899 Dpc->DpcData = NULL;
900 }
901
902 /* Release the lock */
903 KiReleaseSpinLock(&DpcData->DpcLock);
904 }
905
906 /* Re-enable interrupts */
907 if (Enable) _enable();
908
909 /* Return if the DPC was in the queue or not */
910 return DpcData ? TRUE : FALSE;
911 }
912
913 /*
914 * @implemented
915 */
916 VOID
917 NTAPI
918 KeFlushQueuedDpcs(VOID)
919 {
920 PKPRCB CurrentPrcb = KeGetCurrentPrcb();
921 PAGED_CODE();
922
923 /* Check if this is an UP machine */
924 if (KeActiveProcessors == 1)
925 {
926 /* Check if there are DPCs on either queues */
927 if ((CurrentPrcb->DpcData[DPC_NORMAL].DpcQueueDepth > 0) ||
928 (CurrentPrcb->DpcData[DPC_THREADED].DpcQueueDepth > 0))
929 {
930 /* Request an interrupt */
931 HalRequestSoftwareInterrupt(DISPATCH_LEVEL);
932 }
933 }
934 else
935 {
936 /* FIXME: SMP support required */
937 ASSERT(FALSE);
938 }
939 }
940
941 /*
942 * @implemented
943 */
944 BOOLEAN
945 NTAPI
946 KeIsExecutingDpc(VOID)
947 {
948 /* Return if the Dpc Routine is active */
949 return KeGetCurrentPrcb()->DpcRoutineActive;
950 }
951
952 /*
953 * @implemented
954 */
955 VOID
956 NTAPI
957 KeSetImportanceDpc (IN PKDPC Dpc,
958 IN KDPC_IMPORTANCE Importance)
959 {
960 /* Set the DPC Importance */
961 ASSERT_DPC(Dpc);
962 Dpc->Importance = Importance;
963 }
964
965 /*
966 * @implemented
967 */
968 VOID
969 NTAPI
970 KeSetTargetProcessorDpc(IN PKDPC Dpc,
971 IN CCHAR Number)
972 {
973 /* Set a target CPU */
974 ASSERT_DPC(Dpc);
975 Dpc->Number = Number + MAXIMUM_PROCESSORS;
976 }
977
978 /*
979 * @implemented
980 */
981 VOID
982 NTAPI
983 KeGenericCallDpc(IN PKDEFERRED_ROUTINE Routine,
984 IN PVOID Context)
985 {
986 ULONG Barrier = KeNumberProcessors;
987 KIRQL OldIrql;
988 DEFERRED_REVERSE_BARRIER ReverseBarrier;
989 ASSERT(KeGetCurrentIrql () < DISPATCH_LEVEL);
990
991 //
992 // The barrier is the number of processors, each processor will decrement it
993 // by one, so when all processors have run the DPC, the barrier reaches zero
994 //
995 ReverseBarrier.Barrier = Barrier;
996 ReverseBarrier.TotalProcessors = Barrier;
997
998 //
999 // But we don't need the barrier on UP, since we can simply call the routine
1000 // directly while at DISPATCH_LEVEL and not worry about anything else
1001 //
1002 KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
1003 Routine(&KeGetCurrentPrcb()->CallDpc, Context, &Barrier, &ReverseBarrier);
1004 KeLowerIrql(OldIrql);
1005 }
1006
1007 /*
1008 * @implemented
1009 */
1010 VOID
1011 NTAPI
1012 KeSignalCallDpcDone(IN PVOID SystemArgument1)
1013 {
1014 //
1015 // Decrement the barrier, which is actually the processor count
1016 //
1017 InterlockedDecrement((PLONG)SystemArgument1);
1018 }
1019
1020 /*
1021 * @implemented
1022 */
1023 BOOLEAN
1024 NTAPI
1025 KeSignalCallDpcSynchronize(IN PVOID SystemArgument2)
1026 {
1027 //
1028 // There is nothing to do on UP systems -- the processor calling this wins
1029 //
1030 UNREFERENCED_PARAMETER(SystemArgument2);
1031 return TRUE;
1032 }
1033
1034 /* EOF */