From ffc37c2cfdb4d18042d430ba674c77b6a2ecadc7 Mon Sep 17 00:00:00 2001 From: Rex Jolliff Date: Sun, 13 Sep 1998 15:55:36 +0000 Subject: [PATCH] Initial revision svn path=/trunk/; revision=37 --- reactos/drivers/fs/minix/blockdev.c | 84 +++++ reactos/drivers/fs/minix/makefile_rex | 2 + reactos/drivers/fs/minix/minix.c | 454 ++++++++++++++++++++++++++ reactos/drivers/fs/minix/minix_fs.h | 80 +++++ reactos/include/internal/io.h | 40 +++ reactos/include/internal/ob.h | 97 ++++++ reactos/include/internal/ps.h | 53 +++ reactos/ntoskrnl/io/buildirp.c | 232 +++++++++++++ reactos/ntoskrnl/io/vpb.c | 41 +++ reactos/ntoskrnl/tst/readline.c | 90 +++++ 10 files changed, 1173 insertions(+) create mode 100644 reactos/drivers/fs/minix/blockdev.c create mode 100644 reactos/drivers/fs/minix/makefile_rex create mode 100644 reactos/drivers/fs/minix/minix.c create mode 100644 reactos/drivers/fs/minix/minix_fs.h create mode 100644 reactos/include/internal/io.h create mode 100644 reactos/include/internal/ob.h create mode 100644 reactos/include/internal/ps.h create mode 100644 reactos/ntoskrnl/io/buildirp.c create mode 100644 reactos/ntoskrnl/io/vpb.c create mode 100644 reactos/ntoskrnl/tst/readline.c diff --git a/reactos/drivers/fs/minix/blockdev.c b/reactos/drivers/fs/minix/blockdev.c new file mode 100644 index 00000000000..2964d04cbe0 --- /dev/null +++ b/reactos/drivers/fs/minix/blockdev.c @@ -0,0 +1,84 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: services/fs/minix/minix.c + * PURPOSE: Minix FSD + * PROGRAMMER: David Welch (welch@mcmail.com) + * UPDATE HISTORY: + */ + +/* INCLUDES *****************************************************************/ + +#include +#include + +#define NDEBUG +#include + +#include "minix_fs.h" + +/* FUNCTIONS ***************************************************************/ + +BOOLEAN MinixReadSector(IN PDEVICE_OBJECT pDeviceObject, + IN ULONG DiskSector, + IN UCHAR* Buffer) +{ + LARGE_INTEGER sectorNumber; + PIRP irp; + IO_STATUS_BLOCK ioStatus; + KEVENT event; + NTSTATUS status; + ULONG sectorSize; + PULONG mbr; + + DPRINT("MinixReadSector(pDeviceObject %x, DiskSector %d, Buffer %x)\n", + pDeviceObject,DiskSector,Buffer); + + sectorNumber.LowPart = DiskSector * BLOCKSIZE; + + KeInitializeEvent(&event, NotificationEvent, FALSE); + + sectorSize = BLOCKSIZE; + + mbr = ExAllocatePool(NonPagedPool, sectorSize); + + if (!mbr) { + return FALSE; + } + + + irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ, + pDeviceObject, + mbr, + sectorSize, + §orNumber, + &event, + &ioStatus ); + + if (!irp) { + ExFreePool(mbr); + return FALSE; + } + + status = IoCallDriver(pDeviceObject, + irp); + + if (status == STATUS_PENDING) { + KeWaitForSingleObject(&event, + Suspended, + KernelMode, + FALSE, + NULL); + status = ioStatus.Status; + } + + if (!NT_SUCCESS(status)) { + ExFreePool(mbr); + return FALSE; + } + + RtlCopyMemory(Buffer,mbr,sectorSize); + + ExFreePool(mbr); + return TRUE; +} diff --git a/reactos/drivers/fs/minix/makefile_rex b/reactos/drivers/fs/minix/makefile_rex new file mode 100644 index 00000000000..47d8002d22d --- /dev/null +++ b/reactos/drivers/fs/minix/makefile_rex @@ -0,0 +1,2 @@ +all: minix.o blockdev.o + $(LD) -r minix.o blockdev.o -o minixfsd.o diff --git a/reactos/drivers/fs/minix/minix.c b/reactos/drivers/fs/minix/minix.c new file mode 100644 index 00000000000..6a8e3acbe43 --- /dev/null +++ b/reactos/drivers/fs/minix/minix.c @@ -0,0 +1,454 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: services/fs/minix/minix.c + * PURPOSE: Minix FSD + * PROGRAMMER: David Welch (welch@mcmail.com) + * UPDATE HISTORY: + */ + +/* INCLUDES *****************************************************************/ + +#include +#include +#include + +#define NDEBUG +#include + +#include "minix_fs.h" + +/* GLOBALS ******************************************************************/ + +static PDRIVER_OBJECT DriverObject; + +typedef struct +{ + PDEVICE_OBJECT AttachedDevice; + struct minix_inode root_inode; + char superblock_buf[BLOCKSIZE]; + struct minix_super_block* sb; +} MINIX_DEVICE_EXTENSION; + +/* FUNCTIONS ****************************************************************/ + + +static unsigned int MinixGetIndirectBlock(struct minix_inode* inode, + unsigned char* buffer, int blk) +{ + unsigned short int* buf = (unsigned short int *)buffer; + return(buf[blk]); +} + +static unsigned int MinixGetBlock(PDEVICE_OBJECT DeviceObject, + struct minix_inode* inode, + int blk) +{ + int block; + char* buffer; + + + DPRINT("MinixGetBlock(inode %x, blk %d)\n",inode,blk); + + if (blk < 7) + { + block = inode->i_zone[blk]; + return(block); + } + blk = blk - 7; + + buffer = ExAllocatePool(NonPagedPool,1024); + + if (blk < 512) + { + block = inode->i_zone[7]; + MinixReadSector(DeviceObject,block,buffer); + block = MinixGetIndirectBlock(inode,buffer,blk); + ExFreePool(buffer); + return(block); + } + blk = blk - 512; + block = inode->i_zone[8]; + MinixReadSector(DeviceObject,block,buffer); + block = MinixGetIndirectBlock(inode,buffer,(blk>>9)&511); + MinixReadSector(DeviceObject,block,buffer); + block = MinixGetIndirectBlock(inode,buffer,blk&511); + ExFreePool(buffer); + return(block); +} + +NTSTATUS MinixReadBlock(PDEVICE_OBJECT DeviceObject, + struct minix_inode* inode, + int blk, + PVOID buffer) +{ + unsigned int block; + + DPRINT("MinixReadBlock(inode %x, blk %d, buffer %x)\n",inode,blk,buffer); + block = MinixGetBlock(DeviceObject,inode,blk); + DPRINT("block %d\n",block); + return(MinixReadSector(DeviceObject,block,buffer)); +} + +VOID MinixMount(PDEVICE_OBJECT DeviceToMount) +{ + PDEVICE_OBJECT DeviceObject; + MINIX_DEVICE_EXTENSION* DeviceExt; + + IoCreateDevice(DriverObject, + sizeof(MINIX_DEVICE_EXTENSION), + NULL, + FILE_DEVICE_FILE_SYSTEM, + 0, + FALSE, + &DeviceObject); + DeviceObject->Flags = DeviceObject->Flags | DO_DIRECT_IO; + DeviceExt = DeviceObject->DeviceExtension; + + MinixReadSector(DeviceToMount,1,DeviceExt->superblock_buf); + DeviceExt->sb = (struct minix_super_block *)(DeviceExt->superblock_buf); + + DeviceExt->AttachedDevice = IoAttachDeviceToDeviceStack(DeviceObject, + DeviceToMount); +} + +NTSTATUS MinixFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp) +{ + PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp); + PVPB vpb = Stack->Parameters.Mount.Vpb; + PDEVICE_OBJECT DeviceToMount = Stack->Parameters.Mount.DeviceObject; + NTSTATUS Status; + char* superblock_buf; + struct minix_super_block* sb; + + DbgPrint("MinixFileSystemControl(DeviceObject %x, Irp %x)\n",DeviceObject, + Irp); + DPRINT("DeviceToMount %x\n",DeviceToMount); + + superblock_buf = ExAllocatePool(NonPagedPool,BLOCKSIZE); + + DPRINT("MinixReadSector %x\n",MinixReadSector); + MinixReadSector(DeviceToMount,1,superblock_buf); + sb = (struct minix_super_block *)superblock_buf; + DPRINT("Magic %x\n",sb->s_magic); + DPRINT("Imap blocks %x\n",sb->s_imap_blocks); + DPRINT("Zmap blocks %x\n",sb->s_zmap_blocks); + if (sb->s_magic==MINIX_SUPER_MAGIC2) + { + DPRINT("%s() = STATUS_SUCCESS\n",__FUNCTION__); + MinixMount(DeviceToMount); + Status = STATUS_SUCCESS; + } + else + { + DPRINT("%s() = STATUS_UNRECOGNIZED_VOLUME\n",__FUNCTION__); + Status = STATUS_UNRECOGNIZED_VOLUME; + } + + Irp->IoStatus.Status = Status; + Irp->IoStatus.Information = 0; + + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return(Status); +} + + +NTSTATUS MinixReadInode(PDEVICE_OBJECT DeviceObject, + MINIX_DEVICE_EXTENSION* DeviceExt, + ULONG ino, + struct minix_inode* result) +{ + int block; + char* buffer; + struct minix_inode* inodes; + + DPRINT("MinixReadInode(ino %x, result %x)\n",ino,result); + + buffer = ExAllocatePool(NonPagedPool,1024); + inodes = (struct minix_inode *)buffer; + + block = 2 + DeviceExt->sb->s_imap_blocks + DeviceExt->sb->s_zmap_blocks + + ((ino-1) / MINIX_INODES_PER_BLOCK); + DPRINT("Reading block %x offset %x\n",block,block*BLOCKSIZE); + DPRINT("Index %x\n",(ino-1)%MINIX_INODES_PER_BLOCK); + MinixReadSector(DeviceObject,block,buffer); + memcpy(result,&inodes[(ino-1)%MINIX_INODES_PER_BLOCK], + sizeof(struct minix_inode)); + DPRINT("result->i_uid %x\n",result->i_uid); + DPRINT("result->i_size %x\n",result->i_size); + return(STATUS_SUCCESS); +} + +BOOLEAN MinixCompareUnicodeStringToAnsi(PCH AnsiStr, PWCHAR UnicodeStr, + ULONG MaxLen) +{ + unsigned int i = 0; + + while (ii_size/MINIX_DIR_ENTRY_SIZE);i++) + { + offset = i*MINIX_DIR_ENTRY_SIZE; + if ((offset%BLOCKSIZE)==0) + { + MinixReadBlock(DeviceObject, + dir, + offset/BLOCKSIZE, + buffer); + } + entry = (struct minix_dir_entry *)&buffer[offset%BLOCKSIZE]; + DPRINT("Inode %x Name %.30s\n",entry->inode,entry->name); + if (MinixCompareUnicodeStringToAnsi(entry->name,Name,30)) + { + inode = entry->inode; + ExFreePool(buffer); + DPRINT("MinixDirLookup() = %d\n",inode); + return(inode); + } + } + ExFreePool(buffer); + DPRINT("MinixDirLookup() = %d\n",0); + return(0); +} + +NTSTATUS MinixOpen(PDEVICE_OBJECT DeviceObject, + MINIX_DEVICE_EXTENSION* DeviceExt, + PWSTR DeviceName, + struct minix_inode* result) +{ + PWSTR current; + PWSTR next; + PWSTR string = DeviceName; + struct minix_inode current_dir; + unsigned int current_ino; + + DbgPrint("MinixOpen(DeviceObject %x, DeviceName %w, result %x)\n", + DeviceObject,DeviceName,result); + DPRINT("DeviceName %x\n",DeviceName); + + next = &string[0]; + current = next+1; + + current_ino = MINIX_ROOT_INO; + + while (next!=NULL && current_ino!=0) + { + MinixReadInode(DeviceObject,DeviceExt,current_ino,¤t_dir); + + DPRINT("current %w next %x\n",current,next); + + *next = '\\'; + current = next+1; + next = wcschr(next+1,'\\'); + if (next!=NULL) + { + *next=0; + } + + current_ino = MinixDirLookup(DeviceObject,¤t_dir,current); + } + if (next==NULL && current_ino!=0) + { + MinixReadInode(DeviceObject,DeviceExt,current_ino,¤t_dir); + } + memcpy(result,¤t_dir,sizeof(struct minix_inode)); + DPRINT("MinxOpen() = STATUS_SUCCESS\n",0); + return(STATUS_SUCCESS); +} + +NTSTATUS MinixWrite(PDEVICE_OBJECT DeviceObject, PIRP Irp) +{ + DPRINT("MinixWrite(DeviceObject %x Irp %x)\n",DeviceObject,Irp); + + Irp->IoStatus.Status = STATUS_UNSUCCESSFUL; + Irp->IoStatus.Information = 0; + return(STATUS_UNSUCCESSFUL); +} + +NTSTATUS MinixRead(PDEVICE_OBJECT DeviceObject, PIRP Irp) +{ + ULONG Length; + PVOID Buffer; + ULONG Offset; + ULONG CurrentOffset; + PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp); + PFILE_OBJECT FileObject = Stack->FileObject; + MINIX_DEVICE_EXTENSION* DeviceExt = DeviceObject->DeviceExtension; + struct minix_inode* inode = (struct minix_inode *)FileObject->FsContext; + PVOID TempBuffer; + unsigned int i; + + DPRINT("MinixRead(DeviceObject %x, Irp %x)\n",DeviceObject,Irp); + + Length = Stack->Parameters.Read.Length; + Buffer = MmGetSystemAddressForMdl(Irp->MdlAddress); + Offset = Stack->Parameters.Read.ByteOffset.LowPart; + + TempBuffer = ExAllocatePool(NonPagedPool,BLOCKSIZE); + + DPRINT("Length %x Buffer %x Offset %x\n",Length,Buffer,Offset); + + CurrentOffset=Offset; + + if ((Offset%BLOCKSIZE)!=0) + { + CHECKPOINT; + + CurrentOffset = Offset - (Offset%BLOCKSIZE); + + MinixReadBlock(DeviceExt->AttachedDevice,inode, + CurrentOffset/BLOCKSIZE, + TempBuffer); + memcpy(Buffer,TempBuffer+(Offset%BLOCKSIZE), + min(BLOCKSIZE - (Offset%BLOCKSIZE),Length)); + DPRINT("(BLOCKSIZE - (Offset%BLOCKSIZE)) %d\n", + (BLOCKSIZE - (Offset%BLOCKSIZE))); + DPRINT("Length %d\n",Length); + CurrentOffset = CurrentOffset + BLOCKSIZE; + Buffer = Buffer + BLOCKSIZE - (Offset%BLOCKSIZE); + Length = Length - min(BLOCKSIZE - (Offset%BLOCKSIZE),Length); + DPRINT("CurrentOffset %d Buffer %x Length %d\n",CurrentOffset,Buffer, + Length); + } + for (i=0;i<(Length/BLOCKSIZE);i++) + { + CHECKPOINT; + + MinixReadBlock(DeviceExt->AttachedDevice,inode, + CurrentOffset/BLOCKSIZE,Buffer); + CurrentOffset = CurrentOffset + BLOCKSIZE; + Buffer = Buffer + BLOCKSIZE; + Length = Length - BLOCKSIZE; + } + if (Length > 0) + { + CHECKPOINT; + + MinixReadBlock(DeviceExt->AttachedDevice,inode, + CurrentOffset/BLOCKSIZE, + TempBuffer); + memcpy(Buffer,TempBuffer,Length); + } + + Irp->IoStatus.Status = STATUS_SUCCESS; + Irp->IoStatus.Information = Length; + return(STATUS_SUCCESS); +} + +NTSTATUS MinixClose(PDEVICE_OBJECT DeviceObject, PIRP Irp) +{ + PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp); + PFILE_OBJECT FileObject = Stack->FileObject; + + DPRINT("MinixClose(DeviceObject %x Irp %x)\n",DeviceObject,Irp); + + ExFreePool(FileObject->FsContext); + + Irp->IoStatus.Status = STATUS_SUCCESS; + Irp->IoStatus.Information = 0; + + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return(STATUS_SUCCESS); +} + +NTSTATUS MinixCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp) +{ + PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp); + PFILE_OBJECT FileObject = Stack->FileObject; + NTSTATUS Status; + struct minix_inode* result; + MINIX_DEVICE_EXTENSION* DeviceExt; + + DPRINT("MinixCreate(DeviceObject %x, Irp %x)\n",DeviceObject,Irp); + DPRINT("Opening file %x %w\n",FileObject->FileName.Buffer, + FileObject->FileName.Buffer); + DPRINT("FileObject->FileName.Buffer %x\n", + FileObject->FileName.Buffer); + + DeviceExt = (MINIX_DEVICE_EXTENSION *)DeviceObject->DeviceExtension; + result = ExAllocatePool(NonPagedPool,sizeof(struct minix_inode)); + DPRINT("result %x\n",result); + Status = MinixOpen(DeviceExt->AttachedDevice,DeviceExt, + FileObject->FileName.Buffer,result); + + if (Status==STATUS_SUCCESS) + { + FileObject->FsContext=result; + } + + Irp->IoStatus.Status = Status; + Irp->IoStatus.Information = 0; + + IoCompleteRequest(Irp, IO_NO_INCREMENT); + return(Status); +} + +NTSTATUS DriverEntry(PDRIVER_OBJECT _DriverObject, + PUNICODE_STRING RegistryPath) +/* + * FUNCTION: Called by the system to initalize the driver + * ARGUMENTS: + * DriverObject = object describing this driver + * RegistryPath = path to our configuration entries + * RETURNS: Success or failure + */ +{ + PDEVICE_OBJECT DeviceObject; + NTSTATUS ret; + UNICODE_STRING ustr; + ANSI_STRING astr; + + DbgPrint("Minix FSD 0.0.1\n"); + + DriverObject = _DriverObject; + + RtlInitAnsiString(&astr,"\\Device\\Minix"); + RtlAnsiStringToUnicodeString(&ustr,&astr,TRUE); + ret = IoCreateDevice(DriverObject,0,&ustr, + FILE_DEVICE_PARALLEL_PORT,0,FALSE,&DeviceObject); + if (ret!=STATUS_SUCCESS) + { + return(ret); + } + + DeviceObject->Flags=0; + DriverObject->MajorFunction[IRP_MJ_CLOSE] = MinixClose; + DriverObject->MajorFunction[IRP_MJ_CREATE] = MinixCreate; + DriverObject->MajorFunction[IRP_MJ_READ] = MinixRead; + DriverObject->MajorFunction[IRP_MJ_WRITE] = MinixWrite; + DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] = + MinixFileSystemControl; + DriverObject->DriverUnload = NULL; + + IoRegisterFileSystem(DeviceObject); + + return(STATUS_SUCCESS); +} + diff --git a/reactos/drivers/fs/minix/minix_fs.h b/reactos/drivers/fs/minix/minix_fs.h new file mode 100644 index 00000000000..8cfdb9005c7 --- /dev/null +++ b/reactos/drivers/fs/minix/minix_fs.h @@ -0,0 +1,80 @@ +#define MINIX_ROOT_INO 1 + +/* Not the same as the bogus LINK_MAX in . Oh well. */ +#define MINIX_LINK_MAX 250 + +#define MINIX_I_MAP_SLOTS 8 +#define MINIX_Z_MAP_SLOTS 64 +#define MINIX_SUPER_MAGIC 0x137F /* original minix fs */ +#define MINIX_SUPER_MAGIC2 0x138F /* minix fs, 30 char names */ +#define MINIX2_SUPER_MAGIC 0x2468 /* minix V2 fs */ +#define MINIX2_SUPER_MAGIC2 0x2478 /* minix V2 fs, 30 char names */ +#define MINIX_VALID_FS 0x0001 /* Clean fs. */ +#define MINIX_ERROR_FS 0x0002 /* fs has errors. */ + +#define MINIX_INODES_PER_BLOCK ((BLOCKSIZE)/(sizeof (struct minix_inode))) +#define MINIX2_INODES_PER_BLOCK ((BLOCKSIZE)/(sizeof (struct minix2_inode))) + +#define MINIX_V1 0x0001 /* original minix fs */ +#define MINIX_V2 0x0002 /* minix V2 fs */ + + +/* + * This is the original minix inode layout on disk. + * Note the 8-bit gid and atime and ctime. + */ +struct minix_inode { + unsigned short int i_mode; + unsigned short int i_uid; + unsigned long i_size; + unsigned long i_time; + unsigned char i_gid; + unsigned char i_nlinks; + unsigned short int i_zone[9]; +}; + +/* + * The new minix inode has all the time entries, as well as + * long block numbers and a third indirect block (7+1+1+1 + * instead of 7+1+1). Also, some previously 8-bit values are + * now 16-bit. The inode is now 64 bytes instead of 32. + */ +struct minix2_inode { + unsigned short int i_mode; + unsigned short int i_nlinks; + unsigned short int i_uid; + unsigned short int i_gid; + unsigned long i_size; + unsigned long i_atime; + unsigned long i_mtime; + unsigned long i_ctime; + unsigned long i_zone[10]; +}; + +/* + * minix super-block data on disk + */ +struct minix_super_block { + unsigned short int s_ninodes; + unsigned short int s_nzones; + unsigned short int s_imap_blocks; + unsigned short int s_zmap_blocks; + unsigned short int s_firstdatazone; + unsigned short int s_log_zone_size; + unsigned long s_max_size; + unsigned short int s_magic; + unsigned short int s_state; + unsigned long s_zones; +}; + +struct minix_dir_entry { + unsigned short int inode; + char name[0]; +}; +#define MINIX_DIR_ENTRY_SIZE (sizeof(struct minix_dir_entry)+30) + +BOOLEAN MinixReadSector(IN PDEVICE_OBJECT pDeviceObject, + IN ULONG DiskSector, + IN UCHAR* Buffer); + +#define BLOCKSIZE (1024) diff --git a/reactos/include/internal/io.h b/reactos/include/internal/io.h new file mode 100644 index 00000000000..09a373ae8ea --- /dev/null +++ b/reactos/include/internal/io.h @@ -0,0 +1,40 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: include/internal/iomgr.h + * PURPOSE: Internal io manager declarations + * PROGRAMMER: David Welch (welch@mcmail.com) + * UPDATE HISTORY: + * 28/05/97: Created + */ + +#ifndef __INCLUDE_INTERNAL_IOMGR_H +#define __INCLUDE_INTERNAL_IOMGR_H + +#include +#include + +/* + * FUNCTION: Called to initalize a loaded driver + * ARGUMENTS: + * entry = pointer to the driver initialization routine + * RETURNS: Success or failure + */ +NTSTATUS InitalizeLoadedDriver(PDRIVER_INITIALIZE entry); + + + +VOID IoInitCancelHandling(VOID); +VOID IoInitSymbolicLinkImplementation(VOID); + +NTSTATUS IoTryToMountStorageDevice(PDEVICE_OBJECT DeviceObject); +POBJECT IoOpenSymlink(POBJECT SymbolicLink); +POBJECT IoOpenFileOnDevice(POBJECT SymbolicLink, PWCHAR Name); + +PIRP IoBuildFilesystemControlRequest(ULONG MinorFunction, + PDEVICE_OBJECT DeviceObject, + PKEVENT UserEvent, + PIO_STATUS_BLOCK IoStatusBlock, + PDEVICE_OBJECT DeviceToMount); + +#endif diff --git a/reactos/include/internal/ob.h b/reactos/include/internal/ob.h new file mode 100644 index 00000000000..4d71597cc4d --- /dev/null +++ b/reactos/include/internal/ob.h @@ -0,0 +1,97 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: include/internal/objmgr.h + * PURPOSE: Object manager definitions + * PROGRAMMER: David Welch (welch@mcmail.com) + */ + +#ifndef __INCLUDE_INTERNAL_OBJMGR_H +#define __INCLUDE_INTERNAL_OBJMGR_H + +#include + +typedef struct +{ + CSHORT Type; + CSHORT Size; +} COMMON_BODY_HEADER, *PCOMMON_BODY_HEADER; + +typedef PVOID POBJECT; + +typedef struct _DIRECTORY_OBJECT +{ + CSHORT Type; + CSHORT Size; + + /* + * PURPOSE: Head of the list of our subdirectories + */ + LIST_ENTRY head; + KSPIN_LOCK Lock; +} DIRECTORY_OBJECT, *PDIRECTORY_OBJECT; + + +/* + * Enumeration of object types + */ +enum +{ + OBJTYP_INVALID, + OBJTYP_TYPE, + OBJTYP_DIRECTORY, + OBJTYP_SYMLNK, + OBJTYP_DEVICE, + OBJTYP_THREAD, + OBJTYP_FILE, + OBJTYP_MAX, +}; + +BOOL ObAddObjectToNameSpace(PUNICODE_STRING path, POBJECT_HEADER Object); + +VOID ObRegisterType(CSHORT id, OBJECT_TYPE* type); + +VOID ObInitializeObjectHeader(CSHORT id, PWSTR name, + POBJECT_HEADER obj); + +/* + * FUNCTION: Get the size of an object + * ARGUMENTS: + * Type = Object type + * RETURNS: The size in bytes + */ +ULONG ObSizeOf(CSHORT Type); +HANDLE ObAddHandle(PVOID obj); +VOID ObDeleteHandle(HANDLE Handle); +NTSTATUS ObLookupObject(HANDLE rootdir, PWSTR string, PVOID* Object, + PWSTR* UnparsedSection); +PVOID ObGetObjectByHandle(HANDLE h); +PVOID ObGenericCreateObject(PHANDLE Handle, + ACCESS_MASK DesiredAccess, + POBJECT_ATTRIBUTES ObjectAttributes, + CSHORT Type); +NTSTATUS ObOpenObjectByName(POBJECT_ATTRIBUTES ObjectAttributes, + PVOID* Object, PWSTR* UnparsedSection); + +/* + * FUNCTION: Creates an entry within a directory + * ARGUMENTS: + * parent = Parent directory + * object = Header of the object to add + */ +VOID ObCreateEntry(PDIRECTORY_OBJECT parent, POBJECT_HEADER object); + +extern inline POBJECT_HEADER BODY_TO_HEADER(PVOID body) +{ + PCOMMON_BODY_HEADER chdr = (PCOMMON_BODY_HEADER)body; + return(CONTAINING_RECORD((&(chdr->Type)),OBJECT_HEADER,Type)); +} + +extern inline PVOID HEADER_TO_BODY(POBJECT_HEADER obj) +{ + return(((void *)obj)+sizeof(OBJECT_HEADER)-sizeof(COMMON_BODY_HEADER)); +} + +#define OBJECT_ALLOC_SIZE(type) (ObSizeOf(type)+sizeof(OBJECT_HEADER)-sizeof(COMMON_BODY_HEADER)) + +#endif /* __INCLUDE_INTERNAL_OBJMGR_H */ diff --git a/reactos/include/internal/ps.h b/reactos/include/internal/ps.h new file mode 100644 index 00000000000..6856e30a3d4 --- /dev/null +++ b/reactos/include/internal/ps.h @@ -0,0 +1,53 @@ +#ifndef __INCLUDE_INTERNAL_PSMGR_H +#define __INCLUDE_INTERNAL_PSMGR_H + +#include + +extern EPROCESS SystemProcess; +extern HANDLE SystemProcessHandle; + +void PsInitThreadManagment(void); +VOID PsInitProcessManagment(VOID); +VOID PsInitIdleThread(VOID); + +/* + * PURPOSE: Thread states + */ +enum +{ + /* + * PURPOSE: Don't touch + */ + THREAD_STATE_INVALID, + + /* + * PURPOSE: Waiting to be dispatched + */ + THREAD_STATE_RUNNABLE, + + /* + * PURPOSE: Currently running + */ + THREAD_STATE_RUNNING, + + /* + * PURPOSE: Doesn't want to run + */ + THREAD_STATE_SUSPENDED, + + /* + * Waiting to be freed + */ + THREAD_STATE_TERMINATED, +}; + +/* + * Functions the HAL must provide + */ + +void HalInitFirstTask(PKTHREAD thread); +BOOLEAN HalInitTask(PKTHREAD thread, PKSTART_ROUTINE fn, + PVOID StartContext); +void HalTaskSwitch(PKTHREAD thread); + +#endif diff --git a/reactos/ntoskrnl/io/buildirp.c b/reactos/ntoskrnl/io/buildirp.c new file mode 100644 index 00000000000..a7d81ff2552 --- /dev/null +++ b/reactos/ntoskrnl/io/buildirp.c @@ -0,0 +1,232 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: ntoskrnl/io/buildirp.c + * PURPOSE: Building various types of irp + * PROGRAMMER: David Welch (welch@mcmail.com) + * UPDATE HISTORY: + * Created 22/05/98 + */ + +/* INCLUDES *****************************************************************/ + +#include + +#define NDEBUG +#include + +/* FUNCTIONS *****************************************************************/ + +PIRP IoBuildFilesystemControlRequest(ULONG MinorFunction, + PDEVICE_OBJECT DeviceObject, + PKEVENT UserEvent, + PIO_STATUS_BLOCK IoStatusBlock, + PDEVICE_OBJECT DeviceToMount) +/* + * FUNCTION: Allocates and sets up a filesystem control IRP + * ARGUMENTS: + * MinorFunction = Type of filesystem control + * DeviceObject = Device object to send the request to + */ +{ + PIRP Irp; + PIO_STACK_LOCATION StackPtr; + + Irp = IoAllocateIrp(DeviceObject->StackSize,TRUE); + if (Irp==NULL) + { + return(NULL); + } + + Irp->UserIosb = IoStatusBlock; + Irp->UserEvent = UserEvent; + + StackPtr = IoGetNextIrpStackLocation(Irp); + StackPtr->MajorFunction = IRP_MJ_FILE_SYSTEM_CONTROL; + StackPtr->MinorFunction = MinorFunction; + StackPtr->Flags = 0; + StackPtr->Control = 0; + StackPtr->DeviceObject = DeviceObject; + StackPtr->FileObject = NULL; + StackPtr->Parameters.Mount.Vpb = DeviceObject->Vpb; + StackPtr->Parameters.Mount.DeviceObject = DeviceToMount; + + return(Irp); +} + +PIRP IoBuildAsynchronousFsdRequest(ULONG MajorFunction, + PDEVICE_OBJECT DeviceObject, + PVOID Buffer, + ULONG Length, + PLARGE_INTEGER StartingOffset, + PIO_STATUS_BLOCK IoStatusBlock) +/* + * FUNCTION: Allocates and sets up an IRP to be sent to lower level drivers + * ARGUMENTS: + * MajorFunction = One of IRP_MJ_READ, IRP_MJ_WRITE, + * IRP_MJ_FLUSH_BUFFERS or IRP_MJ_SHUTDOWN + * DeviceObject = Device object to send the irp to + * Buffer = Buffer into which data will be read or written + * Length = Length in bytes of the irp to be allocated + * StartingOffset = Starting offset on the device + * IoStatusBlock (OUT) = Storage for the result of the operation + * RETURNS: The IRP allocated on success, or + * NULL on failure + */ +{ + PIRP Irp; + PIO_STACK_LOCATION StackPtr; + + + Irp = IoAllocateIrp(DeviceObject->StackSize,TRUE); + if (Irp==NULL) + { + return(NULL); + } + + Irp->UserBuffer = (LPVOID)Buffer; + if (DeviceObject->Flags&DO_BUFFERED_IO) + { + DPRINT("Doing buffer i/o\n",0); + Irp->AssociatedIrp.SystemBuffer = (PVOID) + ExAllocatePool(NonPagedPool,Length); + if (Irp->AssociatedIrp.SystemBuffer==NULL) + { + return(NULL); + } + Irp->UserBuffer = NULL; + } + if (DeviceObject->Flags&DO_DIRECT_IO) + { + DPRINT("Doing direct i/o\n",0); + + Irp->MdlAddress = MmCreateMdl(NULL,Buffer,Length); + MmProbeAndLockPages(Irp->MdlAddress,UserMode,IoWriteAccess); + Irp->UserBuffer = NULL; + Irp->AssociatedIrp.SystemBuffer = NULL; + } + + Irp->UserIosb = IoStatusBlock; + + StackPtr = IoGetNextIrpStackLocation(Irp); + StackPtr->MajorFunction = MajorFunction; + StackPtr->MinorFunction = 0; + StackPtr->Flags = 0; + StackPtr->Control = 0; + StackPtr->DeviceObject = DeviceObject; + StackPtr->FileObject = NULL; + StackPtr->Parameters.Write.Length = Length; + if (StartingOffset!=NULL) + { + StackPtr->Parameters.Write.ByteOffset.LowPart = + StartingOffset->LowPart; + StackPtr->Parameters.Write.ByteOffset.HighPart = + StartingOffset->HighPart; + } + else + { + StackPtr->Parameters.Write.ByteOffset.LowPart = 0; + StackPtr->Parameters.Write.ByteOffset.HighPart = 0; + } + + return(Irp); +} + +PIRP IoBuildDeviceIoControlRequest(ULONG IoControlCode, + PDEVICE_OBJECT DeviceObject, + PVOID InputBuffer, + ULONG InputBufferLength, + PVOID OutputBuffer, + ULONG OutputBufferLength, + BOOLEAN InternalDeviceIoControl, + PKEVENT Event, + PIO_STATUS_BLOCK IoStatusBlock) +{ + UNIMPLEMENTED; +} + +PIRP IoBuildSynchronousFsdRequest(ULONG MajorFunction, + PDEVICE_OBJECT DeviceObject, + PVOID Buffer, + ULONG Length, + PLARGE_INTEGER StartingOffset, + PKEVENT Event, + PIO_STATUS_BLOCK IoStatusBlock) +/* + * FUNCTION: Allocates and builds an IRP to be sent synchronously to lower + * level driver(s) + * ARGUMENTS: + * MajorFunction = Major function code, one of IRP_MJ_READ, + * IRP_MJ_WRITE, IRP_MJ_FLUSH_BUFFERS, IRP_MJ_SHUTDOWN + * DeviceObject = Target device object + * Buffer = Buffer containing data for a read or write + * Length = Length in bytes of the information to be transferred + * StartingOffset = Offset to begin the read/write from + * Event (OUT) = Will be set when the operation is complete + * IoStatusBlock (OUT) = Set to the status of the operation + * RETURNS: The IRP allocated on success, or + * NULL on failure + */ +{ + PIRP Irp; + PIO_STACK_LOCATION StackPtr; + + DPRINT("IoBuildSynchronousFsdRequest(MajorFunction %x, DeviceObject %x, " + "Buffer %x, Length %x, StartingOffset %x, Event %x, " + "IoStatusBlock %x\n",MajorFunction,DeviceObject,Buffer,Length, + StartingOffset,Event,IoStatusBlock); + + Irp = IoAllocateIrp(DeviceObject->StackSize,TRUE); + if (Irp==NULL) + { + return(NULL); + } + + Irp->UserBuffer = (LPVOID)Buffer; + if (DeviceObject->Flags&DO_BUFFERED_IO) + { + DPRINT("Doing buffer i/o\n",0); + Irp->AssociatedIrp.SystemBuffer = (PVOID) + ExAllocatePool(NonPagedPool,Length); + if (Irp->AssociatedIrp.SystemBuffer==NULL) + { + return(NULL); + } + Irp->UserBuffer = NULL; + } + if (DeviceObject->Flags&DO_DIRECT_IO) + { + DPRINT("Doing direct i/o\n",0); + + Irp->MdlAddress = MmCreateMdl(NULL,Buffer,Length); + MmProbeAndLockPages(Irp->MdlAddress,UserMode,IoWriteAccess); + Irp->UserBuffer = NULL; + Irp->AssociatedIrp.SystemBuffer = NULL; + } + + Irp->UserIosb = IoStatusBlock; + Irp->UserEvent = Event; + + StackPtr = IoGetNextIrpStackLocation(Irp); + StackPtr->MajorFunction = MajorFunction; + StackPtr->MinorFunction = 0; + StackPtr->Flags = 0; + StackPtr->Control = 0; + StackPtr->DeviceObject = DeviceObject; + StackPtr->FileObject = NULL; + StackPtr->Parameters.Write.Length = Length; + if (StartingOffset!=NULL) + { + StackPtr->Parameters.Write.ByteOffset.LowPart = + StartingOffset->LowPart; + StackPtr->Parameters.Write.ByteOffset.HighPart = + StartingOffset->HighPart; + } + else + { + StackPtr->Parameters.Write.ByteOffset.LowPart = 0; + StackPtr->Parameters.Write.ByteOffset.HighPart = 0; + } + + return(Irp); +} diff --git a/reactos/ntoskrnl/io/vpb.c b/reactos/ntoskrnl/io/vpb.c new file mode 100644 index 00000000000..14577bac133 --- /dev/null +++ b/reactos/ntoskrnl/io/vpb.c @@ -0,0 +1,41 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: ntoskrnl/io/vpb.c + * PURPOSE: Volume Parameters Block managment + * PROGRAMMER: David Welch (welch@mcmail.com) + * UPDATE HISTORY: + * Created 22/05/98 + */ + +/* INCLUDES *****************************************************************/ + +#include +#include + +#include + +/* FUNCTIONS *****************************************************************/ + +NTSTATUS IoAttachVpb(PDEVICE_OBJECT DeviceObject) +{ + PVPB Vpb; + + Vpb = ExAllocatePool(NonPagedPool,sizeof(VPB)); + if (Vpb==NULL) + { + return(STATUS_UNSUCCESSFUL); + } + + Vpb->Type = 0; + Vpb->Size = sizeof(VPB) / sizeof(DWORD); + Vpb->Flags = 0; + Vpb->VolumeLabelLength = 0; + Vpb->DeviceObject = NULL; + Vpb->RealDevice = DeviceObject; + Vpb->SerialNumber = 0; + Vpb->ReferenceCount = 0; + memset(Vpb->VolumeLabel,0,sizeof(WCHAR)*MAXIMUM_VOLUME_LABEL_LENGTH); + + DeviceObject->Vpb = Vpb; +} diff --git a/reactos/ntoskrnl/tst/readline.c b/reactos/ntoskrnl/tst/readline.c new file mode 100644 index 00000000000..b2d56c160d7 --- /dev/null +++ b/reactos/ntoskrnl/tst/readline.c @@ -0,0 +1,90 @@ +/* + * COPYRIGHT: See COPYING in the top level directory + * PROJECT: ReactOS kernel + * FILE: ntoskrnl/tst/readline.c + * PURPOSE: Simple readline library + * PROGRAMMER: David Welch (welch@mcmail.com) + * UPDATE HISTORY: + * 28/05/98: Created + */ + +/* INCLUDES *****************************************************************/ + +#include +#include +#include + +#define NDEBUG +#include + +/* GLOBALS ******************************************************************/ + +static HANDLE KeyboardHandle = NULL; + +/* FUNCTIONS ****************************************************************/ + +static unsigned char TstReadLineReadChar(VOID) +{ + KEY_EVENT_RECORD key[2]; + + ZwReadFile(KeyboardHandle, + NULL, + NULL, + NULL, + NULL, + &key[0], + sizeof(KEY_EVENT_RECORD)*2, + 0, + 0); +// DbgPrint("%c",key[0].AsciiChar); + return(key[0].AsciiChar); +} + +VOID TstReadLine(ULONG Length, PCHAR Buffer) +{ + char* current = Buffer; + char tmp; + unsigned int i; + + for (i=0;i