Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-04-26 00:20:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

PE driver loader is complete.

Browse source 
svn path=/trunk/; revision=158
This commit is contained in:
Rex Jolliff 1999-01-13 03:00:06 +00:00
parent dc7be08202
commit b0cbc91ce1
14 changed files with 1489 additions and 1207 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
reactos/include/ddk/cmtypes.h
View file

@ -20,14 +20,14 @@ typedef struct _KEY_OBJECT
ULONG NumSubKeys;
ULONG MaxSubNameLength;
ULONG MaxSubClassLength;
PKEY_OBJECT *SubKeys;
struct _KEY_OBJECT *SubKeys;
ULONG NumValues;
ULONG MaxValueNameLength;
ULONG MaxValueDataLength;
PKEY_VALUE *Values;
WCHAR *Name;
WCHAR *Class;
PKEY_OBJECT *NextKey;
struct _KEY_OBJECT *NextKey;
} KEY_OBJECT, *PKEY_OBJECT;
/* key query information class */

2
reactos/include/ddk/ntddk.h
View file

@ -26,7 +26,7 @@ extern "C"
#include <ddk/ntdef.h>
#include <ddk/defines.h>
#include <ddk/types.h>
#include <ddk/cfgtypes.h>
// #include <ddk/cfgtypes.h>
#include <ddk/cmtypes.h>
#include <ddk/ketypes.h>
#include <ddk/obtypes.h>

2
reactos/include/ddk/types.h
View file

@ -100,8 +100,6 @@ typedef enum _FILE_INFORMATION_CLASS
FileMaximumInformation,
} FILE_INFORMATION_CLASS;
typedef ULONG KEY_INFORMATION_CLASS;
typedef ULONG KEY_VALUE_INFORMATION_CLASS;
typedef LARGE_INTEGER PHYSICAL_ADDRESS;
typedef PHYSICAL_ADDRESS* PPHYSICAL_ADDRESS;
typedef ULONG WAIT_TYPE;

2
reactos/include/internal/io.h
View file

@ -24,7 +24,7 @@ extern POBJECT_TYPE IoSymbolicLinkType;
* entry = pointer to the driver initialization routine
* RETURNS: Success or failure
*/
NTSTATUS InitalizeLoadedDriver(PDRIVER_INITIALIZE entry);
NTSTATUS InitializeLoadedDriver(PDRIVER_INITIALIZE entry);

2
reactos/include/internal/iomgr.h
View file

@ -19,7 +19,7 @@
* entry = pointer to the driver initialization routine
* RETURNS: Success or failure
*/
NTSTATUS InitalizeLoadedDriver(PDRIVER_INITIALIZE entry);
NTSTATUS InitializeLoadedDriver(PDRIVER_INITIALIZE entry);
VOID IoInitCancelHandling(VOID);
VOID IoInitSymbolicLinkImplementation(VOID);

2
reactos/include/internal/ntoskrnl.h
View file

@ -77,7 +77,7 @@ typedef struct
/*
* Initalization functions (called once by main())
*/
void MmInitalize(boot_param* bp);
void MmInitialize(boot_param* bp);
void HalInit(boot_param* bp);
void IoInit(void);
void ObInit(void);

5
reactos/ntoskrnl/cm/registry.c
View file

@ -24,6 +24,7 @@ PKEY_OBJECT RootKey = NULL;
VOID
CmInitializeRegistry(VOID)
{
#if 0
ANSI_STRING AnsiString;
CmKeyType = ExAllocatePool(NonPagedPool, sizeof(OBJECT_TYPE));
@ -79,6 +80,7 @@ CmInitializeRegistry(VOID)
/* FIXME: Create initial predefined symbolic links */
/* HKEY_LOCAL_MACHINE */
/* HKEY_USERS */
#endif
}
NTSTATUS
@ -108,6 +110,7 @@ ZwCreateKey(PHANDLE KeyHandle,
ULONG CreateOptions,
PULONG Disposition)
{
#if 0
/* FIXME: Should CurLevel be alloced to handle arbitrary size components? */
WCHAR *S, *T, CurLevel[255];
PKEY_OBJECT ParentKey, CurSubKey, NewKey;
@ -253,7 +256,7 @@ ZwCreateKey(PHANDLE KeyHandle,
{
return STATUS_UNSUCCESSFUL;
}
#endif
UNIMPLEMENTED;
}

16
reactos/ntoskrnl/io/device.c
View file

@ -113,7 +113,7 @@ VOID IoRegisterDriverReinitialization(PDRIVER_OBJECT DriverObject,
}
NTSTATUS InitalizeLoadedDriver(PDRIVER_INITIALIZE entry)
NTSTATUS InitializeLoadedDriver(PDRIVER_INITIALIZE entry)
/*
* FUNCTION: Called to initalize a loaded driver
* ARGUMENTS:
@ -131,21 +131,25 @@ NTSTATUS InitalizeLoadedDriver(PDRIVER_INITIALIZE entry)
if (DriverObject==NULL)
{
DbgPrint("%s:%d\n",__FILE__,__LINE__);
return(STATUS_INSUFFICIENT_RESOURCES);
return STATUS_INSUFFICIENT_RESOURCES;
}
memset(DriverObject,sizeof(DRIVER_OBJECT),0);
memset(DriverObject, '\0', sizeof(DRIVER_OBJECT));
CHECKPOINT;
/*
* Initalize the driver
* FIXME: Registry in general please
*/
if ((ret=entry(DriverObject,NULL))!=STATUS_SUCCESS)
DPRINT("Calling driver entrypoint at %08lx\n", entry);
if ((ret=entry(DriverObject,NULL)) != STATUS_SUCCESS)
{
DPRINT("Failed to load driver (status %x)\n",ret);
ExFreePool(DriverObject);
return(ret);
return ret;
}
return(STATUS_SUCCESS);
CHECKPOINT;
return STATUS_SUCCESS;
}
NTSTATUS IoAttachDevice(PDEVICE_OBJECT SourceDevice,

625
reactos/ntoskrnl/io/irp.c
View file

@ -1,312 +1,313 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/io/irp.c
* PURPOSE: Handle IRPs
* PROGRAMMER: David Welch (welch@mcmail.com)
* UPDATE HISTORY:
* 24/05/98: Created
*/
/* NOTES *******************************************************************
*
* Layout of an IRP
*
* ################
* # Headers #
* ################
* # #
* # Variable #
* # length list #
* # of io stack #
* # locations #
* # #
* ################
*
*
*
*/
/* INCLUDES ****************************************************************/
#include <internal/string.h>
#include <internal/io.h>
#include <ddk/ntddk.h>
#define NDEBUG
#include <internal/debug.h>
/* FUNCTIONS ****************************************************************/
PDEVICE_OBJECT IoGetDeviceToVerify(PETHREAD Thread)
/*
* FUNCTION: Returns a pointer to the device, representing a removable-media
* device, that is the target of the given thread's I/O request
*/
{
UNIMPLEMENTED;
}
VOID IoFreeIrp(PIRP Irp)
/*
* FUNCTION: Releases a caller allocated irp
* ARGUMENTS:
* Irp = Irp to free
*/
{
ExFreePool(Irp);
}
PIRP IoMakeAssociatedIrp(PIRP Irp, CCHAR StackSize)
/*
* FUNCTION: Allocates and initializes an irp to associated with a master irp
* ARGUMENTS:
* Irp = Master irp
* StackSize = Number of stack locations to be allocated in the irp
* RETURNS: The irp allocated
*/
{
PIRP AssocIrp;
AssocIrp = IoAllocateIrp(StackSize,FALSE);
UNIMPLEMENTED;
}
VOID IoMarkIrpPending(PIRP Irp)
/*
* FUNCTION: Marks the specified irp, indicating further processing will
* be required by other driver routines
* ARGUMENTS:
* Irp = Irp to mark
*/
{
DPRINT("IoGetCurrentIrpStackLocation(Irp) %x\n",
IoGetCurrentIrpStackLocation(Irp));
IoGetCurrentIrpStackLocation(Irp)->Control |= SL_PENDING_RETURNED;
Irp->Tail.Overlay.Thread = KeGetCurrentThread();
DPRINT("IoGetCurrentIrpStackLocation(Irp)->Control %x\n",
IoGetCurrentIrpStackLocation(Irp)->Control);
DPRINT("SL_PENDING_RETURNED %x\n",SL_PENDING_RETURNED);
}
USHORT IoSizeOfIrp(CCHAR StackSize)
/*
* FUNCTION: Determines the size of an IRP
* ARGUMENTS:
* StackSize = number of stack locations in the IRP
* RETURNS: The size of the IRP in bytes
*/
{
return(sizeof(IRP)+((StackSize-1)*sizeof(IO_STACK_LOCATION)));
}
VOID IoInitializeIrp(PIRP Irp, USHORT PacketSize, CCHAR StackSize)
/*
* FUNCTION: Initalizes an irp allocated by the caller
* ARGUMENTS:
* Irp = IRP to initalize
* PacketSize = Size in bytes of the IRP
* StackSize = Number of stack locations in the IRP
*/
{
assert(Irp != NULL);
memset(Irp,0,PacketSize);
Irp->StackCount=StackSize;
Irp->CurrentLocation=StackSize;
Irp->Tail.Overlay.CurrentStackLocation=IoGetCurrentIrpStackLocation(Irp);
}
PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
/*
* FUNCTION: Gets a pointer to the callers location in the I/O stack in
* the given IRP
* ARGUMENTS:
* Irp = Points to the IRP
* RETURNS: A pointer to the stack location
*/
{
DPRINT("IoGetCurrentIrpStackLocation: Irp %08lx CurLoc %d StkCnt %d\n",
Irp,
Irp->CurrentLocation,
Irp->StackCount);
return &Irp->Stack[Irp->CurrentLocation];
}
VOID IoSetNextIrpStackLocation(PIRP Irp)
{
Irp->CurrentLocation--;
Irp->Tail.Overlay.CurrentStackLocation--;
}
PIO_STACK_LOCATION IoGetNextIrpStackLocation(PIRP Irp)
/*
* FUNCTION: Gives a higher level driver access to the next lower driver's
* I/O stack location
* ARGUMENTS:
* Irp = points to the irp
* RETURNS: A pointer to the stack location
*/
{
DPRINT("IoGetNextIrpStackLocation: Irp %08lx CurLoc %d StkCnt %d\n",
Irp,
Irp->CurrentLocation,
Irp->StackCount);
assert(Irp!=NULL);
DPRINT("Irp %x Irp->StackPtr %x\n",Irp,Irp->CurrentLocation);
return(&Irp->Stack[Irp->CurrentLocation-1]);
}
NTSTATUS IoCallDriver(PDEVICE_OBJECT DevObject, PIRP irp)
/*
* FUNCTION: Sends an IRP to the next lower driver
*/
{
NTSTATUS Status;
PDRIVER_OBJECT drv = DevObject->DriverObject;
IO_STACK_LOCATION* param = IoGetNextIrpStackLocation(irp);
DPRINT("Deviceobject %x\n",DevObject);
DPRINT("Irp %x\n",irp);
irp->Tail.Overlay.CurrentStackLocation--;
irp->CurrentLocation--;
DPRINT("Io stack address %x\n",param);
DPRINT("Function %d Routine %x\n",param->MajorFunction,
drv->MajorFunction[param->MajorFunction]);
Status = drv->MajorFunction[param->MajorFunction](DevObject,irp);
return Status;
}
PIRP IoAllocateIrp(CCHAR StackSize, BOOLEAN ChargeQuota)
/*
* FUNCTION: Allocates an IRP
* ARGUMENTS:
* StackSize = the size of the stack required for the irp
* ChargeQuota = Charge allocation to current threads quota
* RETURNS: Irp allocated
*/
{
PIRP Irp;
DPRINT("IoAllocateIrp(StackSize %d ChargeQuota %d)\n",
StackSize,
ChargeQuota);
if (ChargeQuota)
{
Irp = ExAllocatePoolWithQuota(NonPagedPool,IoSizeOfIrp(StackSize));
}
else
{
Irp = ExAllocatePool(NonPagedPool,IoSizeOfIrp(StackSize));
}
if (Irp==NULL)
{
return(NULL);
}
IoInitializeIrp(Irp, IoSizeOfIrp(StackSize), StackSize);
DPRINT("Irp %x Irp->StackPtr %d\n", Irp, Irp->CurrentLocation);
return Irp;
}
VOID IoSetCompletionRoutine(PIRP Irp,
PIO_COMPLETION_ROUTINE CompletionRoutine,
PVOID Context,
BOOLEAN InvokeOnSuccess,
BOOLEAN InvokeOnError,
BOOLEAN InvokeOnCancel)
{
IO_STACK_LOCATION* param = IoGetNextIrpStackLocation(Irp);
param->CompletionRoutine=CompletionRoutine;
param->CompletionContext=Context;
if (InvokeOnSuccess)
{
param->Control = param->Control | SL_INVOKE_ON_SUCCESS;
}
if (InvokeOnError)
{
param->Control = param->Control | SL_INVOKE_ON_ERROR;
}
if (InvokeOnCancel)
{
param->Control = param->Control | SL_INVOKE_ON_CANCEL;
}
}
VOID IopCompleteRequest(struct _KAPC* Apc,
PKNORMAL_ROUTINE* NormalRoutine,
PVOID* NormalContext,
PVOID* SystemArgument1,
PVOID* SystemArgument2)
{
IoSecondStageCompletion((PIRP)(*NormalContext),
IO_NO_INCREMENT);
}
VOID IoCompleteRequest(PIRP Irp, CCHAR PriorityBoost)
/*
* FUNCTION: Indicates the caller has finished all processing for a given
* I/O request and is returning the given IRP to the I/O manager
* ARGUMENTS:
* Irp = Irp to be cancelled
* PriorityBoost = Increment by which to boost the priority of the
* thread making the request
*/
{
unsigned int i;
NTSTATUS Status;
DPRINT("IoCompleteRequest(Irp %x, PriorityBoost %d)\n",
Irp,PriorityBoost);
for (i=0;i<Irp->StackCount;i++)
{
DPRINT("&Irp->Stack[%d].CompletionRoutine %08lx\n",
i,
Irp->Stack[i].CompletionRoutine);
if (Irp->Stack[i].CompletionRoutine != NULL)
{
Status = Irp->Stack[i].CompletionRoutine(
Irp->Stack[i].DeviceObject,
Irp,
Irp->Stack[i].CompletionContext);
if (Status == STATUS_MORE_PROCESSING_REQUIRED)
{
return;
}
}
DPRINT("Irp->Stack[%d].Control %08lx\n", i, Irp->Stack[i].Control);
if (Irp->Stack[i].Control & SL_PENDING_RETURNED)
{
DPRINT("Setting PendingReturned flag\n");
Irp->PendingReturned = TRUE;
}
}
if (Irp->PendingReturned)
{
KeInitializeApc(&Irp->Tail.Apc,
&Irp->Tail.Overlay.Thread->Tcb,
0,
IopCompleteRequest,
NULL,
NULL,
0,
Irp);
KeInsertQueueApc(&Irp->Tail.Apc,NULL,NULL,0);
}
else
{
IoSecondStageCompletion(Irp,PriorityBoost);
}
}
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/io/irp.c
* PURPOSE: Handle IRPs
* PROGRAMMER: David Welch (welch@mcmail.com)
* UPDATE HISTORY:
* 24/05/98: Created
*/
/* NOTES *******************************************************************
*
* Layout of an IRP
*
* ################
* # Headers #
* ################
* # #
* # Variable #
* # length list #
* # of io stack #
* # locations #
* # #
* ################
*
*
*
*/
/* INCLUDES ****************************************************************/
#include <internal/string.h>
#include <internal/io.h>
#include <ddk/ntddk.h>
#define NDEBUG
#include <internal/debug.h>
/* FUNCTIONS ****************************************************************/
PDEVICE_OBJECT IoGetDeviceToVerify(PETHREAD Thread)
/*
* FUNCTION: Returns a pointer to the device, representing a removable-media
* device, that is the target of the given thread's I/O request
*/
{
UNIMPLEMENTED;
}
VOID IoFreeIrp(PIRP Irp)
/*
* FUNCTION: Releases a caller allocated irp
* ARGUMENTS:
* Irp = Irp to free
*/
{
ExFreePool(Irp);
}
PIRP IoMakeAssociatedIrp(PIRP Irp, CCHAR StackSize)
/*
* FUNCTION: Allocates and initializes an irp to associated with a master irp
* ARGUMENTS:
* Irp = Master irp
* StackSize = Number of stack locations to be allocated in the irp
* RETURNS: The irp allocated
*/
{
PIRP AssocIrp;
AssocIrp = IoAllocateIrp(StackSize,FALSE);
UNIMPLEMENTED;
}
VOID IoMarkIrpPending(PIRP Irp)
/*
* FUNCTION: Marks the specified irp, indicating further processing will
* be required by other driver routines
* ARGUMENTS:
* Irp = Irp to mark
*/
{
DPRINT("IoGetCurrentIrpStackLocation(Irp) %x\n",
IoGetCurrentIrpStackLocation(Irp));
IoGetCurrentIrpStackLocation(Irp)->Control |= SL_PENDING_RETURNED;
Irp->Tail.Overlay.Thread = KeGetCurrentThread();
DPRINT("IoGetCurrentIrpStackLocation(Irp)->Control %x\n",
IoGetCurrentIrpStackLocation(Irp)->Control);
DPRINT("SL_PENDING_RETURNED %x\n",SL_PENDING_RETURNED);
}
USHORT IoSizeOfIrp(CCHAR StackSize)
/*
* FUNCTION: Determines the size of an IRP
* ARGUMENTS:
* StackSize = number of stack locations in the IRP
* RETURNS: The size of the IRP in bytes
*/
{
return(sizeof(IRP)+((StackSize-1)*sizeof(IO_STACK_LOCATION)));
}
VOID IoInitializeIrp(PIRP Irp, USHORT PacketSize, CCHAR StackSize)
/*
* FUNCTION: Initalizes an irp allocated by the caller
* ARGUMENTS:
* Irp = IRP to initalize
* PacketSize = Size in bytes of the IRP
* StackSize = Number of stack locations in the IRP
*/
{
assert(Irp != NULL);
memset(Irp,0,PacketSize);
Irp->StackCount=StackSize;
Irp->CurrentLocation=StackSize;
Irp->Tail.Overlay.CurrentStackLocation=IoGetCurrentIrpStackLocation(Irp);
}
PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
/*
* FUNCTION: Gets a pointer to the callers location in the I/O stack in
* the given IRP
* ARGUMENTS:
* Irp = Points to the IRP
* RETURNS: A pointer to the stack location
*/
{
DPRINT("IoGetCurrentIrpStackLocation: Irp %08lx CurLoc %d StkCnt %d\n",
Irp,
Irp->CurrentLocation,
Irp->StackCount);
return &Irp->Stack[Irp->CurrentLocation];
}
VOID IoSetNextIrpStackLocation(PIRP Irp)
{
Irp->CurrentLocation--;
Irp->Tail.Overlay.CurrentStackLocation--;
}
PIO_STACK_LOCATION IoGetNextIrpStackLocation(PIRP Irp)
/*
* FUNCTION: Gives a higher level driver access to the next lower driver's
* I/O stack location
* ARGUMENTS:
* Irp = points to the irp
* RETURNS: A pointer to the stack location
*/
{
DPRINT("IoGetNextIrpStackLocation: Irp %08lx CurLoc %d StkCnt %d\n",
Irp,
Irp->CurrentLocation,
Irp->StackCount);
assert(Irp!=NULL);
DPRINT("Irp %x Irp->StackPtr %x\n",Irp,Irp->CurrentLocation);
return(&Irp->Stack[Irp->CurrentLocation-1]);
}
NTSTATUS IoCallDriver(PDEVICE_OBJECT DevObject, PIRP irp)
/*
* FUNCTION: Sends an IRP to the next lower driver
*/
{
NTSTATUS Status;
PDRIVER_OBJECT drv = DevObject->DriverObject;
IO_STACK_LOCATION* param = IoGetNextIrpStackLocation(irp);
DPRINT("Deviceobject %x\n",DevObject);
DPRINT("Irp %x\n",irp);
irp->Tail.Overlay.CurrentStackLocation--;
irp->CurrentLocation--;
DPRINT("Io stack address %x\n",param);
DPRINT("Function %d Routine %x\n",param->MajorFunction,
drv->MajorFunction[param->MajorFunction]);
Status = drv->MajorFunction[param->MajorFunction](DevObject,irp);
return Status;
}
PIRP IoAllocateIrp(CCHAR StackSize, BOOLEAN ChargeQuota)
/*
* FUNCTION: Allocates an IRP
* ARGUMENTS:
* StackSize = the size of the stack required for the irp
* ChargeQuota = Charge allocation to current threads quota
* RETURNS: Irp allocated
*/
{
PIRP Irp;
DPRINT("IoAllocateIrp(StackSize %d ChargeQuota %d)\n",
StackSize,
ChargeQuota);
if (ChargeQuota)
{
Irp = ExAllocatePoolWithQuota(NonPagedPool,IoSizeOfIrp(StackSize));
}
else
{
Irp = ExAllocatePool(NonPagedPool,IoSizeOfIrp(StackSize));
}
if (Irp==NULL)
{
return(NULL);
}
IoInitializeIrp(Irp, IoSizeOfIrp(StackSize), StackSize);
DPRINT("Irp %x Irp->StackPtr %d\n", Irp, Irp->CurrentLocation);
return Irp;
}
VOID IoSetCompletionRoutine(PIRP Irp,
PIO_COMPLETION_ROUTINE CompletionRoutine,
PVOID Context,
BOOLEAN InvokeOnSuccess,
BOOLEAN InvokeOnError,
BOOLEAN InvokeOnCancel)
{
IO_STACK_LOCATION* param = IoGetNextIrpStackLocation(Irp);
param->CompletionRoutine=CompletionRoutine;
param->CompletionContext=Context;
if (InvokeOnSuccess)
{
param->Control = param->Control | SL_INVOKE_ON_SUCCESS;
}
if (InvokeOnError)
{
param->Control = param->Control | SL_INVOKE_ON_ERROR;
}
if (InvokeOnCancel)
{
param->Control = param->Control | SL_INVOKE_ON_CANCEL;
}
}
VOID IopCompleteRequest(struct _KAPC* Apc,
PKNORMAL_ROUTINE* NormalRoutine,
PVOID* NormalContext,
PVOID* SystemArgument1,
PVOID* SystemArgument2)
{
IoSecondStageCompletion((PIRP)(*NormalContext),
IO_NO_INCREMENT);
}
VOID IoCompleteRequest(PIRP Irp, CCHAR PriorityBoost)
/*
* FUNCTION: Indicates the caller has finished all processing for a given
* I/O request and is returning the given IRP to the I/O manager
* ARGUMENTS:
* Irp = Irp to be cancelled
* PriorityBoost = Increment by which to boost the priority of the
* thread making the request
*/
{
unsigned int i;
NTSTATUS Status;
DPRINT("IoCompleteRequest(Irp %x, PriorityBoost %d)\n",
Irp,PriorityBoost);
for (i=0;i<Irp->StackCount;i++)
{
DPRINT("&Irp->Stack[%d].CompletionRoutine %08lx\n",
i,
Irp->Stack[i].CompletionRoutine);
if (Irp->Stack[i].CompletionRoutine != NULL)
{
Status = Irp->Stack[i].CompletionRoutine(
Irp->Stack[i].DeviceObject,
Irp,
Irp->Stack[i].CompletionContext);
if (Status == STATUS_MORE_PROCESSING_REQUIRED)
{
return;
}
}
DPRINT("Irp->Stack[%d].Control %08lx\n", i, Irp->Stack[i].Control);
if (Irp->Stack[i].Control & SL_PENDING_RETURNED)
{
DPRINT("Setting PendingReturned flag\n");
Irp->PendingReturned = TRUE;
}
}
if (Irp->PendingReturned)
{
KeInitializeApc(&Irp->Tail.Apc,
&Irp->Tail.Overlay.Thread->Tcb,
0,
IopCompleteRequest,
NULL,
NULL,
0,
Irp);
KeInsertQueueApc(&Irp->Tail.Apc,NULL,NULL,0);
}
else
{
IoSecondStageCompletion(Irp,PriorityBoost);
}
}

534
reactos/ntoskrnl/ke/main.c
View file

@ -1,178 +1,356 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/main.c
* PURPOSE: Initalizes the kernel
* PROGRAMMER: David Welch (welch@mcmail.com)
* UPDATE HISTORY:
* 28/05/98: Created
*/
/* INCLUDES *****************************************************************/
#include <windows.h>
#include <internal/ntoskrnl.h>
#include <internal/version.h>
#include <internal/mm.h>
#include <internal/string.h>
#include <internal/symbol.h>
#include <internal/module.h>
#include <internal/mmhal.h>
#include <internal/i386/segment.h>
#define NDEBUG
#include <internal/debug.h>
/* FUNCTIONS ****************************************************************/
void set_breakpoint(unsigned int i, unsigned int addr, unsigned int type,
unsigned int len)
/*
* FUNCTION: Sets a hardware breakpoint
* ARGUMENTS:
* i = breakpoint to set (0 to 3)
* addr = linear address to break on
* type = Type of access to break on
* len = length of the variable to watch
* NOTES:
* The variable to watch must be aligned to its length (i.e. a dword
* breakpoint must be aligned to a dword boundary)
*
* A fatal exception will be generated on the access to the variable.
* It is (at the moment) only really useful for catching undefined
* pointers if you know the variable effected but not the buggy
* routine.
*
* FIXME: Extend to call out to kernel debugger on breakpoint
* Add support for I/O breakpoints
* REFERENCES: See the i386 programmer manual for more details
*/
{
unsigned int mask;
if (i>3)
{
printk("Invalid breakpoint index at %s:%d\n",__FILE__,__LINE__);
return;
}
/*
* Load the linear address
*/
switch (i)
{
case 0:
__asm("movl %0,%%db0\n\t"
: /* no outputs */
: "d" (addr));
break;
case 1:
__asm__("movl %0,%%db1\n\t"
: /* no outputs */
: "d" (addr));
break;
case 2:
__asm__("movl %0,%%db2\n\t"
: /* no outputs */
: "d" (addr));
break;
case 3:
__asm__("movl %0,%%db3\n\t"
: /* no outputs */
: "d" (addr));
break;
}
/*
* Setup mask for dr7
*/
mask = (len<<(16 + 2 + i*4)) + (type<<(16 + i*4)) + (1<<(i*2));
__asm__("movl %%db7,%%eax\n\t"
"orl %0,%%eax\n\t"
"movl %%eax,%%db7\n\t"
: /* no outputs */
: "d" (mask)
: "ax");
}
extern int edata;
extern int end;
asmlinkage void _main(boot_param* _bp)
/*
* FUNCTION: Called by the boot loader to start the kernel
* ARGUMENTS:
* _bp = Pointer to boot parameters initialized by the boot loader
* NOTE: The boot parameters are stored in low memory which will become
* invalid after the memory managment is initialized so we make a local copy.
*/
{
unsigned int i;
unsigned int start;
unsigned int start1;
boot_param bp;
memset((void *)&edata,0,((int)&end)-((int)&edata));
/*
* Copy the parameters to a local buffer because lowmem will go away
*/
memcpy(&bp,_bp,sizeof(boot_param));
/*
* Initalize the console (before printing anything)
*/
HalInitConsole(&bp);
DbgPrint("Starting ReactOS "KERNEL_VERSION"\n");
start = KERNEL_BASE + PAGE_ROUND_UP(bp.module_length[0]);
if (start < ((int)&end))
{
DbgPrint("start %x end %x\n",start,(int)&end);
DbgPrint("Kernel booted incorrectly, aborting\n");
DbgPrint("Reduce the amount of uninitialized data\n");
for(;;);
}
start1 = start+PAGE_ROUND_UP(bp.module_length[1]);
/*
* Initalize various critical subsystems
*/
HalInit(&bp);
MmInitalize(&bp);
KeInit();
ObInit();
PsInit();
IoInit();
/*
* Initalize services loaded at boot time
*/
DPRINT("%d files loaded\n",bp.nr_files);
start = KERNEL_BASE + PAGE_ROUND_UP(bp.module_length[0]);
start1 = start+PAGE_ROUND_UP(bp.module_length[1]);
for (i=1;i<bp.nr_files;i++)
{
process_boot_module(start);
start=start+PAGE_ROUND_UP(bp.module_length[i]);
}
/*
* Test various features of the kernel
*/
TstBegin();
/*
* Enter idle loop
*/
printk("Finished main()\n");
PsTerminateSystemThread(STATUS_SUCCESS);
}
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/main.c
* PURPOSE: Initalizes the kernel
* PROGRAMMER: David Welch (welch@mcmail.com)
* UPDATE HISTORY:
* 28/05/98: Created
*/
/* INCLUDES *****************************************************************/
#include <windows.h>
#include <internal/ntoskrnl.h>
#include <internal/version.h>
#include <internal/mm.h>
#include <internal/string.h>
#include <internal/symbol.h>
#include <internal/module.h>
#include <internal/mmhal.h>
#include <internal/i386/segment.h>
#define NDEBUG
#include <internal/debug.h>
/* FUNCTIONS ****************************************************************/
void set_breakpoint(unsigned int i, unsigned int addr, unsigned int type,
unsigned int len)
/*
* FUNCTION: Sets a hardware breakpoint
* ARGUMENTS:
* i = breakpoint to set (0 to 3)
* addr = linear address to break on
* type = Type of access to break on
* len = length of the variable to watch
* NOTES:
* The variable to watch must be aligned to its length (i.e. a dword
* breakpoint must be aligned to a dword boundary)
*
* A fatal exception will be generated on the access to the variable.
* It is (at the moment) only really useful for catching undefined
* pointers if you know the variable effected but not the buggy
* routine.
*
* FIXME: Extend to call out to kernel debugger on breakpoint
* Add support for I/O breakpoints
* REFERENCES: See the i386 programmer manual for more details
*/
{
unsigned int mask;
if (i>3)
{
printk("Invalid breakpoint index at %s:%d\n",__FILE__,__LINE__);
return;
}
/*
* Load the linear address
*/
switch (i)
{
case 0:
__asm("movl %0,%%db0\n\t"
: /* no outputs */
: "d" (addr));
break;
case 1:
__asm__("movl %0,%%db1\n\t"
: /* no outputs */
: "d" (addr));
break;
case 2:
__asm__("movl %0,%%db2\n\t"
: /* no outputs */
: "d" (addr));
break;
case 3:
__asm__("movl %0,%%db3\n\t"
: /* no outputs */
: "d" (addr));
break;
}
/*
* Setup mask for dr7
*/
mask = (len<<(16 + 2 + i*4)) + (type<<(16 + i*4)) + (1<<(i*2));
__asm__("movl %%db7,%%eax\n\t"
"orl %0,%%eax\n\t"
"movl %%eax,%%db7\n\t"
: /* no outputs */
: "d" (mask)
: "ax");
}
extern int edata;
extern int end;
asmlinkage void _main(boot_param* _bp)
/*
* FUNCTION: Called by the boot loader to start the kernel
* ARGUMENTS:
* _bp = Pointer to boot parameters initialized by the boot loader
* NOTE: The boot parameters are stored in low memory which will become
* invalid after the memory managment is initialized so we make a local copy.
*/
{
unsigned int i;
unsigned int start;
unsigned int start1;
boot_param bp;
memset((void *)&edata,0,((int)&end)-((int)&edata));
/*
* Copy the parameters to a local buffer because lowmem will go away
*/
memcpy(&bp,_bp,sizeof(boot_param));
/*
* Initalize the console (before printing anything)
*/
HalInitConsole(&bp);
DbgPrint("Starting ReactOS "KERNEL_VERSION"\n");
start = KERNEL_BASE + PAGE_ROUND_UP(bp.module_length[0]);
if (start < ((int)&end))
{
DbgPrint("start %x end %x\n",start,(int)&end);
DbgPrint("Kernel booted incorrectly, aborting\n");
DbgPrint("Reduce the amount of uninitialized data\n");
for(;;);
}
start1 = start+PAGE_ROUND_UP(bp.module_length[1]);
/*
* Initalize various critical subsystems
*/
HalInit(&bp);
MmInitialize(&bp);
KeInit();
ObInit();
PsInit();
IoInit();
/*
* Initalize services loaded at boot time
*/
DPRINT("%d files loaded\n",bp.nr_files);
start = KERNEL_BASE + PAGE_ROUND_UP(bp.module_length[0]);
start1 = start+PAGE_ROUND_UP(bp.module_length[1]);
for (i=1;i<bp.nr_files;i++)
{
process_boot_module(start);
start=start+PAGE_ROUND_UP(bp.module_length[i]);
}
/*
* Test various features of the kernel
*/
TstBegin();
/*
* Enter idle loop
*/
printk("Finished main()\n");
PsTerminateSystemThread(STATUS_SUCCESS);
}

2
reactos/ntoskrnl/ke/module.c
View file

@ -396,5 +396,5 @@ BOOLEAN process_boot_module(unsigned int start)
* Call the module initalization routine
*/
func = (PDRIVER_INITIALIZE)(mod->base + entry);
return(InitalizeLoadedDriver(func));
return(InitializeLoadedDriver(func));
}

145
reactos/ntoskrnl/ldr/loader.c
View file

@ -40,6 +40,7 @@ NTSTATUS LdrProcessDriver(PVOID ModuleLoadBase);
/* PE Driver load support */
static NTSTATUS LdrPEProcessDriver(PVOID ModuleLoadBase);
static unsigned int LdrGetKernelSymbolAddr(char *Name);
/* COFF Driver load support */
static NTSTATUS LdrCOFFProcessDriver(PVOID ModuleLoadBase);
@ -48,7 +49,6 @@ static BOOLEAN LdrCOFFDoAddr32Reloc(module *Module, SCNHDR *Section, RELOC *Relo
static BOOLEAN LdrCOFFDoReloc32Reloc(module *Module, SCNHDR *Section, RELOC *Relocation);
static void LdrCOFFGetSymbolName(module *Module, unsigned int Idx, char *Name);
static unsigned int LdrCOFFGetSymbolValue(module *Module, unsigned int Idx);
static unsigned int LdrCOFFGetKernelSymbolAddr(char *Name);
static unsigned int LdrCOFFGetSymbolValueByName(module *Module, char *SymbolName, unsigned int Idx);
/* Image loader forward delcarations */
@ -188,7 +188,8 @@ LdrPEProcessDriver(PVOID ModuleLoadBase)
{
unsigned int DriverSize, Idx;
long int RelocDelta, NumRelocs;
PVOID DriverBase, RelocBase;
DWORD CurrentSize;
PVOID DriverBase, CurrentBase, EntryPoint;
PULONG PEMagic;
PIMAGE_DOS_HEADER PEDosHeader;
PIMAGE_FILE_HEADER PEFileHeader;
@ -196,7 +197,15 @@ LdrPEProcessDriver(PVOID ModuleLoadBase)
PIMAGE_SECTION_HEADER PESectionHeaders;
PRELOCATION_DIRECTORY RelocDir;
PRELOCATION_ENTRY RelocEntry;
PMODULE Library;
PVOID *ImportAddressList;
PULONG FunctionNameList;
PCHAR pName, SymbolNameBuf;
PWORD pHint;
/* FIXME: this could be used to load kernel DLLs also, however */
/* the image headers should be preserved in such a case */
DPRINT("Processing PE Driver at module base:%08lx\n", ModuleLoadBase);
/* Get header pointers */
@ -249,10 +258,10 @@ LdrPEProcessDriver(PVOID ModuleLoadBase)
/* Determine the size of the module */
DPRINT("Sections: (section align:%08lx)\n",
PEOptionalHeader->SectionAlignment);
DriverSize = 0;
DriverSize = PESectionHeaders[0].PointerToRawData;
for (Idx = 0; Idx < PEFileHeader->NumberOfSections; Idx++)
{
DPRINT("Name: %-8.8s VA:%08lx RawSize:%6d Offset:%08lx CHAR:%08lx OfsAdr: %08lx\n",
DPRINT("Name:%-8.8s VA:%08lx RawSz:%6d Offs:%08lx CHAR:%08lx OfsA: %08lx\n",
PESectionHeaders[Idx].Name,
PESectionHeaders[Idx].VirtualAddress,
PESectionHeaders[Idx].SizeOfRawData,
@ -266,7 +275,6 @@ LdrPEProcessDriver(PVOID ModuleLoadBase)
DriverSize,
DriverSize);
#if 0
/* Allocate a virtual section for the module */
DriverBase = MmAllocateSection(DriverSize);
if (DriverBase == 0)
@ -276,10 +284,12 @@ LdrPEProcessDriver(PVOID ModuleLoadBase)
}
CHECKPOINT;
CurrentBase = ModuleLoadBase;
/* Copy image sections into virtual section */
memcpy(DriverBase, ModuleLoadBase, PESectionHeaders[0].PointerToRawData);
CurrentBase = (PVOID) ((DWORD)DriverBase + PESectionHeaders[0].PointerToRawData);
for (Idx = 0; Idx < PEFileHeader->NumberOfSections; Idx++)
{
/* Copy current section into current offset of virtual section */
/* Copy current section into current offset of virtual section */
if (PESectionHeaders[Idx].Characteristics &
(IMAGE_SECTION_CHAR_CODE | IMAGE_SECTION_CHAR_DATA))
{
@ -293,19 +303,19 @@ LdrPEProcessDriver(PVOID ModuleLoadBase)
}
CurrentSize += ROUND_UP(PESectionHeaders[Idx].SizeOfRawData,
PEOptionalHeader->SectionAlignment);
CurrentBase = (PVOID)((DWORD)CurrentBase +
ROUND_UP(PESectionHeaders[Idx].SizeOfRawData,
PEOptionalHeader->SectionAlignment));
}
#else
DriverBase = ModuleLoadBase;
#endif
/* FIXME: Perform relocation fixups */
/* Perform relocation fixups */
RelocDelta = (DWORD) DriverBase - PEOptionalHeader->ImageBase;
RelocDir = (PRELOCATION_DIRECTORY) ((DWORD)ModuleLoadBase +
PEOptionalHeader->DataDirectory[
IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
DPRINT("Relocs: ModuleLoadBase: %08lx RelocDelta %08lx\n",
ModuleLoadBase,
DPRINT("DrvrBase:%08lx ImgBase:%08lx RelocDelta:%08lx\n",
DriverBase,
PEOptionalHeader->ImageBase,
RelocDelta);
while (RelocDir->SizeOfBlock != 0)
{
@ -328,21 +338,108 @@ LdrPEProcessDriver(PVOID ModuleLoadBase)
(RelocEntry[Idx].TypeOffset & 0x0fff)),
(*(PDWORD)((DWORD) DriverBase + RelocDir->VirtualAddress +
(RelocEntry[Idx].TypeOffset & 0x0fff))) + RelocDelta);
if (((RelocEntry[Idx].TypeOffset >> 12) & 0xf) == 3)
{
(*(PDWORD)((DWORD) DriverBase + RelocDir->VirtualAddress +
(RelocEntry[Idx].TypeOffset & 0x0fff))) += RelocDelta;
}
else if (((RelocEntry[Idx].TypeOffset >> 12) & 0xf) != 0)
{
DPRINT("Unknown relocation type %x\n",
(RelocEntry[Idx].TypeOffset >> 12) & 0xf);
return STATUS_UNSUCCESSFUL;
}
}
RelocDir = (PRELOCATION_DIRECTORY)((DWORD)RelocDir +
RelocDir->SizeOfBlock);
getchar();
}
#if 0
/* Perform import fixups */
if (PEOptionalHeader->DataDirectory[
IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress)
{
PIMAGE_IMPORT_MODULE_DIRECTORY ImportModuleDirectory;
/* FIXME: perform import fixups */
/* FIXME: compute address of entry point */
SymbolNameBuf = ExAllocatePool(NonPagedPool, 512);
#endif
/* Process each import module */
ImportModuleDirectory = (PIMAGE_IMPORT_MODULE_DIRECTORY)
((DWORD)ModuleLoadBase + PEOptionalHeader->
DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
while (ImportModuleDirectory->dwRVAModuleName)
{
/* FIXME: handle kernel mode DLLs */
/* return InitializeLoadedDriver(EntryPoint); */
return STATUS_NOT_IMPLEMENTED;
/* Check to make sure that import lib is kernel */
Library = NULL;
pName = (PCHAR) ModuleLoadBase +
ImportModuleDirectory->dwRVAModuleName;
DPRINT("Import module: %s\n", pName);
if (strcmp(pName, "ntoskrnl.exe") &&
strcmp(pName, "HAL.dll"))
{
DPRINT("Kernel mode DLLs are currently unsupported\n");
}
/* Get the import address list */
ImportAddressList = (PVOID *) ((DWORD)ModuleLoadBase +
ImportModuleDirectory->dwRVAFunctionAddressList);
/* Get the list of functions to import */
if (ImportModuleDirectory->dwRVAFunctionNameList != 0)
{
FunctionNameList = (PULONG) ((DWORD)ModuleLoadBase +
ImportModuleDirectory->dwRVAFunctionNameList);
}
else
{
FunctionNameList = (PULONG) ((DWORD)ModuleLoadBase +
ImportModuleDirectory->dwRVAFunctionAddressList);
}
/* Walk through function list and fixup addresses */
while(*FunctionNameList != 0L)
{
if ((*FunctionNameList) & 0x80000000) // hint
{
DPRINT(" Hint: %08lx\n", *FunctionNameList);
if (Library == NULL)
{
DPRINT("Hints for kernel symbols are not handled.\n");
*ImportAddressList = 0;
}
}
else // hint-name
{
pName = (PCHAR)((DWORD)ModuleLoadBase +
*FunctionNameList + 2);
pHint = (PWORD)((DWORD)ModuleLoadBase + *FunctionNameList);
DPRINT(" Hint:%04x Name:%s\n", pHint, pName);
/* Get address for symbol */
if (Library == NULL)
{
*SymbolNameBuf = '_';
strcpy(SymbolNameBuf + 1, pName);
*ImportAddressList = (PVOID) LdrGetKernelSymbolAddr(SymbolNameBuf); if (*ImportAddressList == 0L)
{
DPRINT("Unresolved kernel symbol: %s\n", pName);
}
}
}
ImportAddressList++;
FunctionNameList++;
}
ImportModuleDirectory++;
}
ExFreePool(SymbolNameBuf);
}
/* Compute address of entry point */
EntryPoint = (PVOID) ((DWORD)DriverBase + PEOptionalHeader->AddressOfEntryPoint);
return InitializeLoadedDriver(EntryPoint);
}
NTSTATUS
@ -491,7 +588,7 @@ LdrCOFFProcessDriver(PVOID ModuleLoadBase)
/* Cleanup */
ExFreePool(Module);
return InitalizeLoadedDriver(EntryRoutine);
return InitializeLoadedDriver(EntryRoutine);
}
/* LdrCOFFDoRelocations
@ -594,7 +691,7 @@ LdrCOFFDoReloc32Reloc(module *Module, SCNHDR *Section, RELOC *Relocation)
memset(Name, 0, 255);
LdrCOFFGetSymbolName(Module, Relocation->r_symndx, Name);
Value = (unsigned int) LdrCOFFGetKernelSymbolAddr(Name);
Value = (unsigned int) LdrGetKernelSymbolAddr(Name);
if (Value == 0L)
{
Value = LdrCOFFGetSymbolValueByName(Module, Name, Relocation->r_symndx);
@ -691,7 +788,7 @@ LdrCOFFGetSymbolValue(module *Module, unsigned int Idx)
*/
static unsigned int
LdrCOFFGetKernelSymbolAddr(char *Name)
LdrGetKernelSymbolAddr(char *Name)
{
int i = 0;

2
reactos/ntoskrnl/mm/mm.c
View file

@ -48,7 +48,7 @@ MM_SYSTEM_SIZE MmQuerySystemSize()
UNIMPLEMENTED;
}
void MmInitalize(boot_param* bp)
void MmInitialize(boot_param* bp)
/*
* FUNCTION: Initalize memory managment
*/

1353
reactos/ntoskrnl/mm/npool.c
View file

File diff suppressed because it is too large Load diff