git://git.jankratochvil.net / reactos.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
update for HEAD-2003091401
[reactos.git] / ntoskrnl / ex / resource.c
diff --git a/ntoskrnl/ex/resource.c b/ntoskrnl/ex/resource.c
index d0cbb1f..11d7fc5 100644 (file)
--- a/ntoskrnl/ex/resource.c
+++ b/ntoskrnl/ex/resource.c
@@ -36,6 +36,11 @@
 #define ResourceOwnedExclusive 0x80
 #define ResourceDisableBoost   0x08
 
+//#ifdef __USE_W32API
+//#define NONAMELESSUNION
+//#endif
+
+
 /* INCLUDES *****************************************************************/
 
 #include <ddk/ntddk.h>
@@ -70,6 +75,13 @@ ExTryToAcquireResourceExclusiveLite (
   return(ExAcquireResourceExclusiveLite(Resource,FALSE));
 }
 
+#ifdef ExAcquireResourceExclusive
+#undef ExAcquireResourceExclusive
+#endif
+
+/*
+ * @implemented
+ */
 BOOLEAN
 STDCALL
 ExAcquireResourceExclusive (
@@ -80,6 +92,10 @@ ExAcquireResourceExclusive (
    return(ExAcquireResourceExclusiveLite(Resource,Wait));
 }
 
+
+/*
+ * @implemented
+ */
 BOOLEAN
 STDCALL
 ExAcquireResourceExclusiveLite (
@@ -109,7 +125,7 @@ ExAcquireResourceExclusiveLite (
       && Resource->OwnerThreads[0].OwnerThread == ExGetCurrentResourceThread())
      {
        /* it's ok : same lock for same thread */
-       Resource->OwnerThreads[0].a.OwnerCount++;
+    Resource->OwnerThreads[0].OwnerCount++;
        KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
        DPRINT("ExAcquireResourceExclusiveLite() = TRUE\n");
        return(TRUE);
@@ -146,7 +162,7 @@ ExAcquireResourceExclusiveLite (
    Resource->Flag |= ResourceOwnedExclusive;
    Resource->ActiveCount = 1;
    Resource->OwnerThreads[0].OwnerThread = ExGetCurrentResourceThread();
-   Resource->OwnerThreads[0].a.OwnerCount = 1;
+   Resource->OwnerThreads[0].OwnerCount = 1;
    KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
    DPRINT("ExAcquireResourceExclusiveLite() = TRUE\n");
    return(TRUE);
@@ -166,8 +182,8 @@ static BOOLEAN EiRemoveSharedOwner(PERESOURCE Resource,
    
    if (Resource->OwnerThreads[1].OwnerThread == ResourceThreadId)
      {
-       Resource->OwnerThreads[1].a.OwnerCount--;
-       if (Resource->OwnerThreads[1].a.OwnerCount == 0)
+    Resource->OwnerThreads[1].OwnerCount--;
+    if (Resource->OwnerThreads[1].OwnerCount == 0)
          {
              Resource->ActiveCount--;
             Resource->OwnerThreads[1].OwnerThread = 0;
@@ -181,12 +197,12 @@ static BOOLEAN EiRemoveSharedOwner(PERESOURCE Resource,
        return(FALSE);;
      }
    
-   for (i=0; i<Resource->OwnerThreads[1].a.TableSize; i++)
+   for (i=0; i<Resource->OwnerThreads[1].TableSize; i++)
      {
        if (Resource->OwnerTable[i].OwnerThread == ResourceThreadId)
          {
-            Resource->OwnerTable[i].a.OwnerCount--;
-            if (Resource->OwnerTable[i].a.OwnerCount == 0)
+         Resource->OwnerTable[i].OwnerCount--;
+         if (Resource->OwnerTable[i].OwnerCount == 0)
               {
                  Resource->ActiveCount--;
                  Resource->OwnerTable[i].OwnerThread = 0;
@@ -216,7 +232,7 @@ static BOOLEAN EiAddSharedOwner(PERESOURCE Resource)
      {
        /* no owner, it's easy */
        Resource->OwnerThreads[1].OwnerThread = ExGetCurrentResourceThread();
-       Resource->OwnerThreads[1].a.OwnerCount = 1;
+    Resource->OwnerThreads[1].OwnerCount = 1;
        if (Resource->OwnerTable != NULL)
          {
             ExFreePool(Resource->OwnerTable);
@@ -242,7 +258,7 @@ static BOOLEAN EiAddSharedOwner(PERESOURCE Resource)
                                TAG_OWNER_TABLE);
        if (Resource->OwnerTable == NULL)
          {
-            KeBugCheck(0);
+            KEBUGCHECK(0);
             return(FALSE);
          }
        memset(Resource->OwnerTable,0,sizeof(OWNER_ENTRY)*3);
@@ -250,10 +266,10 @@ static BOOLEAN EiAddSharedOwner(PERESOURCE Resource)
               sizeof(OWNER_ENTRY));
        
        Resource->OwnerThreads[1].OwnerThread = 0;
-       Resource->OwnerThreads[1].a.TableSize = 3;
+    Resource->OwnerThreads[1].TableSize = 3;
        
        Resource->OwnerTable[1].OwnerThread = CurrentThread;
-       Resource->OwnerTable[1].a.OwnerCount = 1;
+    Resource->OwnerTable[1].OwnerCount = 1;
         Resource->ActiveCount++;
        
        return(TRUE);
@@ -262,15 +278,15 @@ static BOOLEAN EiAddSharedOwner(PERESOURCE Resource)
    DPRINT("Search free entries\n");
    
    DPRINT("Number of entries %d\n", 
-         Resource->OwnerThreads[1].a.TableSize);
+      Resource->OwnerThreads[1].TableSize);
    
    freeEntry = NULL;
-   for (i=0; i<Resource->OwnerThreads[1].a.TableSize; i++)
+   for (i=0; i<Resource->OwnerThreads[1].TableSize; i++)
      {
        if (Resource->OwnerTable[i].OwnerThread == CurrentThread)
          {
             DPRINT("Thread already owns resource\n");
-            Resource->OwnerTable[i].a.OwnerCount++;
+         Resource->OwnerTable[i].OwnerCount++;
             return(TRUE);
          }
        if (Resource->OwnerTable[i].OwnerThread == 0)
@@ -290,27 +306,30 @@ static BOOLEAN EiAddSharedOwner(PERESOURCE Resource)
        freeEntry = 
          ExAllocatePoolWithTag(NonPagedPool,
                                sizeof(OWNER_ENTRY)*
-                               (Resource->OwnerThreads[1].a.TableSize+1),
+                (Resource->OwnerThreads[1].TableSize+1),
                                TAG_OWNER_TABLE);
        if (freeEntry == NULL)
          {
-            KeBugCheck(0);
+            KEBUGCHECK(0);
             return(FALSE);
          }
        memcpy(freeEntry,Resource->OwnerTable,
-              sizeof(OWNER_ENTRY)*(Resource->OwnerThreads[1].a.TableSize));
+           sizeof(OWNER_ENTRY)*(Resource->OwnerThreads[1].TableSize));
        ExFreePool(Resource->OwnerTable);
        Resource->OwnerTable=freeEntry;
-       freeEntry=&Resource->OwnerTable[Resource->OwnerThreads[1].a.TableSize];
-       Resource->OwnerThreads[1].a.TableSize++;
+    freeEntry=&Resource->OwnerTable[Resource->OwnerThreads[1].TableSize];
+    Resource->OwnerThreads[1].TableSize++;
      }
    DPRINT("Creating entry\n");
    freeEntry->OwnerThread=ExGetCurrentResourceThread();
-   freeEntry->a.OwnerCount=1;
+   freeEntry->OwnerCount=1;
    Resource->ActiveCount++;
    return(TRUE);
 }
 
+/*
+ * @implemented
+ */
 BOOLEAN
 STDCALL
 ExAcquireResourceSharedLite (
@@ -352,7 +371,7 @@ ExAcquireResourceSharedLite (
        /* 
         * NOTE: Is this correct? Seems the same as ExConvertExclusiveToShared 
         */
-       Resource->OwnerThreads[0].a.OwnerCount++;
+    Resource->OwnerThreads[0].OwnerCount++;
        KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
        DPRINT("ExAcquireResourceSharedLite() = TRUE\n");
        return(TRUE);
@@ -391,6 +410,9 @@ ExAcquireResourceSharedLite (
    return(TRUE);
 }
 
+/*
+ * @implemented
+ */
 VOID
 STDCALL
 ExConvertExclusiveToSharedLite (
@@ -417,16 +439,16 @@ ExConvertExclusiveToSharedLite (
    if (!(Resource->Flag & ResourceOwnedExclusive))
      {
        /* Might not be what the caller expects, better bug check */
-       KeBugCheck(0);
+       KEBUGCHECK(0);
        KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
        return;
      }
    
    //transfer infos from entry 0 to entry 1 and erase entry 0
    Resource->OwnerThreads[1].OwnerThread=Resource->OwnerThreads[0].OwnerThread;
-   Resource->OwnerThreads[1].a.OwnerCount=Resource->OwnerThreads[0].a.OwnerCount;
+   Resource->OwnerThreads[1].OwnerCount=Resource->OwnerThreads[0].OwnerCount;
    Resource->OwnerThreads[0].OwnerThread=0;
-   Resource->OwnerThreads[0].a.OwnerCount=0;
+   Resource->OwnerThreads[0].OwnerCount=0;
    /* erase exclusive flag */
    Resource->Flag &= (~ResourceOwnedExclusive);
    /* if no shared waiters, that's all */
@@ -441,6 +463,9 @@ ExConvertExclusiveToSharedLite (
    DPRINT("ExConvertExclusiveToSharedLite() finished\n");
 }
 
+/*
+ * @implemented
+ */
 VOID
 STDCALL
 ExDisableResourceBoostLite (
@@ -450,6 +475,9 @@ ExDisableResourceBoostLite (
    Resource->Flag |= ResourceDisableBoost;
 }
 
+/*
+ * @implemented
+ */
 ULONG
 STDCALL
 ExGetExclusiveWaiterCount (
@@ -459,6 +487,9 @@ ExGetExclusiveWaiterCount (
   return(Resource->NumberOfExclusiveWaiters);
 }
 
+/*
+ * @implemented
+ */
 BOOLEAN
 STDCALL
 ExAcquireSharedStarveExclusive (
@@ -489,7 +520,7 @@ ExAcquireSharedStarveExclusive (
    if (Resource->ActiveCount == 0) 
      {
        Resource->OwnerThreads[1].OwnerThread=ExGetCurrentResourceThread();
-       Resource->OwnerThreads[1].a.OwnerCount=1;
+    Resource->OwnerThreads[1].OwnerCount=1;
        Resource->ActiveCount=1;
        KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
        DPRINT("ExAcquireSharedStarveExclusive() = TRUE\n");
@@ -500,7 +531,7 @@ ExAcquireSharedStarveExclusive (
        &&  Resource->OwnerThreads[0].OwnerThread==ExGetCurrentResourceThread())
      { 
        /* exclusive, but by same thread : it's ok */
-       Resource->OwnerThreads[0].a.OwnerCount++;
+    Resource->OwnerThreads[0].OwnerCount++;
        KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
        DPRINT("ExAcquireSharedStarveExclusive() = TRUE\n");
        return(TRUE);
@@ -531,6 +562,9 @@ ExAcquireSharedStarveExclusive (
    return(TRUE);
 }
 
+/*
+ * @implemented
+ */
 BOOLEAN
 STDCALL
 ExAcquireSharedWaitForExclusive (
@@ -541,6 +575,15 @@ ExAcquireSharedWaitForExclusive (
   return(ExAcquireResourceSharedLite(Resource,Wait));
 }
 
+
+#ifdef ExDeleteResource
+#undef ExDeleteResource
+#endif
+
+
+/*
+ * @implemented
+ */
 NTSTATUS
 STDCALL
 ExDeleteResource (
@@ -550,6 +593,9 @@ ExDeleteResource (
    return(ExDeleteResourceLite(Resource));
 }
 
+/*
+ * @implemented
+ */
 NTSTATUS
 STDCALL
 ExDeleteResourceLite (
@@ -563,6 +609,9 @@ ExDeleteResourceLite (
    return(STATUS_SUCCESS);;
 }
 
+/*
+ * @implemented
+ */
 ULONG
 STDCALL
 ExGetSharedWaiterCount (
@@ -572,6 +621,14 @@ ExGetSharedWaiterCount (
    return(Resource->NumberOfSharedWaiters);
 }
 
+
+#ifdef ExInitializeResource
+#undef ExInitializeResource
+#endif
+
+/*
+ * @implemented
+ */
 NTSTATUS
 STDCALL
 ExInitializeResource (
@@ -581,6 +638,9 @@ ExInitializeResource (
    return(ExInitializeResourceLite(Resource));
 }
 
+/*
+ * @implemented
+ */
 NTSTATUS STDCALL
 ExInitializeResourceLite (PERESOURCE   Resource)
 {
@@ -602,6 +662,9 @@ ExInitializeResourceLite (PERESOURCE        Resource)
    return(0);
 }
 
+/*
+ * @implemented
+ */
 BOOLEAN
 STDCALL
 ExIsResourceAcquiredExclusiveLite (
@@ -620,11 +683,23 @@ ExIsResourceAcquiredExclusiveLite (
          && Resource->OwnerThreads[0].OwnerThread==ExGetCurrentResourceThread());
 }
 
-ULONG
-STDCALL
-ExIsResourceAcquiredSharedLite (
-       PERESOURCE      Resource
-       )
+
+
+#ifdef ExIsResourceAcquiredSharedLite
+#undef ExIsResourceAcquiredSharedLite
+#endif
+
+
+/*
+ * @implemented
+ */
+ 
+ 
+//NTOSAPI
+//DDKAPI
+USHORT STDCALL
+ExIsResourceAcquiredSharedLite(
+  IN PERESOURCE  Resource)
 /*
  * FUNCTION: Returns whether the current thread has shared access to a given
  *           resource
@@ -637,26 +712,29 @@ ExIsResourceAcquiredSharedLite (
    ULONG i;
    if (Resource->OwnerThreads[0].OwnerThread == ExGetCurrentResourceThread())
      {
-       return(Resource->OwnerThreads[0].a.OwnerCount);
+    return(Resource->OwnerThreads[0].OwnerCount);
      }
    if (Resource->OwnerThreads[1].OwnerThread == ExGetCurrentResourceThread())
      {
-       return(Resource->OwnerThreads[1].a.OwnerCount);
+    return(Resource->OwnerThreads[1].OwnerCount);
      }
-   if (!Resource->OwnerThreads[1].a.TableSize) 
+   if (!Resource->OwnerThreads[1].TableSize) 
      {
        return(0);
      }
-   for (i=0; i<Resource->OwnerThreads[1].a.TableSize; i++)
+   for (i=0; i<Resource->OwnerThreads[1].TableSize; i++)
      {
        if (Resource->OwnerTable[i].OwnerThread==ExGetCurrentResourceThread())
          {
-            return Resource->OwnerTable[i].a.OwnerCount;
+         return Resource->OwnerTable[i].OwnerCount;
          }
      }
    return(0);
 }
 
+/*
+ * @implemented
+ */
 VOID
 STDCALL
 ExReinitializeResourceLite (
@@ -676,11 +754,14 @@ ExReinitializeResourceLite (
        ExFreePool(Resource->OwnerTable);
      }
    Resource->OwnerThreads[0].OwnerThread=0;
-   Resource->OwnerThreads[0].a.OwnerCount=0;
+   Resource->OwnerThreads[0].OwnerCount=0;
    Resource->OwnerThreads[1].OwnerThread=0;
-   Resource->OwnerThreads[1].a.OwnerCount=0;
+   Resource->OwnerThreads[1].OwnerCount=0;
 }
 
+/*
+ * @implemented
+ */
 VOID
 FASTCALL
 ExReleaseResourceLite (
@@ -691,6 +772,16 @@ ExReleaseResourceLite (
                                        ExGetCurrentResourceThread()));
 }
 
+
+
+#ifdef ExReleaseResourceForThread
+#undef ExReleaseResourceForThread
+#endif
+
+
+/*
+ * @implemented
+ */
 VOID
 STDCALL
 ExReleaseResourceForThread (
@@ -701,6 +792,10 @@ ExReleaseResourceForThread (
   return(ExReleaseResourceForThreadLite(Resource,ResourceThreadId));
 }
 
+
+/*
+ * @unimplemented
+ */
 VOID
 STDCALL
 ExReleaseResourceForThreadLite (
@@ -728,8 +823,8 @@ ExReleaseResourceForThreadLite (
      {
        DPRINT("Releasing from exclusive access\n");
        
-       Resource->OwnerThreads[0].a.OwnerCount--;
-       if (Resource->OwnerThreads[0].a.OwnerCount > 0)
+    Resource->OwnerThreads[0].OwnerCount--;
+    if (Resource->OwnerThreads[0].OwnerCount > 0)
          {
             KeReleaseSpinLock(&Resource->SpinLock, oldIrql);
             DPRINT("ExReleaseResourceForThreadLite() finished\n");
@@ -785,6 +880,9 @@ ExReleaseResourceForThreadLite (
 }
 
 
+/*
+ * @unimplemented
+ */
 VOID
 STDCALL
 ExSetResourceOwnerPointer (
Unnamed repository; edit this file 'description' to name the repository.