Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-07-03 03:11:22 +00:00
Code Issues Projects Releases Packages Wiki Activity

[NDK]: Fix Vista vs Server 2003 definition of SECTION_IMAGE_INFORMATION.

Browse source 
[NTOSKRNL]: Gut out almost all the fields in the ReactOS-specific MM_IMAGE_SECTION, and replace them with the NT SECTION_IMAGE_INFORMATION structure instead. Make NtQuerySection simply return a copy of these fields (as on Windows).
[NTOSKRNL]: Update the PE loader code to now store information in SECTION_IMAGE_INFORMATION. Also store LoaderFlags and DllCharacteristics, which were not stored/returned to users before (in NtQuerySection).
[NTOSKRNL]: An entrypoint of NULL should also set ImageContainsCode to FALSE.
[NTOSKRNL]: Implement MmGetImageInformation, which is used by NtQueryInformationProcess(ProcessImageInformation). Also implement this latter info class.
[NTOSKRNL]: Delete ps_i.h, nobody uses this anymore.

svn path=/trunk/; revision=59859
This commit is contained in:
Alex Ionescu 2013-08-28 21:09:16 +00:00
parent 8453b44a7f
commit bf493b93af
7 changed files with 174 additions and 677 deletions
Download patch file Download diff file Expand all files Collapse all files

23
reactos/include/ndk/mmtypes.h
View file

@ -343,11 +343,30 @@ typedef struct _SECTION_IMAGE_INFORMATION
USHORT ImageCharacteristics; USHORT ImageCharacteristics;
USHORT DllCharacteristics; USHORT DllCharacteristics;
USHORT Machine; USHORT Machine;
UCHAR ImageContainsCode; BOOLEAN ImageContainsCode;
UCHAR Spare1; #if (NTDDI_VERSION >= NTDDI_LONGHORN)
union
{
struct
{
UCHAR ComPlusNativeReady:1;
UCHAR ComPlusILOnly:1;
UCHAR ImageDynamicallyRelocated:1;
UCHAR ImageMappedFlat:1;
UCHAR Reserved:4;
};
UCHAR ImageFlags;
};
#else
BOOLEAN Spare1;
#endif
ULONG LoaderFlags; ULONG LoaderFlags;
ULONG ImageFileSize; ULONG ImageFileSize;
#if (NTDDI_VERSION >= NTDDI_LONGHORN)
ULONG CheckSum;
#else
ULONG Reserved[1]; ULONG Reserved[1];
#endif
} SECTION_IMAGE_INFORMATION, *PSECTION_IMAGE_INFORMATION; } SECTION_IMAGE_INFORMATION, *PSECTION_IMAGE_INFORMATION;
#ifndef NTOS_MODE_USER #ifndef NTOS_MODE_USER

19
reactos/ntoskrnl/include/internal/mm.h
View file

@ -216,18 +216,9 @@ typedef struct _MM_SECTION_SEGMENT
typedef struct _MM_IMAGE_SECTION_OBJECT typedef struct _MM_IMAGE_SECTION_OBJECT
{ {
ULONG_PTR ImageBase; SECTION_IMAGE_INFORMATION ImageInformation;
ULONG_PTR StackReserve; PVOID BasedAddress;
ULONG_PTR StackCommit;
ULONG_PTR EntryPoint;
USHORT Subsystem;
USHORT ImageCharacteristics;
USHORT MinorSubsystemVersion;
USHORT MajorSubsystemVersion;
USHORT Machine;
BOOLEAN Executable;
ULONG NrSegments; ULONG NrSegments;
ULONG ImageSize;
PMM_SECTION_SEGMENT Segments; PMM_SECTION_SEGMENT Segments;
} MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT; } MM_IMAGE_SECTION_OBJECT, *PMM_IMAGE_SECTION_OBJECT;
@ -1548,6 +1539,12 @@ MmFindRegion(
/* section.c *****************************************************************/ /* section.c *****************************************************************/
VOID
NTAPI
MmGetImageInformation(
OUT PSECTION_IMAGE_INFORMATION ImageInformation
);
PFILE_OBJECT PFILE_OBJECT
NTAPI NTAPI
MmGetFileObjectForSection( MmGetFileObjectForSection(

599
reactos/ntoskrnl/include/internal/ps_i.h
View file

@ -6,602 +6,3 @@
* PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org) * PROGRAMMERS: Alex Ionescu (alex.ionescu@reactos.org)
* Thomas Weidenmueller (w3seek@reactos.org) * Thomas Weidenmueller (w3seek@reactos.org)
*/ */
//
// Process Information Classes
//
static const INFORMATION_CLASS_INFO PsProcessInfoClass[] =
{
/* ProcessBasicInformation */
IQS_SAME
(
PROCESS_BASIC_INFORMATION,
ULONG,
ICIF_QUERY
),
/* ProcessQuotaLimits */
IQS_SAME
(
QUOTA_LIMITS,
ULONG,
ICIF_QUERY | ICIF_SET
),
/* ProcessIoCounters */
IQS_SAME
(
IO_COUNTERS,
ULONG,
ICIF_QUERY
),
/* ProcessVmCounters */
IQS_SAME
(
VM_COUNTERS,
ULONG,
ICIF_QUERY
),
/* ProcessTimes */
IQS_SAME
(
KERNEL_USER_TIMES,
ULONG,
ICIF_QUERY
),
/* ProcessBasePriority */
IQS_SAME
(
KPRIORITY,
ULONG,
ICIF_SET
),
/* ProcessRaisePriority */
IQS_SAME
(
ULONG,
ULONG,
ICIF_SET
),
/* ProcessDebugPort */
IQS_SAME
(
HANDLE,
ULONG,
ICIF_QUERY
),
/* ProcessExceptionPort */
IQS_SAME
(
HANDLE,
ULONG,
ICIF_SET
),
/* ProcessAccessToken */
IQS_SAME
(
PROCESS_ACCESS_TOKEN,
ULONG,
ICIF_SET
),
/* ProcessLdtInformation */
IQS_SAME
(
UCHAR,
ULONG,
ICIF_QUERY | ICIF_SET
),
/* ProcessLdtSize */
IQS_SAME
(
UCHAR,
ULONG,
ICIF_SET
),
/* ProcessDefaultHardErrorMode */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY | ICIF_SET
),
/* ProcessIoPortHandlers */
IQS_SAME
(
UCHAR,
ULONG,
ICIF_SET
),
/* ProcessPooledUsageAndLimits */
IQS_SAME
(
POOLED_USAGE_AND_LIMITS,
ULONG,
ICIF_QUERY
),
/* ProcessWorkingSetWatch */
IQS_SAME
(
PROCESS_WS_WATCH_INFORMATION,
ULONG,
ICIF_QUERY | ICIF_SET
),
/* ProcessUserModeIOPL */
IQS_SAME
(
UCHAR,
ULONG,
ICIF_SET
),
/* ProcessEnableAlignmentFaultFixup */
IQS_SAME
(
BOOLEAN,
ULONG,
ICIF_SET
),
/* ProcessPriorityClass */
IQS_SAME
(
PROCESS_PRIORITY_CLASS,
USHORT,
ICIF_QUERY | ICIF_SET
),
/* ProcessWx86Information */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY
),
/* ProcessHandleCount */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY
),
/* ProcessAffinityMask */
IQS_SAME
(
KAFFINITY,
ULONG,
ICIF_SET
),
/* ProcessPriorityBoost */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY | ICIF_SET
),
/* ProcessDeviceMap */
IQS
(
((PROCESS_DEVICEMAP_INFORMATION*)0)->Query,
((PROCESS_DEVICEMAP_INFORMATION*)0)->Set,
ULONG,
ULONG,
ICIF_QUERY | ICIF_SET
),
/* ProcessSessionInformation */
IQS_SAME
(
PROCESS_SESSION_INFORMATION,
ULONG,
ICIF_QUERY | ICIF_SET
),
/* ProcessForegroundInformation */
IQS_SAME
(
BOOLEAN,
ULONG,
ICIF_SET
),
/* ProcessWow64Information */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY
),
/* ProcessImageFileName */
IQS_SAME
(
UNICODE_STRING,
ULONG,
ICIF_QUERY | ICIF_SIZE_VARIABLE
),
/* ProcessLUIDDeviceMapsEnabled */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessBreakOnTermination */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY | ICIF_SET
),
/* ProcessDebugObjectHandle */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessDebugFlags */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessHandleTracing */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessIoPriority */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessExecuteFlags */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessTlsInformation */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessCookie */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessImageInformation */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessCycleTime */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessPagePriority */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
/* ProcessInstrumentationCallback */
IQS_SAME
(
UCHAR,
UCHAR,
0
),
};
//
// Thread Information Classes
//
static const INFORMATION_CLASS_INFO PsThreadInfoClass[] =
{
/* ThreadBasicInformation */
IQS_SAME
(
THREAD_BASIC_INFORMATION,
ULONG,
ICIF_QUERY
),
/* ThreadTimes */
IQS_SAME
(
KERNEL_USER_TIMES,
ULONG,
ICIF_QUERY
),
/* ThreadPriority */
IQS_SAME
(
KPRIORITY,
ULONG,
ICIF_QUERY
),
/* ThreadBasePriority */
IQS_SAME
(
LONG,
ULONG,
ICIF_QUERY
),
/* ThreadAffinityMask */
IQS_SAME
(
KAFFINITY,
ULONG,
ICIF_QUERY
),
/* ThreadImpersonationToken */
IQS_SAME
(
HANDLE,
ULONG,
ICIF_QUERY | ICIF_SET
),
/* ThreadDescriptorTableEntry */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadEnableAlignmentFaultFixup */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadEventPair_Reusable */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadQuerySetWin32StartAddress */
IQS_SAME
(
PVOID,
ULONG,
ICIF_QUERY | ICIF_SET
),
/* ThreadZeroTlsCell */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadPerformanceCount */
IQS_SAME
(
LARGE_INTEGER,
ULONG,
ICIF_QUERY
),
/* ThreadAmILastThread */
IQS_SAME
(
BOOLEAN,
BOOLEAN,
ICIF_QUERY
),
/* ThreadIdealProcessor */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadPriorityBoost */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadSetTlsArrayAddress */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadIsIoPending */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY
),
/* ThreadHideFromDebugger */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadPriorityBoost */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadSetTlsArrayAddress */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadIsIoPending */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY
),
/* ThreadHideFromDebugger */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadBreakOnTermination */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadSwitchLegacyState */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadIsTerminated */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY
),
/* ThreadLastSystemCall */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadIoPriority */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadCycleTime */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadPagePriority */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY
),
/* ThreadActualBasePriority */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
/* ThreadTebInformation */
IQS_SAME
(
ULONG,
ULONG,
ICIF_QUERY
),
/* ThreadCSwitchMon */
IQS_SAME
(
UCHAR,
UCHAR,
ICIF_QUERY
),
};

16
reactos/ntoskrnl/mm/ARM3/section.c
View file

@ -1495,6 +1495,22 @@ MmGetFileObjectForSection(IN PVOID SectionObject)
return ((PROS_SECTION_OBJECT)SectionObject)->FileObject; return ((PROS_SECTION_OBJECT)SectionObject)->FileObject;
} }
VOID
NTAPI
MmGetImageInformation (OUT PSECTION_IMAGE_INFORMATION ImageInformation)
{
PSECTION_OBJECT SectionObject;
/* Get the section object of this process*/
SectionObject = PsGetCurrentProcess()->SectionObject;
ASSERT(SectionObject != NULL);
ASSERT(MiIsRosSectionObject(SectionObject) == TRUE);
/* Return the image information */
DPRINT1("HERE!\n");
*ImageInformation = ((PROS_SECTION_OBJECT)SectionObject)->ImageSection->ImageInformation;
}
NTSTATUS NTSTATUS
NTAPI NTAPI
MmGetFileNameForFileObject(IN PFILE_OBJECT FileObject, MmGetFileNameForFileObject(IN PFILE_OBJECT FileObject,

4
reactos/ntoskrnl/mm/ARM3/sysldr.c
View file

@ -156,7 +156,7 @@ MiLoadImageSection(IN OUT PVOID *SectionPtr,
} }
/* Reserve system PTEs needed */ /* Reserve system PTEs needed */
PteCount = ROUND_TO_PAGES(Section->ImageSection->ImageSize) >> PAGE_SHIFT; PteCount = ROUND_TO_PAGES(Section->ImageSection->ImageInformation.ImageFileSize) >> PAGE_SHIFT;
PointerPte = MiReserveSystemPtes(PteCount, SystemPteSpace); PointerPte = MiReserveSystemPtes(PteCount, SystemPteSpace);
if (!PointerPte) if (!PointerPte)
{ {
@ -3040,7 +3040,7 @@ LoaderScan:
ASSERT(Status != STATUS_ALREADY_COMMITTED); ASSERT(Status != STATUS_ALREADY_COMMITTED);
/* Get the size of the driver */ /* Get the size of the driver */
DriverSize = ((PROS_SECTION_OBJECT)Section)->ImageSection->ImageSize; DriverSize = ((PROS_SECTION_OBJECT)Section)->ImageSection->ImageInformation.ImageFileSize;
/* Make sure we're not being loaded into session space */ /* Make sure we're not being loaded into session space */
if (!Flags) if (!Flags)

158
reactos/ntoskrnl/mm/section.c
View file

@ -199,6 +199,7 @@ NTSTATUS NTAPI PeFmtCreateSection(IN CONST VOID * FileHeader,
ULONG cbHeadersSize = 0; ULONG cbHeadersSize = 0;
ULONG nSectionAlignment; ULONG nSectionAlignment;
ULONG nFileAlignment; ULONG nFileAlignment;
ULONG ImageBase;
const IMAGE_DOS_HEADER * pidhDosHeader; const IMAGE_DOS_HEADER * pidhDosHeader;
const IMAGE_NT_HEADERS32 * pinhNtHeader; const IMAGE_NT_HEADERS32 * pinhNtHeader;
const IMAGE_OPTIONAL_HEADER32 * piohOptHeader; const IMAGE_OPTIONAL_HEADER32 * piohOptHeader;
@ -389,17 +390,54 @@ l_ReadHeaderFromFile:
/* PE32 */ /* PE32 */
case IMAGE_NT_OPTIONAL_HDR32_MAGIC: case IMAGE_NT_OPTIONAL_HDR32_MAGIC:
{ {
if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, ImageBase)) if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, ImageBase))
ImageSectionObject->ImageBase = piohOptHeader->ImageBase; ImageBase = piohOptHeader->ImageBase;
if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfImage)) if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfImage))
ImageSectionObject->ImageSize = piohOptHeader->SizeOfImage; ImageSectionObject->ImageInformation.ImageFileSize = piohOptHeader->SizeOfImage;
if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfStackReserve)) if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfStackReserve))
ImageSectionObject->StackReserve = piohOptHeader->SizeOfStackReserve; ImageSectionObject->ImageInformation.MaximumStackSize = piohOptHeader->SizeOfStackReserve;
if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfStackCommit)) if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfStackCommit))
ImageSectionObject->StackCommit = piohOptHeader->SizeOfStackCommit; ImageSectionObject->ImageInformation.CommittedStackSize = piohOptHeader->SizeOfStackCommit;
if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, Subsystem))
{
ImageSectionObject->ImageInformation.SubSystemType = piohOptHeader->Subsystem;
if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, MinorSubsystemVersion) &&
RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, MajorSubsystemVersion))
{
ImageSectionObject->ImageInformation.SubSystemMinorVersion = piohOptHeader->MinorSubsystemVersion;
ImageSectionObject->ImageInformation.SubSystemMajorVersion = piohOptHeader->MajorSubsystemVersion;
}
}
if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, AddressOfEntryPoint))
{
ImageSectionObject->ImageInformation.TransferAddress = (PVOID) (ImageBase +
piohOptHeader->AddressOfEntryPoint);
}
if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfCode))
ImageSectionObject->ImageInformation.ImageContainsCode = piohOptHeader->SizeOfCode != 0;
else
ImageSectionObject->ImageInformation.ImageContainsCode = TRUE;
if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, AddressOfEntryPoint))
{
if (piohOptHeader->AddressOfEntryPoint == 0)
{
ImageSectionObject->ImageInformation.ImageContainsCode = FALSE;
}
}
if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, LoaderFlags))
ImageSectionObject->ImageInformation.LoaderFlags = piohOptHeader->LoaderFlags;
if (RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, DllCharacteristics))
ImageSectionObject->ImageInformation.DllCharacteristics = piohOptHeader->DllCharacteristics;
break; break;
} }
@ -413,10 +451,9 @@ l_ReadHeaderFromFile:
if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, ImageBase)) if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, ImageBase))
{ {
ImageBase = pioh64OptHeader->ImageBase;
if(pioh64OptHeader->ImageBase > MAXULONG_PTR) if(pioh64OptHeader->ImageBase > MAXULONG_PTR)
DIE(("ImageBase exceeds the address space\n")); DIE(("ImageBase exceeds the address space\n"));
ImageSectionObject->ImageBase = (ULONG_PTR)pioh64OptHeader->ImageBase;
} }
if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfImage)) if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfImage))
@ -424,7 +461,7 @@ l_ReadHeaderFromFile:
if(pioh64OptHeader->SizeOfImage > MAXULONG_PTR) if(pioh64OptHeader->SizeOfImage > MAXULONG_PTR)
DIE(("SizeOfImage exceeds the address space\n")); DIE(("SizeOfImage exceeds the address space\n"));
ImageSectionObject->ImageSize = pioh64OptHeader->SizeOfImage; ImageSectionObject->ImageInformation.ImageFileSize = pioh64OptHeader->SizeOfImage;
} }
if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfStackReserve)) if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfStackReserve))
@ -432,7 +469,7 @@ l_ReadHeaderFromFile:
if(pioh64OptHeader->SizeOfStackReserve > MAXULONG_PTR) if(pioh64OptHeader->SizeOfStackReserve > MAXULONG_PTR)
DIE(("SizeOfStackReserve exceeds the address space\n")); DIE(("SizeOfStackReserve exceeds the address space\n"));
ImageSectionObject->StackReserve = (ULONG_PTR)pioh64OptHeader->SizeOfStackReserve; ImageSectionObject->ImageInformation.MaximumStackSize = (ULONG_PTR) pioh64OptHeader->SizeOfStackReserve;
} }
if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfStackCommit)) if(RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfStackCommit))
@ -440,42 +477,59 @@ l_ReadHeaderFromFile:
if(pioh64OptHeader->SizeOfStackCommit > MAXULONG_PTR) if(pioh64OptHeader->SizeOfStackCommit > MAXULONG_PTR)
DIE(("SizeOfStackCommit exceeds the address space\n")); DIE(("SizeOfStackCommit exceeds the address space\n"));
ImageSectionObject->StackCommit = (ULONG_PTR)pioh64OptHeader->SizeOfStackCommit; ImageSectionObject->ImageInformation.CommittedStackSize = (ULONG_PTR) pioh64OptHeader->SizeOfStackCommit;
} }
if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, Subsystem))
{
ImageSectionObject->ImageInformation.SubSystemType = pioh64OptHeader->Subsystem;
if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, MinorSubsystemVersion) &&
RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, MajorSubsystemVersion))
{
ImageSectionObject->ImageInformation.SubSystemMinorVersion = pioh64OptHeader->MinorSubsystemVersion;
ImageSectionObject->ImageInformation.SubSystemMajorVersion = pioh64OptHeader->MajorSubsystemVersion;
}
}
if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, AddressOfEntryPoint))
{
ImageSectionObject->ImageInformation.TransferAddress = (PVOID) (ImageBase +
pioh64OptHeader->AddressOfEntryPoint);
}
if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, SizeOfCode))
ImageSectionObject->ImageInformation.ImageContainsCode = pioh64OptHeader->SizeOfCode != 0;
else
ImageSectionObject->ImageInformation.ImageContainsCode = TRUE;
if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, AddressOfEntryPoint))
{
if (pioh64OptHeader->AddressOfEntryPoint == 0)
{
ImageSectionObject->ImageInformation.ImageContainsCode = FALSE;
}
}
if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, LoaderFlags))
ImageSectionObject->ImageInformation.LoaderFlags = pioh64OptHeader->LoaderFlags;
if (RTL_CONTAINS_FIELD(pioh64OptHeader, cbOptHeaderSize, DllCharacteristics))
ImageSectionObject->ImageInformation.DllCharacteristics = pioh64OptHeader->DllCharacteristics;
break; break;
} }
} }
/* [1], section 3.4.2 */ /* [1], section 3.4.2 */
if((ULONG_PTR)ImageSectionObject->ImageBase % 0x10000) if((ULONG_PTR)ImageBase % 0x10000)
DIE(("ImageBase is not aligned on a 64KB boundary")); DIE(("ImageBase is not aligned on a 64KB boundary"));
if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, Subsystem)) ImageSectionObject->ImageInformation.ImageCharacteristics = pinhNtHeader->FileHeader.Characteristics;
{ ImageSectionObject->ImageInformation.Machine = pinhNtHeader->FileHeader.Machine;
ImageSectionObject->Subsystem = piohOptHeader->Subsystem; ImageSectionObject->ImageInformation.GpValue = 0;
ImageSectionObject->ImageInformation.ZeroBits = 0;
if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, MinorSubsystemVersion) && ImageSectionObject->BasedAddress = (PVOID)ImageBase;
RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, MajorSubsystemVersion))
{
ImageSectionObject->MinorSubsystemVersion = piohOptHeader->MinorSubsystemVersion;
ImageSectionObject->MajorSubsystemVersion = piohOptHeader->MajorSubsystemVersion;
}
}
if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, AddressOfEntryPoint))
{
ImageSectionObject->EntryPoint = ImageSectionObject->ImageBase +
piohOptHeader->AddressOfEntryPoint;
}
if(RTL_CONTAINS_FIELD(piohOptHeader, cbOptHeaderSize, SizeOfCode))
ImageSectionObject->Executable = piohOptHeader->SizeOfCode != 0;
else
ImageSectionObject->Executable = TRUE;
ImageSectionObject->ImageCharacteristics = pinhNtHeader->FileHeader.Characteristics;
ImageSectionObject->Machine = pinhNtHeader->FileHeader.Machine;
/* SECTION HEADERS */ /* SECTION HEADERS */
nStatus = STATUS_INVALID_IMAGE_FORMAT; nStatus = STATUS_INVALID_IMAGE_FORMAT;
@ -3597,18 +3651,18 @@ ExeFmtpCreateImageSection(HANDLE FileHandle,
* Some defaults * Some defaults
*/ */
/* FIXME? are these values platform-dependent? */ /* FIXME? are these values platform-dependent? */
if(ImageSectionObject->StackReserve == 0) if (ImageSectionObject->ImageInformation.MaximumStackSize == 0)
ImageSectionObject->StackReserve = 0x40000; ImageSectionObject->ImageInformation.MaximumStackSize = 0x40000;
if(ImageSectionObject->StackCommit == 0) if(ImageSectionObject->ImageInformation.CommittedStackSize == 0)
ImageSectionObject->StackCommit = 0x1000; ImageSectionObject->ImageInformation.CommittedStackSize = 0x1000;
if(ImageSectionObject->ImageBase == 0) if(ImageSectionObject->BasedAddress == NULL)
{ {
if(ImageSectionObject->ImageCharacteristics & IMAGE_FILE_DLL) if(ImageSectionObject->ImageInformation.ImageCharacteristics & IMAGE_FILE_DLL)
ImageSectionObject->ImageBase = 0x10000000; ImageSectionObject->BasedAddress = (PVOID)0x10000000;
else else
ImageSectionObject->ImageBase = 0x00400000; ImageSectionObject->BasedAddress = (PVOID)0x00400000;
} }
/* /*
@ -4237,21 +4291,12 @@ NtQuerySection(IN HANDLE SectionHandle,
_SEH2_TRY _SEH2_TRY
{ {
memset(Sii, 0, sizeof(SECTION_IMAGE_INFORMATION));
if (Section->AllocationAttributes & SEC_IMAGE) if (Section->AllocationAttributes & SEC_IMAGE)
{ {
PMM_IMAGE_SECTION_OBJECT ImageSectionObject; PMM_IMAGE_SECTION_OBJECT ImageSectionObject;
ImageSectionObject = Section->ImageSection; ImageSectionObject = Section->ImageSection;
Sii->TransferAddress = (PVOID)ImageSectionObject->EntryPoint; *Sii = ImageSectionObject->ImageInformation;
Sii->MaximumStackSize = ImageSectionObject->StackReserve;
Sii->CommittedStackSize = ImageSectionObject->StackCommit;
Sii->SubSystemType = ImageSectionObject->Subsystem;
Sii->SubSystemMinorVersion = ImageSectionObject->MinorSubsystemVersion;
Sii->SubSystemMajorVersion = ImageSectionObject->MajorSubsystemVersion;
Sii->ImageCharacteristics = ImageSectionObject->ImageCharacteristics;
Sii->Machine = ImageSectionObject->Machine;
Sii->ImageContainsCode = ImageSectionObject->Executable;
} }
if (ResultLength != NULL) if (ResultLength != NULL)
@ -4386,11 +4431,10 @@ MmMapViewOfSection(IN PVOID SectionObject,
SectionSegments = ImageSectionObject->Segments; SectionSegments = ImageSectionObject->Segments;
NrSegments = ImageSectionObject->NrSegments; NrSegments = ImageSectionObject->NrSegments;
ImageBase = (ULONG_PTR)*BaseAddress; ImageBase = (ULONG_PTR)*BaseAddress;
if (ImageBase == 0) if (ImageBase == 0)
{ {
ImageBase = ImageSectionObject->ImageBase; ImageBase = (ULONG_PTR)ImageSectionObject->BasedAddress;
} }
ImageSize = 0; ImageSize = 0;
@ -4405,7 +4449,7 @@ MmMapViewOfSection(IN PVOID SectionObject,
} }
} }
ImageSectionObject->ImageSize = (ULONG)ImageSize; ImageSectionObject->ImageInformation.ImageFileSize = (ULONG)ImageSize;
/* Check for an illegal base address */ /* Check for an illegal base address */
if ((ImageBase + ImageSize) > (ULONG_PTR)MmHighestUserAddress) if ((ImageBase + ImageSize) > (ULONG_PTR)MmHighestUserAddress)

32
reactos/ntoskrnl/ps/query.c
View file

@ -17,9 +17,6 @@
/* FIXME: From winbase.h... what to do? */ /* FIXME: From winbase.h... what to do? */
#define SEM_NOALIGNMENTFAULTEXCEPT 0x04 #define SEM_NOALIGNMENTFAULTEXCEPT 0x04
/* Include Information Class Tables */
#include "internal/ps_i.h"
/* Debugging Level */ /* Debugging Level */
ULONG PspTraceLevel = 0; ULONG PspTraceLevel = 0;
@ -108,7 +105,8 @@ NtQueryInformationProcess(IN HANDLE ProcessHandle,
_SEH2_END; _SEH2_END;
} }
if((ProcessInformationClass == ProcessCookie) && if (((ProcessInformationClass == ProcessCookie) ||
(ProcessInformationClass == ProcessImageInformation)) &&
(ProcessHandle != NtCurrentProcess())) (ProcessHandle != NtCurrentProcess()))
{ {
/* /*
@ -823,8 +821,30 @@ NtQueryInformationProcess(IN HANDLE ProcessHandle,
break; break;
case ProcessImageInformation: case ProcessImageInformation:
DPRINT1("Image Information Query Not implemented: %lx\n", ProcessInformationClass);
Status = STATUS_NOT_IMPLEMENTED; /* Set the length required and validate it */
Length = sizeof(SECTION_IMAGE_INFORMATION);
if (ProcessInformationLength != Length)
{
/* Break out */
Status = STATUS_INFO_LENGTH_MISMATCH;
break;
}
/* Enter SEH to protect write */
_SEH2_TRY
{
MmGetImageInformation((PSECTION_IMAGE_INFORMATION)ProcessInformation);
}
_SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
/* Get the exception code */
Status = _SEH2_GetExceptionCode();
}
_SEH2_END;
/* Indicate success */
Status = STATUS_SUCCESS;
break; break;
case ProcessDebugObjectHandle: case ProcessDebugObjectHandle: