git.oblomov.eu Git - wine/blob - dlls/ntdll/handletable.c

   1 /*
   2  * Handle Tables
   3  *
   4  * Copyright (C) 2004 Robert Shearman
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #include "ntstatus.h"
  24 #define WIN32_NO_STATUS
  25 #include "windef.h"
  26 #include "winternl.h"
  27 #include "wine/debug.h"
  28 #include "ntdll_misc.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  31
  32 /**************************************************************************
  33  *      RtlInitializeHandleTable   (NTDLL.@)
  34  *
  35  * Initializes a handle table.
  36  *
  37  * PARAMS
  38  *  MaxHandleCount [I] The maximum number of handles the handle table will support.
  39  *  HandleSize     [I] The size of each handle.
  40  *  HandleTable    [I/O] The handle table.
  41  *
  42  * RETURNS
  43  *  Nothing.
  44  *
  45  * SEE
  46  *  RtlDestroyHandleTable().
  47  */
  48 void WINAPI RtlInitializeHandleTable(ULONG MaxHandleCount, ULONG HandleSize, RTL_HANDLE_TABLE * HandleTable)
  49 {
  50     TRACE("(%u, %u, %p)\n", MaxHandleCount, HandleSize, HandleTable);
  51
  52     memset(HandleTable, 0, sizeof(*HandleTable));
  53     HandleTable->MaxHandleCount = MaxHandleCount;
  54     HandleTable->HandleSize = HandleSize;
  55 }
  56
  57 /**************************************************************************
  58  *      RtlDestroyHandleTable   (NTDLL.@)
  59  *
  60  * Destroys a handle table and frees associated resources.
  61  *
  62  * PARAMS
  63  *  HandleTable    [I] The handle table.
  64  *
  65  * RETURNS
  66  *  Any status code returned by NtFreeVirtualMemory().
  67  *
  68  * NOTES
  69  *  The native version of this API doesn't free the virtual memory that has
  70  *  been previously reserved, only the committed memory. There is no harm
  71  *  in also freeing the reserved memory because it won't have been handed out
  72  *  to any callers. I believe it is "more polite" to free everything.
  73  *
  74  * SEE
  75  *  RtlInitializeHandleTable().
  76  */
  77 NTSTATUS WINAPI RtlDestroyHandleTable(RTL_HANDLE_TABLE * HandleTable)
  78 {
  79     SIZE_T Size = 0;
  80
  81     TRACE("(%p)\n", HandleTable);
  82
  83     /* native version only releases committed memory, but we also release reserved */
  84     return NtFreeVirtualMemory(
  85         NtCurrentProcess(),
  86         &HandleTable->FirstHandle,
  87         &Size,
  88         MEM_RELEASE);
  89 }
  90
  91 /**************************************************************************
  92  *      RtlpAllocateSomeHandles   (internal)
  93  *
  94  * Reserves memory for the handles if not previously done and commits memory
  95  * for a batch of handles if none are free and adds them to the free list.
  96  *
  97  * PARAMS
  98  *  HandleTable    [I/O] The handle table.
  99  *
 100  * RETURNS
 101  *  NTSTATUS code.
 102  */
 103 static NTSTATUS RtlpAllocateSomeHandles(RTL_HANDLE_TABLE * HandleTable)
 104 {
 105     NTSTATUS status;
 106     if (!HandleTable->FirstHandle)
 107     {
 108         PVOID FirstHandleAddr = NULL;
 109         SIZE_T MaxSize = HandleTable->MaxHandleCount * HandleTable->HandleSize;
 110
 111         /* reserve memory for the handles, but don't commit it yet because we
 112          * probably won't use most of it and it will use up physical memory */
 113         status = NtAllocateVirtualMemory(
 114             NtCurrentProcess(),
 115             &FirstHandleAddr,
 116             0,
 117             &MaxSize,
 118             MEM_RESERVE,
 119             PAGE_READWRITE);
 120         if (status != STATUS_SUCCESS)
 121             return status;
 122         HandleTable->FirstHandle = FirstHandleAddr;
 123         HandleTable->ReservedMemory = HandleTable->FirstHandle;
 124         HandleTable->MaxHandle = (char *)HandleTable->FirstHandle + MaxSize;
 125     }
 126     if (!HandleTable->NextFree)
 127     {
 128         SIZE_T Offset, CommitSize = 4096; /* one page */
 129         RTL_HANDLE * FreeHandle = NULL;
 130         PVOID NextAvailAddr = HandleTable->ReservedMemory;
 131
 132         if (HandleTable->ReservedMemory >= HandleTable->MaxHandle)
 133             return STATUS_NO_MEMORY; /* the handle table is completely full */
 134
 135         status = NtAllocateVirtualMemory(
 136             NtCurrentProcess(),
 137             &NextAvailAddr,
 138             0,
 139             &CommitSize,
 140             MEM_COMMIT,
 141             PAGE_READWRITE);
 142         if (status != STATUS_SUCCESS)
 143             return status;
 144
 145         for (Offset = 0; Offset < CommitSize; Offset += HandleTable->HandleSize)
 146         {
 147             /* make sure we don't go over handle limit, even if we can
 148              * because of rounding of the table size up to the next page
 149              * boundary */
 150             if ((char *)HandleTable->ReservedMemory + Offset >= (char *)HandleTable->MaxHandle)
 151                 break;
 152
 153             FreeHandle = (RTL_HANDLE *)((char *)HandleTable->ReservedMemory + Offset);
 154
 155             FreeHandle->Next = (RTL_HANDLE *)((char *)HandleTable->ReservedMemory +
 156                 Offset + HandleTable->HandleSize);
 157         }
 158
 159         /* shouldn't happen because we already test for this above, but
 160          * handle it just in case */
 161         if (!FreeHandle)
 162             return STATUS_NO_MEMORY;
 163
 164         /* set the last handle's Next pointer to NULL so that when we run
 165          * out of free handles we trigger another commit of memory and
 166          * initialize the free pointers */
 167         FreeHandle->Next = NULL;
 168
 169         HandleTable->NextFree = HandleTable->ReservedMemory;
 170
 171         HandleTable->ReservedMemory = (char *)HandleTable->ReservedMemory + CommitSize;
 172     }
 173     return STATUS_SUCCESS;
 174 }
 175
 176 /**************************************************************************
 177  *      RtlAllocateHandle   (NTDLL.@)
 178  *
 179  * Allocates a handle from the handle table.
 180  *
 181  * PARAMS
 182  *  HandleTable    [I/O] The handle table.
 183  *  HandleIndex    [O] Index of the handle returned. Optional.
 184  *
 185  * RETURNS
 186  *  Success: Pointer to allocated handle.
 187  *  Failure: NULL.
 188  *
 189  * SEE
 190  *  RtlFreeHandle().
 191  */
 192 RTL_HANDLE * WINAPI RtlAllocateHandle(RTL_HANDLE_TABLE * HandleTable, ULONG * HandleIndex)
 193 {
 194     RTL_HANDLE * ret;
 195
 196     TRACE("(%p, %p)\n", HandleTable, HandleIndex);
 197
 198     if (!HandleTable->NextFree && RtlpAllocateSomeHandles(HandleTable) != STATUS_SUCCESS)
 199         return NULL;
 200
 201     ret = (RTL_HANDLE *)HandleTable->NextFree;
 202     HandleTable->NextFree = ret->Next;
 203
 204     if (HandleIndex)
 205         *HandleIndex = (ULONG)(((PCHAR)ret - (PCHAR)HandleTable->FirstHandle) / HandleTable->HandleSize);
 206
 207     return ret;
 208 }
 209
 210 /**************************************************************************
 211  *      RtlFreeHandle   (NTDLL.@)
 212  *
 213  * Frees an allocated handle.
 214  *
 215  * PARAMS
 216  *  HandleTable    [I/O] The handle table.
 217  *  Handle         [I] The handle to be freed.
 218  *
 219  * RETURNS
 220  *  Success: TRUE.
 221  *  Failure: FALSE.
 222  *
 223  * SEE
 224  *  RtlAllocateHandle().
 225  */
 226 BOOLEAN WINAPI RtlFreeHandle(RTL_HANDLE_TABLE * HandleTable, RTL_HANDLE * Handle)
 227 {
 228     TRACE("(%p, %p)\n", HandleTable, Handle);
 229     /* NOTE: we don't validate the handle and we don't make Handle->Next even
 230      * again to signal that it is no longer in user - that is done as a side
 231      * effect of setting Handle->Next to the previously next free handle in
 232      * the handle table */
 233     memset(Handle, 0, HandleTable->HandleSize);
 234     Handle->Next = (RTL_HANDLE *)HandleTable->NextFree;
 235     HandleTable->NextFree = Handle;
 236     return TRUE;
 237 }
 238
 239 /**************************************************************************
 240  *      RtlIsValidHandle   (NTDLL.@)
 241  *
 242  * Determines whether a handle is valid or not.
 243  *
 244  * PARAMS
 245  *  HandleTable    [I] The handle table.
 246  *  Handle         [I] The handle to be tested.
 247  *
 248  * RETURNS
 249  *  Valid: TRUE.
 250  *  Invalid: FALSE.
 251  */
 252 BOOLEAN WINAPI RtlIsValidHandle(const RTL_HANDLE_TABLE * HandleTable, const RTL_HANDLE * Handle)
 253 {
 254     TRACE("(%p, %p)\n", HandleTable, Handle);
 255     /* make sure handle is within used region and that it is aligned on
 256      * a HandleTable->HandleSize boundary and that Handle->Next is odd,
 257      * indicating that the handle is active */
 258     if ((Handle >= (RTL_HANDLE *)HandleTable->FirstHandle) &&
 259       (Handle < (RTL_HANDLE *)HandleTable->ReservedMemory) &&
 260       !((ULONG_PTR)Handle & (HandleTable->HandleSize - 1)) &&
 261       ((ULONG_PTR)Handle->Next & 1))
 262         return TRUE;
 263     else
 264         return FALSE;
 265 }
 266
 267 /**************************************************************************
 268  *      RtlIsValidIndexHandle   (NTDLL.@)
 269  *
 270  * Determines whether a handle index is valid or not.
 271  *
 272  * PARAMS
 273  *  HandleTable    [I] The handle table.
 274  *  Index          [I] The index of the handle to be tested.
 275  *  ValidHandle    [O] The handle Index refers to.
 276  *
 277  * RETURNS
 278  *  Valid: TRUE.
 279  *  Invalid: FALSE.
 280  */
 281 BOOLEAN WINAPI RtlIsValidIndexHandle(const RTL_HANDLE_TABLE * HandleTable, ULONG Index, RTL_HANDLE ** ValidHandle)
 282 {
 283     RTL_HANDLE * Handle;
 284
 285     TRACE("(%p, %u, %p)\n", HandleTable, Index, ValidHandle);
 286     Handle = (RTL_HANDLE *)
 287         ((char *)HandleTable->FirstHandle + Index * HandleTable->HandleSize);
 288
 289     if (RtlIsValidHandle(HandleTable, Handle))
 290     {
 291         *ValidHandle = Handle;
 292         return TRUE;
 293     }
 294     return FALSE;
 295 }