[ros-diffs] [ion] 25632: - Multiple fixes to ERESOURCE implementation.

Author: ion
Date: Fri Jan 26 02:48:48 2007
New Revision: 25632

URL: http://svn.reactos.org/svn/reactos?rev=25632&view=rev
Log:
- Multiple fixes to ERESOURCE implementation.

Modified:
    trunk/reactos/ntoskrnl/ex/resource.c

Modified: trunk/reactos/ntoskrnl/ex/resource.c
URL:
http://svn.reactos.org/svn/reactos/trunk/reactos/ntoskrnl/ex/resource.c?rev…
==============================================================================
--- trunk/reactos/ntoskrnl/ex/resource.c (original)
+++ trunk/reactos/ntoskrnl/ex/resource.c Fri Jan 26 02:48:48 2007
@@ -20,16 +20,13 @@
 
 #include <ntoskrnl.h>
 #define NDEBUG
-#include <internal/debug.h>
-
-#if defined (ALLOC_PRAGMA)
-#pragma alloc_text(INIT, ExpResourceInitialization)
-#endif
+#include <debug.h>
 
 /* Macros for reading resource flags */
 #define IsExclusiveWaiting(r)   (r->NumberOfExclusiveWaiters)
 #define IsSharedWaiting(r)      (r->NumberOfSharedWaiters)
 #define IsOwnedExclusive(r)     (r->Flag & ResourceOwnedExclusive)
+#define IsBoostAllowed(r)       (r->Flag & ResourceHasDisabledPriorityBoost)
 
 /* DATA***********************************************************************/
 
@@ -258,6 +255,7 @@
                             IN PKIRQL OldIrql)
 {
     POWNER_ENTRY Owner, Table;
+    KIRQL OldIrql2;
     ULONG NewSize, OldSize;
     DPRINT("ExpExpandResourceOwnerTable: %p\n", Resource);
 
@@ -285,7 +283,7 @@
                                   TAG_RESOURCE_TABLE);
 
     /* Zero the table */
-    RtlZeroMemory((PVOID)(Table + OldSize),
+    RtlZeroMemory(Table + OldSize,
                   (NewSize - OldSize) * sizeof(OWNER_ENTRY));
 
     /* Lock the resource */
@@ -302,22 +300,24 @@
     else
     {
         /* Copy the table */
-        RtlCopyMemory((PVOID)Table,
+        RtlCopyMemory(Table,
                       Owner,
                       OldSize * sizeof(OWNER_ENTRY));
 
         /* Acquire dispatcher lock to prevent thread boosting */
-        KiAcquireDispatcherLockAtDpcLevel();
+        OldIrql2 = KiAcquireDispatcherLock();
 
         /* Set the new table data */
         Table->TableSize = NewSize;
         Resource->OwnerTable = Table;
 
+        /* Release dispatcher lock */
+        KiReleaseDispatcherLock(OldIrql2);
+
         /* Sanity check */
         ExpVerifyResource(Resource);
 
-        /* Release locks */
-        KiReleaseDispatcherLockFromDpcLevel();
+        /* Release lock */
         ExReleaseResourceLock(&Resource->SpinLock, *OldIrql);
 
         /* Free the old table */
@@ -358,9 +358,7 @@
                  IN PKIRQL OldIrql)
 {
     POWNER_ENTRY Owner, Limit;
-    ULONG Size;
     POWNER_ENTRY FreeEntry = NULL;
-    DPRINT("ExpFindFreeEntry: %p\n", Resource);
 
     /* Sanity check */
     ASSERT(OldIrql != 0);
@@ -378,34 +376,24 @@
         Owner = Resource->OwnerTable;
         if (Owner)
         {
-            /* Loop every entry */
-            Size = Owner->TableSize;
-            Limit = &Owner[Size];
-
-            /* Go to the next entry and loop */
+            /* Set the limit, move to the next owner and loop owner entries */
+            Limit = &Owner[Owner->TableSize];
             Owner++;
             do
             {
-                /* Check for a free entry */
+                /* Check if the entry is free */
                 if (!Owner->OwnerThread)
                 {
-                    /* Found one, return it!*/
-                    FreeEntry = Owner;
-                    break;
+                    /* Update the resource entry and return it */
+                    KeGetCurrentThread()->ResourceIndex = (UCHAR)(Owner -
+                                                                  Resource->
+                                                                  OwnerTable);
+                    return Owner;
                 }
 
-                /* Move on */
+                /* Move to the next one */
                 Owner++;
             } while (Owner != Limit);
-
-            /* If we found a free entry by now, return it */
-            if (FreeEntry)
-            {
-                /* Set the resource index */
-                KeGetCurrentThread()->ResourceIndex = 
-                    (UCHAR)(Owner - Resource->OwnerTable);
-                return FreeEntry;
-            }
         }
 
         /* No free entry, expand the table */
@@ -445,63 +433,39 @@
                       IN PKIRQL OldIrql)
 {
     POWNER_ENTRY FreeEntry, Owner, Limit;
-    ULONG Size;
-    DPRINT("ExpFindEntryForThread: %p\n", Resource);
 
     /* Start by looking in the static array */
-    if (Resource->OwnerThreads[0].OwnerThread == Thread)
-    {
-        /* Found it, return it! */
-        return &Resource->OwnerThreads[0];
-    }
-    else if (Resource->OwnerThreads[1].OwnerThread == Thread)
-    {
-        /* Return it */
-        return &Resource->OwnerThreads[1];
-    }
-    else
-    {
-        /* Check if the first array is empty for our use */
-        FreeEntry = NULL;
-        if (!Resource->OwnerThreads[1].OwnerThread)
-        {
-            /* Use this as the first free entry */
-            FreeEntry = &Resource->OwnerThreads[1];
-        }
-
-        /* Get the current table pointer */
-        Owner = Resource->OwnerTable;
-        if (!Owner)
-        {
-            /* The current table is empty, so no size */
-            Size = 0;
-        }
-        else
-        {
-            /* We have a table, get it's size and limit */
-            Size = Owner->TableSize;
-            Limit = &Owner[Size];
-
-            /* Go to the next entry and loop */
+    Owner = &Resource->OwnerThreads[0];
+    if (Owner->OwnerThread == Thread) return Owner;
+    Owner++;
+    if (Owner->OwnerThread == Thread) return Owner;
+
+    /* Check if this is a free entry */
+    FreeEntry = !Owner->OwnerThread ? Owner : NULL;
+
+    /* Loop the table */
+    Owner = Resource->OwnerTable;
+    if (Owner)
+    {
+        /* Calculate the limit, skip the first entry, and start looping */
+        Limit = &Owner[Owner->TableSize];
+        Owner++;
+        do
+        {
+            /* Check if we found a match */
+            if (Owner->OwnerThread == Thread)
+            {
+                /* We did, update the index and return it */
+                KeGetCurrentThread()->ResourceIndex = (UCHAR)(Owner -
+                                                              Resource->
+                                                              OwnerTable);
+                return Owner;
+            }
+
+            /* If we don't yet have a free entry and this one is, choose it */
+            if (!(FreeEntry) && !(Owner->OwnerThread)) FreeEntry = Owner;
             Owner++;
-            do
-            {
-                /* Check for a match */
-                if (Owner->OwnerThread == Thread)
-                {
-                    /* Match found! Set the resource index */
-                    KeGetCurrentThread()->ResourceIndex = 
-                        (UCHAR)(Owner - Resource->OwnerTable);
-                    return Owner;
-                }
-
-                /* If we don't have a free entry yet, make this one free */
-                if (!(FreeEntry) && !(Owner->OwnerThread)) FreeEntry = Owner;
-
-                /* Move on */
-                Owner++;
-            } while (Owner != Limit);
-        }
+        } while (Owner != Limit);
     }
 
     /* Check if it's OK to do an expansion */
@@ -511,8 +475,8 @@
     if (FreeEntry)
     {
         /* Set the resource index */
-        KeGetCurrentThread()->ResourceIndex = (UCHAR)
-                                              (Owner - Resource->OwnerTable);
+        KeGetCurrentThread()->ResourceIndex = (UCHAR)(FreeEntry -
+                                                      Resource->OwnerTable);
         return FreeEntry;
     }
 
@@ -538,19 +502,11 @@
  * @remarks None.
  *
  *--*/
-#if 0
-
-/*
- * Disabled, read the comments bellow.
- */
 VOID
 FASTCALL
 ExpBoostOwnerThread(IN PKTHREAD Thread,
                     IN PKTHREAD OwnerThread)
 {
-    BOOLEAN Released = FALSE;
-    DPRINT("ExpBoostOwnerThread: %p\n", Thread);
-
     /* Make sure the owner thread is a pointer, not an ID */
     if (!((ULONG_PTR)OwnerThread & 0x3))
     {
@@ -558,8 +514,8 @@
         if ((OwnerThread->Priority < Thread->Priority) &&
             (OwnerThread->Priority < 14))
         {
-            /* Make sure we're at dispatch */
-            ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
+            /* Acquire the thread lock */
+            KiAcquireThreadLock(Thread);
 
             /* Set the new priority */
             OwnerThread->PriorityDecrement += 14 - OwnerThread->Priority;
@@ -568,17 +524,13 @@
             OwnerThread->Quantum = OwnerThread->QuantumReset;
 
             /* Update the kernel state */
-            KiSetPriorityThread(OwnerThread, 14, &Released);
-
-            /* Reacquire lock if it got releases */
-            if (Released) KiAcquireDispatcherLockFromDpcLevel();
-
-            /* Make sure we're still at dispatch */
-            ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
-        }
-    }
-}
-#endif
+            KiSetPriorityThread(OwnerThread, 14);
+
+            /* Release the thread lock */
+            KiReleaseThreadLock(Thread);
+        }
+    }
+}
 
 /*++
  * @name ExpWaitForResource
@@ -601,20 +553,21 @@
 ExpWaitForResource(IN PERESOURCE_XP Resource,
                    IN PVOID Object)
 {
-#if DBG
     ULONG i;
     ULONG Size;
-    KIRQL OldIrql;
     POWNER_ENTRY Owner;
-#endif
     ULONG WaitCount = 0;
     NTSTATUS Status;
     LARGE_INTEGER Timeout;
+    PKTHREAD Thread, OwnerThread;
+#if DBG
+    KIRQL OldIrql;
+#endif
 
     /* Increase contention count and use a 5 second timeout */
     Resource->ContentionCount++;
     Timeout.QuadPart = 500 * -10000;
-    for(;;)
+    for (;;)
     {
         /* Wait for ownership */
         Status = KeWaitForSingleObject(Object,
@@ -675,20 +628,10 @@
             ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
 #endif
         }
-#if 0
-/* 
- * Disabled because:
- * - We cannot access the OwnerTable without locking the resource.  
- * - The shared waiters may wait also on the semaphore. It makes no sense to boost a
waiting thread.  
- * - The thread header is initialized like KeWaitForSingleObject (?, ?, ?, TRUE, ?). 
- *   During the boost, possible the dispatcher lock is released but the thread block
(WaitNext) isn't changed. 
- */
 
         /* Check if we can boost */
-        if (!(Resource->Flag & ResourceHasDisabledPriorityBoost))
-        {
-            PKTHREAD Thread, OwnerThread;
-
+        if (IsBoostAllowed(Resource))
+        {
             /* Get the current kernel thread and lock the dispatcher */
             Thread = KeGetCurrentThread();
             Thread->WaitIrql = KiAcquireDispatcherLock();
@@ -725,7 +668,6 @@
                 }
             }
         }
-#endif
     }
 }
 
@@ -791,8 +733,6 @@
 
     /* Check if there is a shared owner or exclusive owner */
 TryAcquire:
-    DPRINT("ExAcquireResourceExclusiveLite(Resource 0x%p, Wait %d)\n",
-           Resource, Wait);
     if (Resource->ActiveCount)
     {
         /* Check if it's exclusively owned, and we own it */
@@ -831,7 +771,7 @@
                     ExpWaitForResource(Resource, Resource->ExclusiveWaiters);
 
                     /* Set owner and return success */
-                    Resource->OwnerThreads[0].OwnerThread = Thread;
+                    Resource->OwnerThreads[0].OwnerThread =
ExGetCurrentResourceThread();
                     return TRUE;
                 }
             }
@@ -905,21 +845,10 @@
 
     /* See if nobody owns us */
 TryAcquire:
-    DPRINT("ExAcquireResourceSharedLite(Resource 0x%p, Wait %d)\n",
-            Resource, Wait);
     if (!Resource->ActiveCount)
     {
-        if (Resource->NumberOfSharedWaiters == 0)
-        {
-           Owner = &Resource->OwnerThreads[1];
-        }
-        else
-        {
-           /* Find a free entry */
-           Owner = ExpFindFreeEntry(Resource, &OldIrql);
-           if (!Owner) goto TryAcquire;
-        }
-
+        /* Setup the owner entry */
+        Owner = &Resource->OwnerThreads[1];
         Owner->OwnerThread = Thread;
         Owner->OwnerCount = 1;
         Resource->ActiveCount = 1;
@@ -1066,8 +995,6 @@
 
     /* See if nobody owns us */
 TryAcquire:
-    DPRINT("ExAcquireSharedStarveExclusive(Resource 0x%p, Wait %d)\n",
-            Resource, Wait);
     if (!Resource->ActiveCount)
     {
         /* Nobody owns it, so let's take control */
@@ -1097,22 +1024,6 @@
         /* Find a free entry */
         Owner = ExpFindFreeEntry(Resource, &OldIrql);
         if (!Owner) goto TryAcquire;
-
-        /* If we got here, then we need to wait. Are we allowed? */
-        if (!Wait)
-        {
-            /* Release the lock and return */
-            ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
-            return TRUE;
-        }
-
-        /* Check if we have a shared waiters semaphore */
-        if (!Resource->SharedWaiters)
-        {
-            /* Allocate one and try again */
-            ExpAllocateSharedWaiterSemaphore(Resource, &OldIrql);
-            goto TryAcquire;
-        }
     }
     else
     {
@@ -1194,8 +1105,8 @@
  *--*/
 BOOLEAN
 NTAPI
-ExAcquireSharedWaitForExclusive(PERESOURCE resource,
-                                BOOLEAN Wait)
+ExAcquireSharedWaitForExclusive(IN PERESOURCE resource,
+                                IN BOOLEAN Wait)
 {
     KIRQL OldIrql;
     ERESOURCE_THREAD Thread;
@@ -1214,8 +1125,6 @@
 
     /* See if nobody owns us */
 TryAcquire:
-    DPRINT("ExAcquireSharedWaitForExclusive(Resource 0x%p, Wait %d)\n",
-            Resource, Wait);
     if (!Resource->ActiveCount)
     {
         /* Nobody owns it, so let's take control */
@@ -1241,16 +1150,20 @@
             ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
             return TRUE;
         }
-        else
-        {
-            /* Find a free entry */
-            Owner = ExpFindFreeEntry(Resource, &OldIrql);
-            if (!Owner) goto TryAcquire;
-
-            /* If we got here, then we need to wait. Are we allowed? */
+
+        /* Find a free entry */
+        Owner = ExpFindFreeEntry(Resource, &OldIrql);
+        if (!Owner) goto TryAcquire;
+    }
+    else
+    {
+        /* Try to find if there are exclusive waiters */
+        if (IsExclusiveWaiting(Resource))
+        {
+            /* We have to wait for the exclusive waiter to be done */
             if (!Wait)
             {
-                /* Release the lock and return */
+                /* So bail out if we're not allowed */
                 ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
                 return TRUE;
             }
@@ -1263,38 +1176,6 @@
                 goto TryAcquire;
             }
 
-            /* Now take control of the resource */
-            Owner->OwnerThread = Thread;
-            Owner->OwnerCount = 1;
-            Resource->NumberOfSharedWaiters++;
-
-            /* Release the lock and wait for it to be ours */
-            ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
-            ExpWaitForResource(Resource, Resource->SharedWaiters);
-            return TRUE;
-        }
-    }
-    else
-    {
-        /* Try to find if there are exclusive waiters */
-        if (IsExclusiveWaiting(Resource))
-        {
-            /* We have to wait for the exclusive waiter to be done */
-            if (!Wait)
-            {
-                /* So bail out if we're not allowed */
-                ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
-                return TRUE;
-            }
-
-            /* Check if we have a shared waiters semaphore */
-            if (!Resource->SharedWaiters)
-            {
-                /* Allocate one and try again */
-                ExpAllocateSharedWaiterSemaphore(Resource, &OldIrql);
-                goto TryAcquire;
-            }
-
             /* Now wait for the resource */
             Resource->NumberOfSharedWaiters++;
             ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
@@ -1304,7 +1185,7 @@
             ExAcquireResourceLock(&Resource->SpinLock, &OldIrql);
 
             /* Find who owns it now */
-            Owner = ExpFindEntryForThread(Resource, Thread, &OldIrql);
+            while (!(Owner = ExpFindEntryForThread(Resource, Thread, &OldIrql)));
 
             /* Sanity checks */
             ASSERT(IsOwnedExclusive(Resource) == FALSE);
@@ -1347,6 +1228,32 @@
             return TRUE;
         }
     }
+
+    /* We have to wait for the exclusive waiter to be done */
+    if (!Wait)
+    {
+        /* So bail out if we're not allowed */
+        ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
+        return TRUE;
+    }
+
+    /* Check if we have a shared waiters semaphore */
+    if (!Resource->SharedWaiters)
+    {
+        /* Allocate one and try again */
+        ExpAllocateSharedWaiterSemaphore(Resource, &OldIrql);
+        goto TryAcquire;
+    }
+
+    /* Take control */
+    Owner->OwnerThread = Thread;
+    Owner->OwnerCount = 1;
+    Resource->NumberOfSharedWaiters++;
+
+    /* Release the lock and return */
+    ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
+    ExpWaitForResource(Resource, Resource->SharedWaiters);
+    return TRUE;
 }
 
 /*++
@@ -1372,10 +1279,6 @@
     ULONG OldWaiters;
     KIRQL OldIrql;
     PERESOURCE_XP Resource = (PERESOURCE_XP)resource;
-    DPRINT("ExConvertExclusiveToSharedLite(Resource 0x%p)\n", Resource);
-
-    /* Lock the resource */
-    ExAcquireResourceLock(&Resource->SpinLock, &OldIrql);
 
     /* Sanity checks */
     ASSERT(KeIsExecutingDpc() == FALSE);
@@ -1383,14 +1286,17 @@
     ASSERT(IsOwnedExclusive(Resource));
     ASSERT(Resource->OwnerThreads[0].OwnerThread ==
(ERESOURCE_THREAD)PsGetCurrentThread());
 
+    /* Lock the resource */
+    ExAcquireResourceLock(&Resource->SpinLock, &OldIrql);
+
     /* Erase the exclusive flag */
     Resource->Flag &= ~ResourceOwnedExclusive;
 
     /* Check if we have shared waiters */
-    OldWaiters = Resource->NumberOfSharedWaiters;
-    if (OldWaiters)
+    if (IsSharedWaiting(Resource))
     {
         /* Make the waiters active owners */
+        OldWaiters = Resource->NumberOfSharedWaiters;
         Resource->ActiveCount = Resource->ActiveCount + (USHORT)OldWaiters;
         Resource->NumberOfSharedWaiters = 0;
 
@@ -1427,7 +1333,6 @@
 {
     KIRQL OldIrql;
     PERESOURCE_XP Resource = (PERESOURCE_XP)resource;
-    DPRINT("ExDeleteResourceLite(Resource 0x%p)\n", Resource);
 
     /* Sanity checks */
     ASSERT(IsSharedWaiting(Resource) == FALSE);
@@ -1559,7 +1464,6 @@
 ExInitializeResourceLite(PERESOURCE resource)
 {
     PERESOURCE_XP Resource = (PERESOURCE_XP)resource;
-    DPRINT("ExInitializeResourceLite(Resource 0x%p)\n", Resource);
 
     /* Clear the structure */
     RtlZeroMemory(Resource, sizeof(ERESOURCE_XP));
@@ -1806,7 +1710,6 @@
     KIRQL OldIrql;
     POWNER_ENTRY Owner, Limit;
     PERESOURCE_XP Resource = (PERESOURCE_XP)resource;
-    DPRINT("ExReleaseResourceLite: %p\n", Resource);
 
     /* Sanity check */
     ExpVerifyResource(Resource);
@@ -1832,42 +1735,45 @@
         /* Clear the owner */
         Resource->OwnerThreads[0].OwnerThread = 0;
 
-        /* Check if there are shared waiters */
-        if (IsSharedWaiting(Resource))
-        {
-            /* Remove the exclusive flag */
-            Resource->Flag &= ~ResourceOwnedExclusive;
-
-            /* Give ownage to another thread */
-            Count = Resource->NumberOfSharedWaiters;
-            Resource->ActiveCount = (USHORT)Count;
-            Resource->NumberOfSharedWaiters = 0;
-
-            /* Release lock and let someone else have it */
-            ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
-            KeReleaseSemaphore(Resource->SharedWaiters, 0, Count, FALSE);
-            return;
-         }
-         else if (IsExclusiveWaiting(Resource))
-         {
-            /* Give exclusive access */
-            Resource->OwnerThreads[0].OwnerThread = 1;
-            Resource->OwnerThreads[0].OwnerCount = 1;
-            Resource->ActiveCount = 1;
-            Resource->NumberOfExclusiveWaiters--;
-
-            /* Release the lock and give it away */
-            ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
-            KeSetEventBoostPriority(Resource->ExclusiveWaiters,
-                                    (PKTHREAD*)
-                                    &Resource->OwnerThreads[0].OwnerThread);
-            return;
-         }
+        /* Check the active count */
+        ASSERT(Resource->ActiveCount > 0);
+        if (!(--Resource->ActiveCount))
+        {
+            /* Check if there are shared waiters */
+            if (IsSharedWaiting(Resource))
+            {
+                /* Remove the exclusive flag */
+                Resource->Flag &= ~ResourceOwnedExclusive;
+
+                /* Give ownage to another thread */
+                Count = Resource->NumberOfSharedWaiters;
+                Resource->ActiveCount = (SHORT)Count;
+                Resource->NumberOfSharedWaiters = 0;
+
+                /* Release lock and let someone else have it */
+                ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
+                KeReleaseSemaphore(Resource->SharedWaiters, 0, Count, FALSE);
+                return;
+            }
+            else if (IsExclusiveWaiting(Resource))
+            {
+                /* Give exclusive access */
+                Resource->OwnerThreads[0].OwnerThread = 1;
+                Resource->OwnerThreads[0].OwnerCount = 1;
+                Resource->ActiveCount = 1;
+                Resource->NumberOfExclusiveWaiters--;
+
+                /* Release the lock and give it away */
+                ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
+                KeSetEventBoostPriority(Resource->ExclusiveWaiters,
+                                        (PKTHREAD*)
+                                        &Resource->OwnerThreads[0].OwnerThread);
+                return;
+            }
+        }
 
          /* Remove the exclusive flag */
          Resource->Flag &= ~ResourceOwnedExclusive;
-
-         Resource->ActiveCount = 0;
     }
     else
     {
@@ -1876,6 +1782,11 @@
         {
             /* Found it, get owner */
             Owner = &Resource->OwnerThreads[1];
+        }
+        else if (Resource->OwnerThreads[0].OwnerThread == Thread)
+        {
+            /* Found it, get owner */
+            Owner = &Resource->OwnerThreads[0];
         }
         else
         {
@@ -1965,7 +1876,6 @@
 
     /* Release lock */
     ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
-    return;
 }
 
 /*++
@@ -1998,7 +1908,6 @@
     POWNER_ENTRY Owner;
     PERESOURCE_XP Resource = (PERESOURCE_XP)resource;
     ASSERT(Thread != 0);
-    DPRINT("ExReleaseResourceForThreadLite: %p\n", Resource);
 
     /* Get the thread and lock the resource */
     ExAcquireResourceLock(&Resource->SpinLock, &OldIrql);
@@ -2034,7 +1943,7 @@
 
                 /* Give ownage to another thread */
                 Count = Resource->NumberOfSharedWaiters;
-                Resource->ActiveCount = (USHORT)Count;
+                Resource->ActiveCount = (SHORT)Count;
                 Resource->NumberOfSharedWaiters = 0;
 
                 /* Release lock and let someone else have it */
@@ -2147,7 +2056,6 @@
 
     /* Release lock */
     ExReleaseResourceLock(&Resource->SpinLock, OldIrql);
-    return;
 }
 
 /*++
@@ -2266,7 +2174,6 @@
     KIRQL OldIrql;
     BOOLEAN Acquired = FALSE;
     PERESOURCE_XP Resource = (PERESOURCE_XP)resource;
-    DPRINT("ExTryToAcquireResourceExclusiveLite: %p\n", Resource);
 
     /* Sanity check */
     ASSERT((Resource->Flag & ResourceNeverExclusive) == 0);