[ros-diffs] [ion] 23045: [FORMATTING] - Cleanup timer.c

Author: ion
Date: Thu Jul 13 23:43:10 2006
New Revision: 23045

URL: http://svn.reactos.org/svn/reactos?rev=23045&view=rev
Log:
[FORMATTING] - Cleanup timer.c

Modified:
    trunk/reactos/ntoskrnl/ke/timer.c

Modified: trunk/reactos/ntoskrnl/ke/timer.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/ke/timer.c?rev=23…
==============================================================================
--- trunk/reactos/ntoskrnl/ke/timer.c (original)
+++ trunk/reactos/ntoskrnl/ke/timer.c Thu Jul 13 23:43:10 2006
@@ -1,98 +1,230 @@
 /*
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
+ * PROJECT:         ReactOS Kernel
+ * LICENSE:         GPL - See COPYING in the top level directory
  * FILE:            ntoskrnl/ke/timer.c
  * PURPOSE:         Handle Kernel Timers (Kernel-part of Executive Timers)
- *
- * PROGRAMMERS:     Alex Ionescu (alex(a)relsoft.net) - Reimplemented some parts, fixed
many bugs.
- *                  David Welch (welch(a)mcmail.com) &  Phillip Susi - Original
Implementation.
+ * PROGRAMMERS:     Alex Ionescu (alex.ionescu(a)reactos.org)
+ *                  David Welch (welch(a)mcmail.com)
  */
 
 /* INCLUDES ***************************************************************/
 
 #include <ntoskrnl.h>
-
 #define NDEBUG
 #include <internal/debug.h>
 
 /* GLOBALS ****************************************************************/
 
 LIST_ENTRY KiTimerListHead;
-
 #define SYSTEM_TIME_UNITS_PER_MSEC (10000)
 
-/* FUNCTIONS **************************************************************/
-
-BOOLEAN STDCALL KiInsertTimer(PKTIMER Timer, LARGE_INTEGER DueTime);
-VOID STDCALL KiHandleExpiredTimer(PKTIMER Timer);
-
-/*
- * @implemented
- *
- * FUNCTION: Removes a timer from the system timer list
- * ARGUMENTS:
- *       Timer = timer to cancel
- * RETURNS: True if the timer was running
- *          False otherwise
- *
- * DANGER!
- * The statement in the DDK for KeCancelTimer that "if a DPC object is
- * associated with the timer, it too is canceled" is wrong -- nothing is
- * done with the DPC object when the timer is removed from the system
- * queue. So its very likely that the DPC will run after you have canceled
- * the timer!
- * For what it's worth, calling KeRemoveQueueDpc after KeCancelTimer would
- * be sufficient to prevent any problems associated with destroying the DPC
- * object, at least as the OS is currently implemented. This is because the
- * DPC dispatcher doesn't need access to the object once the DPC is
- * dequeued, and the dequeuing happens before the DPC routine gets called."
- * -Gunnar (article by Walter Oney)
- */
-BOOLEAN
-STDCALL
-KeCancelTimer(PKTIMER Timer)
-{
+/* PRIVATE FUNCTIONS ******************************************************/
+
+VOID
+NTAPI
+KiRemoveTimer(IN PKTIMER Timer)
+{
+    /* Remove the timer */
+    Timer->Header.Inserted = FALSE;
+    RemoveEntryList(&Timer->TimerListEntry);
+}
+
+/*
+ * Note: This function is called with the Dispatcher Lock held.
+ */
+BOOLEAN
+NTAPI
+KiInsertTimer(IN PKTIMER Timer,
+              IN LARGE_INTEGER DueTime)
+{
+    LARGE_INTEGER SystemTime;
+    LARGE_INTEGER DifferenceTime;
+    ULONGLONG InterruptTime;
+
+    /* Set default data */
+    Timer->Header.Inserted = TRUE;
+    Timer->Header.Absolute = FALSE;
+    if (!Timer->Period) Timer->Header.SignalState = FALSE;
+
+    /* Convert to relative time if needed */
+    if (DueTime.HighPart >= 0)
+    {
+        /* Get System Time */
+        KeQuerySystemTime(&SystemTime);
+
+        /* Do the conversion */
+        DifferenceTime.QuadPart = SystemTime.QuadPart - DueTime.QuadPart;
+
+        /* Make sure it hasn't already expired */
+        if (DifferenceTime.HighPart >= 0)
+        {
+            /* Cancel everything */
+            Timer->Header.SignalState = TRUE;
+            Timer->Header.Inserted = FALSE;
+            return FALSE;
+        }
+
+        /* Set the time as Absolute */
+        Timer->Header.Absolute = TRUE;
+        DueTime = DifferenceTime;
+    }
+
+    /* Get the Interrupt Time */
+    InterruptTime = KeQueryInterruptTime();
+
+    /* Set the Final Due Time */
+    Timer->DueTime.QuadPart = InterruptTime - DueTime.QuadPart;
+
+    /* Now insert it into the Timer List */
+    InsertAscendingList(&KiTimerListHead,
+                        Timer,
+                        KTIMER,
+                        TimerListEntry,
+                        DueTime.QuadPart);
+    return TRUE;
+}
+
+/*
+ * We enter this function at IRQL DISPATCH_LEVEL, and with the
+ * Dispatcher Lock held!
+ */
+VOID
+NTAPI
+KiHandleExpiredTimer(IN PKTIMER Timer)
+{
+    LARGE_INTEGER DueTime;
+
+    /* Set it as Signaled */
+    Timer->Header.SignalState = TRUE;
+
+    /* Check if it has any waiters */
+    if (!IsListEmpty(&Timer->Header.WaitListHead))
+    {
+        /* Wake them */
+        KiWaitTest(Timer, IO_NO_INCREMENT);
+    }
+
+    /* If the Timer is periodic, reinsert the timer with the new due time */
+    if (Timer->Period)
+    {
+        /* Reinsert the Timer */
+        DueTime.QuadPart = Timer->Period * -SYSTEM_TIME_UNITS_PER_MSEC;
+        while (!KiInsertTimer(Timer, DueTime));
+    }
+
+    /* Check if the Timer has a DPC */
+    if (Timer->Dpc)
+    {
+        /* Insert the DPC */
+        KeInsertQueueDpc(Timer->Dpc,
+                         NULL,
+                         NULL);
+    }
+}
+
+VOID
+NTAPI
+KiExpireTimers(IN PKDPC Dpc,
+               IN PVOID DeferredContext,
+               IN PVOID SystemArgument1,
+               IN PVOID SystemArgument2)
+{
+    PKTIMER Timer;
+    ULONGLONG InterruptTime;
+    LIST_ENTRY ExpiredTimerList;
+    PLIST_ENTRY ListHead, NextEntry;
     KIRQL OldIrql;
-    BOOLEAN Inserted = FALSE;
-
-    DPRINT("KeCancelTimer(Timer %x)\n",Timer);
+
+    /* Initialize the Expired Timer List */
+    InitializeListHead(&ExpiredTimerList);
 
     /* Lock the Database and Raise IRQL */
     OldIrql = KeAcquireDispatcherDatabaseLock();
 
-    /* Check if it's inserted, and remove it if it is */
-    if ((Inserted = Timer->Header.Inserted)) {
-
-        /* Remove from list */
-        DPRINT("Timer was inserted, removing\n");
+    /* Query Interrupt Times */
+    InterruptTime = KeQueryInterruptTime();
+
+    /* Loop through the Timer List */
+    ListHead = &KiTimerListHead;
+    NextEntry = ListHead->Flink;
+    while (NextEntry != ListHead)
+    {
+        /* Get the timer */
+        Timer = CONTAINING_RECORD(NextEntry, KTIMER, TimerListEntry);
+
+        /* Check if we have to Expire it */
+        if (InterruptTime < Timer->DueTime.QuadPart) break;
+
+        /* Remove it from the Timer List, add it to the Expired List */
         RemoveEntryList(&Timer->TimerListEntry);
+        InsertTailList(&ExpiredTimerList, &Timer->TimerListEntry);
+        NextEntry = ListHead->Flink;
+    }
+
+    /* Expire the Timers */
+    while (ExpiredTimerList.Flink != &ExpiredTimerList)
+    {
+        /* Get the Timer */
+        Timer = CONTAINING_RECORD(ExpiredTimerList.Flink,
+                                  KTIMER,
+                                  TimerListEntry);
+
+        /* Remove it */
+        ///
+        // GCC IS A BRAINDEAD PIECE OF SHIT. WILL GIVE 5$ FOR EACH DEV KILLED.
+        ///
         Timer->Header.Inserted = FALSE;
-
-    } else {
-
-        DPRINT("Timer was not inserted\n");
+        RemoveEntryList(&Timer->TimerListEntry);
+        //KiRemoveTimer(Timer);
+
+        /* Expire it */
+        KiHandleExpiredTimer(Timer);
     }
 
     /* Release Dispatcher Lock */
     KeReleaseDispatcherDatabaseLock(OldIrql);
-
-    /* Return the old state */
-    DPRINT("Old State: %d\n", Inserted);
-    return(Inserted);
-}
-
-/*
- * @implemented
- *
- * FUNCTION: Initalizes a kernel timer object
- * ARGUMENTS:
- *          Timer = caller supplied storage for the timer
- * NOTE: This function initializes a notification timer
- */
-VOID
-STDCALL
-KeInitializeTimer (PKTIMER Timer)
-
+}
+
+/* PUBLIC FUNCTIONS **********************************************************/
+
+/*
+ * @implemented
+ */
+BOOLEAN
+NTAPI
+KeCancelTimer(IN OUT PKTIMER Timer)
+{
+    KIRQL OldIrql;
+    BOOLEAN Inserted;
+    ASSERT_TIMER(Timer);
+    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
+
+    /* Lock the Database and Raise IRQL */
+    OldIrql = KeAcquireDispatcherDatabaseLock();
+
+    /* Check if it's inserted, and remove it if it is */
+    Inserted = Timer->Header.Inserted;
+    if (Inserted)
+    {
+        ///
+        // GCC IS A BRAINDEAD PIECE OF SHIT. WILL GIVE 5$ FOR EACH DEV KILLED.
+        ///
+        Timer->Header.Inserted = FALSE;
+        RemoveEntryList(&Timer->TimerListEntry);
+        //KiRemoveTimer(Timer);
+    }
+
+    /* Release Dispatcher Lock */
+    KeReleaseDispatcherDatabaseLock(OldIrql);
+    return Inserted;
+}
+
+/*
+ * @implemented
+ */
+VOID
+NTAPI
+KeInitializeTimer(OUT PKTIMER Timer)
 {
     /* Call the New Function */
     KeInitializeTimerEx(Timer, NotificationTimer);
@@ -100,24 +232,12 @@
 
 /*
  * @implemented
- *
- * FUNCTION: Initializes a kernel timer object
- * ARGUMENTS:
- *          Timer = caller supplied storage for the timer
- *          Type = the type of timer (notification or synchronization)
- * NOTE: When a notification type expires all waiting threads are released
- * and the timer remains signalled until it is explicitly reset. When a
- * syncrhonization timer expires its state is set to signalled until a
- * single waiting thread is released and then the timer is reset.
- */
-VOID
-STDCALL
-KeInitializeTimerEx (PKTIMER Timer,
-                     TIMER_TYPE Type)
-{
-
-    DPRINT("KeInitializeTimerEx(%x, %d)\n", Timer, Type);
-
+ */
+VOID
+NTAPI
+KeInitializeTimerEx(OUT PKTIMER Timer,
+                    IN TIMER_TYPE Type)
+{
     /* Initialize the Dispatch Header */
     KeInitializeDispatcherHeader(&Timer->Header,
                                  TimerNotificationObject + Type,
@@ -129,37 +249,26 @@
     Timer->Period = 0;
 }
 
-
-/*
- * @implemented
- */
-BOOLEAN
-STDCALL
-KeReadStateTimer (PKTIMER Timer)
+/*
+ * @implemented
+ */
+BOOLEAN
+NTAPI
+KeReadStateTimer(IN PKTIMER Timer)
 {
     /* Return the Signal State */
+    ASSERT_TIMER(Timer);
     return (BOOLEAN)Timer->Header.SignalState;
 }
 
 /*
  * @implemented
- *
- * FUNCTION: Sets the absolute or relative interval at which a timer object
- * is to be set to the signaled state and optionally supplies a
- * CustomTimerDpc to be executed when the timer expires.
- * ARGUMENTS:
- *          Timer = Points to a previously initialized timer object
- *          DueTimer = If positive then absolute time to expire at
- *                     If negative then the relative time to expire at
- *          Dpc = If non-NULL then a dpc to be called when the timer expires
- * RETURNS: True if the timer was already in the system timer queue
- *          False otherwise
- */
-BOOLEAN
-STDCALL
-KeSetTimer (PKTIMER Timer,
-            LARGE_INTEGER DueTime,
-            PKDPC Dpc)
+ */
+BOOLEAN
+NTAPI
+KeSetTimer(IN OUT PKTIMER Timer,
+           IN LARGE_INTEGER DueTime,
+           IN PKDPC Dpc OPTIONAL)
 {
     /* Call the newer function and supply a period of 0 */
     return KeSetTimerEx(Timer, DueTime, 0, Dpc);
@@ -167,41 +276,32 @@
 
 /*
  * @implemented
- *
- * FUNCTION: Sets the absolute or relative interval at which a timer object
- * is to be set to the signaled state and optionally supplies a
- * CustomTimerDpc to be executed when the timer expires.
- * ARGUMENTS:
- *          Timer = Points to a previously initialized timer object
- *          DueTimer = If positive then absolute time to expire at
- *                     If negative then the relative time to expire at
- *          Dpc = If non-NULL then a dpc to be called when the timer expires
- * RETURNS: True if the timer was already in the system timer queue
- *          False otherwise
- */
-BOOLEAN
-STDCALL
-KeSetTimerEx (PKTIMER Timer,
-              LARGE_INTEGER DueTime,
-              LONG Period,
-              PKDPC Dpc)
+ */
+BOOLEAN
+NTAPI
+KeSetTimerEx(IN OUT PKTIMER Timer,
+             IN LARGE_INTEGER DueTime,
+             IN LONG Period,
+             IN PKDPC Dpc OPTIONAL)
 {
     KIRQL OldIrql;
     BOOLEAN Inserted;
-
-    DPRINT("KeSetTimerEx(Timer %x, DueTime %I64d, Period %d, Dpc %x)\n", Timer,
DueTime.QuadPart, Period, Dpc);
-    ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
+    ASSERT_TIMER(Timer);
+    ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
 
     /* Lock the Database and Raise IRQL */
     OldIrql = KeAcquireDispatcherDatabaseLock();
 
     /* Check if it's inserted, and remove it if it is */
-    if ((Inserted = Timer->Header.Inserted)) {
-
-        /* Remove from list */
-        DPRINT("Timer was already inserted\n");
+    Inserted = Timer->Header.Inserted;
+    if (Inserted)
+    {
+        ///
+        // GCC IS A BRAINDEAD PIECE OF SHIT. WILL GIVE 5$ FOR EACH DEV KILLED.
+        ///
+        Timer->Header.Inserted = FALSE;
         RemoveEntryList(&Timer->TimerListEntry);
-        Timer->Header.Inserted = FALSE;
+        //KiRemoveTimer(Timer);
     }
 
     /* Set Default Timer Data */
@@ -241,174 +341,7 @@
     KeReleaseDispatcherDatabaseLock(OldIrql);
 
     /* Return old state */
-    DPRINT("Old State: %d\n", Inserted);
     return Inserted;
 }
 
-VOID
-STDCALL
-KiExpireTimers(PKDPC Dpc,
-               PVOID DeferredContext,
-               PVOID SystemArgument1,
-               PVOID SystemArgument2)
-{
-    PKTIMER Timer;
-    ULONGLONG InterruptTime;
-    LIST_ENTRY ExpiredTimerList;
-    PLIST_ENTRY ListHead, NextEntry;
-    KIRQL OldIrql;
-
-    /* Initialize the Expired Timer List */
-    InitializeListHead(&ExpiredTimerList);
-
-    /* Lock the Database and Raise IRQL */
-    OldIrql = KeAcquireDispatcherDatabaseLock();
-
-    /* Query Interrupt Times */
-    InterruptTime = KeQueryInterruptTime();
-
-    /* Loop through the Timer List */
-    ListHead = &KiTimerListHead;
-    NextEntry = ListHead->Flink;
-    while (NextEntry != ListHead)
-    {
-        /* Get the timer */
-        Timer = CONTAINING_RECORD(NextEntry, KTIMER, TimerListEntry);
-
-        /* Check if we have to Expire it */
-        if (InterruptTime < Timer->DueTime.QuadPart) break;
-
-        /* Remove it from the Timer List, add it to the Expired List */
-        RemoveEntryList(&Timer->TimerListEntry);
-        InsertTailList(&ExpiredTimerList, &Timer->TimerListEntry);
-        NextEntry = ListHead->Flink;
-    }
-
-    /* Expire the Timers */
-    while (ExpiredTimerList.Flink != &ExpiredTimerList)
-    {
-        /* Get the Timer */
-        Timer = CONTAINING_RECORD(ExpiredTimerList.Flink,
-                                  KTIMER,
-                                  TimerListEntry);
-
-        /* Remove it */
-        Timer->Header.Inserted = FALSE;
-        RemoveEntryList(&Timer->TimerListEntry);
-
-        /* Expire it */
-        KiHandleExpiredTimer(Timer);
-    }
-
-    /* Release Dispatcher Lock */
-    KeReleaseDispatcherDatabaseLock(OldIrql);
-}
-
-/*
- * We enter this function at IRQL DISPATCH_LEVEL, and with the
- * Dispatcher Lock held!
- */
-VOID
-STDCALL
-KiHandleExpiredTimer(PKTIMER Timer)
-{
-    LARGE_INTEGER DueTime;
-
-    /* Set it as Signaled */
-    Timer->Header.SignalState = TRUE;
-
-    /* Check if it has any waiters */
-    if (!IsListEmpty(&Timer->Header.WaitListHead))
-    {
-        /* Wake them */
-        KiWaitTest(Timer, IO_NO_INCREMENT);
-    }
-
-    /* If the Timer is periodic, reinsert the timer with the new due time */
-    if (Timer->Period) {
-
-        /* Reinsert the Timer */
-        DueTime.QuadPart = Timer->Period * -SYSTEM_TIME_UNITS_PER_MSEC;
-        if (!KiInsertTimer(Timer, DueTime)) {
-
-           /* FIXME: I will think about how to handle this and fix it ASAP -- Alex */
-           DPRINT("CRITICAL UNHANDLED CASE: TIMER ALREADY EXPIRED!!!\n");
-        };
-    }
-
-    /* Check if the Timer has a DPC */
-    if (Timer->Dpc) {
-
-        DPRINT("Timer->Dpc %x Timer->Dpc->DeferredRoutine %x\n",
Timer->Dpc, Timer->Dpc->DeferredRoutine);
-
-        /* Insert the DPC */
-        KeInsertQueueDpc(Timer->Dpc,
-                         NULL,
-                         NULL);
-
-        DPRINT("Finished dpc routine\n");
-    }
-}
-
-/*
- * Note: This function is called with the Dispatcher Lock held.
- */
-BOOLEAN
-STDCALL
-KiInsertTimer(PKTIMER Timer,
-              LARGE_INTEGER DueTime)
-{
-    LARGE_INTEGER SystemTime;
-    LARGE_INTEGER DifferenceTime;
-    ULONGLONG InterruptTime;
-
-    DPRINT("KiInsertTimer(Timer %x DueTime %I64d)\n", Timer,
DueTime.QuadPart);
-
-    /* Set default data */
-    Timer->Header.Inserted = TRUE;
-    Timer->Header.Absolute = FALSE;
-    if (!Timer->Period) Timer->Header.SignalState = FALSE;
-
-    /* Convert to relative time if needed */
-    if (DueTime.u.HighPart >= 0) {
-
-        /* Get System Time */
-        KeQuerySystemTime(&SystemTime);
-
-        /* Do the conversion */
-        DifferenceTime.QuadPart = SystemTime.QuadPart - DueTime.QuadPart;
-        DPRINT("Time Difference is: %I64d\n", DifferenceTime.QuadPart);
-
-        /* Make sure it hasn't already expired */
-        if (DifferenceTime.u.HighPart >= 0) {
-
-            /* Cancel everything */
-            DPRINT("Timer already expired: %d\n", DifferenceTime.u.HighPart);
-            Timer->Header.SignalState = TRUE;
-            Timer->Header.Inserted = FALSE;
-            return FALSE;
-        }
-
-        /* Set the time as Absolute */
-        Timer->Header.Absolute = TRUE;
-        DueTime = DifferenceTime;
-    }
-
-    /* Get the Interrupt Time */
-    InterruptTime = KeQueryInterruptTime();
-
-    /* Set the Final Due Time */
-    Timer->DueTime.QuadPart = InterruptTime - DueTime.QuadPart;
-    DPRINT("Final Due Time is: %I64d\n", Timer->DueTime.QuadPart);
-
-    /* Now insert it into the Timer List */
-    DPRINT("Inserting Timer into list\n");
-    InsertAscendingList(&KiTimerListHead,
-                        Timer,    
-                        KTIMER,
-                        TimerListEntry,
-                        DueTime.QuadPart);
-
-    return TRUE;
-}
 /* EOF */