[ros-diffs] [weiden] 14007: - fixed handle table structures

- fixed handle table structures
- implement generic executive handle tables (since there don't exist
documents that describe the parameters of most of these functions (which
are kernel internal only), i made them up as required)
- adjusted OB's handle manager to use ex handle tables
- adjusted the client id manager to use ex handle tables
Modified: trunk/reactos/config
Modified: trunk/reactos/include/ddk/kefuncs.h
Modified: trunk/reactos/include/ntos/obtypes.h
Modified: trunk/reactos/ntoskrnl/Makefile
Added: trunk/reactos/ntoskrnl/ex/handle.c
Modified: trunk/reactos/ntoskrnl/ex/init.c
Modified: trunk/reactos/ntoskrnl/ex/sysinfo.c
Modified: trunk/reactos/ntoskrnl/ex/work.c
Modified: trunk/reactos/ntoskrnl/include/internal/ex.h
Modified: trunk/reactos/ntoskrnl/include/internal/ob.h
Modified: trunk/reactos/ntoskrnl/include/internal/ps.h
Modified: trunk/reactos/ntoskrnl/io/iomgr.c
Modified: trunk/reactos/ntoskrnl/io/pnpmgr.c
Modified: trunk/reactos/ntoskrnl/lpc/close.c
Modified: trunk/reactos/ntoskrnl/ob/handle.c
Modified: trunk/reactos/ntoskrnl/ob/object.c
Modified: trunk/reactos/ntoskrnl/ps/cid.c
Modified: trunk/reactos/ntoskrnl/ps/create.c
Modified: trunk/reactos/ntoskrnl/ps/idle.c
Modified: trunk/reactos/ntoskrnl/ps/kill.c
Modified: trunk/reactos/ntoskrnl/ps/process.c
Modified: trunk/reactos/ntoskrnl/ps/psmgr.c
Modified: trunk/reactos/ntoskrnl/ps/thread.c
Modified: trunk/reactos/subsys/win32k/misc/object.c
  _____  

Modified: trunk/reactos/config
--- trunk/reactos/config	2005-03-13 13:59:06 UTC (rev 14006)
+++ trunk/reactos/config	2005-03-13 14:21:47 UTC (rev 14007)
@@ -15,22 +15,22 @@

 # be optimized for. 
 #
 
-OARCH := i486
+OARCH := i586
 
 #
 # Whether to compile in the kernel debugger
 #
-KDBG := 0
+KDBG := 1
 
 #
 # Whether to compile for debugging
 #
-DBG := 0
+DBG := 1
 
 #
 # Whether to compile with optimizations
 #
-OPTIMIZED := 0
+OPTIMIZED := 1
 
 #
 # Whether to compile a multiprocessor or single processor version
  _____  

Modified: trunk/reactos/include/ddk/kefuncs.h
--- trunk/reactos/include/ddk/kefuncs.h	2005-03-13 13:59:06 UTC (rev
14006)
+++ trunk/reactos/include/ddk/kefuncs.h	2005-03-13 14:21:47 UTC (rev
14007)
@@ -42,6 +42,15 @@

 
 #ifndef __USE_W32API
 
+static __inline
+VOID
+KeMemoryBarrier(
+  VOID)
+{
+  volatile LONG Barrier;
+  __asm__ __volatile__ ("xchg %%eax, %0" : : "m" (Barrier) :
"%eax");
+}
+
 VOID STDCALL KeAcquireSpinLockAtDpcLevel (IN PKSPIN_LOCK
SpinLock);
 
 #define KefAcquireSpinLockAtDpcLevel KeAcquireSpinLockAtDpcLevel
  _____  

Modified: trunk/reactos/include/ntos/obtypes.h
--- trunk/reactos/include/ntos/obtypes.h	2005-03-13 13:59:06 UTC
(rev 14006)
+++ trunk/reactos/include/ntos/obtypes.h	2005-03-13 14:21:47 UTC
(rev 14007)
@@ -87,18 +87,42 @@

    PVOID SecurityQualityOfService;
 } OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
 
+typedef struct _HANDLE_TABLE_ENTRY_INFO {
+    ULONG AuditMask;
+} HANDLE_TABLE_ENTRY_INFO, *PHANDLE_TABLE_ENTRY_INFO;
+
+typedef struct _HANDLE_TABLE_ENTRY {
+    union {
+        PVOID Object;
+        ULONG_PTR ObAttributes;
+        PHANDLE_TABLE_ENTRY_INFO InfoTable;
+        ULONG_PTR Value;
+    } u1;
+    union {
+        ULONG GrantedAccess;
+        USHORT GrantedAccessIndex;
+        LONG NextFreeTableEntry;
+    } u2;
+} HANDLE_TABLE_ENTRY, *PHANDLE_TABLE_ENTRY;
+
 #endif /* __USE_W32API */
 
 typedef struct _HANDLE_TABLE
 {
-   LIST_ENTRY ListHead;
-   KSPIN_LOCK ListLock;
-} HANDLE_TABLE;
+    ULONG Flags;
+    LONG HandleCount;
+    PHANDLE_TABLE_ENTRY **Table;
+    PEPROCESS QuotaProcess;
+    HANDLE UniqueProcessId;
+    LONG FirstFreeTableEntry;
+    LONG NextIndexNeedingPool;
+    ERESOURCE HandleTableLock;
+    LIST_ENTRY HandleTableList;
+    KEVENT HandleContentionEvent;
+} HANDLE_TABLE, *PHANDLE_TABLE;
 
 #ifndef __USE_W32API
 
-typedef struct _HANDLE_TABLE *PHANDLE_TABLE;
-
 /*
  * FIXME: These will eventually become centerfold in the compliant Ob
Manager
  * For now, they are only here so Device Map is properly defined before
the header
  _____  

Modified: trunk/reactos/ntoskrnl/Makefile
--- trunk/reactos/ntoskrnl/Makefile	2005-03-13 13:59:06 UTC (rev
14006)
+++ trunk/reactos/ntoskrnl/Makefile	2005-03-13 14:21:47 UTC (rev
14007)
@@ -239,6 +239,7 @@

 	ex/event.o \
 	ex/evtpair.o \
 	ex/fmutex.o \
+	ex/handle.o \
 	ex/hashtab.o \
 	ex/init.o \
 	ex/interlck.o \
  _____  

Added: trunk/reactos/ntoskrnl/ex/handle.c
--- trunk/reactos/ntoskrnl/ex/handle.c	2005-03-13 13:59:06 UTC (rev
14006)
+++ trunk/reactos/ntoskrnl/ex/handle.c	2005-03-13 14:21:47 UTC (rev
14007)
@@ -0,0 +1,949 @@

+/* $Id:$
+ * 
+ * COPYRIGHT:       See COPYING in the top level directory
+ * PROJECT:         ReactOS kernel
+ * FILE:            ntoskrnl/ex/handle.c
+ * PURPOSE:         Generic Executive Handle Tables
+ * 
+ * PROGRAMMERS:     Thomas Weidenmueller <w3seek(a)reactos.com>
+ *
+ *  TODO:
+ *
+ *  - the last entry of a subhandle list should be reserved for
auditing
+ *
+ *  ExSweepHandleTable (???)
+ *  ExReferenceHandleDebugInfo
+ *  ExSnapShotHandleTables
+ *  ExpMoveFreeHandles (???)
+ */
+
+/* INCLUDES
*****************************************************************/
+
+#include <ntoskrnl.h>
+
+#define NDEBUG
+#include <internal/debug.h>
+
+static LIST_ENTRY ExpHandleTableHead;
+static FAST_MUTEX ExpHandleTableListLock;
+static LARGE_INTEGER ExpHandleShortWait;
+
+#define ExAcquireHandleTableListLock()
\
+  ExAcquireFastMutexUnsafe(&ExpHandleTableListLock)
+
+#define ExReleaseHandleTableListLock()
\
+  ExReleaseFastMutexUnsafe(&ExpHandleTableListLock)
+
+#define ExAcquireHandleTableLockExclusive(HandleTable)
\
+  ExAcquireResourceExclusiveLite(&(HandleTable)->HandleTableLock, TRUE)
+
+#define ExAcquireHandleTableLockShared(HandleTable)
\
+  ExAcquireResourceSharedLite(&(HandleTable)->HandleTableLock, TRUE)
+
+#define ExReleaseHandleTableLock(HandleTable)
\
+  ExReleaseResourceLite(&(HandleTable)->HandleTableLock)
+
+/*
+   5 bits: reserved
+   8 bits: top level index
+   10 bits: middle level index
+   9 bits: sub handle index
+*/
+#define N_TLI_BITS 8 /* top level index */
+#define N_MLI_BITS 10 /* middle level index */
+#define N_EI_BITS 9 /* sub handle index */
+#define TLI_OFFSET (N_MLI_BITS + N_EI_BITS)
+#define MLI_OFFSET N_EI_BITS
+#define EI_OFFSET 0
+
+#define N_TOPLEVEL_POINTERS (1 << N_TLI_BITS)
+#define N_MIDDLELEVEL_POINTERS (1 << N_MLI_BITS)
+#define N_SUBHANDLE_ENTRIES (1 << N_EI_BITS)
+#define EX_MAX_HANDLES (N_TOPLEVEL_POINTERS * N_MIDDLELEVEL_POINTERS *
N_SUBHANDLE_ENTRIES)
+
+#define VALID_HANDLE_MASK (((N_TOPLEVEL_POINTERS - 1) << TLI_OFFSET) |
\
+  ((N_MIDDLELEVEL_POINTERS - 1) << MLI_OFFSET) | ((N_SUBHANDLE_ENTRIES
- 1) << EI_OFFSET))
+#define TLI_FROM_HANDLE(index) (ULONG)(((index) >> TLI_OFFSET) &
(N_TOPLEVEL_POINTERS - 1))
+#define MLI_FROM_HANDLE(index) (ULONG)(((index) >> MLI_OFFSET) &
(N_MIDDLELEVEL_POINTERS - 1))
+#define ELI_FROM_HANDLE(index) (ULONG)(((index) >> EI_OFFSET) &
(N_SUBHANDLE_ENTRIES - 1))
+
+#define N_MAX_HANDLE (N_TOPLEVEL_POINTERS * N_MIDDLELEVEL_POINTERS *
N_SUBHANDLE_ENTRIES)
+
+#define BUILD_HANDLE(tli, mli, eli) ((((tli) & (N_TOPLEVEL_POINTERS -
1)) << TLI_OFFSET) | \
+  (((mli) & (N_MIDDLELEVEL_POINTERS - 1)) << MLI_OFFSET) | (((eli) &
(N_SUBHANDLE_ENTRIES - 1)) << EI_OFFSET))
+
+#define IS_INVALID_EX_HANDLE(index)
\
+  (((index) & ~VALID_HANDLE_MASK) != 0)
+#define IS_VALID_EX_HANDLE(index)
\
+  (((index) & ~VALID_HANDLE_MASK) == 0)
+
+/**********************************************************************
********/
+
+VOID
+ExpInitializeHandleTables(VOID)
+{
+  ExpHandleShortWait.QuadPart = -50000;
+  InitializeListHead(&ExpHandleTableHead);
+  ExInitializeFastMutex(&ExpHandleTableListLock);
+}
+
+PHANDLE_TABLE
+ExCreateHandleTable(IN PEPROCESS QuotaProcess  OPTIONAL)
+{
+  PHANDLE_TABLE HandleTable;
+  
+  PAGED_CODE();
+  
+  if(QuotaProcess != NULL)
+  {
+    /* FIXME - Charge process quota before allocating the handle table!
*/
+  }
+
+  /* allocate enough memory for the handle table and the lowest level
*/
+  HandleTable = ExAllocatePoolWithTag(NonPagedPool,
+                                      sizeof(HANDLE_TABLE) +
(N_TOPLEVEL_POINTERS * sizeof(PHANDLE_TABLE_ENTRY*)),
+                                      TAG('E', 'x', 'H',
't'));
+  if(HandleTable != NULL)
+  {
+    /* initialize the handle table */
+    HandleTable->Flags = 0;
+    HandleTable->HandleCount = 0;
+    HandleTable->Table = (PHANDLE_TABLE_ENTRY**)(HandleTable + 1);
+    HandleTable->QuotaProcess = QuotaProcess;
+    HandleTable->FirstFreeTableEntry = -1; /* no entries freed so far
*/
+    HandleTable->NextIndexNeedingPool = 0; /* no entries freed so far,
so we have to allocate already for the first handle */
+    HandleTable->UniqueProcessId = (QuotaProcess ?
QuotaProcess->UniqueProcessId : PsGetCurrentProcessId());
+
+    ExInitializeResource(&HandleTable->HandleTableLock);
+
+    KeInitializeEvent(&HandleTable->HandleContentionEvent,
+                      NotificationEvent,
+                      FALSE);
+
+    RtlZeroMemory(HandleTable->Table, N_TOPLEVEL_POINTERS *
sizeof(PHANDLE_TABLE_ENTRY*));
+
+    /* during bootup KeGetCurrentThread() might be NULL, needs to be
fixed... */
+    if(KeGetCurrentThread() != NULL)
+    {
+      /* insert it into the global handle table list */
+      KeEnterCriticalRegion();
+
+      ExAcquireHandleTableListLock();
+      InsertTailList(&ExpHandleTableHead,
+                     &HandleTable->HandleTableList);
+      ExReleaseHandleTableListLock();
+
+      KeLeaveCriticalRegion();
+    }
+    else
+    {
+      InsertTailList(&ExpHandleTableHead,
+                     &HandleTable->HandleTableList);
+    }
+  }
+  else
+  {
+    /* FIXME - return the quota to the process */
+  }
+  
+  return HandleTable;
+}
+
+static BOOLEAN
+ExLockHandleTableEntryNoDestructionCheck(IN PHANDLE_TABLE HandleTable,
+                                         IN PHANDLE_TABLE_ENTRY Entry)
+{
+  ULONG_PTR Current, New;
+
+  PAGED_CODE();
+
+  DPRINT("Entering handle table entry 0x%x lock...\n", Entry);
+
+  ASSERT(HandleTable);
+  ASSERT(Entry);
+
+  for(;;)
+  {
+    Current = (volatile ULONG_PTR)Entry->u1.Object;
+
+    if(!Current)
+    {
+      DPRINT("Attempted to lock empty handle table entry 0x%x or handle
table shut down\n", Entry);
+      break;
+    }
+
+    if(!(Current & EX_HANDLE_ENTRY_LOCKED))
+    {
+      New = Current | EX_HANDLE_ENTRY_LOCKED;
+      if(InterlockedCompareExchangePointer(&Entry->u1.Object,
+                                           (PVOID)New,
+                                           (PVOID)Current) ==
(PVOID)Current)
+      {
+        DPRINT("SUCCESS handle table 0x%x entry 0x%x lock\n",
HandleTable, Entry);
+        /* we acquired the lock */
+        return TRUE;
+      }
+    }
+
+    /* wait about 5ms at maximum so we don't wait forever in
unfortunate
+       co-incidences where releasing the lock in another thread happens
right
+       before we're waiting on the contention event to get pulsed,
which might
+       never happen again... */
+    KeWaitForSingleObject(&HandleTable->HandleContentionEvent,
+                          Executive,
+                          KernelMode,
+                          FALSE,
+                          &ExpHandleShortWait);
+  }
+
+  return FALSE;
+}
+
+VOID
+ExDestroyHandleTable(IN PHANDLE_TABLE HandleTable,
+                     IN PEX_DESTROY_HANDLE_CALLBACK
DestroyHandleCallback  OPTIONAL,
+                     IN PVOID Context  OPTIONAL)
+{
+  PHANDLE_TABLE_ENTRY **tlp, **lasttlp, *mlp, *lastmlp;
+  PEPROCESS QuotaProcess;
+  
+  PAGED_CODE();
+  
+  ASSERT(HandleTable);
+  
+  KeEnterCriticalRegion();
+  
+  /* ensure there's no other operations going by acquiring an exclusive
lock */
+  ExAcquireHandleTableLockExclusive(HandleTable);
+  
+  ASSERT(!(HandleTable->Flags & EX_HANDLE_TABLE_CLOSING));
+  
+  HandleTable->Flags |= EX_HANDLE_TABLE_CLOSING;
+  
+  KePulseEvent(&HandleTable->HandleContentionEvent,
+               EVENT_INCREMENT,
+               FALSE);
+  
+  /* remove the handle table from the global handle table list */
+  ExAcquireHandleTableListLock();
+  RemoveEntryList(&HandleTable->HandleTableList);
+  ExReleaseHandleTableListLock();
+  
+  /* call the callback function to cleanup the objects associated with
the
+     handle table */
+  if(DestroyHandleCallback != NULL)
+  {
+    for(tlp = HandleTable->Table, lasttlp = HandleTable->Table +
N_TOPLEVEL_POINTERS;
+        tlp != lasttlp;
+        tlp++)
+    {
+      if((*tlp) != NULL)
+      {
+        for(mlp = *tlp, lastmlp = (*tlp) + N_MIDDLELEVEL_POINTERS;
+            mlp != lastmlp;
+            mlp++)
+        {
+          if((*mlp) != NULL)
+          {
+            PHANDLE_TABLE_ENTRY curee, laste;
+            
+            for(curee = *mlp, laste = *mlp + N_SUBHANDLE_ENTRIES;
+                curee != laste;
+                curee++)
+            {
+              if(curee->u1.Object != NULL &&
ExLockHandleTableEntryNoDestructionCheck(HandleTable, curee))
+              {
+                DestroyHandleCallback(HandleTable, curee->u1.Object,
curee->u2.GrantedAccess, Context);
+                ExUnlockHandleTableEntry(HandleTable, curee);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  
+  QuotaProcess = HandleTable->QuotaProcess;
+  
+  /* free the tables */
+  for(tlp = HandleTable->Table, lasttlp = HandleTable->Table +
N_TOPLEVEL_POINTERS;
+      tlp != lasttlp;
+      tlp++)
+  {
+    if((*tlp) != NULL)
+    {
+      for(mlp = *tlp, lastmlp = (*tlp) + N_MIDDLELEVEL_POINTERS;
+          mlp != lastmlp;
+          mlp++)
+      {
+        if((*mlp) != NULL)
+        {
+          ExFreePool(*mlp);
+          
+          if(QuotaProcess != NULL)
+          {
+            /* FIXME - return the quota to the process */
+          }
+        }
+      }
+
+      ExFreePool(*tlp);
+      
+      if(QuotaProcess != NULL)
+      {
+        /* FIXME - return the quota to the process */
+      }
+    }
+  }
+  
+  ExReleaseHandleTableLock(HandleTable);
+  
+  KeLeaveCriticalRegion();
+  
+  /* free the handle table */
+  ExDeleteResource(&HandleTable->HandleTableLock);
+  ExFreePool(HandleTable);
+  
+  if(QuotaProcess != NULL)
+  {
+    /* FIXME - return the quota to the process */
+  }
+}
+
+PHANDLE_TABLE
+ExDupHandleTable(IN PEPROCESS QuotaProcess  OPTIONAL,
+                 IN PEX_DUPLICATE_HANDLE_CALLBACK
DuplicateHandleCallback  OPTIONAL,
+                 IN PVOID Context  OPTIONAL,
+                 IN PHANDLE_TABLE SourceHandleTable)
+{
+  PHANDLE_TABLE HandleTable;
+  
+  PAGED_CODE();
+  
+  ASSERT(SourceHandleTable);
+
+  HandleTable = ExCreateHandleTable(QuotaProcess);
+  if(HandleTable != NULL)
+  {
+    PHANDLE_TABLE_ENTRY **tlp, **srctlp, **etlp, *mlp, *srcmlp, *emlp,
stbl, srcstbl, estbl;
+    LONG tli, mli, eli;
+    
+    tli = mli = eli = 0;
+  
+    /* make sure the other handle table isn't being changed during the
duplication */
+    ExAcquireHandleTableLockShared(SourceHandleTable);
+    
+    /* allocate enough tables */
+    etlp = SourceHandleTable->Table + N_TOPLEVEL_POINTERS;
+    for(srctlp = SourceHandleTable->Table, tlp = HandleTable->Table;
+        srctlp != etlp;
+        srctlp++, tlp++)
+    {
+      if(*srctlp != NULL)
+      {
+        /* allocate middle level entry tables */
+        if(QuotaProcess != NULL)
+        {
+          /* FIXME - Charge process quota before allocating the handle
table! */
+        }
+        
+        *tlp = ExAllocatePoolWithTag(PagedPool,
+                                     N_MIDDLELEVEL_POINTERS *
sizeof(PHANDLE_TABLE_ENTRY),
+                                     TAG('E', 'x', 'H',
't'));
+        if(*tlp != NULL)
+        {
+          RtlZeroMemory(*tlp, N_MIDDLELEVEL_POINTERS *
sizeof(PHANDLE_TABLE_ENTRY));
+          
+          KeMemoryBarrier();
+          
+          emlp = *srctlp + N_MIDDLELEVEL_POINTERS;
+          for(srcmlp = *srctlp, mlp = *tlp;
+              srcmlp != emlp;
+              srcmlp++, mlp++)
+          {
+            if(*srcmlp != NULL)
+            {
+              /* allocate subhandle tables */
+              if(QuotaProcess != NULL)
+              {
+                /* FIXME - Charge process quota before allocating the
handle table! */
+              }
+
+              *mlp = ExAllocatePoolWithTag(PagedPool,
+                                           N_SUBHANDLE_ENTRIES *
sizeof(HANDLE_TABLE_ENTRY),
+                                           TAG('E', 'x', 'H',
't'));
+              if(*mlp != NULL)
+              {
+                RtlZeroMemory(*mlp, N_SUBHANDLE_ENTRIES *
sizeof(HANDLE_TABLE_ENTRY));
+              }
+              else
+              {
+                goto freehandletable;
+              }
+            }
+            else
+            {
+              *mlp = NULL;
+            }
+          }
+        }
+        else
+        {
+freehandletable:
+          DPRINT1("Failed to duplicate handle table 0x%x\n",
SourceHandleTable);
+
+          ExReleaseHandleTableLock(SourceHandleTable);
+          
+          ExDestroyHandleTable(HandleTable,
+                               NULL,
+                               NULL);
+          /* allocate an empty handle table */
+          return ExCreateHandleTable(QuotaProcess);
+        }
+      }
+    }
+
+    /* duplicate the handles */
+    HandleTable->HandleCount = SourceHandleTable->HandleCount;
+    HandleTable->FirstFreeTableEntry =
SourceHandleTable->FirstFreeTableEntry;
+    HandleTable->NextIndexNeedingPool =
SourceHandleTable->NextIndexNeedingPool;
+
+    /* make sure all tables are zeroed */
+    KeMemoryBarrier();
+
+    etlp = SourceHandleTable->Table + N_TOPLEVEL_POINTERS;
+    for(srctlp = SourceHandleTable->Table, tlp = HandleTable->Table;
+        srctlp != etlp;
+        srctlp++, tlp++, tli++)
+    {
+      if(*srctlp != NULL)
+      {
+        ASSERT(*tlp != NULL);
+
+        emlp = *srctlp + N_MIDDLELEVEL_POINTERS;
+        for(srcmlp = *srctlp, mlp = *tlp;
+            srcmlp != emlp;
+            srcmlp++, mlp++, mli++)
+        {
+          if(*srcmlp != NULL)
+          {
+            ASSERT(*mlp != NULL);
+
+            /* walk all handle entries and duplicate them if wanted */
+            estbl = *srcmlp + N_SUBHANDLE_ENTRIES;
+            for(srcstbl = *srcmlp, stbl = *mlp;
+                srcstbl != estbl;
+                srcstbl++, stbl++, eli++)
+            {
+              /* try to duplicate the source handle */
+              if(srcstbl->u1.Object != NULL &&
+                 ExLockHandleTableEntry(SourceHandleTable,
+                                        srcstbl))
+              {
+                /* ask the caller if this handle should be duplicated
*/
+                if(DuplicateHandleCallback != NULL &&
+                   !DuplicateHandleCallback(HandleTable,
+                                            srcstbl,
+                                            Context))
+                {
+                  /* free the entry and chain it into the free list */
+                  HandleTable->HandleCount--;
+                  stbl->u1.Object = NULL;
+                  stbl->u2.NextFreeTableEntry =
HandleTable->FirstFreeTableEntry;
+                  HandleTable->FirstFreeTableEntry = BUILD_HANDLE(tli,
mli, eli);
+                }
+                else
+                {
+                  /* duplicate the handle and unlock it */
+                  stbl->u2.GrantedAccess = srcstbl->u2.GrantedAccess;
+                  stbl->u1.ObAttributes = srcstbl->u1.ObAttributes &
~EX_HANDLE_ENTRY_LOCKED;
+                }
+                ExUnlockHandleTableEntry(SourceHandleTable,
+                                         srcstbl);
+              }
+              else
+              {
+                /* this is a free handle table entry, copy over the
entire
+                   structure as-is */
+                *stbl = *srcstbl;
+              }
+            }
+          }
+        }
+      }
+    }
+    
+    /* release the source handle table */
+    ExReleaseHandleTableLock(SourceHandleTable);
+  }
+  
+  return HandleTable;
+}
+
+static PHANDLE_TABLE_ENTRY
+ExpAllocateHandleTableEntry(IN PHANDLE_TABLE HandleTable,
+                            OUT PLONG Handle)
+{
+  PHANDLE_TABLE_ENTRY Entry = NULL;
+  
+  PAGED_CODE();
+  
+  ASSERT(HandleTable);
+  ASSERT(Handle);
+  ASSERT(KeGetCurrentThread() != NULL);
+  
+  DPRINT("HT[0x%x]: HandleCount: %d\n", HandleTable,
HandleTable->HandleCount);
+  
+  if(HandleTable->HandleCount < EX_MAX_HANDLES)
+  {
+    ULONG tli, mli, eli;
+    
+    if(HandleTable->FirstFreeTableEntry != -1)
+    {
+      /* there's a free handle entry we can just grab and use */
+      tli = TLI_FROM_HANDLE(HandleTable->FirstFreeTableEntry);
+      mli = MLI_FROM_HANDLE(HandleTable->FirstFreeTableEntry);
+      eli = ELI_FROM_HANDLE(HandleTable->FirstFreeTableEntry);
+      
+      /* the pointer should be valid in any way!!! */
+      ASSERT(HandleTable->Table[tli]);
+      ASSERT(HandleTable->Table[tli][mli]);
+      
+      Entry = &HandleTable->Table[tli][mli][eli];
+      
+      *Handle = HandleTable->FirstFreeTableEntry;
+      
+      /* save the index to the next free handle (if available) */
+      HandleTable->FirstFreeTableEntry = Entry->u2.NextFreeTableEntry;
+      Entry->u2.NextFreeTableEntry = 0;
+      Entry->u1.Object = NULL;
+      
+      HandleTable->HandleCount++;
+    }
+    else
+    {
+      /* we need to allocate a new subhandle table first */
+      PHANDLE_TABLE_ENTRY cure, laste, ntbl, *nmtbl;
+      ULONG i;
+      BOOLEAN AllocatedMtbl;
+
+      ASSERT(HandleTable->NextIndexNeedingPool <= N_MAX_HANDLE);
+      
+      /* the index of the next table to be allocated was saved in
+         NextIndexNeedingPool the last time a handle entry was
allocated and
+         the subhandle entry list was full. the subhandle entry index
of
+         NextIndexNeedingPool should be 0 here! */
+      tli = TLI_FROM_HANDLE(HandleTable->NextIndexNeedingPool);
+      mli = MLI_FROM_HANDLE(HandleTable->NextIndexNeedingPool);
+      DPRINT("HandleTable->NextIndexNeedingPool: 0x%x\n",
HandleTable->NextIndexNeedingPool);
+      DPRINT("tli: 0x%x mli: 0x%x eli: 0x%x\n", tli, mli,
ELI_FROM_HANDLE(HandleTable->NextIndexNeedingPool));
+
+      ASSERT(ELI_FROM_HANDLE(HandleTable->NextIndexNeedingPool) == 0);
+
+      DPRINT("HandleTable->Table[%d] == 0x%x\n", tli,
HandleTable->Table[tli]);
+      
+      /* allocate a middle level entry list if required */
+      nmtbl = HandleTable->Table[tli];
+      if(nmtbl == NULL)
+      {
+        if(HandleTable->QuotaProcess != NULL)
+        {
+          /* FIXME - Charge process quota before allocating the handle
table! */
+        }
+        
+        nmtbl = ExAllocatePoolWithTag(PagedPool,
+                                      N_MIDDLELEVEL_POINTERS *
sizeof(PHANDLE_TABLE_ENTRY),
+                                      TAG('E', 'x', 'H',
't'));
+        if(nmtbl == NULL)
+        {
+          if(HandleTable->QuotaProcess != NULL)
+          {
+            /* FIXME - return the quota to the process */
+          }
+          
+          return NULL;
+        }
+        
+        /* clear the middle level entry list */
+        RtlZeroMemory(nmtbl, N_MIDDLELEVEL_POINTERS *
sizeof(PHANDLE_TABLE_ENTRY));
+        
+        /* make sure the table was zeroed before we set one item */
+        KeMemoryBarrier();
+        
+        /* note, don't set the the pointer in the top level list yet
because we
+           might screw up lookups if allocating a subhandle entry table
failed
+           and this newly allocated table might get freed again */
+        AllocatedMtbl = TRUE;
+      }
+      else
+      {
+        AllocatedMtbl = FALSE;
+        
+        /* allocate a subhandle entry table in any case! */
+        ASSERT(nmtbl[mli] == NULL);
+      }
+
+      DPRINT("HandleTable->Table[%d][%d] == 0x%x\n", tli, mli,
nmtbl[mli]);
+
+      if(HandleTable->QuotaProcess != NULL)
+      {
+        /* FIXME - Charge process quota before allocating the handle
table! */
+      }
+
+      ntbl = ExAllocatePoolWithTag(PagedPool,
+                                   N_SUBHANDLE_ENTRIES *
sizeof(HANDLE_TABLE_ENTRY),
+                                   TAG('E', 'x', 'H',
't'));
+      if(ntbl == NULL)
+      {
+        if(HandleTable->QuotaProcess != NULL)
+        {
+          /* FIXME - Return process quota charged  */
+        }
+        
+        /* free the middle level entry list, if allocated, because it's
empty and
+           unused */
+        if(AllocatedMtbl)
+        {
+          ExFreePool(nmtbl);
+          
+          if(HandleTable->QuotaProcess != NULL)
+          {
+            /* FIXME - Return process quota charged  */
+          }
+        }
+        
+        return NULL;
+      }
+      
+      /* let's just use the very first entry */
+      Entry = ntbl;
+      Entry->u1.ObAttributes = EX_HANDLE_ENTRY_LOCKED;
+      Entry->u2.NextFreeTableEntry = 0;
+      
+      *Handle = HandleTable->NextIndexNeedingPool;
+      
+      HandleTable->HandleCount++;
+      
+      /* set the FirstFreeTableEntry member to the second entry and
chain the
+         free entries */
+      HandleTable->FirstFreeTableEntry =
HandleTable->NextIndexNeedingPool + 1;
+      for(cure = Entry + 1, laste = Entry + N_SUBHANDLE_ENTRIES, i =
HandleTable->FirstFreeTableEntry + 1;
+          cure != laste;
+          cure++, i++)
+      {
+        cure->u1.Object = NULL;
+        cure->u2.NextFreeTableEntry = i;
+      }
+      /* truncate the free entry list */
+      (cure - 1)->u2.NextFreeTableEntry = -1;
+
+      /* save the pointers to the allocated list(s) */
+      InterlockedExchangePointer(&nmtbl[mli], ntbl);
+      if(AllocatedMtbl)
+      {
+        InterlockedExchangePointer(&HandleTable->Table[tli], nmtbl);
+      }
+      
+      /* increment the NextIndexNeedingPool to the next index where we
need to
+         allocate new memory */
+      HandleTable->NextIndexNeedingPool += N_SUBHANDLE_ENTRIES;
+    }
+  }
+  else
+  {
+    DPRINT1("Can't allocate any more handles in handle table 0x%x!\n",
HandleTable);
+  }
+  
+  return Entry;
+}
+
+static VOID
+ExpFreeHandleTableEntry(IN PHANDLE_TABLE HandleTable,
+                        IN PHANDLE_TABLE_ENTRY Entry,
+                        IN LONG Handle)
+{
+  PAGED_CODE();
+  
+  ASSERT(HandleTable);
+  ASSERT(Entry);
+  ASSERT(IS_VALID_EX_HANDLE(Handle));
+  
+  DPRINT("ExpFreeHandleTableEntry HT:0x%x Entry:0x%x\n", HandleTable,
Entry);
+  
+  /* automatically unlock the entry if currently locked. We however
don't notify
+     anyone who waited on the handle because we're holding an exclusive
lock after
+     all and these locks will fail then */
+  InterlockedExchangePointer(&Entry->u1.Object, NULL);
+  Entry->u2.NextFreeTableEntry = HandleTable->FirstFreeTableEntry;
+  HandleTable->FirstFreeTableEntry = Handle;
+  
+  HandleTable->HandleCount--;
+}
+
+static PHANDLE_TABLE_ENTRY
+ExpLookupHandleTableEntry(IN PHANDLE_TABLE HandleTable,
+                          IN LONG Handle)
+{
+  PHANDLE_TABLE_ENTRY Entry = NULL;
+  
+  PAGED_CODE();
+  
+  ASSERT(HandleTable);
+  
+  if(IS_VALID_EX_HANDLE(Handle))
+  {
+    ULONG tli, mli, eli;
+    PHANDLE_TABLE_ENTRY *mlp;
+    
+    tli = TLI_FROM_HANDLE(Handle);
+    mli = MLI_FROM_HANDLE(Handle);
+    eli = ELI_FROM_HANDLE(Handle);
+    
+    mlp = HandleTable->Table[tli];
+    if(Handle < HandleTable->NextIndexNeedingPool &&
+       mlp != NULL && mlp[mli] != NULL && mlp[mli][eli].u1.Object !=
NULL)
+    {
+      Entry = &mlp[mli][eli];
+      DPRINT("handle lookup 0x%x -> entry 0x%x [HT:0x%x] ptr: 0x%x\n",
Handle, Entry, HandleTable, mlp[mli][eli].u1.Object);
+    }
+  }
+  else
+  {
+    DPRINT("Looking up invalid handle 0x%x\n", Handle);
+  }
+  
+  return Entry;
+}
+
+BOOLEAN
+ExLockHandleTableEntry(IN PHANDLE_TABLE HandleTable,
+                       IN PHANDLE_TABLE_ENTRY Entry)
+{
+  ULONG_PTR Current, New;
+
+  PAGED_CODE();
+  
+  DPRINT("Entering handle table entry 0x%x lock...\n", Entry);
+  
+  ASSERT(HandleTable);
+  ASSERT(Entry);
+  
+  for(;;)
+  {
+    Current = (volatile ULONG_PTR)Entry->u1.Object;
+    
+    if(!Current || (HandleTable->Flags & EX_HANDLE_TABLE_CLOSING))
+    {
+      DPRINT("Attempted to lock empty handle table entry 0x%x or handle
table shut down\n", Entry);
+      break;
+    }
+    
+    if(!(Current & EX_HANDLE_ENTRY_LOCKED))
+    {
+      New = Current | EX_HANDLE_ENTRY_LOCKED;
+      if(InterlockedCompareExchangePointer(&Entry->u1.Object,
+                                           (PVOID)New,
+                                           (PVOID)Current) ==
(PVOID)Current)
+      {
+        DPRINT("SUCCESS handle table 0x%x entry 0x%x lock\n",
HandleTable, Entry);
+        /* we acquired the lock */
+        return TRUE;
+      }
+    }
+
+    /* wait about 5ms at maximum so we don't wait forever in
unfortunate
+       co-incidences where releasing the lock in another thread happens
right
+       before we're waiting on the contention event to get pulsed,
which might
+       never happen again... */
+    KeWaitForSingleObject(&HandleTable->HandleContentionEvent,
+                          Executive,
+                          KernelMode,
+                          FALSE,
+                          &ExpHandleShortWait);
+  }
+
+  return FALSE;
+}
+
+VOID
+ExUnlockHandleTableEntry(IN PHANDLE_TABLE HandleTable,
+                         IN PHANDLE_TABLE_ENTRY Entry)
+{
+  ULONG_PTR Current, New;
+  
+  PAGED_CODE();
+  
+  ASSERT(HandleTable);
+  ASSERT(Entry);
+  
+  DPRINT("ExUnlockHandleTableEntry HT:0x%x Entry:0x%x\n", HandleTable,
Entry);
+  
+  Current = (volatile ULONG_PTR)Entry->u1.Object;
+
+  ASSERT(Current & EX_HANDLE_ENTRY_LOCKED);
+  
+  New = Current & ~EX_HANDLE_ENTRY_LOCKED;
+  
+  InterlockedExchangePointer(&Entry->u1.Object,
+                             (PVOID)New);
+
+  /* we unlocked the entry, pulse the contention event so threads
who're waiting
+     on the release can continue */
+  KePulseEvent(&HandleTable->HandleContentionEvent,
+               EVENT_INCREMENT,
+               FALSE);
+}
+
+LONG
+ExCreateHandle(IN PHANDLE_TABLE HandleTable,
+               IN PHANDLE_TABLE_ENTRY Entry)
+{
+  PHANDLE_TABLE_ENTRY NewHandleTableEntry;
+  LONG Handle = EX_INVALID_HANDLE;
+  
+  PAGED_CODE();
+  
+  ASSERT(HandleTable);
+  ASSERT(Entry);
+  
+  /* The highest bit in Entry->u1.Object has to be 1 so we make sure
it's a
+     pointer to kmode memory. It will cleared though because it also
indicates
+     the lock */
+  ASSERT((ULONG_PTR)Entry->u1.Object & EX_HANDLE_ENTRY_LOCKED);
+  
+  KeEnterCriticalRegion();
+  ExAcquireHandleTableLockExclusive(HandleTable);
+  
+  NewHandleTableEntry = ExpAllocateHandleTableEntry(HandleTable,
+                                                    &Handle);
+  if(NewHandleTableEntry != NULL)
+  {
+    *NewHandleTableEntry = *Entry;
+    
+    ExUnlockHandleTableEntry(HandleTable,
+                             NewHandleTableEntry);
+  }
+
+  ExReleaseHandleTableLock(HandleTable);
+  KeLeaveCriticalRegion();
+
+  return Handle;
+}
+
+BOOLEAN
+ExDestroyHandle(IN PHANDLE_TABLE HandleTable,
+                IN LONG Handle)
+{
+  PHANDLE_TABLE_ENTRY HandleTableEntry;
+  BOOLEAN Ret = FALSE;
+  
+  PAGED_CODE();
+  
+  ASSERT(HandleTable);
+  
+  KeEnterCriticalRegion();
+  ExAcquireHandleTableLockExclusive(HandleTable);
+  
+  HandleTableEntry = ExpLookupHandleTableEntry(HandleTable,
+                                               Handle);
+  
+  if(HandleTableEntry != NULL && ExLockHandleTableEntry(HandleTable,
HandleTableEntry))
+  {
+    /* free and automatically unlock the handle. However we don't need
to pulse
+       the contention event since other locks on this entry will fail
*/
+    ExpFreeHandleTableEntry(HandleTable,
+                            HandleTableEntry,
+                            Handle);
+    Ret = TRUE;
+  }
+  
+  ExReleaseHandleTableLock(HandleTable);
+  KeLeaveCriticalRegion();
+  
+  return Ret;
+}
+
+VOID
+ExDestroyHandleByEntry(IN PHANDLE_TABLE HandleTable,
+                       IN PHANDLE_TABLE_ENTRY Entry,
+                       IN LONG Handle)
+{
+  PAGED_CODE();
+
+  ASSERT(HandleTable);
+  ASSERT(Entry);
+  
+  /* This routine requires the entry to be locked */
+  ASSERT((ULONG_PTR)Entry->u1.Object & EX_HANDLE_ENTRY_LOCKED);
+  
+  DPRINT("DestroyHandleByEntry HT:0x%x Entry:0x%x\n", HandleTable,
Entry);
+
[truncated at 1000 lines; 2866 more skipped]