which included commits to RCS files with non-trunk default branches.
svn path=/trunk/; revision=40
FILE_DEVICE_WAVE_IN,
FILE_DEVICE_WAVE_OUT,
FILE_DEVICE_8042_PORT,
+ FILE_DEVICE_FILE_SYSTEM,
/*
* Values beyond this are reserved for ISVs
FILE_DOES_NOT_EXIST,
};
+#define IRP_MN_USER_FS_REQUEST 0x00
+#define IRP_MN_MOUNT_VOLUME 0x01
+#define IRP_MN_VERIFY_VOLUME 0x02
+#define IRP_MN_LOAD_FILE_SYSTEM 0x03
+
#endif
OUT PVOID FileInformation,
OUT PULONG ReturnedLength
);
+VOID IoRegisterFileSystem(PDEVICE_OBJECT DeviceObject);
+PDEVICE_OBJECT IoGetAttachedDevice(PDEVICE_OBJECT DeviceObject);
KDPC dpc;
} IO_TIMER, *PIO_TIMER;
+typedef struct _IO_SECURITY_CONTEXT
+{
+ PSECURITY_QUALITY_OF_SERVICE SecurityQos;
+ PACCESS_STATE AccessState;
+ ACCESS_MASK DesiredAccess;
+ ULONG FullCreateOptions;
+} IO_SECURITY_CONTEXT, *PIO_SECURITY_CONTEXT;
+
/*
* PURPOSE: IRP stack location
*/
typedef struct _IO_STACK_LOCATION
{
- /*
- * Type of request
- */
UCHAR MajorFunction;
-
- /*
- * Further information about request type
- */
- UCHAR MinorFunction;
-
- /*
- *
- */
- UCHAR Flags;
-
- /*
- * FUNCTION: Various flags including for the io completion routine
- */
+ UCHAR MinorFunction;
+ UCHAR Flags;
UCHAR Control;
- /*
- * Parameters for request
- */
union
{
struct
{
- /*
- * Number of bytes to be transferrred
- */
+ PIO_SECURITY_CONTEXT SecurityContext;
+ ULONG Options;
+ USHORT FileAttributes;
+ USHORT ShareAccess;
+ ULONG EaLength;
+ } Create;
+ struct
+ {
ULONG Length;
-
- /*
- * Possibly used to sort incoming request (to be documented)
- */
ULONG Key;
-
- /*
- * Optional starting offset for read
- */
LARGE_INTEGER ByteOffset;
} Read;
struct
ULONG IoControlCode;
PVOID Type3InputBuffer;
} DeviceIoControl;
-
+ struct
+ {
+ struct _VPB* Vpb;
+ struct _DEVICE_OBJECT* DeviceObject;
+ } Mount;
} Parameters;
- /*
- * PURPOSE: Completion routine
- * NOTE: If this is the nth stack location (where the 1st is passed to the
- * highest level driver) then this is the completion routine set by
- * the (n-1)th driver
- */
PIO_COMPLETION_ROUTINE CompletionRoutine;
PVOID CompletionContext;
- /*
- * Driver created device object representing the target device
- */
struct _DEVICE_OBJECT* DeviceObject;
- /*
- * File object (if any) associated with DeviceObject
- */
struct _FILE_OBJECT* FileObject;
} IO_STACK_LOCATION, *PIO_STACK_LOCATION;
KAPC Apc;
ULONG CompletionKey;
} Tail;
- ULONG CurrentLocation;
+ CHAR StackCount;
+ CHAR CurrentLocation;
IO_STACK_LOCATION Stack[1];
} IRP, *PIRP;
+#define VPB_MOUNTED 0x00000001
+#define VPB_LOCKED 0x00000002
+#define VPB_PERSISTENT 0x00000004
+#define VPB_REMOVE_PENDING 0x00000008
typedef struct _VPB
{
typedef struct _DRIVER_OBJECT
{
- /*
- * PURPOSE: Magic values for debugging
- */
CSHORT Type;
CSHORT Size;
PDEVICE_OBJECT DeviceObject;
#include <ddk/ketypes.h>
#include <ddk/obtypes.h>
#include <ddk/mmtypes.h>
+#include <ddk/setypes.h>
#include <ddk/iotypes.h>
#include <ddk/extypes.h>
#include <ddk/pstypes.h>
-#include <ddk/setypes.h>
#include <ddk/ioctrl.h>
#include <internal/hal/ddk.h>
KPROCESSOR_MODE AccessMode);
NTSTATUS ObOpenObjectByName(POBJECT_ATTRIBUTES ObjectAttributes,
- PVOID* Object);
+ PVOID* Object, PWSTR* UnparsedSection);
struct _OBJECT;
+
typedef struct _OBJECT_TYPE
{
/*
} OBJECT_HEADER, *POBJECT_HEADER;
-/*
- * PURPOSE: Defines an object
- */
-typedef struct _OBJECT_ATTRIBUTES
-{
- ULONG Length;
- HANDLE RootDirectory;
- PUNICODE_STRING ObjectName;
- ULONG Attributes;
- PVOID SecurityDescriptor;
- PVOID SecurityQualityOfService;
+typedef struct _OBJECT_ATTRIBUTES {
+ ULONG Length;
+ HANDLE RootDirectory;
+ PUNICODE_STRING ObjectName;
+ ULONG Attributes;
+ SECURITY_DESCRIPTOR *SecurityDescriptor;
+ SECURITY_QUALITY_OF_SERVICE *SecurityQualityOfService;
} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
* 29/08/98: ACCESS_TOKEN definition from Boudewijn Dekker
*/
+#ifndef __INCLUDE_DDK_SETYPES_H
+#define __INCLUDE_DDK_SETYPES_H
+
typedef ULONG ACCESS_MODE, *PACCESS_MODE;
+typedef SECURITY_QUALITY_OF_SERVICE* PSECURITY_QUALITY_OF_SERVICE;
typedef struct _SECURITY_SUBJECT_CONTEXT
{
PVOID AuditData;
UCHAR VariablePart[0];
} ACCESS_TOKEN, *PACCESS_TOKEN;
+
+#endif
// STATUS_WRONG_VOLUME,
STATUS_FS_DRIVER_REQUIRED,
STATUS_NOT_SUPPORTED = 9999,
- STATUS_DISK_OPERATION_FAILED
+ STATUS_DISK_OPERATION_FAILED,
+
+ /*
+ * Reactos codes
+ */
+ STATUS_FS_QUERY_REQUIRED,
};
#endif /* __INCLUDE_DDK_STATUS_H */
#include <windows.h>
+typedef struct _OBJDIR_INFORMATION {
+ UNICODE_STRING ObjectName;
+ UNICODE_STRING ObjectTypeName; // Directory, Device ...
+ UCHAR Data[0];
+} OBJDIR_INFORMATION, *POBJDIR_INFORMATION;
+
+
/*
* FUNCTION: Closes an object handle
* ARGUMENTS:
NTSTATUS ZwOpenSection(PHANDLE KeyHandle, ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes);
+NTSTATUS ZwQueryDirectoryObject(IN HANDLE DirObjHandle,
+ OUT POBJDIR_INFORMATION DirObjInformation,
+ IN ULONG BufferLength,
+ IN BOOLEAN GetNextIndex,
+ IN BOOLEAN IgnoreInputIndex,
+ IN OUT PULONG ObjectIndex,
+ OUT PULONG DataWritten OPTIONAL);
+
/*
* FUNCTION: Returns information about an open file
* ARGUMENTS:
+NTSTATUS ZwReadFile(HANDLE FileHandle,
+ HANDLE EventHandle,
+ PIO_APC_ROUTINE ApcRoutine,
+ PVOID ApcContext,
+ PIO_STATUS_BLOCK IoStatusBlock,
+ PVOID Buffer,
+ ULONG Length,
+ PLARGE_INTEGER ByteOffset,
+ PULONG Key);
+
+
-#if KERNEL_SUPPORTS_OBJECT_ATTRIBUTES_CORRECTLY
-typedef struct _OBJECT_ATTRIBUTES {
- ULONG Length;
- HANDLE RootDirectory;
- PUNICODE_STRING ObjectName;
- ULONG Attributes;
- SECURITY_DESCRIPTOR *SecurityDescriptor;
- SECURITY_QUALITY_OF_SERVICE *SecurityQualityOfService;
-} OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES;
-#endif
-
-
-
-/*
-#if IOTYPES_DIDNT_DECLARE_THIS
-typedef struct _IO_STATUS_BLOCK {
- NTSTATUS Status;
- ULONG Information;
-} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
-#endif
-*/
+
#define NtCurrentProcess() ( (HANDLE) 0xFFFFFFFF )
#define NtCurrentThread() ( (HANDLE) 0xFFFFFFFE )
// directory information
-typedef struct _OBJDIR_INFORMATION {
- UNICODE_STRING ObjectName;
- UNICODE_STRING ObjectTypeName; // Directory, Device ...
- UCHAR Data[0];
-} OBJDIR_INFORMATION, *POBJDIR_INFORMATION;
-
typedef struct _FILE_DIRECTORY_INFORMATION {
ULONG NextEntryOffset;
#ifndef __INTERNAL_DEBUG
#define __INTERNAL_DEBUG
+
+#ifndef NDEBUG
+#define DPRINT1(x) DbgPrint(x)
+#else
+#define DPRINT1(x)
+#endif
+
#define UNIMPLEMENTED do {DbgPrint("%s at %s:%d is umimplemented, have a nice day\n",__FUNCTION__,__FILE__,__LINE__); for(;;); } while(0);
#ifndef NDEBUG
typedef struct
{
+ CSHORT Type;
+ CSHORT Size;
FILE_OBJECT* File;
} SECTION_OBJECT;
ULONG Length;
ULONG Attributes;
LIST_ENTRY Entry;
+ ULONG LockCount;
union
{
- SECTION_OBJECT* Section;
- } d;
+ struct
+ {
+ SECTION_OBJECT* Section;
+ ULONG ViewOffset;
+ } SectionData;
+ } Data;
} MEMORY_AREA;
*/
asmlinkage void free_page(unsigned int physical_base, unsigned int nr);
-/*
- * FUNCTION: Returns the physical address mapped by a given virtual address
- * ARGUMENTS:
- * vaddr = virtual address to query
- * RETURNS: The physical address if present in memory
- * Zero if paged out or invalid
- * NOTE: This doesn't do any synchronization
- */
-unsigned int get_page_physical_address(unsigned int vaddr);
-
void mark_page_not_writable(unsigned int vaddr);
void VirtualInit(boot_param* bp);
/*
*
*/
-{
+{
+ unsigned int nsyms;
unsigned int text_base;
unsigned int data_base;
unsigned int bss_base;
#ifndef __VERSION_H
#define __VERSION_H
-#define KERNEL_VERSION "0.0.10"
+#define KERNEL_VERSION "0.0.11"
#define KERNEL_MAJOR_VERSION 0
#define KERNEL_MINOR_VERSION 0
-#define KERNEL_PATCH_LEVEL 10
+#define KERNEL_PATCH_LEVEL 11
#endif
IoRaiseInformationalHardError
IoReadPartitionTable
IoRegisterDriverReinitialization
+IoRegisterFileSystem
IoRegisterShutdownNotification
IoReleaseCancelSpinLock
IoRemoveShareAccess
ZwUnmapViewOfSection
ZwWriteFile
sprintf
+wcschr
*/
printk("Exception: %d(%x)\n",type,error_code&0xffff);
printk("CS:EIP %x:%x\n",cs&0xffff,eip);
- for(;;);
+// for(;;);
printk("EAX: %.8x EBX: %.8x ECX: %.8x\n",eax,ebx,ecx);
printk("EDX: %.8x EBP: %.8x ESI: %.8x\n",edx,ebp,esi);
printk("EDI: %.8x EFLAGS: %.8x ",edi,eflags);
/* GLOBALS ******************************************************************/
+#define BOCHS_LOGGER_PORT (0x3ed)
+
/*
* PURPOSE: Current cursor position
*/
char* address;
int offset;
int i;
-
+
+ outb_p(BOCHS_LOGGER_PORT,c);
+
switch(c)
{
case '\n':
: "m" (eflags));
}
-void InitConsole(boot_param* bp)
+void HalInitConsole(boot_param* bp)
/*
* FUNCTION: Initalize the console
* ARGUMENTS:
#include <windows.h>
#include <ddk/ntddk.h>
#include <internal/ntoskrnl.h>
-#include <internal/psmgr.h>
+#include <internal/ps.h>
#include <internal/string.h>
#include <internal/hal.h>
#include <internal/hal/segment.h>
#include <windows.h>
#include <ddk/ntddk.h>
-#include <internal/objmgr.h>
-#include <internal/iomgr.h>
+#include <internal/ob.h>
+#include <internal/io.h>
#include <internal/string.h>
+#include <wstring.h>
#define NDEBUG
#include <internal/debug.h>
* FileAttributes = Attributes to create the file with
* ShareAccess = Type of shared access the caller would like to the file
* CreateDisposition = Specifies what to do, depending on whether the
- * file already existings
+ * file already exists
* CreateOptions = Options for creating a new file
* EaBuffer = Undocumented
* EaLength = Undocumented
PDEVICE_OBJECT DeviceObject;
PFILE_OBJECT FileObject;
PIO_STACK_LOCATION StackLoc;
+ PWSTR Remainder;
+
+ DPRINT("ZwOpenFile(FileHandle %x, ObjectAttributes %x, "
+ "ObjectAttributes->ObjectName->Buffer %w)\n",FileHandle,
+ ObjectAttributes,ObjectAttributes->ObjectName->Buffer);
assert_irql(PASSIVE_LEVEL);
*FileHandle=0;
+
+ FileObject = ObGenericCreateObject(FileHandle,0,NULL,OBJTYP_FILE);
+ memset(FileObject,0,sizeof(FILE_OBJECT));
+
+ Status = ObOpenObjectByName(ObjectAttributes,&Object,&Remainder);
- Status = ObOpenObjectByName(ObjectAttributes,&Object);
- DPRINT("Object %x Status %x\n",Object,Status);
- if (!NT_SUCCESS(Status))
- {
- return(Status);
+ if (Status != STATUS_SUCCESS && Status != STATUS_FS_QUERY_REQUIRED)
+ {
+ DPRINT("%s() = Failed to find object\n",__FUNCTION__);
+ ObDeleteHandle(*FileHandle);
+ *FileHandle=0;
+ ExFreePool(FileObject);
+ return(STATUS_UNSUCCESSFUL);
}
+
DeviceObject = (PDEVICE_OBJECT)Object;
-
- FileObject = ObGenericCreateObject(FileHandle,0,NULL,OBJTYP_FILE);
- DPRINT("FileObject %x DeviceObject %x\n",FileObject,DeviceObject);
- memset(FileObject,0,sizeof(FILE_OBJECT));
+ DeviceObject = IoGetAttachedDevice(DeviceObject);
+ DPRINT("DeviceObject %x\n",DeviceObject);
+
+ if (Status == STATUS_SUCCESS)
+ {
+ CHECKPOINT;
+ FileObject->Flags = FileObject->Flags | FO_DIRECT_DEVICE_OPEN;
+ FileObject->FileName.Buffer = ExAllocatePool(NonPagedPool,
+ ObjectAttributes->Length);
+ RtlCopyUnicodeString(&(FileObject->FileName),
+ ObjectAttributes->ObjectName);
+ }
+ else
+ {
+ CHECKPOINT;
+ if (DeviceObject->DeviceType != FILE_DEVICE_FILE_SYSTEM &&
+ DeviceObject->DeviceType != FILE_DEVICE_DISK)
+ {
+ ObDeleteHandle(*FileHandle);
+ *FileHandle=0;
+ ExFreePool(FileObject);
+ return(STATUS_UNSUCCESSFUL);
+ }
+ if (!(DeviceObject->Vpb->Flags & VPB_MOUNTED))
+ {
+ Status = IoTryToMountStorageDevice(DeviceObject);
+ if (Status!=STATUS_SUCCESS)
+ {
+ ObDeleteHandle(*FileHandle);
+ *FileHandle=0;
+ ExFreePool(FileObject);
+ return(Status);
+ }
+ DeviceObject = IoGetAttachedDevice(DeviceObject);
+ }
+ DPRINT("Remainder %w\n",Remainder);
+ FileObject->FileName.Buffer = ExAllocatePool(NonPagedPool,
+ wstrlen(Remainder));
+ RtlInitUnicodeString(&(FileObject->FileName),Remainder);
+ DPRINT("FileObject->FileName.Buffer %x %w\n",
+ FileObject->FileName.Buffer,FileObject->FileName.Buffer);
+ }
+ CHECKPOINT;
+
FileObject->DeviceObject=DeviceObject;
- FileObject->Flags = FileObject->Flags | FO_DIRECT_DEVICE_OPEN;
+ FileObject->Vpb=DeviceObject->Vpb;
KeInitializeEvent(&Event,NotificationEvent,FALSE);
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
if (Irp==NULL)
{
+ ObDeleteHandle(*FileHandle);
+ *FileHandle=0;
+ ExFreePool(FileObject);
return(STATUS_UNSUCCESSFUL);
}
StackLoc = IoGetNextIrpStackLocation(Irp);
- DPRINT("StackLoc %x\n",StackLoc);
StackLoc->MajorFunction = IRP_MJ_CREATE;
StackLoc->MinorFunction = 0;
StackLoc->Flags = 0;
StackLoc->Control = 0;
StackLoc->DeviceObject = DeviceObject;
StackLoc->FileObject=FileObject;
- DPRINT("DeviceObject %x\n",DeviceObject);
- DPRINT("DeviceObject->DriverObject %x\n",DeviceObject->DriverObject);
- IoCallDriver(DeviceObject,Irp);
+ Status = IoCallDriver(DeviceObject,Irp);
+ if (Status==STATUS_PENDING)
+ {
+ KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL);
+ Status = IoStatusBlock->Status;
+ }
+
+ if (Status!=STATUS_SUCCESS)
+ {
+ ObDeleteHandle(*FileHandle);
+ *FileHandle=0;
+ ExFreePool(FileObject);
+ }
- return(STATUS_SUCCESS);
+ return(Status);
}
#include <ddk/ntddk.h>
-#include <internal/iomgr.h>
-#include <internal/objmgr.h>
+#include <internal/io.h>
+#include <internal/ob.h>
#include <internal/string.h>
#define NDEBUG
UNIMPLEMENTED;
}
+PDEVICE_OBJECT IoGetAttachedDevice(PDEVICE_OBJECT DeviceObject)
+{
+ PDEVICE_OBJECT Current = DeviceObject;
+
+ DPRINT("IoGetAttachDevice(DeviceObject %x)\n",DeviceObject);
+
+ while (Current->AttachedDevice!=NULL)
+ {
+ Current = Current->AttachedDevice;
+ DPRINT("Current %x\n",Current);
+ }
+ return(Current);
+}
+
PDEVICE_OBJECT IoAttachDeviceToDeviceStack(PDEVICE_OBJECT SourceDevice,
PDEVICE_OBJECT TargetDevice)
{
- UNIMPLEMENTED;
+ PDEVICE_OBJECT AttachedDevice = IoGetAttachedDevice(TargetDevice);
+
+ DPRINT("IoAttachDeviceToDeviceStack(SourceDevice %x, TargetDevice %x)\n",
+ SourceDevice,TargetDevice);
+
+ AttachedDevice->AttachedDevice = SourceDevice;
+ SourceDevice->StackSize = AttachedDevice->StackSize + 1;
+ return(AttachedDevice);
}
VOID IoRegisterDriverReinitialization(PDRIVER_OBJECT DriverObject,
OBJECT_ATTRIBUTES dev_attr;
HANDLE devh;
- DPRINT("IoCreateDevice(DriverObject %x, DeviceName %w)\n",DriverObject,
- DeviceName->Buffer);
-
- InitializeObjectAttributes(&dev_attr,DeviceName,0,NULL,NULL);
- dev = ObGenericCreateObject(&devh,0,&dev_attr,OBJTYP_DEVICE);
+ if (DeviceName!=NULL)
+ {
+ DPRINT("IoCreateDevice(DriverObject %x, DeviceName %w)\n",DriverObject,
+ DeviceName->Buffer);
+ }
+ else
+ {
+ DPRINT("IoCreateDevice(DriverObject %x)\n",DriverObject);
+ }
+
+ if (DeviceName!=NULL)
+ {
+ InitializeObjectAttributes(&dev_attr,DeviceName,0,NULL,NULL);
+ dev = ObGenericCreateObject(&devh,0,&dev_attr,OBJTYP_DEVICE);
+ }
+ else
+ {
+ dev = ObGenericCreateObject(&devh,0,NULL,OBJTYP_DEVICE);
+ }
*DeviceObject=NULL;
return(STATUS_INSUFFICIENT_RESOURCES);
}
+ dev->AttachedDevice=NULL;
dev->DeviceType=DeviceType;
dev->StackSize=1;
dev->AlignmentRequirement=1;
KeInitializeDeviceQueue(&dev->DeviceQueue);
+ if (dev->DeviceType==FILE_DEVICE_DISK)
+ {
+ IoAttachVpb(dev);
+ }
+
*DeviceObject=dev;
DPRINT("dev->DriverObject %x\n",dev->DriverObject);
/* INCLUDES *****************************************************************/
#include <ddk/ntddk.h>
+#include <internal/io.h>
+#define NDEBUG
#include <internal/debug.h>
/* TYPES *******************************************************************/
KeInitializeSpinLock(&FileSystemListLock);
}
-NTSTATUS IoAskFileSystemToMountDevice(PDEVICE_OBJECT DeviceObject)
+NTSTATUS IoAskFileSystemToMountDevice(PDEVICE_OBJECT DeviceObject,
+ PDEVICE_OBJECT DeviceToMount)
{
- UNIMPLEMENTED;
+ PIRP Irp;
+ KEVENT Event;
+ IO_STATUS_BLOCK IoStatusBlock;
+ NTSTATUS Status;
+
+ DPRINT("IoAskFileSystemToMountDevice(DeviceObject %x, DeviceToMount %x)\n",
+ DeviceObject,DeviceToMount);
+
+ KeInitializeEvent(&Event,NotificationEvent,FALSE);
+ Irp = IoBuildFilesystemControlRequest(IRP_MN_MOUNT_VOLUME,
+ DeviceObject,
+ &Event,
+ &IoStatusBlock,
+ DeviceToMount);
+ Status = IoCallDriver(DeviceObject,Irp);
+ if (Status==STATUS_PENDING)
+ {
+ KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL);
+ Status = IoStatusBlock.Status;
+ }
+ return(Status);
}
NTSTATUS IoAskFileSystemToLoad(PDEVICE_OBJECT DeviceObject)
FILE_SYSTEM_OBJECT* current;
NTSTATUS Status;
+ DPRINT("IoTryToMountStorageDevice(DeviceObject %x)\n",DeviceObject);
+
KeAcquireSpinLock(&FileSystemListLock,&oldlvl);
current_entry = FileSystemListHead.Flink;
- while (current_entry!=NULL)
+ while (current_entry!=(&FileSystemListHead))
{
current = CONTAINING_RECORD(current_entry,FILE_SYSTEM_OBJECT,Entry);
- Status = IoAskFileSystemToMountDevice(DeviceObject);
+ Status = IoAskFileSystemToMountDevice(current->DeviceObject,
+ DeviceObject);
switch (Status)
{
case STATUS_FS_DRIVER_REQUIRED:
{
FILE_SYSTEM_OBJECT* fs;
+ DPRINT("IoRegisterFileSystem(DeviceObject %x)\n",DeviceObject);
+
fs=ExAllocatePool(NonPagedPool,sizeof(FILE_SYSTEM_OBJECT));
assert(fs!=NULL);
KIRQL oldlvl;
PLIST_ENTRY current_entry;
FILE_SYSTEM_OBJECT* current;
+
+ DPRINT("IoUnregisterFileSystem(DeviceObject %x)\n",DeviceObject);
KeAcquireSpinLock(&FileSystemListLock,&oldlvl);
current_entry = FileSystemListHead.Flink;
- while (current_entry!=NULL)
+ while (current_entry!=(&FileSystemListHead))
{
current = CONTAINING_RECORD(current_entry,FILE_SYSTEM_OBJECT,Entry);
if (current->DeviceObject == DeviceObject)
#include <windows.h>
#include <ddk/ntddk.h>
-#include <internal/objmgr.h>
+#include <internal/ob.h>
#define NDEBUG
#include <internal/debug.h>
/*
* Register iomgr types
*/
- CHECKPOINT;
RtlInitAnsiString(&astring,"Device");
- CHECKPOINT;
RtlAnsiStringToUnicodeString(&DeviceObjectType.TypeName,&astring,TRUE);
- CHECKPOINT;
ObRegisterType(OBJTYP_DEVICE,&DeviceObjectType);
- CHECKPOINT;
+
RtlInitAnsiString(&astring,"File");
RtlAnsiStringToUnicodeString(&FileObjectType.TypeName,&astring,TRUE);
ObRegisterType(OBJTYP_FILE,&FileObjectType);
- CHECKPOINT;
+
/*
* Create the device directory
*/
RtlInitAnsiString(&astring,"\\Device");
- CHECKPOINT;
RtlAnsiStringToUnicodeString(&string,&astring,TRUE);
- CHECKPOINT;
InitializeObjectAttributes(&attr,&string,0,NULL,NULL);
- CHECKPOINT;
ZwCreateDirectoryObject(&handle,0,&attr);
- CHECKPOINT;
+
+ RtlInitAnsiString(&astring,"\\??");
+ RtlAnsiStringToUnicodeString(&string,&astring,TRUE);
+ InitializeObjectAttributes(&attr,&string,0,NULL,NULL);
+ ZwCreateDirectoryObject(&handle,0,&attr);
+
IoInitCancelHandling();
IoInitSymbolicLinkImplementation();
+ IoInitFileSystemImplementation();
}
/* INCLUDES *****************************************************************/
#include <ddk/ntddk.h>
+#include <internal/ob.h>
+#define NDEBUG
#include <internal/debug.h>
/* GLOBALS ******************************************************************/
typedef struct
{
- PVOID Target;
-} SYMBOLIC_LINK_OBJECT;
+ CSHORT Type;
+ CSHORT Size;
+ UNICODE_STRING TargetName;
+ OBJECT_ATTRIBUTES Target;
+} SYMLNK_OBJECT, *PSYMLNK_OBJECT;
OBJECT_TYPE SymlinkObjectType = {{NULL,0,0},
0,
0,
ULONG_MAX,
ULONG_MAX,
- sizeof(SYMBOLIC_LINK_OBJECT),
+ sizeof(SYMLNK_OBJECT),
0,
NULL,
NULL,
/* FUNCTIONS *****************************************************************/
+NTSTATUS ZwOpenSymbolicLinkObject(OUT PHANDLE LinkHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes)
+{
+ NTSTATUS Status;
+ PVOID Object;
+ PWSTR Ignored;
+
+ Status = ObOpenObjectByName(ObjectAttributes,&Object,&Ignored);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+ *LinkHandle = ObAddHandle(Object);
+ return(STATUS_SUCCESS);
+}
+
+NTSTATUS ZwQuerySymbolicLinkObject(IN HANDLE LinkHandle,
+ IN OUT PUNICODE_STRING LinkTarget,
+ OUT PULONG ReturnedLength OPTIONAL)
+{
+ COMMON_BODY_HEADER* hdr = ObGetObjectByHandle(LinkHandle);
+ PSYMLNK_OBJECT SymlinkObject = (PSYMLNK_OBJECT)hdr;
+
+ if (hdr==NULL)
+ {
+ return(STATUS_INVALID_HANDLE);
+ }
+
+ RtlCopyUnicodeString(LinkTarget,SymlinkObject->Target.ObjectName);
+ if (ReturnedLength!=NULL)
+ {
+ *ReturnedLength=SymlinkObject->Target.Length;
+ }
+ return(STATUS_SUCCESS);
+}
+
+
+POBJECT IoOpenSymlink(POBJECT _Symlink)
+{
+ PVOID Result;
+ PSYMLNK_OBJECT Symlink = (PSYMLNK_OBJECT)_Symlink;
+ PWSTR Ignored;
+
+ DPRINT("IoOpenSymlink(_Symlink %x)\n",Symlink);
+
+ DPRINT("Target %w\n",Symlink->Target.ObjectName->Buffer);
+
+ ObOpenObjectByName(&(Symlink->Target),&Result,&Ignored);
+ return(Result);
+}
+
VOID IoInitSymbolicLinkImplementation(VOID)
{
+ ANSI_STRING astring;
+ RtlInitAnsiString(&astring,"Symbolic Link");
+ RtlAnsiStringToUnicodeString(&SymlinkObjectType.TypeName,&astring,TRUE);
+ ObRegisterType(OBJTYP_SYMLNK,&SymlinkObjectType);
}
NTSTATUS IoCreateUnprotectedSymbolicLink(PUNICODE_STRING SymbolicLinkName,
NTSTATUS IoCreateSymbolicLink(PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName)
{
- UNIMPLEMENTED;
+ OBJECT_ATTRIBUTES ObjectAttributes;
+ HANDLE SymbolicLinkHandle;
+ PSYMLNK_OBJECT SymbolicLink;
+ PUNICODE_STRING TargetName;
+
+ DPRINT("IoCreateSymbolicLink(SymbolicLinkName %w, DeviceName %w)\n",
+ SymbolicLinkName->Buffer,DeviceName->Buffer);
+
+ InitializeObjectAttributes(&ObjectAttributes,SymbolicLinkName,0,NULL,NULL);
+ SymbolicLink = ObGenericCreateObject(&SymbolicLinkHandle,0,
+ &ObjectAttributes,OBJTYP_SYMLNK);
+ if (SymbolicLink == NULL)
+ {
+ return(STATUS_UNSUCCESSFUL);
+ }
+ SymbolicLink->TargetName.Buffer = ExAllocatePool(NonPagedPool,
+ ((wstrlen(DeviceName->Buffer)+1)*2));
+ SymbolicLink->TargetName.MaximumLength = wstrlen(DeviceName->Buffer);
+ SymbolicLink->TargetName.Length = 0;
+ RtlCopyUnicodeString(&(SymbolicLink->TargetName),DeviceName);
+ DPRINT("DeviceName %w\n",SymbolicLink->TargetName.Buffer);
+ InitializeObjectAttributes(&(SymbolicLink->Target),
+ &(SymbolicLink->TargetName),0,NULL,NULL);
+ DPRINT("%s() = STATUS_SUCCESS\n",__FUNCTION__);
+ return(STATUS_SUCCESS);
}
NTSTATUS IoDeleteSymbolicLink(PUNICODE_STRING DeviceName)
void IoRaiseInformationalHardError(void);
void IoReadPartitionTable(void);
void IoRegisterDriverReinitialization(void);
+void IoRegisterFileSystem(void);
void IoRegisterShutdownNotification(void);
void IoReleaseCancelSpinLock(void);
void IoRemoveShareAccess(void);
void ZwUnmapViewOfSection(void);
void ZwWriteFile(void);
void sprintf(void);
+void wcschr(void);
#ifdef __cplusplus
}
#endif
{"_IoRaiseInformationalHardError",(unsigned int)IoRaiseInformationalHardError},
{"_IoReadPartitionTable",(unsigned int)IoReadPartitionTable},
{"_IoRegisterDriverReinitialization",(unsigned int)IoRegisterDriverReinitialization},
+{"_IoRegisterFileSystem",(unsigned int)IoRegisterFileSystem},
{"_IoRegisterShutdownNotification",(unsigned int)IoRegisterShutdownNotification},
{"_IoReleaseCancelSpinLock",(unsigned int)IoReleaseCancelSpinLock},
{"_IoRemoveShareAccess",(unsigned int)IoRemoveShareAccess},
{"_ZwUnmapViewOfSection",(unsigned int)ZwUnmapViewOfSection},
{"_ZwWriteFile",(unsigned int)ZwWriteFile},
{"_sprintf",(unsigned int)sprintf},
+{"_wcschr",(unsigned int)wcschr},
{NULL,NULL},
};
* range described by the MDL
*/
{
- PVOID base;
+ PVOID base = NULL;
unsigned int i;
ULONG* mdl_pages=NULL;
MEMORY_AREA* Result;
Mdl->ByteCount,
0,
&Result);
+ CHECKPOINT;
mdl_pages = (ULONG *)(Mdl + 1);
for (i=0; i<(PAGE_ROUND_UP(Mdl->ByteCount)/PAGESIZE); i++)
{
{
return(NULL);
}
- CHECKPOINT;
+ DPRINT("Result %x\n",Result);
Attributes = PA_WRITE | PA_READ | PA_EXECUTE | PA_SYSTEM;
for (i=0;i<=(Length/PAGESIZE);i++)
{
* Setup the system area descriptor list
*/
BaseAddress = KERNEL_BASE;
- Length = ((ULONG)&etext) - KERNEL_BASE;
+ Length = PAGE_ROUND_UP(((ULONG)&etext)) - KERNEL_BASE;
ParamLength = ParamLength - Length;
MmCreateMemoryArea(KernelMode,MEMORY_AREA_SYSTEM,&BaseAddress,
Length,0,&kernel_text_desc);
- Length = ((ULONG)&end) - ((ULONG)&etext);
+ Length = PAGE_ROUND_UP(((ULONG)&end)) - PAGE_ROUND_UP(((ULONG)&etext));
ParamLength = ParamLength - Length;
DPRINT("Length %x\n",Length);
BaseAddress = PAGE_ROUND_UP(((ULONG)&etext));
{
KPROCESSOR_MODE FaultMode;
MEMORY_AREA* MemoryArea;
+ KIRQL oldlvl;
+ ULONG stat;
/*
* Get the address for the page fault
*/
unsigned int cr2;
__asm__("movl %%cr2,%0\n\t" : "=d" (cr2));
- DPRINT("Page fault at address %x with eip %x\n",cr2,eip);
- for(;;);
+ DbgPrint("Page fault at address %x with eip %x\n",cr2,eip);
cr2 = PAGE_ROUND_DOWN(cr2);
- assert_irql(DISPATCH_LEVEL);
+ if (KeGetCurrentIrql()!=PASSIVE_LEVEL)
+ {
+ DbgPrint("Recursive page fault detected\n");
+ KeBugCheck(0);
+ for(;;);
+ }
+
+ KeRaiseIrql(DISPATCH_LEVEL,&oldlvl);
/*
* Find the memory area for the faulting address
switch (MemoryArea->Type)
{
case MEMORY_AREA_SYSTEM:
- return(0);
+ stat = 0;
+ break;
case MEMORY_AREA_SECTION_VIEW:
- return(MmSectionHandleFault(MemoryArea,cr2));
+ stat = MmSectionHandleFault(MemoryArea,cr2);
+
+ default:
+ stat = 0;
+ break;
+ }
+ if (stat)
+ {
+ KeLowerIrql(oldlvl);
}
- return(0);
+ return(stat);
}
#include <windows.h>
#include <ddk/ntddk.h>
-#include <internal/objmgr.h>
+#include <internal/ob.h>
#include <internal/string.h>
#define NDEBUG
typedef struct
{
PVOID obj;
-} HANDLE_REP;
+} HANDLE_REP, *PHANDLE_REP;
#define HANDLE_BLOCK_ENTRIES ((PAGESIZE-sizeof(LIST_ENTRY))/sizeof(HANDLE_REP))
* parent = Parent process (or NULL if this is the first process)
*/
{
+ DPRINT("ObjInitializeHandleTable(parent %x)\n",parent);
+
InitializeListHead(&handle_list_head);
KeInitializeSpinLock(&handle_list_lock);
}
-PVOID ObGetObjectByHandle(HANDLE h)
-/*
- * FUNCTION: Translate a handle to the corresponding object
- * ARGUMENTS:
- * h = Handle to translate
- * RETURNS: The object
- */
+static PHANDLE_REP ObTranslateHandle(HANDLE* h)
{
- LIST_ENTRY* current = handle_list_head.Flink;
+ PLIST_ENTRY current = handle_list_head.Flink;
unsigned int handle = ((unsigned int)h) - 1;
unsigned int count=handle/HANDLE_BLOCK_ENTRIES;
HANDLE_BLOCK* blk = NULL;
for (i=0;i<count;i++)
{
current = current->Flink;
- if (current==NULL)
+ if (current==(&handle_list_head))
{
return(NULL);
}
}
blk = (HANDLE_BLOCK *)current;
- return(blk->handles[handle%HANDLE_BLOCK_ENTRIES].obj);
+ return(&(blk->handles[handle%HANDLE_BLOCK_ENTRIES]));
+}
+
+PVOID ObGetObjectByHandle(HANDLE h)
+/*
+ * FUNCTION: Translate a handle to the corresponding object
+ * ARGUMENTS:
+ * h = Handle to translate
+ * RETURNS: The object
+ */
+{
+ DPRINT("ObGetObjectByHandle(h %x)\n",h);
+
+ if (h==NULL)
+ {
+ return(NULL);
+ }
+
+ return(ObTranslateHandle(h)->obj);
+}
+
+VOID ObDeleteHandle(HANDLE Handle)
+{
+ PHANDLE_REP Rep = ObTranslateHandle(Handle);
+ Rep->obj=NULL;
}
HANDLE ObAddHandle(PVOID obj)
unsigned int i;
HANDLE_BLOCK* new_blk = NULL;
- DPRINT("ObAddHandle(obj %)\n",obj);
+ DPRINT("ObAddHandle(obj %x)\n",obj);
/*
* Scan through the currently allocated handle blocks looking for a free
* slot
*/
- while (current!=NULL)
+ while (current!=(&handle_list_head))
{
HANDLE_BLOCK* blk = (HANDLE_BLOCK *)current;
#include <windows.h>
#include <wstring.h>
#include <ddk/ntddk.h>
-#include <internal/objmgr.h>
+#include <internal/ob.h>
+#include <internal/io.h>
#include <internal/string.h>
#define NDEBUG
{
PVOID Object;
NTSTATUS Status;
+ PWSTR Ignored;
- Status = ObOpenObjectByName(ObjectAttributes,&Object);
+ *DirectoryHandle = 0;
+
+ Status = ObOpenObjectByName(ObjectAttributes,&Object,&Ignored);
if (!NT_SUCCESS(Status))
{
return(Status);
}
if (BODY_TO_HEADER(Object)->Type!=OBJTYP_DIRECTORY)
- {
+ {
return(STATUS_UNSUCCESSFUL);
}
*DirectoryHandle = ObAddHandle(Object);
+ CHECKPOINT;
return(STATUS_SUCCESS);
}
* RETURNS: Status
*/
{
- POBJECT_HEADER hdr = ObGetObjectByHandle(DirObjHandle);
- PDIRECTORY_OBJECT dir = (PDIRECTORY_OBJECT)(HEADER_TO_BODY(hdr));
+ COMMON_BODY_HEADER* hdr = ObGetObjectByHandle(DirObjHandle);
+ PDIRECTORY_OBJECT dir = (PDIRECTORY_OBJECT)hdr;
ULONG EntriesToRead;
PLIST_ENTRY current_entry;
POBJECT_HEADER current;
ULONG i=0;
ULONG EntriesToSkip;
+ DPRINT("ZwQueryDirectoryObject(DirObjHandle %x)\n",DirObjHandle);
+ DPRINT("dir %x namespc_root %x\n",dir,HEADER_TO_BODY(&(namespc_root.hdr)));
+
assert_irql(PASSIVE_LEVEL);
EntriesToRead = BufferLength / sizeof(OBJDIR_INFORMATION);
*DataWritten = 0;
+ DPRINT("EntriesToRead %d\n",EntriesToRead);
+
current_entry = dir->head.Flink;
/*
*/
if (!IgnoreInputIndex)
{
+ CHECKPOINT;
+
EntriesToSkip = *ObjectIndex;
while ( i<EntriesToSkip && current_entry!=NULL)
{
}
}
+ DPRINT("DirObjInformation %x\n",DirObjInformation);
+
/*
* Read the maximum entries possible into the buffer
*/
- while ( i<EntriesToRead && current_entry!=NULL)
+ while ( i<EntriesToRead && current_entry!=(&(dir->head)))
{
current = CONTAINING_RECORD(current_entry,OBJECT_HEADER,entry);
+ DPRINT("Scanning %w\n",current->name.Buffer);
+ DirObjInformation[i].ObjectName.Buffer =
+ ExAllocatePool(NonPagedPool,current->name.Length);
+ DirObjInformation[i].ObjectName.Length = current->name.Length;
+ DirObjInformation[i].ObjectName.MaximumLength = current->name.Length;
+ DPRINT("DirObjInformation[i].ObjectName.Buffer %x\n",
+ DirObjInformation[i].ObjectName.Buffer);
RtlCopyUnicodeString(&DirObjInformation[i].ObjectName,
&(current->name));
i++;
current_entry = current_entry->Flink;
(*DataWritten) = (*DataWritten) + sizeof(OBJDIR_INFORMATION);
+ CHECKPOINT;
}
+ CHECKPOINT;
/*
* Optionally, count the number of entries in the directory
*/
- if (!GetNextIndex)
+ if (GetNextIndex)
{
*ObjectIndex=i;
}
else
{
- while ( current_entry!=NULL )
+ while ( current_entry!=(&(dir->head)) )
{
current_entry=current_entry->Flink;
i++;
}
NTSTATUS ObOpenObjectByName(POBJECT_ATTRIBUTES ObjectAttributes,
- PVOID* Object)
+ PVOID* Object, PWSTR* UnparsedSection)
{
+ NTSTATUS Status;
DPRINT("ObOpenObjectByName(ObjectAttributes %x, Object %x)\n",
ObjectAttributes,Object);
DPRINT("ObjectAttributes = {ObjectName %x ObjectName->Buffer %w}\n",
ObjectAttributes->ObjectName,ObjectAttributes->ObjectName->Buffer);
- *Object = ObLookupObject(ObjectAttributes->RootDirectory,
- ObjectAttributes->ObjectName->Buffer);
+ *Object = NULL;
+ Status = ObLookupObject(ObjectAttributes->RootDirectory,
+ ObjectAttributes->ObjectName->Buffer,
+ Object,
+ UnparsedSection);
DPRINT("*Object %x\n",*Object);
- if ((*Object)==NULL)
- {
- return(STATUS_NO_SUCH_FILE);
- }
- return(STATUS_SUCCESS);
+ return(Status);
}
void ObInit(void)
* NULL otherwise
*/
{
- LIST_ENTRY* current = ((PDIRECTORY_OBJECT)dir)->head.Flink;
+ LIST_ENTRY* current = dir->head.Flink;
POBJECT_HEADER current_obj;
+
DPRINT("ObDirLookup(dir %x, name %w)\n",dir,name);
+
if (name[0]==0)
{
- return(BODY_TO_HEADER(dir));
+ return(dir);
}
if (name[0]=='.'&&name[1]==0)
{
- return(BODY_TO_HEADER(dir));
+ return(dir);
}
if (name[0]=='.'&&name[1]=='.'&&name[2]==0)
{
- return(BODY_TO_HEADER(BODY_TO_HEADER(dir)->Parent));
+ return(BODY_TO_HEADER(dir)->Parent);
}
- while (current!=(&((PDIRECTORY_OBJECT)dir)->head))
+ while (current!=(&(dir->head)))
{
current_obj = CONTAINING_RECORD(current,OBJECT_HEADER,entry);
+ DPRINT("Scanning %w\n",current_obj->name.Buffer);
if ( wcscmp(current_obj->name.Buffer, name)==0)
{
- return(current_obj);
+ return(HEADER_TO_BODY(current_obj));
}
current = current->Flink;
}
+ DPRINT("%s() = NULL\n",__FUNCTION__);
return(NULL);
}
{
DPRINT("ObjCreateEntry(%x,%x,%x,%w)\n",parent,Object,Object->name.Buffer,
Object->name.Buffer);
- DPRINT("root type %d\n",namespc_root.hdr.Type);
- DPRINT("%x\n",&(namespc_root.hdr.Type));
- DPRINT("type %x\n",&(parent->Type));
- DPRINT("type %x\n",&(BODY_TO_HEADER(parent)->Type));
- DPRINT("type %d\n",parent->Type);
assert(parent->Type == OBJTYP_DIRECTORY);
/*
InsertTailList(&parent->head,&Object->entry);
}
-PVOID ObLookupObject(HANDLE rooth, PWSTR string)
+NTSTATUS ObLookupObject(HANDLE rootdir, PWSTR string, PVOID* Object,
+ PWSTR* UnparsedSection)
/*
* FUNCTION: Lookup an object within the system namespc
* ARGUMENTS:
PWSTR current;
PWSTR next;
PDIRECTORY_OBJECT current_dir = NULL;
- POBJECT_HEADER current_hdr;
+ NTSTATUS Status;
- DPRINT("root %x string %w\n",rooth,string);
+ DPRINT("ObLookupObject(rootdir %x, string %x, string %w, Object %x, "
+ "UnparsedSection %x)\n",rootdir,string,string,Object,
+ UnparsedSection);
+
- if (rooth==NULL)
+ *UnparsedSection = NULL;
+ *Object = NULL;
+
+ if (rootdir==NULL)
{
current_dir = HEADER_TO_BODY(&(namespc_root.hdr));
}
else
{
- ObReferenceObjectByHandle(rooth,DIRECTORY_TRAVERSE,NULL,
+ ObReferenceObjectByHandle(rootdir,DIRECTORY_TRAVERSE,NULL,
UserMode,(PVOID*)¤t_dir,NULL);
}
*/
if (string[0]==0)
{
- DPRINT("current_dir %x\n",current_dir);
- DPRINT("type %d\n",current_dir->Type);
- return(current_dir);
+ *Object=current_dir;
+ return(STATUS_SUCCESS);
}
- DPRINT("string = %w\n",string);
-
if (string[0]!='\\')
{
DbgPrint("(%s:%d) Non absolute pathname passed to %s\n",__FILE__,
__LINE__,__FUNCTION__);
- return(NULL);
+ return(STATUS_UNSUCCESSFUL);
}
- current = string+1;
- DPRINT("current %w\n",current);
- next = wcschr(string+1,'\\');
- if (next!=NULL)
- {
- *next=0;
- }
- DPRINT("next %x\n",next);
+ next = &string[0];
+ current = next+1;
- while (next!=NULL)
- {
- DPRINT("Scanning %w next %w current %x\n",current,next+1,
- current_dir);
-
- /*
- * Check the current object is a directory
- */
- if (current_dir->Type!=OBJTYP_DIRECTORY)
+ while (next!=NULL && current_dir->Type==OBJTYP_DIRECTORY)
+ {
+ *next = '\\';
+ current = next+1;
+ next = wcschr(next+1,'\\');
+ if (next!=NULL)
{
- DbgPrint("(%s:%d) Bad path component\n",__FILE__,
- __LINE__);
- ExFreePool(string);
- return(NULL);
+ *next=0;
}
+
+ DPRINT("current %w current[5] %x next %x ",current,current[5],next);
+ if (next!=NULL)
+ {
+ DPRINT("(next+1) %w",next+1);
+ }
+ DPRINT("\n",0);
- /*
- * Lookup the next component of the path in the directory
- */
- current_hdr=(PDIRECTORY_OBJECT)ObDirLookup(current_dir,current);
- if (current_hdr==NULL)
+ current_dir=(PDIRECTORY_OBJECT)ObDirLookup(current_dir,current);
+ if (current_dir==NULL)
{
DbgPrint("(%s:%d) Path component not found\n",__FILE__,
__LINE__);
ExFreePool(string);
- return(NULL);
+ return(STATUS_UNSUCCESSFUL);
}
- current_dir = HEADER_TO_BODY(current_hdr);
-
- current = next+1;
- next = wcschr(next+1,'\\');
- if (next!=NULL)
+
+ DPRINT("current_dir %x\n",current_dir);
+ DPRINT("current_dir->Type %d OBJTYP_SYMLNK %d OBJTYP_DIRECTORY %d\n",
+ current_dir->Type,OBJTYP_SYMLNK,OBJTYP_DIRECTORY);
+ DPRINT("&(current_dir->Type) %x\n",&(current_dir->Type));
+ if (current_dir->Type==OBJTYP_SYMLNK)
{
- *next=0;
+ current_dir = IoOpenSymlink(current_dir);
}
+
}
+ DPRINT("next %x\n",next);
+ DPRINT("current %x current %w\n",current,current);
+ if (next==NULL)
+ {
+ if (current_dir==NULL)
+ {
+ Status = STATUS_UNSUCCESSFUL;
+ }
+ else
+ {
+ Status = STATUS_SUCCESS;
+ }
+ }
+ else
+ {
+ CHECKPOINT;
+ *next = '\\';
+ *UnparsedSection = next;
+ switch(current_dir->Type)
+ {
+ case OBJTYP_DEVICE:
+ CHECKPOINT;
+ Status = STATUS_FS_QUERY_REQUIRED;
+ break;
+
+ default:
+ current_dir = NULL;
+ Status = STATUS_UNSUCCESSFUL;
+ break;
+ }
+ }
+ CHECKPOINT;
+ *Object = current_dir;
- DPRINT("current_dir %x current %x\n",current_dir,current);
- DPRINT("current %w\n",current);
- current_hdr = ObDirLookup(current_dir,current);
- if (current_hdr==NULL)
- {
- return(NULL);
- }
- DPRINT("Returning %x %x\n",current_hdr,HEADER_TO_BODY(current_hdr));
- return(HEADER_TO_BODY(current_hdr));
+ return(Status);
}
/* INCLUDES *****************************************************************/
#include <ddk/ntddk.h>
-#include <internal/objmgr.h>
+#include <internal/ob.h>
#include <wstring.h>
#define NDEBUG
PWSTR path;
PWSTR name;
PDIRECTORY_OBJECT parent;
+ PWSTR Ignored;
DPRINT("ObGenericCreateObject(Handle %x, DesiredAccess %x,"
- "ObjectAttributes %x, Type %x)\n",Handle,DesiredAccess,ObjectAttributes,
+ "ObjectAttributes %x, Type %d)\n",Handle,DesiredAccess,ObjectAttributes,
Type);
/*
name=name+1;
}
- hdr->Parent = ObLookupObject(ObjectAttributes->RootDirectory,path);
-
+ ObLookupObject(ObjectAttributes->RootDirectory,path,
+ &hdr->Parent,&Ignored);
+
/*
* Initialize the object header
*/
RtlInitUnicodeString(&obj->name,name);
DPRINT("name %w\n",obj->name.Buffer);
}
+ DPRINT("obj->Type %d\n",obj->Type);
+ DPRINT("obj %x\n",obj);
+ DPRINT("&(obj->Type) %x\n",&(obj->Type));
}
#include <ddk/ntddk.h>
+#define NDEBUG
#include <internal/debug.h>
/* GLOBALS ******************************************************************/
/* FUNCTIONS *****************************************************************/
+VOID PsInitProcessManagment(VOID)
+{
+ InitializeListHead(&(SystemProcess.Pcb.MemoryAreaList));
+}
+
PKPROCESS KeGetCurrentProcess(VOID)
{
- return(NULL);
-// return(&(PsGetCurrentProcess()->Pcb));
+ return(&(PsGetCurrentProcess()->Pcb));
}
struct _EPROCESS* PsGetCurrentProcess(VOID)
* FUNCTION: Returns a pointer to the current process
*/
{
+ DPRINT("PsGetCurrentProcess() = %x\n",PsGetCurrentThread()->ThreadsProcess);
return(PsGetCurrentThread()->ThreadsProcess);
}
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
- * FILE: kernel/psmgr/psmgr.c
+ * FILE: ntoskrnl/ps/psmgr.c
* PURPOSE: Process managment
* PROGRAMMER: David Welch (welch@mcmail.com)
*/
#include <windows.h>
#include <ddk/ntddk.h>
-#include <internal/psmgr.h>
+#include <internal/ps.h>
/* FUNCTIONS ***************************************************************/
VOID PsInit(VOID)
{
ObjInitializeHandleTable(NULL);
+ PsInitProcessManagment();
PsInitThreadManagment();
PsInitIdleThread();
}
#include <windows.h>
#include <ddk/ntddk.h>
#include <internal/ke.h>
-#include <internal/objmgr.h>
+#include <internal/ob.h>
#include <internal/string.h>
#include <internal/hal.h>
-#include <internal/psmgr.h>
+#include <internal/ps.h>
#define NDEBUG
#include <internal/debug.h>
if (current->ThreadState == THREAD_STATE_RUNNABLE &&
current != (PKTHREAD)CurrentThread)
{
- DPRINT("Scheduling this one %x\n",current);
+ DPRINT("Scheduling this one %x\n",current);
CurrentThread = current;
CurrentThread->Tcb.ThreadState = THREAD_STATE_RUNNING;
KeReleaseSpinLock(&ThreadListLock,irql);
#define Aa_Difference 'A'-'a';
+PUNICODE_STRING RtlDuplicateUnicodeString(PUNICODE_STRING Dest,
+ PUNICODE_STRING Src)
+{
+ if (Dest==NULL)
+ {
+ Dest=ExAllocatePool(NonPagedPool,sizeof(UNICODE_STRING));
+ }
+}
+
VOID RtlUpperString(PSTRING DestinationString, PSTRING SourceString)
{
UNIMPLEMENTED;
unsigned long i;
if(AllocateDestinationString==TRUE) {
- DestinationString->Buffer=ExAllocatePool(NonPagedPool, SourceString->Length*2+1);
+ DestinationString->Buffer=ExAllocatePool(NonPagedPool, (SourceString->Length+1)*2);
DestinationString->MaximumLength=SourceString->Length;
};
case 'w':
sw = va_arg(args,short int *);
// DPRINT("L %x\n",sw);
- while ((*sw)!=0)
+ if (sw==NULL)
{
- *str++ = (char)(*sw++);
+// CHECKPOINT;
+ s = "<NULL>";
+ while ((*s)!=0)
+ {
+ *str++ = *s++;
+ }
+// CHECKPOINT;
+// DbgPrint("str %x\n",str);
}
+ else
+ {
+ while ((*sw)!=0)
+ {
+ *str++ = (char)(*sw++);
+ }
+ }
+// CHECKPOINT;
continue;
case 's':
#define NDEBUG
#include <internal/debug.h>
-#include <in.h>
-
int ShellChangeDir(char* args);
int ShellListDir(char* args);
+VOID TstReadLineInit(VOID);
+VOID TstReadLine(ULONG Length, PCHAR Buffer);
/* GLOBALS ******************************************************************/
-static HANDLE CurrentDirHandle;
-static UNICODE_STRING CurrentDirName;
-static HANDLE KeyboardHandle;
+static HANDLE CurrentDirHandle = NULL;
+static UNICODE_STRING CurrentDirName = {NULL,0,0};
typedef struct
{
int ShellListDir(char* args)
{
+ OBJDIR_INFORMATION DirObj[50];
+ ULONG Idx;
+ ULONG Length;
+ ULONG i;
+
+ ZwQueryDirectoryObject(CurrentDirHandle,
+ &(DirObj[0]),
+ sizeof(DirObj),
+ TRUE,
+ TRUE,
+ &Idx,
+ &Length);
+
+ for (i=0;i<(Length/sizeof(OBJDIR_INFORMATION));i++)
+ {
+ DbgPrint("Scanning %w\n",DirObj[i].ObjectName.Buffer);
+ }
}
VOID ShellDisplayPrompt()
{
- printk("%w# ",CurrentDirName->Buffer);
-}
-
-VOID ShellGetCommand(char* cmd)
-{
- do
- {
- ZwReadFile(hfile,NULL,NULL,NULL,NULL,cmd,1,0,0);
- printk("%c",*cmd);
- cmd++;
- } while((*cmd)!='\n');
- *cmd=0;
+ printk("%w# ",CurrentDirName.Buffer);
}
VOID ShellProcessCommand(char* cmd)
OBJECT_ATTRIBUTES attr;
char cmd[255];
+
RtlInitAnsiString(&astr,"\\");
RtlAnsiStringToUnicodeString(&CurrentDirName,&astr,TRUE);
RtlAnsiStringToUnicodeString(&ufilename,&afilename,TRUE);
InitializeObjectAttributes(&attr,&ufilename,0,NULL,NULL);
ZwOpenDirectoryObject(&CurrentDirHandle,0,&attr);
-
- RtlInitAnsiString(&afilename,"\\Device\\Keyboard");
- RtlAnsiStringToUnicodeString(&ufilename,&afilename,TRUE);
- InitializeObjectAttributes(&attr,&ufilename,0,NULL,NULL);
- ZwOpenFile(&KeyboardHandle,0,&attr,NULL,0,0);
+ TstReadLineInit();
+
for(;;)
{
ShellDisplayPrompt();
- ShellGetCommand(cmd);
+ TstReadLine(255,cmd);
ShellProcessCommand(cmd);
}
}
DEFINES = -DCHECKED_BUILD -DWIN32_LEAN_AND_MEAN -DDBG
CC = $(PREFIX)gcc
NATIVE_CC = gcc
-CFLAGS = -O2 -I../../include -I../include -fno-builtin $(DEFINES) -Wall -Wstrict-prototypes
+CFLAGS = -O2 -I../../../include -I../../include -I../include -fno-builtin $(DEFINES) -Wall -Wstrict-prototypes
CXXFLAGS = $(CFLAGS)
NASM = nasm
NFLAGS = -i../include/ -f$(NASM_FORMAT)