Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-05-23 11:04:52 +00:00
Code Issues Projects Releases Packages Wiki Activity

[REFORMATTING]

Browse source 
- Reindent the dbgbuffer.c code to the ReactOS Standard Indentation.

svn path=/trunk/; revision=54662
This commit is contained in:
Aleksey Bragin 2011-12-16 15:45:09 +00:00
parent ce424af08c
commit b8928d9e26
1 changed files with 296 additions and 292 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

588
reactos/lib/rtl/dbgbuffer.c
View file

@ -1,8 +1,8 @@
/* COPYRIGHT: See COPYING in the top level directory /* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
* FILE: lib/rtl/dbgbuffer.c * FILE: lib/rtl/dbgbuffer.c
* PROGRAMER: James Tabor * PROGRAMER: James Tabor
*/ */
/* INCLUDES *****************************************************************/ /* INCLUDES *****************************************************************/
@ -14,388 +14,392 @@
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
/* /*
* @unimplemented * @unimplemented
*/ */
PRTL_DEBUG_INFORMATION NTAPI PRTL_DEBUG_INFORMATION
NTAPI
RtlCreateQueryDebugBuffer(IN ULONG Size, RtlCreateQueryDebugBuffer(IN ULONG Size,
IN BOOLEAN EventPair) IN BOOLEAN EventPair)
{ {
NTSTATUS Status; NTSTATUS Status;
PRTL_DEBUG_INFORMATION Buf = NULL; PRTL_DEBUG_INFORMATION Buf = NULL;
SIZE_T ViewSize = 100 * PAGE_SIZE; SIZE_T ViewSize = 100 * PAGE_SIZE;
Status = NtAllocateVirtualMemory( NtCurrentProcess(), Status = NtAllocateVirtualMemory(NtCurrentProcess(),
(PVOID*)&Buf, (PVOID*)&Buf,
0, 0,
&ViewSize, &ViewSize,
MEM_COMMIT, MEM_COMMIT,
PAGE_READWRITE); PAGE_READWRITE);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status)) return NULL;
{
return NULL;
}
Buf->ViewBaseClient = Buf; Buf->ViewBaseClient = Buf;
Buf->ViewSize = (ULONG)ViewSize; Buf->ViewSize = (ULONG)ViewSize;
DPRINT("RtlCQDB: BA: %p BS: 0x%lx\n", Buf->ViewBaseClient, Buf->ViewSize); DPRINT("RtlCQDB: BA: %p BS: 0x%lx\n", Buf->ViewBaseClient, Buf->ViewSize);
return Buf; return Buf;
} }
/* /*
* @unimplemented * @unimplemented
*/ */
NTSTATUS NTAPI NTSTATUS
NTAPI
RtlDestroyQueryDebugBuffer(IN PRTL_DEBUG_INFORMATION Buf) RtlDestroyQueryDebugBuffer(IN PRTL_DEBUG_INFORMATION Buf)
{ {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
if (NULL != Buf) if (NULL != Buf)
{ {
Status = NtFreeVirtualMemory( NtCurrentProcess(), Status = NtFreeVirtualMemory(NtCurrentProcess(),
(PVOID)Buf, (PVOID)Buf,
(PSIZE_T)&Buf->ViewSize, /* FIXME: not portable! */ (PSIZE_T)&Buf->ViewSize, /* FIXME: not portable! */
MEM_RELEASE); MEM_RELEASE);
} }
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
DPRINT1("RtlDQDB: Failed to free VM!\n"); DPRINT1("RtlDQDB: Failed to free VM!\n");
} }
return Status; return Status;
} }
/* /*
* Based on lib/epsapi/enum/modules.c by KJK::Hyperion. * Based on lib/epsapi/enum/modules.c by KJK::Hyperion.
* *
*/ */
NTSTATUS NTAPI NTSTATUS
NTAPI
RtlpQueryRemoteProcessModules(HANDLE ProcessHandle, RtlpQueryRemoteProcessModules(HANDLE ProcessHandle,
IN PRTL_PROCESS_MODULES Modules OPTIONAL, IN PRTL_PROCESS_MODULES Modules OPTIONAL,
IN ULONG Size OPTIONAL, IN ULONG Size OPTIONAL,
OUT PULONG ReturnedSize) OUT PULONG ReturnedSize)
{ {
PROCESS_BASIC_INFORMATION pbiInfo; PROCESS_BASIC_INFORMATION pbiInfo;
PPEB_LDR_DATA ppldLdrData; PPEB_LDR_DATA ppldLdrData;
LDR_DATA_TABLE_ENTRY lmModule; LDR_DATA_TABLE_ENTRY lmModule;
PLIST_ENTRY pleListHead; PLIST_ENTRY pleListHead;
PLIST_ENTRY pleCurEntry; PLIST_ENTRY pleCurEntry;
PRTL_PROCESS_MODULE_INFORMATION ModulePtr = NULL; PRTL_PROCESS_MODULE_INFORMATION ModulePtr = NULL;
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
ULONG UsedSize = sizeof(ULONG); ULONG UsedSize = sizeof(ULONG);
ANSI_STRING AnsiString; ANSI_STRING AnsiString;
PCHAR p; PCHAR p;
DPRINT("RtlpQueryRemoteProcessModules Start\n"); DPRINT("RtlpQueryRemoteProcessModules Start\n");
/* query the process basic information (includes the PEB address) */ /* query the process basic information (includes the PEB address) */
Status = NtQueryInformationProcess ( ProcessHandle, Status = NtQueryInformationProcess(ProcessHandle,
ProcessBasicInformation, ProcessBasicInformation,
&pbiInfo, &pbiInfo,
sizeof(PROCESS_BASIC_INFORMATION), sizeof(PROCESS_BASIC_INFORMATION),
NULL); NULL);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
/* failure */ /* failure */
DPRINT("NtQueryInformationProcess 1 0x%lx \n", Status); DPRINT("NtQueryInformationProcess 1 0x%lx \n", Status);
return Status; return Status;
} }
if (Modules == NULL || Size == 0) if (Modules == NULL || Size == 0)
{ {
Status = STATUS_INFO_LENGTH_MISMATCH; Status = STATUS_INFO_LENGTH_MISMATCH;
} }
else else
{ {
Modules->NumberOfModules = 0; Modules->NumberOfModules = 0;
ModulePtr = &Modules->Modules[0]; ModulePtr = &Modules->Modules[0];
Status = STATUS_SUCCESS; Status = STATUS_SUCCESS;
} }
/* get the address of the PE Loader data */ /* get the address of the PE Loader data */
Status = NtReadVirtualMemory ( ProcessHandle, Status = NtReadVirtualMemory(ProcessHandle,
&(pbiInfo.PebBaseAddress->Ldr), &(pbiInfo.PebBaseAddress->Ldr),
&ppldLdrData, &ppldLdrData,
sizeof(ppldLdrData), sizeof(ppldLdrData),
NULL ); NULL);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
/* failure */ /* failure */
DPRINT("NtReadVirtualMemory 1 0x%lx \n", Status); DPRINT("NtReadVirtualMemory 1 0x%lx \n", Status);
return Status; return Status;
} }
/* head of the module list: the last element in the list will point to this */ /* head of the module list: the last element in the list will point to this */
pleListHead = &ppldLdrData->InLoadOrderModuleList; pleListHead = &ppldLdrData->InLoadOrderModuleList;
/* get the address of the first element in the list */ /* get the address of the first element in the list */
Status = NtReadVirtualMemory ( ProcessHandle, Status = NtReadVirtualMemory(ProcessHandle,
&(ppldLdrData->InLoadOrderModuleList.Flink), &(ppldLdrData->InLoadOrderModuleList.Flink),
&pleCurEntry, &pleCurEntry,
sizeof(pleCurEntry), sizeof(pleCurEntry),
NULL ); NULL);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
/* failure */ /* failure */
DPRINT("NtReadVirtualMemory 2 0x%lx \n", Status); DPRINT("NtReadVirtualMemory 2 0x%lx \n", Status);
return Status; return Status;
} }
while(pleCurEntry != pleListHead) while(pleCurEntry != pleListHead)
{ {
UNICODE_STRING Unicode;
WCHAR Buffer[256 * sizeof(WCHAR)];
UNICODE_STRING Unicode; /* read the current module */
WCHAR Buffer[256 * sizeof(WCHAR)]; Status = NtReadVirtualMemory(ProcessHandle,
CONTAINING_RECORD(pleCurEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks),
&lmModule,
sizeof(LDR_DATA_TABLE_ENTRY),
NULL);
/* read the current module */ /* Import module name from remote Process user space. */
Status = NtReadVirtualMemory ( ProcessHandle, Unicode.Length = lmModule.FullDllName.Length;
CONTAINING_RECORD(pleCurEntry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks), Unicode.MaximumLength = lmModule.FullDllName.MaximumLength;
&lmModule, Unicode.Buffer = Buffer;
sizeof(LDR_DATA_TABLE_ENTRY),
NULL );
/* Import module name from remote Process user space. */ Status = NtReadVirtualMemory(ProcessHandle,
Unicode.Length = lmModule.FullDllName.Length; lmModule.FullDllName.Buffer,
Unicode.MaximumLength = lmModule.FullDllName.MaximumLength; Unicode.Buffer,
Unicode.Buffer = Buffer; Unicode.Length,
NULL);
Status = NtReadVirtualMemory ( ProcessHandle, if (!NT_SUCCESS(Status))
lmModule.FullDllName.Buffer,
Unicode.Buffer,
Unicode.Length,
NULL );
if (!NT_SUCCESS(Status))
{
/* failure */
DPRINT( "NtReadVirtualMemory 3 0x%lx \n", Status);
return Status;
}
DPRINT(" Module %wZ\n", &Unicode);
if (UsedSize > Size)
{ {
Status = STATUS_INFO_LENGTH_MISMATCH; /* failure */
DPRINT( "NtReadVirtualMemory 3 0x%lx \n", Status);
return Status;
} }
else if (Modules != NULL)
DPRINT(" Module %wZ\n", &Unicode);
if (UsedSize > Size)
{ {
ModulePtr->Section = 0; Status = STATUS_INFO_LENGTH_MISMATCH;
ModulePtr->MappedBase = NULL; // FIXME: ??
ModulePtr->ImageBase = lmModule.DllBase;
ModulePtr->ImageSize = lmModule.SizeOfImage;
ModulePtr->Flags = lmModule.Flags;
ModulePtr->LoadOrderIndex = 0; // FIXME: ??
ModulePtr->InitOrderIndex = 0; // FIXME: ??
ModulePtr->LoadCount = lmModule.LoadCount;
AnsiString.Length = 0;
AnsiString.MaximumLength = 256;
AnsiString.Buffer = ModulePtr->FullPathName;
RtlUnicodeStringToAnsiString(&AnsiString,
&Unicode,
FALSE);
p = strrchr(ModulePtr->FullPathName, '\\');
if (p != NULL)
ModulePtr->OffsetToFileName = (USHORT)(p - ModulePtr->FullPathName + 1);
else
ModulePtr->OffsetToFileName = 0;
ModulePtr++;
Modules->NumberOfModules++;
} }
UsedSize += sizeof(RTL_PROCESS_MODULE_INFORMATION); else if (Modules != NULL)
{
ModulePtr->Section = 0;
ModulePtr->MappedBase = NULL; // FIXME: ??
ModulePtr->ImageBase = lmModule.DllBase;
ModulePtr->ImageSize = lmModule.SizeOfImage;
ModulePtr->Flags = lmModule.Flags;
ModulePtr->LoadOrderIndex = 0; // FIXME: ??
ModulePtr->InitOrderIndex = 0; // FIXME: ??
ModulePtr->LoadCount = lmModule.LoadCount;
/* address of the next module in the list */ AnsiString.Length = 0;
pleCurEntry = lmModule.InLoadOrderLinks.Flink; AnsiString.MaximumLength = 256;
} AnsiString.Buffer = ModulePtr->FullPathName;
RtlUnicodeStringToAnsiString(&AnsiString,
&Unicode,
FALSE);
if (ReturnedSize != 0) p = strrchr(ModulePtr->FullPathName, '\\');
*ReturnedSize = UsedSize; if (p != NULL)
ModulePtr->OffsetToFileName = (USHORT)(p - ModulePtr->FullPathName + 1);
else
ModulePtr->OffsetToFileName = 0;
DPRINT("RtlpQueryRemoteProcessModules End\n"); ModulePtr++;
Modules->NumberOfModules++;
}
UsedSize += sizeof(RTL_PROCESS_MODULE_INFORMATION);
/* address of the next module in the list */
pleCurEntry = lmModule.InLoadOrderLinks.Flink;
}
if (ReturnedSize != 0)
*ReturnedSize = UsedSize;
DPRINT("RtlpQueryRemoteProcessModules End\n");
/* success */ /* success */
return (STATUS_SUCCESS); return (STATUS_SUCCESS);
} }
/* /*
* @unimplemented * @unimplemented
*/ */
NTSTATUS NTAPI NTSTATUS
NTAPI
RtlQueryProcessDebugInformation(IN ULONG ProcessId, RtlQueryProcessDebugInformation(IN ULONG ProcessId,
IN ULONG DebugInfoMask, IN ULONG DebugInfoMask,
IN OUT PRTL_DEBUG_INFORMATION Buf) IN OUT PRTL_DEBUG_INFORMATION Buf)
{ {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
ULONG Pid = (ULONG)(ULONG_PTR) NtCurrentTeb()->ClientId.UniqueProcess; ULONG Pid = (ULONG)(ULONG_PTR) NtCurrentTeb()->ClientId.UniqueProcess;
Buf->Flags = DebugInfoMask; Buf->Flags = DebugInfoMask;
Buf->OffsetFree = sizeof(RTL_DEBUG_INFORMATION); Buf->OffsetFree = sizeof(RTL_DEBUG_INFORMATION);
DPRINT("QueryProcessDebugInformation Start\n"); DPRINT("QueryProcessDebugInformation Start\n");
/* /*
Currently ROS can not read-only from kenrel space, and doesn't Currently ROS can not read-only from kenrel space, and doesn't
check for boundaries inside kernel space that are page protected check for boundaries inside kernel space that are page protected
from every one but the kernel. aka page 0 - 2 from every one but the kernel. aka page 0 - 2
*/ */
if (ProcessId <= 1) if (ProcessId <= 1)
{ {
Status = STATUS_ACCESS_VIOLATION; Status = STATUS_ACCESS_VIOLATION;
}
else
if (Pid == ProcessId)
{
if (DebugInfoMask & RTL_DEBUG_QUERY_MODULES)
{
PRTL_PROCESS_MODULES Mp;
ULONG ReturnSize = 0;
ULONG MSize;
Mp = (PRTL_PROCESS_MODULES)(Buf + Buf->OffsetFree);
/* I like this better than the do & while loop. */
Status = LdrQueryProcessModuleInformation( NULL,
0 ,
&ReturnSize);
Status = LdrQueryProcessModuleInformation( Mp,
ReturnSize ,
&ReturnSize);
if (!NT_SUCCESS(Status))
{
return Status;
}
MSize = Mp->NumberOfModules * (sizeof(RTL_PROCESS_MODULES) + 8);
Buf->Modules = Mp;
Buf->OffsetFree = Buf->OffsetFree + MSize;
}
if (DebugInfoMask & RTL_DEBUG_QUERY_HEAPS)
{
PRTL_PROCESS_HEAPS Hp;
ULONG HSize;
Hp = (PRTL_PROCESS_HEAPS)(Buf + Buf->OffsetFree);
HSize = sizeof(RTL_PROCESS_HEAPS);
if (DebugInfoMask & RTL_DEBUG_QUERY_HEAP_TAGS)
{
}
if (DebugInfoMask & RTL_DEBUG_QUERY_HEAP_BLOCKS)
{
}
Buf->Heaps = Hp;
Buf->OffsetFree = Buf->OffsetFree + HSize;
}
if (DebugInfoMask & RTL_DEBUG_QUERY_LOCKS)
{
PRTL_PROCESS_LOCKS Lp;
ULONG LSize;
Lp = (PRTL_PROCESS_LOCKS)(Buf + Buf->OffsetFree);
LSize = sizeof(RTL_PROCESS_LOCKS);
Buf->Locks = Lp;
Buf->OffsetFree = Buf->OffsetFree + LSize;
} }
else
if (Pid == ProcessId)
{
if (DebugInfoMask & RTL_DEBUG_QUERY_MODULES)
{
PRTL_PROCESS_MODULES Mp;
ULONG ReturnSize = 0;
ULONG MSize;
DPRINT("QueryProcessDebugInformation end \n"); Mp = (PRTL_PROCESS_MODULES)(Buf + Buf->OffsetFree);
DPRINT("QueryDebugInfo : 0x%lx\n", Buf->OffsetFree);
}
else
{
HANDLE hProcess;
CLIENT_ID ClientId;
OBJECT_ATTRIBUTES ObjectAttributes;
Buf->TargetProcessHandle = NtCurrentProcess(); /* I like this better than the do & while loop. */
Status = LdrQueryProcessModuleInformation(NULL,
0,
&ReturnSize);
Status = LdrQueryProcessModuleInformation(Mp,
ReturnSize ,
&ReturnSize);
if (!NT_SUCCESS(Status))
{
return Status;
}
ClientId.UniqueThread = 0; MSize = Mp->NumberOfModules * (sizeof(RTL_PROCESS_MODULES) + 8);
ClientId.UniqueProcess = (HANDLE)(ULONG_PTR)ProcessId; Buf->Modules = Mp;
InitializeObjectAttributes(&ObjectAttributes, Buf->OffsetFree = Buf->OffsetFree + MSize;
NULL, }
0,
NULL,
NULL);
Status = NtOpenProcess( &hProcess, if (DebugInfoMask & RTL_DEBUG_QUERY_HEAPS)
(PROCESS_ALL_ACCESS), {
&ObjectAttributes, PRTL_PROCESS_HEAPS Hp;
&ClientId ); ULONG HSize;
if (!NT_SUCCESS(Status))
{
return Status;
}
if (DebugInfoMask & RTL_DEBUG_QUERY_MODULES) Hp = (PRTL_PROCESS_HEAPS)(Buf + Buf->OffsetFree);
{ HSize = sizeof(RTL_PROCESS_HEAPS);
PRTL_PROCESS_MODULES Mp; if (DebugInfoMask & RTL_DEBUG_QUERY_HEAP_TAGS)
ULONG ReturnSize = 0; {
ULONG MSize; // TODO
}
if (DebugInfoMask & RTL_DEBUG_QUERY_HEAP_BLOCKS)
{
// TODO
}
Buf->Heaps = Hp;
Buf->OffsetFree = Buf->OffsetFree + HSize;
Mp = (PRTL_PROCESS_MODULES)(Buf + Buf->OffsetFree); }
Status = RtlpQueryRemoteProcessModules( hProcess, if (DebugInfoMask & RTL_DEBUG_QUERY_LOCKS)
NULL, {
0, PRTL_PROCESS_LOCKS Lp;
&ReturnSize); ULONG LSize;
Status = RtlpQueryRemoteProcessModules( hProcess, Lp = (PRTL_PROCESS_LOCKS)(Buf + Buf->OffsetFree);
Mp, LSize = sizeof(RTL_PROCESS_LOCKS);
ReturnSize , Buf->Locks = Lp;
&ReturnSize); Buf->OffsetFree = Buf->OffsetFree + LSize;
if (!NT_SUCCESS(Status)) }
{
return Status;
}
MSize = Mp->NumberOfModules * (sizeof(RTL_PROCESS_MODULES) + 8); DPRINT("QueryProcessDebugInformation end \n");
Buf->Modules = Mp; DPRINT("QueryDebugInfo : 0x%lx\n", Buf->OffsetFree);
Buf->OffsetFree = Buf->OffsetFree + MSize; }
} else
{
HANDLE hProcess;
CLIENT_ID ClientId;
OBJECT_ATTRIBUTES ObjectAttributes;
if (DebugInfoMask & RTL_DEBUG_QUERY_HEAPS) Buf->TargetProcessHandle = NtCurrentProcess();
{
PRTL_PROCESS_HEAPS Hp;
ULONG HSize;
Hp = (PRTL_PROCESS_HEAPS)(Buf + Buf->OffsetFree); ClientId.UniqueThread = 0;
HSize = sizeof(RTL_PROCESS_HEAPS); ClientId.UniqueProcess = (HANDLE)(ULONG_PTR)ProcessId;
if (DebugInfoMask & RTL_DEBUG_QUERY_HEAP_TAGS) InitializeObjectAttributes(&ObjectAttributes,
{ NULL,
} 0,
if (DebugInfoMask & RTL_DEBUG_QUERY_HEAP_BLOCKS) NULL,
{ NULL);
}
Buf->Heaps = Hp;
Buf->OffsetFree = Buf->OffsetFree + HSize;
} Status = NtOpenProcess(&hProcess,
(PROCESS_ALL_ACCESS),
&ObjectAttributes,
&ClientId );
if (!NT_SUCCESS(Status))
{
return Status;
}
if (DebugInfoMask & RTL_DEBUG_QUERY_LOCKS) if (DebugInfoMask & RTL_DEBUG_QUERY_MODULES)
{ {
PRTL_PROCESS_LOCKS Lp; PRTL_PROCESS_MODULES Mp;
ULONG LSize; ULONG ReturnSize = 0;
ULONG MSize;
Lp = (PRTL_PROCESS_LOCKS)(Buf + Buf->OffsetFree); Mp = (PRTL_PROCESS_MODULES)(Buf + Buf->OffsetFree);
LSize = sizeof(RTL_PROCESS_LOCKS);
Buf->Locks = Lp;
Buf->OffsetFree = Buf->OffsetFree + LSize;
}
DPRINT("QueryProcessDebugInformation end \n"); Status = RtlpQueryRemoteProcessModules(hProcess,
DPRINT("QueryDebugInfo : 0x%lx\n", Buf->OffsetFree); NULL,
} 0,
return Status; &ReturnSize);
Status = RtlpQueryRemoteProcessModules(hProcess,
Mp,
ReturnSize ,
&ReturnSize);
if (!NT_SUCCESS(Status))
{
return Status;
}
MSize = Mp->NumberOfModules * (sizeof(RTL_PROCESS_MODULES) + 8);
Buf->Modules = Mp;
Buf->OffsetFree = Buf->OffsetFree + MSize;
}
if (DebugInfoMask & RTL_DEBUG_QUERY_HEAPS)
{
PRTL_PROCESS_HEAPS Hp;
ULONG HSize;
Hp = (PRTL_PROCESS_HEAPS)(Buf + Buf->OffsetFree);
HSize = sizeof(RTL_PROCESS_HEAPS);
if (DebugInfoMask & RTL_DEBUG_QUERY_HEAP_TAGS)
{
// TODO
}
if (DebugInfoMask & RTL_DEBUG_QUERY_HEAP_BLOCKS)
{
// TODO
}
Buf->Heaps = Hp;
Buf->OffsetFree = Buf->OffsetFree + HSize;
}
if (DebugInfoMask & RTL_DEBUG_QUERY_LOCKS)
{
PRTL_PROCESS_LOCKS Lp;
ULONG LSize;
Lp = (PRTL_PROCESS_LOCKS)(Buf + Buf->OffsetFree);
LSize = sizeof(RTL_PROCESS_LOCKS);
Buf->Locks = Lp;
Buf->OffsetFree = Buf->OffsetFree + LSize;
}
DPRINT("QueryProcessDebugInformation end \n");
DPRINT("QueryDebugInfo : 0x%lx\n", Buf->OffsetFree);
}
return Status;
} }
/* EOL */ /* EOL */