Author: fireball
Date: Fri Jul 14 00:47:59 2006
New Revision: 23046
URL: http://svn.reactos.org/svn/reactos?rev=23046&view=rev
Log:
Added a check for a non-null WndProc into IntCallWndProcA/W. Instead of bugchecking, it shows a DPRINT1 now to inform about a bug.
As a side effect, mIRC now works in ReactOS.
Modified:
trunk/reactos/dll/win32/user32/windows/message.c
Modified: trunk/reactos/dll/win32/user32/windows/message.c
URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/user32/windows/m…
==============================================================================
--- trunk/reactos/dll/win32/user32/windows/message.c (original)
+++ trunk/reactos/dll/win32/user32/windows/message.c Fri Jul 14 00:47:59 2006
@@ -1141,6 +1141,12 @@
MSG UnicodeMsg;
LRESULT Result;
+ if (WndProc == NULL)
+ {
+ DPRINT1("IntCallWindowsProcW() called with WndProc = NULL!\n");
+ return FALSE;
+ }
+
if (IsAnsiProc)
{
UnicodeMsg.hwnd = hWnd;
@@ -1176,6 +1182,12 @@
MSG AnsiMsg;
MSG UnicodeMsg;
LRESULT Result;
+
+ if (WndProc == NULL)
+ {
+ DPRINT1("IntCallWindowsProcA() called with WndProc = NULL!\n");
+ return FALSE;
+ }
if (IsAnsiProc)
{
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 */