OS_Develop/Windows-Server-2003
OS_Develop/Windows-Server-2003
1
0
Fork 0
Code Pull Requests Activity
master
Windows-Server-2003/base/wmi/inc/chunkimp.h

847 lines
21 KiB
C
Raw Permalink Normal View History

Initiall commit
2024-08-04 01:28:15 +02:00
/*++
Copyright (c) 1997-1999 Microsoft Corporation
Module Name:
chunkimpl.h
Abstract:
This routine will manage allocations of chunks of structures. It also
contains a handy unicode to ansi conversion function
Author:
16-Jan-1997 AlanWar
Revision History:
--*/
PENTRYHEADER EtwpAllocEntry(
PCHUNKINFO ChunkInfo
)
/*++
Routine Description:
This routine will allocate a single structure within a list of chunks
of structures.
Arguments:
ChunkInfo describes the chunks of structures
Return Value:
Pointer to structure or NULL if one cannot be allocated. Entry returns
with its refcount set to 1
--*/
{
PLIST_ENTRY ChunkList, EntryList, FreeEntryHead;
PCHUNKHEADER Chunk;
PBYTE EntryPtr;
ULONG EntryCount, ChunkSize;
PENTRYHEADER Entry;
ULONG i;
#ifdef HEAPVALIDATION
EtwpAssert(RtlValidateProcessHeaps());
#endif
EtwpEnterCriticalSection();
ChunkList = ChunkInfo->ChunkHead.Flink;
//
// Loop over all chunks to see if any chunk has a free entry for us
while(ChunkList != &ChunkInfo->ChunkHead)
{
Chunk = CONTAINING_RECORD(ChunkList, CHUNKHEADER, ChunkList);
if (! IsListEmpty(&Chunk->FreeEntryHead))
{
EntryList = RemoveHeadList(&Chunk->FreeEntryHead);
Chunk->EntriesInUse++;
EtwpLeaveCriticalSection();
Entry = (CONTAINING_RECORD(EntryList,
ENTRYHEADER,
FreeEntryList));
EtwpAssert(Entry->Flags & FLAG_ENTRY_ON_FREE_LIST);
memset(Entry, 0, ChunkInfo->EntrySize);
Entry->Chunk = Chunk;
Entry->RefCount = 1;
Entry->Flags = ChunkInfo->InitialFlags;
Entry->Signature = ChunkInfo->Signature;
#if DBG
InterlockedIncrement(&ChunkInfo->AllocCount);
#endif
return(Entry);
}
ChunkList = ChunkList->Flink;
}
EtwpLeaveCriticalSection();
//
// There are no more free entries in any of the chunks. Allocate a new
// chunk if we can
ChunkSize = (ChunkInfo->EntrySize * ChunkInfo->EntriesPerChunk) +
sizeof(CHUNKHEADER);
Chunk = (PCHUNKHEADER)EtwpAlloc(ChunkSize);
if (Chunk != NULL)
{
//
// Initialize the chunk by building the free list of entries within
// it while also initializing each entry.
memset(Chunk, 0, ChunkSize);
FreeEntryHead = &Chunk->FreeEntryHead;
InitializeListHead(FreeEntryHead);
EntryPtr = (PBYTE)Chunk + sizeof(CHUNKHEADER);
EntryCount = ChunkInfo->EntriesPerChunk - 1;
for (i = 0; i < EntryCount; i++)
{
Entry = (PENTRYHEADER)EntryPtr;
Entry->Chunk = Chunk;
Entry->Flags = FLAG_ENTRY_ON_FREE_LIST;
InsertHeadList(FreeEntryHead,
&((PENTRYHEADER)EntryPtr)->FreeEntryList);
EntryPtr = EntryPtr + ChunkInfo->EntrySize;
}
//
// EntryPtr now points to the last entry in the chunk which has not
// been placed on the free list. This will be the entry returned
// to the caller.
Entry = (PENTRYHEADER)EntryPtr;
Entry->Chunk = Chunk;
Entry->RefCount = 1;
Entry->Flags = ChunkInfo->InitialFlags;
Entry->Signature = ChunkInfo->Signature;
Chunk->EntriesInUse = 1;
//
// Now place the newly allocated chunk onto the list of chunks
EtwpEnterCriticalSection();
InsertHeadList(&ChunkInfo->ChunkHead, &Chunk->ChunkList);
EtwpLeaveCriticalSection();
} else {
EtwpDebugPrint(("WMI: Could not allocate memory for new chunk %x\n",
ChunkInfo));
Entry = NULL;
}
return(Entry);
}
void EtwpFreeEntry(
PCHUNKINFO ChunkInfo,
PENTRYHEADER Entry
)
/*++
Routine Description:
This routine will free an entry within a chunk and if the chunk has no
more allocated entries then the chunk will be returned to the pool.
Arguments:
ChunkInfo describes the chunks of structures
Entry is the chunk entry to free
Return Value:
--*/
{
PCHUNKHEADER Chunk;
EtwpAssert(Entry != NULL);
EtwpAssert(! (Entry->Flags & FLAG_ENTRY_ON_FREE_LIST))
EtwpAssert((Entry->Flags & FLAG_ENTRY_INVALID))
EtwpAssert(Entry->RefCount == 0);
EtwpAssert(Entry->Signature == ChunkInfo->Signature);
Chunk = Entry->Chunk;
EtwpAssert(Chunk->EntriesInUse > 0);
EtwpEnterCriticalSection();
if ((--Chunk->EntriesInUse == 0) &&
(ChunkInfo->ChunkHead.Blink != &Chunk->ChunkList))
{
//
// We return the chunks memory back to the heap if there are no
// more entries within the chunk in use and the chunk was not the
// first chunk to be allocated.
RemoveEntryList(&Chunk->ChunkList);
EtwpLeaveCriticalSection();
EtwpFree(Chunk);
} else {
//
// Otherwise just mark the entry as free and put it back on the
// chunks free list.
#if DBG
memset(Entry, 0xCCCCCCCC, ChunkInfo->EntrySize);
#endif
Entry->Flags = FLAG_ENTRY_ON_FREE_LIST;
Entry->Signature = 0;
InsertTailList(&Chunk->FreeEntryHead, &Entry->FreeEntryList);
EtwpLeaveCriticalSection();
}
}
ULONG EtwpUnreferenceEntry(
PCHUNKINFO ChunkInfo,
PENTRYHEADER Entry
)
/*+++
Routine Description:
This routine will remove a reference count from the entry and if the
reference count reaches zero then the entry is removed from its active
list and then cleaned up and finally freed.
Arguments:
ChunkInfo points at structure that describes the entry
Entry is the entry to unreference
Return Value:
New refcount of the entry
---*/
{
ULONG RefCount;
EtwpAssert(Entry != NULL);
EtwpAssert(Entry->RefCount > 0);
EtwpAssert(Entry->Signature == ChunkInfo->Signature);
EtwpEnterCriticalSection();
InterlockedDecrement(&Entry->RefCount);
RefCount = Entry->RefCount;
if (RefCount == 0)
{
//
// Entry has reached a ref count of 0 so mark it as invalid and remove
// it from its active list.
Entry->Flags |= FLAG_ENTRY_INVALID;
if ((Entry->InUseEntryList.Flink != NULL) &&
(Entry->Flags & FLAG_ENTRY_REMOVE_LIST))
{
RemoveEntryList(&Entry->InUseEntryList);
}
EtwpLeaveCriticalSection();
if (ChunkInfo->EntryCleanup != NULL)
{
//
// Call cleanup routine to free anything contained by the entry
(*ChunkInfo->EntryCleanup)(ChunkInfo, Entry);
}
//
// Place the entry back on its free list
EtwpFreeEntry(ChunkInfo, Entry);
} else {
EtwpLeaveCriticalSection();
}
return(RefCount);
}
ULONG AnsiSizeForUnicodeString(
PWCHAR UnicodeString,
ULONG *AnsiSizeInBytes
)
/*++
Routine Description:
This routine will return the length needed to represent the unicode
string as ANSI
Arguments:
UnicodeString is the unicode string whose ansi length is returned
Return Value:
Number of bytes needed to represent unicode string as ANSI
--*/
{
EtwpAssert(UnicodeString != NULL);
try
{
*AnsiSizeInBytes = WideCharToMultiByte(CP_ACP,
0,
UnicodeString,
-1,
NULL,
0, NULL, NULL) * sizeof(WCHAR);
} except(EXCEPTION_EXECUTE_HANDLER) {
return(ERROR_NOACCESS);
}
return((*AnsiSizeInBytes == 0) ? GetLastError() : ERROR_SUCCESS);
}
ULONG UnicodeToAnsi(
LPCWSTR pszW,
LPSTR * ppszA,
ULONG *AnsiSizeInBytes OPTIONAL
)
/*++
Routine Description:
Convert Unicode string into its ansi equivalent
Arguments:
pszW is unicode string to convert
*ppszA on entry has a pointer to a ansi string into which the answer
is written. If NULL on entry then a buffer is allocated and returned
in it.
Return Value:
Error code
--*/
{
ULONG cbAnsi, cCharacters;
ULONG Status;
ULONG cbAnsiUsed;
BOOLEAN CallerReturnBuffer = (*ppszA != NULL);
//
// If input is null then just return the same.
if (pszW == NULL)
{
*ppszA = NULL;
return(ERROR_SUCCESS);
}
try
{
cCharacters = wcslen(pszW)+1;
} except(EXCEPTION_EXECUTE_HANDLER) {
EtwpDebugPrint(("WMI: Bad pointer %x passed to UnicodeToAnsi\n", pszW));
return(ERROR_NOACCESS);
}
// Determine number of bytes to be allocated for ANSI string. An
// ANSI string can have at most 2 bytes per character (for Double
// Byte Character Strings.)
cbAnsi = cCharacters*2;
// Use of the OLE allocator is not required because the resultant
// ANSI string will never be passed to another COM component. You
// can use your own allocator.
if (*ppszA == NULL)
{
*ppszA = (LPSTR) EtwpAlloc(cbAnsi);
if (NULL == *ppszA)
{
return(ERROR_NOT_ENOUGH_MEMORY);
}
}
// Convert to ANSI.
try
{
cbAnsiUsed = WideCharToMultiByte(CP_ACP, 0, pszW, cCharacters, *ppszA,
cbAnsi, NULL, NULL);
} except(EXCEPTION_EXECUTE_HANDLER) {
if (! CallerReturnBuffer)
{
EtwpFree(*ppszA);
*ppszA = NULL;
}
return(ERROR_NOACCESS);
}
if (AnsiSizeInBytes != NULL)
{
*AnsiSizeInBytes = cbAnsiUsed;
}
if (0 == cbAnsiUsed)
{
Status = GetLastError();
if (! CallerReturnBuffer)
{
EtwpFree(*ppszA);
*ppszA = NULL;
}
return(Status);
}
return(ERROR_SUCCESS);
}
ULONG AnsiToUnicode(
LPCSTR pszA,
LPWSTR * ppszW
)
/*++
Routine Description:
Convert Ansi string into its Unicode equivalent
Arguments:
pszA is ansi string to convert
*ppszW on entry has a pointer to a unicode string into which the answer
is written. If NULL on entry then a buffer is allocated and returned
in it.
Return Value:
Error code
--*/
{
ULONG cCharacters;
ULONG Status;
ULONG cbUnicodeUsed;
BOOLEAN CallerReturnBuffer = (*ppszW != NULL);
//
// If input is null then just return the same.
if (pszA == NULL)
{
*ppszW = NULL;
return(ERROR_SUCCESS);
}
//
// Determine the count of characters needed for Unicode string
try
{
cCharacters = MultiByteToWideChar(CP_ACP, 0, pszA, -1, NULL, 0);
} except(EXCEPTION_EXECUTE_HANDLER) {
EtwpDebugPrint(("WMI: Bad pointer %x passed to AnsiToUnicode\n", pszA));
return(ERROR_NOACCESS);
}
if (cCharacters == 0)
{
*ppszW = NULL;
return(GetLastError());
}
// Use of the OLE allocator is not required because the resultant
// ANSI string will never be passed to another COM component. You
// can use your own allocator.
if (*ppszW == NULL)
{
*ppszW = (LPWSTR) EtwpAlloc(cCharacters * sizeof(WCHAR));
}
if (NULL == *ppszW)
return(ERROR_NOT_ENOUGH_MEMORY);
// Convert to Unicode
try
{
cbUnicodeUsed = MultiByteToWideChar(CP_ACP, 0, pszA, -1, *ppszW, cCharacters);
} except(EXCEPTION_EXECUTE_HANDLER) {
if (! CallerReturnBuffer)
{
EtwpFree(*ppszW);
*ppszW = NULL;
}
return(ERROR_NOACCESS);
}
if (0 == cbUnicodeUsed)
{
Status = GetLastError();
if (! CallerReturnBuffer)
{
EtwpFree(*ppszW);
*ppszW = NULL;
}
return(Status);
}
return(ERROR_SUCCESS);
}
ULONG UnicodeSizeForAnsiString(
LPCSTR pszA,
ULONG *UnicodeSizeInBytes
)
/*++
Routine Description:
This routine will return the length needed to represent the ansi
string as UNICODE
Arguments:
pszA is ansi string to convert
Return Value:
Error code
--*/
{
EtwpAssert(pszA != NULL);
//
// Determine the count of characters needed for Unicode string
try
{
*UnicodeSizeInBytes = MultiByteToWideChar(CP_ACP, 0, pszA, -1, NULL, 0) * sizeof(WCHAR);
} except(EXCEPTION_EXECUTE_HANDLER) {
return(ERROR_NOACCESS);
}
return((*UnicodeSizeInBytes == 0) ? GetLastError() : ERROR_SUCCESS);
}
#if 0 // TODO: Delete me
ULONG EtwpStaticInstanceNameSize(
PWMIINSTANCEINFO WmiInstanceInfo
)
/*+++
Routine Description:
This routine will calculate the size needed to place instance names in
a WNODE_ALL_DATA
Arguments:
WmiInstanceInfo describes to instance set whose instance name size
is to be calculated
Return Value:
Size needed to place instance names in a WNODE_ALL_DATA plus 3. The
extra 3 bytes are added in case the OffsetInstanceNameOffsets need to be
padded since they must be on a 4 byte boundry.
---*/
{
ULONG NameSize;
ULONG i;
ULONG SuffixLen;
//
// If we already computed this then just return the results
if (WmiInstanceInfo->InstanceNameSize != 0)
{
return(WmiInstanceInfo->InstanceNameSize);
}
//
// Start with a name size of 3 in case the OffsetInstanceNameOffset will
// need to be padded so that it starts on a 4 byte boundry.
NameSize = 3;
if (WmiInstanceInfo->Flags & IS_INSTANCE_BASENAME)
{
//
// For static base names we assume that there will never be more than
// 999999 instances of a guid.
SuffixLen = MAXBASENAMESUFFIXSIZE * sizeof(WCHAR);
EtwpAssert((WmiInstanceInfo->BaseIndex + WmiInstanceInfo->InstanceCount) < 999999);
NameSize += ((wcslen(WmiInstanceInfo->BaseName) * sizeof(WCHAR)) + 2 + SuffixLen + sizeof(ULONG)) * WmiInstanceInfo->InstanceCount;
} else if (WmiInstanceInfo->Flags & IS_INSTANCE_STATICNAMES)
{
//
// Count up each size of the static instance names in the list
for (i = 0; i < WmiInstanceInfo->InstanceCount; i++)
{
NameSize += (wcslen(WmiInstanceInfo->StaticNamePtr[i]) + 2) * sizeof(WCHAR) + sizeof(ULONG);
}
}
WmiInstanceInfo->InstanceNameSize = NameSize;
return(NameSize);
}
void EtwpInsertStaticNames(
PWNODE_ALL_DATA Wnode,
ULONG MaxWnodeSize,
PWMIINSTANCEINFO WmiInstanceInfo
)
/*+++
Routine Description:
This routine will copy into the WNODE_ALL_DATA instance names for a
static instance name set. If the Wnode_All_data is too small then it
is converted to a WNODE_TOO_SMALL
Arguments:
Wnode points at the WNODE_ALL_DATA
MaxWnodeSize is the maximum size of the Wnode
WmiInstanceInfo is the Instance Info
Return Value:
---*/
{
PWCHAR NamePtr;
PULONG NameOffsetPtr;
ULONG InstanceCount;
ULONG i;
WCHAR Index[7];
PWCHAR StaticName;
ULONG SizeNeeded;
ULONG NameLen;
USHORT Len;
ULONG PaddedBufferSize;
if ((WmiInstanceInfo->Flags &
(IS_INSTANCE_BASENAME | IS_INSTANCE_STATICNAMES)) == 0)
{
EtwpDebugPrint(("WMI: Try to setup static names for dynamic guid\n"));
return;
}
InstanceCount = WmiInstanceInfo->InstanceCount;
//
// Pad out the size of the buffer to a 4 byte boundry since the
// OffsetInstanceNameOffsets must be on a 4 byte boundry
PaddedBufferSize = (Wnode->WnodeHeader.BufferSize + 3) & ~3;
//
// Compute size needed to write instance names.
SizeNeeded = (InstanceCount * sizeof(ULONG)) +
EtwpStaticInstanceNameSize(WmiInstanceInfo) +
Wnode->WnodeHeader.BufferSize;
if (SizeNeeded > MaxWnodeSize)
{
//
// If not enough space left then change into a WNODE_TOO_SMALL
Wnode->WnodeHeader.BufferSize = sizeof(WNODE_TOO_SMALL);
Wnode->WnodeHeader.Flags = WNODE_FLAG_TOO_SMALL;
((PWNODE_TOO_SMALL)Wnode)->SizeNeeded = SizeNeeded;
return;
}
//
// Build the array of offsets to instance names
NameOffsetPtr = (PULONG)((PBYTE)Wnode + PaddedBufferSize);
Wnode->OffsetInstanceNameOffsets = (ULONG)((PBYTE)NameOffsetPtr - (PBYTE)Wnode);
NamePtr = (PWCHAR)(NameOffsetPtr + InstanceCount);
if (WmiInstanceInfo->Flags & IS_INSTANCE_BASENAME)
{
if (WmiInstanceInfo->Flags & IS_PDO_INSTANCENAME)
{
Wnode->WnodeHeader.Flags |= WNODE_FLAG_PDO_INSTANCE_NAMES;
}
for (i = 0; i < InstanceCount; i++)
{
*NameOffsetPtr++ = (ULONG)((PBYTE)NamePtr - (PBYTE)Wnode);
wcscpy(NamePtr+1,
WmiInstanceInfo->BaseName);
swprintf(Index, L"%d", WmiInstanceInfo->BaseIndex+i);
wcscat(NamePtr+1, Index);
NameLen = wcslen(NamePtr+1) + 1;
*NamePtr = (USHORT)NameLen * sizeof(WCHAR);
NamePtr += NameLen + 1;
}
} else if (WmiInstanceInfo->Flags & IS_INSTANCE_STATICNAMES) {
for (i = 0; i < InstanceCount; i++)
{
*NameOffsetPtr++ = (ULONG)((PBYTE)NamePtr - (PBYTE)Wnode);
StaticName = WmiInstanceInfo->StaticNamePtr[i];
Len = (wcslen(StaticName)+1) * sizeof(WCHAR);
*NamePtr++ = Len;
wcscpy(NamePtr, StaticName);
NamePtr += Len / sizeof(WCHAR);
}
}
Wnode->WnodeHeader.BufferSize = SizeNeeded;
}
#endif
#ifdef HEAPVALIDATION
PVOID EtwpAlloc(
ULONG Size
)
{
PVOID p;
EtwpAssert(RtlValidateProcessHeaps());
p = RtlAllocateHeap(EtwpProcessHeap, 0, Size);
EtwpDebugPrint(("WMI: EtwpAlloc %x (%x)\n", p, Size));
return(p);
}
void EtwpFree(
PVOID p
)
{
EtwpDebugPrint(("WMI: EtwpFree %x\n", p));
EtwpAssert(p != NULL);
EtwpAssert(RtlValidateProcessHeaps());
RtlFreeHeap(EtwpProcessHeap, 0, p);
}
#endif
#ifdef MEMPHIS
void __cdecl DebugOut(char *Format, ...)
{
char Buffer[1024];
va_list pArg;
ULONG i;
va_start(pArg, Format);
i = _vsnprintf(Buffer, sizeof(Buffer), Format, pArg);
OutputDebugString(Buffer);
}
#else
void __cdecl DebugOut(char *Format, ...)
{
char Buffer[1024];
va_list pArg;
ULONG i;
i = sprintf(Buffer, "[%d] - ", GetTickCount());
va_start(pArg, Format);
i = _vsnprintf(&Buffer[i], sizeof(Buffer), Format, pArg);
DbgPrint(Buffer);
}
#endif
#ifndef MEMPHIS
ULONG EtwpCheckGuidAccess(
LPGUID Guid,
ACCESS_MASK DesiredAccess
)
{
HANDLE Handle;
ULONG Status;
Status = EtwpOpenKernelGuid(Guid,
DesiredAccess,
&Handle,
IOCTL_WMI_OPEN_GUID
);
if (Status == ERROR_SUCCESS)
{
CloseHandle(Handle);
}
return(Status);
}
ULONG EtwpBuildGuidObjectAttributes(
IN LPGUID Guid,
OUT POBJECT_ATTRIBUTES ObjectAttributes,
OUT PUNICODE_STRING GuidString,
OUT PWCHAR GuidObjectName
)
{
WCHAR GuidChar[37];
EtwpAssert(Guid != NULL);
//
// Build up guid name into the ObjectAttributes
//
swprintf(GuidChar, L"%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
Guid->Data1, Guid->Data2,
Guid->Data3,
Guid->Data4[0], Guid->Data4[1],
Guid->Data4[2], Guid->Data4[3],
Guid->Data4[4], Guid->Data4[5],
Guid->Data4[6], Guid->Data4[7]);
EtwpAssert(wcslen(GuidChar) == 36);
wcscpy(GuidObjectName, WmiGuidObjectDirectory);
wcscat(GuidObjectName, GuidChar);
RtlInitUnicodeString(GuidString, GuidObjectName);
memset(ObjectAttributes, 0, sizeof(OBJECT_ATTRIBUTES));
ObjectAttributes->Length = sizeof(OBJECT_ATTRIBUTES);
ObjectAttributes->ObjectName = GuidString;
return(ERROR_SUCCESS);
}
ULONG EtwpOpenKernelGuid(
LPGUID Guid,
ACCESS_MASK DesiredAccess,
PHANDLE Handle,
ULONG Ioctl
)
{
WMIOPENGUIDBLOCK WmiOpenGuidBlock;
UNICODE_STRING GuidString;
ULONG ReturnSize;
ULONG Status;
WCHAR GuidObjectName[WmiGuidObjectNameLength+1];
OBJECT_ATTRIBUTES ObjectAttributes;
Status = EtwpBuildGuidObjectAttributes(Guid,
&ObjectAttributes,
&GuidString,
GuidObjectName);
if (Status == ERROR_SUCCESS)
{
WmiOpenGuidBlock.ObjectAttributes = &ObjectAttributes;
WmiOpenGuidBlock.DesiredAccess = DesiredAccess;
Status = EtwpSendWmiKMRequest(NULL,
Ioctl,
(PVOID)&WmiOpenGuidBlock,
sizeof(WMIOPENGUIDBLOCK),
(PVOID)&WmiOpenGuidBlock,
sizeof(WMIOPENGUIDBLOCK),
&ReturnSize,
NULL);
if (Status == ERROR_SUCCESS)
{
*Handle = WmiOpenGuidBlock.Handle.Handle;
} else {
*Handle = NULL;
}
}
return(Status);
}
#endif

Copy Permalink