while (current2 != NULL && !current2->Valid && current_size < MAX_RW_LENGTH)
{
PVOID address = current2->BaseAddress;
- for (i = 0; i < (Bcb->CacheSegmentSize / PAGE_SIZE); i++, address += PAGE_SIZE)
+ for (i = 0; i < (Bcb->CacheSegmentSize / PAGE_SIZE); i++, address = RVA(address, PAGE_SIZE))
{
*MdlPages++ = MmGetPfnForProcess(NULL, address);
}
IN PVOID Context2
)
{
- UNIMPLEMENTED;
-
LARGE_INTEGER i;
+ UNIMPLEMENTED;
i.QuadPart = 0;
return i;
}
OUT PLARGE_INTEGER OldestLsn OPTIONAL
)
{
- UNIMPLEMENTED;
-
LARGE_INTEGER i;
+ UNIMPLEMENTED;
i.QuadPart = 0;
return i;
}
/* GLOBALS *******************************************************************/
-POBJECT_TYPE EXPORTED ExEventPairObjectType = NULL;
+POBJECT_TYPE ExEventPairObjectType = NULL;
static GENERIC_MAPPING ExEventPairMapping = {
STANDARD_RIGHTS_READ,
KeCreateApplicationProcessorIdleThread(KeNumberProcessors);
/* Allocate a stack for use when booting the processor */
- ProcessorStack = Ki386InitialStackArray[((int)KeNumberProcessors)] + MM_STACK_SIZE;
+ ProcessorStack = RVA(Ki386InitialStackArray[((int)KeNumberProcessors)], MM_STACK_SIZE);
/* Tell HAL a new CPU is being started */
HalStartNextProcessor(0, (ULONG)ProcessorStack - 2*sizeof(FX_SAVE_AREA));
/* Class 16 - Handle Information */
QSI_DEF(SystemHandleInformation)
{
+ PEPROCESS pr, syspr;
+ int curSize, i = 0;
+ ULONG hCount = 0;
+
PSYSTEM_HANDLE_INFORMATION Shi =
(PSYSTEM_HANDLE_INFORMATION) Buffer;
DPRINT("SystemHandleInformation 1\n");
- PEPROCESS pr, syspr;
- int curSize, i = 0;
- ULONG hCount = 0;
-
/* First Calc Size from Count. */
syspr = PsGetNextProcess(NULL);
pr = syspr;
/* Class 18 - Information */
QSI_DEF(SystemPageFileInformation)
{
+ UNICODE_STRING FileName; /* FIXME */
SYSTEM_PAGEFILE_INFORMATION *Spfi = (SYSTEM_PAGEFILE_INFORMATION *) Buffer;
if (Size < sizeof (SYSTEM_PAGEFILE_INFORMATION))
return (STATUS_INFO_LENGTH_MISMATCH);
}
- UNICODE_STRING FileName; /* FIXME */
RtlInitUnicodeString(&FileName, NULL); /* FIXME */
/* FIXME */
FSRTL_FAT_LEGAL | FSRTL_HPFS_LEGAL | FSRTL_NTFS_LEGAL /* 0x7f */
};
-PUCHAR EXPORTED FsRtlLegalAnsiCharacterArray = LegalAnsiCharacterArray;
+PUCHAR FsRtlLegalAnsiCharacterArray = LegalAnsiCharacterArray;
/* FUNCTIONS *****************************************************************/
#ifndef __NTOSKRNL_INCLUDE_INTERNAL_ARCH_KE_H
#define __NTOSKRNL_INCLUDE_INTERNAL_ARCH_KE_H
-#ifdef i386
+#ifdef _M_IX86
#include "../i386/ke.h"
#else
#error "Unknown processor"
#ifndef __NTOSKRNL_INCLUDE_INTERNAL_ARCH_MM_H
#define __NTOSKRNL_INCLUDE_INTERNAL_ARCH_MM_H
-#ifdef i386
+#ifdef _M_IX86
#include <internal/i386/mm.h>
#else
#error "Unknown processor"
#ifndef __NTOSKRNL_INCLUDE_INTERNAL_ARCH_PS_H
#define __NTOSKRNL_INCLUDE_INTERNAL_ARCH_PS_H
-#ifdef i386
+#ifdef _M_IX86
#include <internal/i386/ps.h>
#define KiArchContextSwitch KiSwapContext
#define KiArchInitThreadWithContext Ke386InitThreadWithContext
typedef
VOID
-STDCALL
-(*PKSYSTEM_ROUTINE)(PKSTART_ROUTINE StartRoutine,
+(STDCALL*PKSYSTEM_ROUTINE)(PKSTART_ROUTINE StartRoutine,
PVOID StartContext);
VOID
#define LOCK "lock ; "
#else
#define LOCK ""
-#define KeGetCurrentIrql(X) (((PKPCR)KPCR_BASE)->Irql)
+#define KeGetCurrentIrql() (((PKPCR)KPCR_BASE)->Irql)
#endif
#if defined(__GNUC__)
/* MACROS *************************************************************************/
-#define KeEnterCriticalRegion(X) \
+#define KeEnterCriticalRegion() \
{ \
PKTHREAD _Thread = KeGetCurrentThread(); \
if (_Thread) _Thread->KernelApcDisable--; \
}
-#define KeLeaveCriticalRegion(X) \
+#define KeLeaveCriticalRegion() \
{ \
PKTHREAD _Thread = KeGetCurrentThread(); \
if((_Thread) && (++_Thread->KernelApcDisable == 0)) \
VOID STDCALL
DbgBreakPointNoBugCheck(VOID);
-STDCALL
VOID
+STDCALL
KeInitializeProfile(struct _KPROFILE* Profile,
struct _KPROCESS* Process,
PVOID ImageBase,
KPROFILE_SOURCE ProfileSource,
KAFFINITY Affinity);
-STDCALL
VOID
+STDCALL
KeStartProfile(struct _KPROFILE* Profile,
PVOID Buffer);
-STDCALL
VOID
+STDCALL
KeStopProfile(struct _KPROFILE* Profile);
-STDCALL
ULONG
+STDCALL
KeQueryIntervalProfile(KPROFILE_SOURCE ProfileSource);
-STDCALL
VOID
+STDCALL
KeSetIntervalProfile(KPROFILE_SOURCE ProfileSource,
ULONG Interval);
ULONG OwnsSessionWorkingSetShared:1;
ULONG ApcNeeded:1;
};
- ULONG SameThreadPassiveFlags; /* 248 */
+ ULONG SameThreadApcFlags; /* 248 */
};
UCHAR ForwardClusterOnly; /* 24C */
UCHAR DisablePageFaultClustering; /* 24D */
IopDisplayLoadingMessage(PVOID ServiceName,
BOOLEAN Unicode)
{
- if (SetupMode) return;
CHAR TextBuffer[256];
+ if (SetupMode) return;
if (Unicode)
{
sprintf(TextBuffer, "Loading %S...\n", (PWCHAR)ServiceName);
/* DATA ********************************************************************/
-POBJECT_TYPE EXPORTED IoDeviceObjectType = NULL;
-POBJECT_TYPE EXPORTED IoFileObjectType = NULL;
+POBJECT_TYPE IoDeviceObjectType = NULL;
+POBJECT_TYPE IoFileObjectType = NULL;
extern POBJECT_TYPE IoControllerObjectType;
-ULONG EXPORTED IoReadOperationCount = 0;
-LARGE_INTEGER EXPORTED IoReadTransferCount = {{0, 0}};
-ULONG EXPORTED IoWriteOperationCount = 0;
-LARGE_INTEGER EXPORTED IoWriteTransferCount = {{0, 0}};
-ULONG IoOtherOperationCount = 0;
-LARGE_INTEGER IoOtherTransferCount = {{0, 0}};
-KSPIN_LOCK EXPORTED IoStatisticsLock = 0;
+ULONG IoReadOperationCount = 0;
+LARGE_INTEGER IoReadTransferCount = {{0, 0}};
+ULONG IoWriteOperationCount = 0;
+LARGE_INTEGER IoWriteTransferCount = {{0, 0}};
+ULONG IoOtherOperationCount = 0;
+LARGE_INTEGER IoOtherTransferCount = {{0, 0}};
+KSPIN_LOCK IoStatisticsLock = 0;
GENERIC_MAPPING IopFileMapping = {
FILE_GENERIC_READ,
}
/* Probe and Lock */
- _SEH_FILTER(FreeAndGoOn)
- {
- /* Free the IRP and its MDL */
- IoFreeMdl(Irp->MdlAddress);
- IoFreeIrp(Irp);
- return EXCEPTION_CONTINUE_SEARCH;
- }
_SEH_TRY
{
/* Do the probe */
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMIRegistrationControl(
IN PDEVICE_OBJECT DeviceObject,
IN ULONG Action
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMIAllocateInstanceIds(
IN GUID *Guid,
IN ULONG InstanceCount,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMISuggestInstanceName(
IN PDEVICE_OBJECT PhysicalDeviceObject OPTIONAL,
IN PUNICODE_STRING SymbolicLinkName OPTIONAL,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMIWriteEvent(
IN PVOID WnodeEventItem
)
/*
* @unimplemented
*/
-STDCALL
-NTSTATUS IoWMIOpenBlock(
+NTSTATUS
+STDCALL IoWMIOpenBlock(
IN GUID *DataBlockGuid,
IN ULONG DesiredAccess,
OUT PVOID *DataBlockObject
/*
* @unimplemented
*/
-STDCALL
-NTSTATUS IoWMIQueryAllData(
+NTSTATUS
+STDCALL IoWMIQueryAllData(
IN PVOID DataBlockObject,
IN OUT ULONG *InOutBufferSize,
OUT PVOID OutBuffer
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMIQueryAllDataMultiple(
IN PVOID *DataBlockObjectList,
IN ULONG ObjectCount,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMIQuerySingleInstance(
IN PVOID DataBlockObject,
IN PUNICODE_STRING InstanceName,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMIQuerySingleInstanceMultiple(
IN PVOID *DataBlockObjectList,
IN PUNICODE_STRING InstanceNames,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMISetSingleInstance(
IN PVOID DataBlockObject,
IN PUNICODE_STRING InstanceName,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMISetSingleItem(
IN PVOID DataBlockObject,
IN PUNICODE_STRING InstanceName,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMIExecuteMethod(
IN PVOID DataBlockObject,
IN PUNICODE_STRING InstanceName,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMISetNotificationCallback(
IN PVOID Object,
IN WMI_NOTIFICATION_CALLBACK Callback,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMIHandleToInstanceName(
IN PVOID DataBlockObject,
IN HANDLE FileHandle,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
IoWMIDeviceObjectToInstanceName(
IN PVOID DataBlockObject,
IN PDEVICE_OBJECT DeviceObject,
#endif
}
}
- ((VOID STDCALL(*)(PVOID))(Prcb->SignalDone->WorkerRoutine))(Prcb->SignalDone->CurrentPacket[0]);
+ ((VOID (STDCALL*)(PVOID))(Prcb->SignalDone->WorkerRoutine))(Prcb->SignalDone->CurrentPacket[0]);
Ke386TestAndClearBit(KeGetCurrentProcessorNumber(), &Prcb->SignalDone->TargetSet);
if (InterlockedCompareExchangeUL(&Prcb->SignalDone->CurrentPacket[2], 0, 0))
{
VOID
STDCALL
-KiIpiSendPacket(ULONG TargetSet, VOID STDCALL (*WorkerRoutine)(PVOID), PVOID Argument, ULONG Count, BOOLEAN Synchronize)
+KiIpiSendPacket(ULONG TargetSet, VOID (STDCALL*WorkerRoutine)(PVOID), PVOID Argument, ULONG Count, BOOLEAN Synchronize)
{
ULONG i, Processor, CurrentProcessor;
PKPRCB Prcb, CurrentPrcb;
/*
* @unimplemented
*/
-STDCALL
PKDEVICE_QUEUE_ENTRY
+STDCALL
KeRemoveByKeyDeviceQueueIfBusy(IN PKDEVICE_QUEUE DeviceQueue,
IN ULONG SortKey)
{
}
VOID
+#ifdef __GNUC__
__attribute((noinline))
+#endif
KiSystemStartup(BOOLEAN BootProcessor)
{
DPRINT("KiSystemStartup(%d)\n", BootProcessor);
/* FUNCTIONS *****************************************************************/
-STDCALL
VOID
+STDCALL
KeInitializeProfile(PKPROFILE Profile,
PKPROCESS Process,
PVOID ImageBase,
Profile->Process = Process;
Profile->RegionStart = ImageBase;
Profile->BucketShift = BucketSize - 2; /* See ntinternals.net -- Alex */
- Profile->RegionEnd = (PVOID)(ULONG_PTR)ImageBase + ImageSize;
+ Profile->RegionEnd = (PVOID)((ULONG_PTR)ImageBase + ImageSize);
Profile->Active = FALSE;
Profile->Source = ProfileSource;
Profile->Affinity = Affinity;
}
-STDCALL
VOID
+STDCALL
KeStartProfile(PKPROFILE Profile,
PVOID Buffer)
{
if (!FreeBuffer) ExFreePool(SourceBuffer);
}
-STDCALL
VOID
+STDCALL
KeStopProfile(PKPROFILE Profile)
{
KIRQL OldIrql;
if (CurrentSource) ExFreePool(CurrentSource);
}
-STDCALL
ULONG
+STDCALL
KeQueryIntervalProfile(KPROFILE_SOURCE ProfileSource)
{
/* Check if this is the timer profile */
}
}
-STDCALL
VOID
+STDCALL
KeSetIntervalProfile(KPROFILE_SOURCE ProfileSource,
ULONG Interval)
{
/*
* @implemented
*/
-STDCALL
VOID
+STDCALL
KeProfileInterrupt(PKTRAP_FRAME TrapFrame)
{
/* Called from HAL for Timer Profiling */
}
/* Get the Pointer to the Bucket Value representing this EIP */
- BucketValue = (PULONG)(((ULONG_PTR)(Profile->Buffer +
+ BucketValue = (PULONG)((((ULONG_PTR)Profile->Buffer +
(TrapFrame->Eip - (ULONG_PTR)Profile->RegionStart))
>> Profile->BucketShift) &~ 0x3);
* from the trap frame into the buffer, while using buckets and
* shifting like we specified. -- Alex
*/
-STDCALL
VOID
+STDCALL
KeProfileInterruptWithSource(IN PKTRAP_FRAME TrapFrame,
IN KPROFILE_SOURCE Source)
{
/*
* @implemented
*/
-STDCALL
VOID
+STDCALL
KeSetProfileIrql(IN KIRQL ProfileIrql)
{
/* Set the IRQL at which Profiling will run */
Protect = PAGE_EXECUTE_READWRITE;
}
#endif
- if (PageAddress < DriverBase + DriverSize)
+ if (PageAddress < RVA(DriverBase, DriverSize))
{
MmSetPageProtect(NULL, PageAddress, Protect);
}
PageAddress = (PVOID)((ULONG_PTR)PageAddress + PAGE_SIZE);
while ((ULONG_PTR)PageAddress + PAGE_SIZE < (ULONG_PTR)BaseAddress + Length)
{
- if (PageAddress < DriverBase + DriverSize)
+ if (PageAddress < RVA(DriverBase, DriverSize))
{
MmSetPageProtect(NULL, PageAddress, Protect);
}
PageAddress = (PVOID)((ULONG_PTR)PageAddress + PAGE_SIZE);
}
if (PageAddress < (PVOID)((ULONG_PTR)BaseAddress + Length) &&
- PageAddress < DriverBase + DriverSize)
+ PageAddress < RVA(DriverBase, DriverSize))
{
Protect = LdrLookupPageProtection(PageAddress, DriverBase, &PENtHeaders->FileHeader, PESectionHeaders);
MmSetPageProtect(NULL, PageAddress, Protect);
Delta = (ULONG_PTR)DriverBase - NtHeaders->OptionalHeader.ImageBase;
RelocationDir = (PIMAGE_BASE_RELOCATION)((ULONG_PTR)DriverBase + RelocationDDir->VirtualAddress);
RelocationEnd = (PIMAGE_BASE_RELOCATION)((ULONG_PTR)RelocationDir + RelocationDDir->Size);
- MaxAddress = DriverBase + DriverSize;
+ MaxAddress = RVA(DriverBase, DriverSize);
while (RelocationDir < RelocationEnd &&
RelocationDir->SizeOfBlock > 0)
{
Count = (RelocationDir->SizeOfBlock - sizeof(IMAGE_BASE_RELOCATION)) / sizeof(USHORT);
- Address = DriverBase + RelocationDir->VirtualAddress;
+ Address = RVA(DriverBase, RelocationDir->VirtualAddress);
TypeOffset = (PUSHORT)(RelocationDir + 1);
for (i = 0; i < Count; i++)
{
Offset = *TypeOffset & 0xFFF;
Type = *TypeOffset >> 12;
- ShortPtr = (PUSHORT)(Address + Offset);
+ ShortPtr = (PUSHORT)(RVA(Address, Offset));
/* Don't relocate after the end of the loaded driver */
if ((PVOID)ShortPtr >= MaxAddress)
return STATUS_SUCCESS;
}
+#ifndef PATH_MAX
+#define PATH_MAX 260
+#endif
static NTSTATUS
LdrPEGetOrLoadModule (
}
/* Get the import address list. */
- ImportAddressList = (PVOID*)(DriverBase + (ULONG_PTR)ImportModuleDirectory->FirstThunk);
+ ImportAddressList = (PVOID*)RVA(DriverBase, ImportModuleDirectory->FirstThunk);
/* Get the list of functions to import. */
if (ImportModuleDirectory->OriginalFirstThunk != 0)
{
- FunctionNameList = (PULONG) (DriverBase + (ULONG_PTR)ImportModuleDirectory->OriginalFirstThunk);
+ FunctionNameList = (PULONG)RVA(DriverBase, ImportModuleDirectory->OriginalFirstThunk);
}
else
{
- FunctionNameList = (PULONG)(DriverBase + (ULONG_PTR)ImportModuleDirectory->FirstThunk);
+ FunctionNameList = (PULONG)RVA(DriverBase, ImportModuleDirectory->FirstThunk);
}
/* Walk through function list and fixup addresses. */
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
LdrFindResourceDirectory_U(
IN PVOID BaseAddress,
IN PLDR_RESOURCE_INFO ResourceInfo,
/*
* @unimplemented
*/
-STDCALL
NTSTATUS
+STDCALL
LdrEnumResources(
IN PVOID BaseAddress,
IN PLDR_RESOURCE_INFO ResourceInfo,
/* FUNCTIONS ****************************************************************/
-#define RVA(m, b) ((ULONG)b + m)
-
NTSTATUS STDCALL
LdrGetProcedureAddress (IN PVOID BaseAddress,
IN PANSI_STRING Name,
PVOID Address = BaseAddress;
Offset = (ULONG_PTR)Address % PAGE_SIZE;
- Address -= Offset;
+ Address = RVA(Address, - Offset);
NumberOfBytes += Offset;
MmLockAddressSpace(MmGetKernelAddressSpace());
PMADDRESS_SPACE ProcessAddressSpace = &Process->AddressSpace;
PMEMORY_AREA MemoryArea;
PHYSICAL_ADDRESS BoundaryAddressMultiple;
- BoundaryAddressMultiple.QuadPart = 0;
PVOID AllocatedBase = BaseAddress;
+ BoundaryAddressMultiple.QuadPart = 0;
/* Acquire the Lock */
MmLockAddressSpace(ProcessAddressSpace);
TRUE,
FALSE,
BoundaryAddressMultiple);
- AllocatedBase = AllocatedBase - PAGE_SIZE;
+ AllocatedBase = RVA(AllocatedBase, -PAGE_SIZE);
} while (Status != STATUS_SUCCESS);
/* Initialize the Region */
/* Unlock Address Space */
DPRINT("Returning\n");
MmUnlockAddressSpace(ProcessAddressSpace);
- return AllocatedBase + PAGE_SIZE;
+ return RVA(AllocatedBase, PAGE_SIZE);
}
VOID
PVOID BaseAddress;
PMEMORY_AREA MemoryArea;
PHYSICAL_ADDRESS BoundaryAddressMultiple;
- BoundaryAddressMultiple.QuadPart = 0;
ULONG ViewSize = 0;
PVOID ImageBase = 0;
+ BoundaryAddressMultiple.QuadPart = 0;
/* Initialize the Addresss Space */
MmInitializeAddressSpace(Process, ProcessAddressSpace);
if (Section->AllocationAttributes & SEC_IMAGE)
{
Segment = MemoryArea->Data.SectionData.Segment;
- Info->AllocationBase = MemoryArea->StartingAddress - Segment->VirtualAddress;
+ Info->AllocationBase = (PBYTE)MemoryArea->StartingAddress - Segment->VirtualAddress;
Info->Type = MEM_IMAGE;
}
else
ObpDecrementHandleCount(PVOID ObjectBody)
{
POBJECT_HEADER ObjectHeader = BODY_TO_HEADER(ObjectBody);
- DPRINT("Header: %x\n", ObjectHeader);
LONG NewHandleCount = InterlockedDecrement(&ObjectHeader->HandleCount);
+ DPRINT("Header: %x\n", ObjectHeader);
DPRINT("NewHandleCount: %x\n", NewHandleCount);
DPRINT("HEADER_TO_OBJECT_NAME: %x\n", HEADER_TO_OBJECT_NAME(ObjectHeader));
if (FoundHeader && FoundHeader->Type == ObDirectoryType &&
RemainingPath.Buffer)
{
- ObpAddEntryDirectory(FoundObject, Header, NULL);
- ObjectAttached = TRUE;
-
/* The name was changed so let's update it */
/* FIXME: TEMPORARY HACK This will go in ObFindObject in the next commit */
PVOID NewName;
PWSTR BufferPos = RemainingPath.Buffer;
ULONG Delta = 0;
+ ObpAddEntryDirectory(FoundObject, Header, NULL);
+ ObjectAttached = TRUE;
+
ObjectNameInfo = HEADER_TO_OBJECT_NAME(Header);
if (BufferPos[0] == L'\\')
/* FUNCTIONS *****************************************************************/
-STDCALL
VOID
+STDCALL
PspReapRoutine(PVOID Context)
{
KIRQL OldIrql;
ProcessObject,
sizeof(EPROCESS),
FALSE);
- PsIdleProcess->Pcb.DirectoryTableBase =
- (LARGE_INTEGER)(LONGLONG)(ULONG)MmGetPageDirectory();
+ PsIdleProcess->Pcb.DirectoryTableBase.QuadPart = (ULONG_PTR)MmGetPageDirectory();
strcpy(PsIdleProcess->ImageFileName, "Idle");
/*
InitializeListHead(&PsInitialSystemProcess->ThreadListHead);
#ifndef SCHED_REWRITE
+ {
PTOKEN BootToken;
/* No parent, this is the Initial System Process. Assign Boot Token */
BootToken->TokenInUse = TRUE;
PsInitialSystemProcess->Token.Object = BootToken; /* FIXME */
ObReferenceObject(BootToken);
+ }
#endif
}
/* GLOBALS ******************************************************************/
-PACL EXPORTED SePublicDefaultDacl = NULL;
-PACL EXPORTED SeSystemDefaultDacl = NULL;
+PACL SePublicDefaultDacl = NULL;
+PACL SeSystemDefaultDacl = NULL;
PACL SePublicDefaultUnrestrictedDacl = NULL;
PACL SePublicOpenDacl = NULL;
/* atomically increment the luid */
do
{
- PrevLuid = (volatile LARGE_INTEGER)LuidValue;
+ PrevLuid = LuidValue;
NewLuid = RtlLargeIntegerAdd(PrevLuid,
LuidIncrement);
} while(ExfInterlockedCompareExchange64(&LuidValue.QuadPart,
/* GLOBALS ******************************************************************/
-PSE_EXPORTS EXPORTED SeExports = NULL;
+PSE_EXPORTS SeExports = NULL;
SE_EXPORTS SepExports;
static ERESOURCE SepSubjectContextLock;
NTSTATUS Status;
ULONG uSize;
ULONG i;
+ ULONG uLocalSystemLength;
+ ULONG uWorldLength;
+ ULONG uAuthUserLength;
+ ULONG uAdminsLength;
+ PTOKEN AccessToken;
+ PVOID SidArea;
PAGED_CODE();
- ULONG uLocalSystemLength = RtlLengthSid(SeLocalSystemSid);
- ULONG uWorldLength = RtlLengthSid(SeWorldSid);
- ULONG uAuthUserLength = RtlLengthSid(SeAuthenticatedUserSid);
- ULONG uAdminsLength = RtlLengthSid(SeAliasAdminsSid);
-
- PTOKEN AccessToken;
-
- PVOID SidArea;
+ uLocalSystemLength = RtlLengthSid(SeLocalSystemSid);
+ uWorldLength = RtlLengthSid(SeWorldSid);
+ uAuthUserLength = RtlLengthSid(SeAuthenticatedUserSid);
+ uAdminsLength = RtlLengthSid(SeAliasAdminsSid);
/*
* Initialize the token
CTL_CODE(FILE_DEVICE_BATTERY, 0x13, METHOD_BUFFERED, FILE_READ_ACCESS)
-typedef NTSTATUS DDKAPI
-(*BCLASS_DISABLE_STATUS_NOTIFY)(
+typedef NTSTATUS
+(DDKAPI*BCLASS_DISABLE_STATUS_NOTIFY)(
IN PVOID Context);
-typedef NTSTATUS DDKAPI
-(*BCLASS_QUERY_INFORMATION)(
+typedef NTSTATUS
+(DDKAPI*BCLASS_QUERY_INFORMATION)(
IN PVOID Context,
IN ULONG BatteryTag,
IN BATTERY_QUERY_INFORMATION_LEVEL Level,
IN ULONG BufferLength,
OUT PULONG ReturnedLength);
-typedef NTSTATUS DDKAPI
-(*BCLASS_QUERY_STATUS)(
+typedef NTSTATUS
+(DDKAPI*BCLASS_QUERY_STATUS)(
IN PVOID Context,
IN ULONG BatteryTag,
OUT PBATTERY_STATUS BatteryStatus);
-typedef NTSTATUS DDKAPI
-(*BCLASS_QUERY_TAG)(
+typedef NTSTATUS
+(DDKAPI*BCLASS_QUERY_TAG)(
IN PVOID Context,
OUT PULONG BatteryTag);
-typedef NTSTATUS DDKAPI
-(*BCLASS_SET_INFORMATION)(
+typedef NTSTATUS
+(DDKAPI*BCLASS_SET_INFORMATION)(
IN PVOID Context,
IN ULONG BatteryTag,
IN BATTERY_SET_INFORMATION_LEVEL Level,
IN PVOID Buffer OPTIONAL);
-typedef NTSTATUS DDKAPI
-(*BCLASS_SET_STATUS_NOTIFY)(
+typedef NTSTATUS
+(DDKAPI*BCLASS_SET_STATUS_NOTIFY)(
IN PVOID Context,
IN ULONG BatteryTag,
IN PBATTERY_NOTIFY BatteryNotify);
#endif
#ifndef DECL_IMPORT
-#define DECL_IMPORT __attribute__((dllimport))
+#define DECL_IMPORT __declspec(dllimport)
#endif
#ifndef DECL_EXPORT
-#define DECL_EXPORT __attribute__((dllexport))
+#define DECL_EXPORT __declspec(dllexport)
#endif
/* Windows NT status codes */
BOOLEAN KernelApcInProgress;
BOOLEAN KernelApcPending;
BOOLEAN UserApcPending;
-} KAPC_STATE, *PKAPC_STATE, *__restrict PRKAPC_STATE;
+} KAPC_STATE, *PKAPC_STATE, *RESTRICTED_POINTER PRKAPC_STATE;
#if (VER_PRODUCTBUILD >= 2600)
);
typedef
-VOID NTAPI
-(*POPLOCK_WAIT_COMPLETE_ROUTINE) (
+VOID
+(NTAPI*POPLOCK_WAIT_COMPLETE_ROUTINE) (
IN PVOID Context,
IN PIRP Irp
);
typedef
-VOID NTAPI
-(*POPLOCK_FS_PREPOST_IRP) (
+VOID
+(NTAPI*POPLOCK_FS_PREPOST_IRP) (
IN PVOID Context,
IN PIRP Irp
);
ULONG IdleHandlerReserved[4];
} PROCESSOR_IDLE_TIMES, *PPROCESSOR_IDLE_TIMES;
-typedef BOOLEAN DDKFASTAPI
-(*PPROCESSOR_IDLE_HANDLER)(
+typedef BOOLEAN
+(DDKFASTAPI*PPROCESSOR_IDLE_HANDLER)(
IN OUT PPROCESSOR_IDLE_TIMES IdleTimes);
typedef struct _PROCESSOR_IDLE_HANDLER_INFO {
PPROCESSOR_IDLE_HANDLER Handler;
} PROCESSOR_IDLE_HANDLER_INFO, *PPROCESSOR_IDLE_HANDLER_INFO;
-typedef VOID DDKFASTAPI
-(*PSET_PROCESSOR_THROTTLE)(
+typedef VOID
+(DDKFASTAPI*PSET_PROCESSOR_THROTTLE)(
IN UCHAR Throttle);
-typedef NTSTATUS DDKFASTAPI
-(*PSET_PROCESSOR_THROTTLE2)(
+typedef NTSTATUS
+(DDKFASTAPI*PSET_PROCESSOR_THROTTLE2)(
IN UCHAR Throttle);
#define MAX_IDLE_HANDLERS 3
PowerStateMaximum
} POWER_STATE_HANDLER_TYPE, *PPOWER_STATE_HANDLER_TYPE;
-typedef NTSTATUS DDKAPI
-(*PENTER_STATE_SYSTEM_HANDLER)(
+typedef NTSTATUS
+(DDKAPI*PENTER_STATE_SYSTEM_HANDLER)(
IN PVOID SystemContext);
-typedef NTSTATUS DDKAPI
-(*PENTER_STATE_HANDLER)(
+typedef NTSTATUS
+(DDKAPI*PENTER_STATE_HANDLER)(
IN PVOID Context,
IN PENTER_STATE_SYSTEM_HANDLER SystemHandler OPTIONAL,
IN PVOID SystemContext,
PVOID Context;
} POWER_STATE_HANDLER, *PPOWER_STATE_HANDLER;
-typedef NTSTATUS STDCALL
-(*PENTER_STATE_NOTIFY_HANDLER)(
+typedef NTSTATUS
+(STDCALL*PENTER_STATE_NOTIFY_HANDLER)(
IN POWER_STATE_HANDLER_TYPE State,
IN PVOID Context,
IN BOOLEAN Entering);
/*
** Definitions specific to this Device Driver Kit
*/
-#define DDKAPI __attribute__((stdcall))
-#define DDKFASTAPI __attribute__((fastcall))
-#define DDKCDECLAPI __attribute__((cdecl))
+#define DDKAPI __stdcall
+#define DDKFASTAPI __fastcall
+#define DDKCDECLAPI __cdecl
#if defined(_NTOSKRNL_)
#ifndef NTOSAPI
VOID)
{
ULONG Value;
-
+#if defined(__GNUC__)
__asm__ __volatile__ ("movl %%fs:0x1C, %0\n\t"
: "=r" (Value)
: /* no inputs */
);
+#elif defined(_MSC_VER)
+ __asm mov eax, fs:[1Ch]
+ __asm mov [Value], eax
+#endif
return (struct _KPCR *) Value;
}
VOID)
{
ULONG Value;
-
+#if defined(__GNUC__)
__asm__ __volatile__ ("movl %%fs:0x20, %0\n\t"
: "=r" (Value)
: /* no inputs */
);
+#elif defined(_MSC_VER)
+ __asm mov eax, fs:[20h]
+ __asm mov [Value], eax
+#endif
return (struct _KPRCB *) Value;
}
} DUMMYUNIONNAME;
} DISK_SIGNATURE, *PDISK_SIGNATURE;
-typedef VOID DDKFASTAPI
-(*PTIME_UPDATE_NOTIFY_ROUTINE)(
+typedef VOID
+(DDKFASTAPI*PTIME_UPDATE_NOTIFY_ROUTINE)(
IN HANDLE ThreadId,
IN KPROCESSOR_MODE Mode);
VOID)
{
volatile LONG Barrier;
+#if defined(__GNUC__)
__asm__ __volatile__ ("xchg %%eax, %0" : : "m" (Barrier) : "%eax");
+#elif defined(_MSC_VER)
+ __asm xchg [Barrier], eax
+#endif
}
NTOSAPI
#if __GNUC__ >=3
#pragma GCC system_header
#endif
+
+/* TODO: some compilers support this */
+#define RESTRICTED_POINTER
#define NTAPI __stdcall
#define OBJ_INHERIT 0x00000002
#elif defined(__WATCOMC__)
#define DECLSPEC_NORETURN
#define DECLARE_STDCALL_P( type ) type __stdcall
+#elif defined(_MSC_VER)
+#define DECLSPEC_NORETURN __declspec(noreturn)
+#define DECLARE_STDCALL_P( type ) type __stdcall
#endif /* __GNUC__/__WATCOMC__ */
#define MAKEWORD(a,b) ((WORD)(((BYTE)(a))|(((WORD)((BYTE)(b)))<<8)))
#define MAKELONG(a,b) ((LONG)(((WORD)(a))|(((DWORD)((WORD)(b)))<<16)))
#endif /* __cplusplus */
#endif /* __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) */
#endif /* NONAMELESSUNION */
-#elif defined(__WATCOMC__)
+#elif defined(__WATCOMC__) || defined(_MSC_VER)
#define _ANONYMOUS_UNION
#define _ANONYMOUS_STRUCT
#endif /* __GNUC__/__WATCOMC__ */
unsigned short Data3;
unsigned char Data4[8];
} GUID, *REFGUID, *LPGUID;
-#define SYSTEM_LUID { QuadPart:999 }
+#define SYSTEM_LUID { 0x3E7, 0x0 }
#endif /* GUID_DEFINED */
/* ACE Access Types, also in ntifs.h */
#endif /* NONAMELESSUNION */
ULONGLONG QuadPart;
} ULARGE_INTEGER, *PULARGE_INTEGER;
-typedef LARGE_INTEGER LUID,*PLUID;
+typedef struct _LUID {
+ DWORD LowPart;
+ LONG HighPart;
+} LUID, *PLUID;
#pragma pack(push,4)
typedef struct _LUID_AND_ATTRIBUTES {
LUID Luid;
return ret;
}
-static __inline__ PVOID GetFiberData(void)
-{
- void* ret;
- __asm__ __volatile__ (
- "movl %%fs:0x10,%0\n"
- "movl (%0),%0"
- : "=r" (ret) /* allow use of reg eax,ebx,ecx,edx,esi,edi */
- );
- return ret;
-}
-
static __inline__ struct _TEB * NtCurrentTeb(void)
{
struct _TEB *ret;
return ret;
}
-#else
+#elif defined(__WATCOMC__)
extern PVOID GetCurrentFiber(void);
#pragma aux GetCurrentFiber = \
value [eax] \
modify [eax];
-extern PVOID GetFiberData(void);
-#pragma aux GetFiberData = \
- "mov eax, dword ptr fs:0x10" \
- "mov eax, [eax]" \
+extern struct _TEB * NtCurrentTeb(void);
+#pragma aux NtCurrentTeb = \
+ "mov eax, dword ptr fs:0x18" \
value [eax] \
modify [eax];
-#endif /* __GNUC__ */
+#elif defined(_MSC_VER)
+
+static __inline PVOID GetCurrentFiber(void)
+{
+ PVOID p;
+ __asm mov eax, fs:[10h]
+ __asm mov [p], eax
+ return p;
+}
+
+static __inline struct _TEB * NtCurrentTeb(void)
+{
+ struct _TEB *p;
+ __asm mov eax, fs:[18h]
+ __asm mov [p], eax
+ return p;
+}
+
+#endif /* __GNUC__/__WATCOMC__/_MSC_VER */
+
+static __inline PVOID GetFiberData(void)
+{
+ return *((PVOID *)GetCurrentFiber());
+}
#endif /* RC_INVOKED */