Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-03 13:15:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

Updated the minix driver

Browse source 
Moved console handling into csrss
Gave each process a name for debugging purposes

svn path=/trunk/; revision=1088
This commit is contained in:
David Welch 2000-03-22 18:36:00 +00:00
parent a1c9a520cf
commit 0bd4cf0cbf
48 changed files with 1107 additions and 1044 deletions
Download patch file Download diff file Expand all files Collapse all files

10
reactos/Makefile
View file

@ -34,13 +34,14 @@ LOADERS = dos
# #
# Select the device drivers and filesystems you want # Select the device drivers and filesystems you want
# #
DEVICE_DRIVERS = blue ide keyboard null parallel serial vidport vga/display vga/miniport DEVICE_DRIVERS = blue ide keyboard null parallel serial vidport
# DEVICE_DRIVERS = beep event floppy ide_test mouse sound test test1 # DEVICE_DRIVERS = beep event floppy ide_test mouse sound test test1
FS_DRIVERS = vfat FS_DRIVERS = vfat minix
# FS_DRIVERS = minix ext2 template # FS_DRIVERS = minix ext2 template
KERNEL_SERVICES = $(DEVICE_DRIVERS) $(FS_DRIVERS) KERNEL_SERVICES = $(DEVICE_DRIVERS) $(FS_DRIVERS)
APPS = args hello shell test cat bench apc shm lpc thread event file gditest APPS = args hello shell test cat bench apc shm lpc thread event file gditest \
pteb
all: buildno $(COMPONENTS) $(DLLS) $(SUBSYS) $(LOADERS) $(KERNEL_SERVICES) $(APPS) all: buildno $(COMPONENTS) $(DLLS) $(SUBSYS) $(LOADERS) $(KERNEL_SERVICES) $(APPS)
@ -232,7 +233,8 @@ $(SUBSYS:%=%_dist): %_dist:
install: all install: all
./install.sh /mnt/hda1 ./install.sh /mnt/hda1
./install.sh /mnt/hda4
make_floppy_dirs: make_floppy_dirs:
ifeq ($(DOSCLI),yes) ifeq ($(DOSCLI),yes)
mkdir $(FLOPPY_DIR)\dlls mkdir $(FLOPPY_DIR)\dlls

39
reactos/apps/tests/pteb/Makefile Normal file
View file

@ -0,0 +1,39 @@
#
#
#
OBJECTS = pteb.o
PROGS = pteb.exe
LIBS =
CLEAN_FILES = pteb.o pteb.exe
all: pteb.exe
clean: $(CLEAN_FILES:%=%_clean)
$(CLEAN_FILES:%=%_clean): %_clean:
- $(RM) $*
.phony: clean $(CLEAN_FILES:%=%_clean)
floppy: $(PROGS:%=$(FLOPPY_DIR)/apps/%)
$(PROGS:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* $(FLOPPY_DIR)\apps\$*
else
$(CP) $* $(FLOPPY_DIR)/apps/$*
endif
dist: $(PROGS:%=../../$(DIST_DIR)/apps/%)
$(PROGS:%=../../$(DIST_DIR)/apps/%): ../../$(DIST_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* ..\..\$(DIST_DIR)\apps\$*
else
$(CP) $* ../../$(DIST_DIR)/apps/$*
endif
pteb.exe: $(OBJECTS)
$(CC) $(OBJECTS) -o pteb.exe
include ../../rules.mak

14
reactos/apps/tests/pteb/pteb.c Normal file
View file

@ -0,0 +1,14 @@
#include <stdio.h>
int main(int argc, char* argv[])
{
int x;
printf("TEB dumpper\n");
__asm__("movl %%fs:0x18, %0\n\t"
: "=g" (x)
: /* no inputs */);
printf("fs[0x18] %x\n", x);
return(0);
}

5
reactos/apps/utils/shell/shell.c
View file

@ -1,4 +1,4 @@
/* $Id: shell.c,v 1.35 2000/03/16 20:02:44 ekohl Exp $ /* $Id: shell.c,v 1.36 2000/03/22 18:35:45 dwelch Exp $
* *
* PROJECT : ReactOS Operating System * PROJECT : ReactOS Operating System
* DESCRIPTION: ReactOS' Native Shell * DESCRIPTION: ReactOS' Native Shell
@ -454,7 +454,7 @@ void ParseCommandLine (void)
int main(void) int main(void)
{ {
static char line[255]; static char line[255];
AllocConsole(); AllocConsole();
InputHandle = GetStdHandle(STD_INPUT_HANDLE); InputHandle = GetStdHandle(STD_INPUT_HANDLE);
OutputHandle = GetStdHandle(STD_OUTPUT_HANDLE); OutputHandle = GetStdHandle(STD_OUTPUT_HANDLE);
@ -462,7 +462,6 @@ int main(void)
debug_printf("Shell Starting...\n"); debug_printf("Shell Starting...\n");
ParseCommandLine (); ParseCommandLine ();
// SetCurrentDirectoryA("C:\\");
for(;;) for(;;)
{ {

58
reactos/drivers/fs/minix/block.c
View file

@ -11,7 +11,7 @@
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#define NDEBUG //#define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
#include "minix.h" #include "minix.h"
@ -25,13 +25,12 @@ static unsigned int MinixGetBlock(PDEVICE_OBJECT DeviceObject,
{ {
int block; int block;
PVOID BaseAddress; PVOID BaseAddress;
PCACHE_SEGMENT CacheSeg;
ULONG blk; ULONG blk;
blk = FileOffset / BLOCKSIZE;
DPRINT("MinixGetBlock(inode %x, blk %d)\n",inode,blk); DPRINT("MinixGetBlock(inode %x, blk %d)\n",inode,blk);
blk = FileOffset / BLOCKSIZE;
/* /*
* The first few blocks are available in the inode * The first few blocks are available in the inode
*/ */
@ -49,17 +48,15 @@ static unsigned int MinixGetBlock(PDEVICE_OBJECT DeviceObject,
{ {
block = inode->i_zone[7]; block = inode->i_zone[7];
MinixRequestCacheBlock(DeviceObject, BaseAddress = ExAllocatePool(NonPagedPool, 512);
DeviceExt->Bcb,
block * BLOCKSIZE, MinixReadSector(DeviceObject,
&BaseAddress, block,
&CacheSeg); BaseAddress);
block = ((PUSHORT)BaseAddress)[blk]; block = ((PUSHORT)(BaseAddress))[blk];
CcReleaseCachePage(DeviceExt->Bcb, ExFreePool(BaseAddress);
CacheSeg,
TRUE);
return(block); return(block);
} }
@ -69,31 +66,27 @@ static unsigned int MinixGetBlock(PDEVICE_OBJECT DeviceObject,
*/ */
blk = blk - 512; blk = blk - 512;
block = inode->i_zone[8]; block = inode->i_zone[8];
MinixRequestCacheBlock(DeviceObject, BaseAddress = ExAllocatePool(NonPagedPool, 512);
DeviceExt->Bcb,
block * BLOCKSIZE, MinixReadSector(DeviceObject,
&BaseAddress, block,
&CacheSeg); BaseAddress);
block = ((PUSHORT)BaseAddress)[(blk>>9)&511]; block = ((PUSHORT)BaseAddress)[(blk>>9)&511];
CcReleaseCachePage(DeviceExt->Bcb, ExFreePool(BaseAddress);
CacheSeg,
TRUE);
MinixRequestCacheBlock(DeviceObject,
DeviceExt->Bcb, BaseAddress = ExAllocatePool(NonPagedPool, 512);
block * BLOCKSIZE,
&BaseAddress, MinixReadSector(DeviceObject,
&CacheSeg); block,
BaseAddress);
block = ((PUSHORT)BaseAddress)[blk&512]; block = ((PUSHORT)BaseAddress)[blk&512];
CcReleaseCachePage(DeviceExt->Bcb, ExFreePool(BaseAddress);
CacheSeg,
TRUE);
return(block); return(block);
} }
@ -105,7 +98,6 @@ NTSTATUS MinixReadBlock(PDEVICE_OBJECT DeviceObject,
PULONG DiskOffset) PULONG DiskOffset)
{ {
unsigned int block; unsigned int block;
NTSTATUS Status;
DPRINT("MinixReadBlock()\n"); DPRINT("MinixReadBlock()\n");

8
reactos/drivers/fs/minix/blockdev.c
View file

@ -20,7 +20,7 @@
/* FUNCTIONS ***************************************************************/ /* FUNCTIONS ***************************************************************/
BOLEAN MinixReadPage(PDEVICE_OBJECT DeviceObject, BOOLEAN MinixReadPage(PDEVICE_OBJECT DeviceObject,
ULONG Offset, ULONG Offset,
PVOID Buffer) PVOID Buffer)
{ {
@ -37,12 +37,12 @@ BOLEAN MinixReadPage(PDEVICE_OBJECT DeviceObject,
return(Result); return(Result);
} }
} }
return(True); return(TRUE);
} }
BOOLEAN MinixReadSector(IN PDEVICE_OBJECT pDeviceObject, BOOLEAN MinixReadSector(IN PDEVICE_OBJECT pDeviceObject,
IN ULONG DiskSector, IN ULONG DiskSector,
IN UCHAR* Buffer) IN PVOID Buffer)
{ {
LARGE_INTEGER sectorNumber; LARGE_INTEGER sectorNumber;
PIRP irp; PIRP irp;
@ -107,7 +107,7 @@ BOOLEAN MinixReadSector(IN PDEVICE_OBJECT pDeviceObject,
BOOLEAN MinixWriteSector(IN PDEVICE_OBJECT pDeviceObject, BOOLEAN MinixWriteSector(IN PDEVICE_OBJECT pDeviceObject,
IN ULONG DiskSector, IN ULONG DiskSector,
IN UCHAR* Buffer) IN PVOID Buffer)
{ {
LARGE_INTEGER sectorNumber; LARGE_INTEGER sectorNumber;
PIRP irp; PIRP irp;

58
reactos/drivers/fs/minix/dir.c
View file

@ -12,14 +12,15 @@
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <string.h> #include <string.h>
#define NDEBUG //#define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
#include "minix.h" #include "minix.h"
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
BOOLEAN MinixCompareUnicodeStringToAnsi(PCH AnsiStr, PWCHAR UnicodeStr, BOOLEAN MinixCompareUnicodeStringToAnsi(PCH AnsiStr,
PWCHAR UnicodeStr,
ULONG MaxLen) ULONG MaxLen)
{ {
unsigned int i = 0; unsigned int i = 0;
@ -44,6 +45,7 @@ BOOLEAN MinixCompareUnicodeStringToAnsi(PCH AnsiStr, PWCHAR UnicodeStr,
#define ENTRIES_PER_BLOCK (BLOCKSIZE / MINIX_DIR_ENTRY_SIZE) #define ENTRIES_PER_BLOCK (BLOCKSIZE / MINIX_DIR_ENTRY_SIZE)
ULONG MinixDirLookup(PMINIX_DEVICE_EXTENSION DeviceExt, ULONG MinixDirLookup(PMINIX_DEVICE_EXTENSION DeviceExt,
PDEVICE_OBJECT DeviceObject,
struct minix_inode* dir, struct minix_inode* dir,
PWCHAR Name) PWCHAR Name)
{ {
@ -51,69 +53,66 @@ ULONG MinixDirLookup(PMINIX_DEVICE_EXTENSION DeviceExt,
unsigned int offset; unsigned int offset;
unsigned int i; unsigned int i;
unsigned int inode; unsigned int inode;
PCCB Ccb = NULL; PVOID Block;
ULONG DiskOffset;
DPRINT("MinixDirLookup(DeviceExt %x, dir %x, Name %S)\n",DeviceExt,dir, DPRINT("MinixDirLookup(DeviceExt %x, dir %x, Name %S)\n",DeviceExt,dir,
Name); Name);
Block = ExAllocatePool(NonPagedPool, 512);
for (i=0;i<(dir->i_size/MINIX_DIR_ENTRY_SIZE);i++) for (i=0;i<(dir->i_size/MINIX_DIR_ENTRY_SIZE);i++)
{ {
CHECKPOINT; CHECKPOINT;
offset = i*MINIX_DIR_ENTRY_SIZE; offset = i*MINIX_DIR_ENTRY_SIZE;
if ((offset%BLOCKSIZE)==0) if ((offset%BLOCKSIZE)==0)
{ {
CHECKPOINT; MinixReadBlock(DeviceObject,
if (Ccb != NULL) DeviceExt,
{
CHECKPOINT;
CbReleaseFromRead(&DeviceExt->Dccb,Ccb);
}
CHECKPOINT;
MinixReadBlock(DeviceExt,
dir, dir,
offset/BLOCKSIZE, offset/BLOCKSIZE,
&Ccb); &DiskOffset);
MinixReadSector(DeviceObject,
DiskOffset,
Block);
} }
current_entry = (struct minix_dir_entry *) current_entry = (struct minix_dir_entry *)
(Ccb->Buffer+offset%BLOCKSIZE); (Block+offset%BLOCKSIZE);
DPRINT("Inode %x Name %.30s\n",current_entry->inode, DPRINT("Inode %x Name %.30s\n",current_entry->inode,
current_entry->name); current_entry->name);
if (MinixCompareUnicodeStringToAnsi(current_entry->name, if (MinixCompareUnicodeStringToAnsi(current_entry->name,
Name,30)) Name,30))
{ {
inode = current_entry->inode; inode = current_entry->inode;
CbReleaseFromRead(&DeviceExt->Dccb,Ccb); ExFreePool(Block);
DPRINT("MinixDirLookup() = %d\n",inode); DPRINT("MinixDirLookup() = %d\n",inode);
return(inode); return(inode);
} }
} }
CHECKPOINT; CHECKPOINT;
if (Ccb != NULL) ExFreePool(Block);
{
CbReleaseFromRead(&DeviceExt->Dccb,Ccb);
}
DPRINT("MinixDirLookup() = %d\n",0); DPRINT("MinixDirLookup() = %d\n",0);
return(0); return(0);
} }
NTSTATUS MinixOpen(PDEVICE_OBJECT DeviceObject, NTSTATUS MinixOpen(PDEVICE_OBJECT DeviceObject,
MINIX_DEVICE_EXTENSION* DeviceExt, MINIX_DEVICE_EXTENSION* DeviceExt,
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject,
PMINIX_FSCONTEXT result, PMINIX_FSCONTEXT result,
PULONG Information) PULONG Information)
{ {
PWSTR current; PWSTR current;
PWSTR next; PWSTR next;
PWSTR string = DeviceName; PWSTR string;
struct minix_inode current_dir; struct minix_inode current_dir;
unsigned int current_ino; unsigned int current_ino;
PWSTR DeviceName;
DeviceName = FileObject->FileName.Buffer; string = ExAllocatePool(NonPagedPool,
2*(wcslen(FileObject->FileName.Buffer)+1));
wcscpy(string, FileObject->FileName.Buffer);
DbgPrint("MinixOpen(DeviceObject %x, DeviceName %S, result %x)\n", DbgPrint("MinixOpen(DeviceObject %x, DeviceName %S, result %x)\n",
DeviceObject,DeviceName,result); DeviceObject,string,result);
DPRINT("DeviceName %x\n",DeviceName);
next = &string[0]; next = &string[0];
@ -135,7 +134,10 @@ NTSTATUS MinixOpen(PDEVICE_OBJECT DeviceObject,
*next=0; *next=0;
} }
current_ino = MinixDirLookup(DeviceExt,&current_dir,current); current_ino = MinixDirLookup(DeviceExt,
DeviceObject,
&current_dir,
current);
} }
if (next==NULL && current_ino!=0) if (next==NULL && current_ino!=0)
{ {
@ -149,8 +151,6 @@ NTSTATUS MinixOpen(PDEVICE_OBJECT DeviceObject,
result = ExAllocatePool(NonPagedPool, sizeof(MINIX_FSCONTEXT)); result = ExAllocatePool(NonPagedPool, sizeof(MINIX_FSCONTEXT));
memcpy(&result->inode,&current_dir,sizeof(struct minix_inode)); memcpy(&result->inode,&current_dir,sizeof(struct minix_inode));
CcInitializeFileCache(FileObject,
&result->Bcb);
DPRINT("MinxOpen() = STATUS_SUCCESS\n",0); DPRINT("MinxOpen() = STATUS_SUCCESS\n",0);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
@ -176,7 +176,7 @@ NTSTATUS MinixDirectoryControl(PDEVICE_OBJECT DeviceObject,
PIRP Irp) PIRP Irp)
{ {
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp); PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = Stack->FileObject; // PFILE_OBJECT FileObject = Stack->FileObject;
if (Stack->MinorFunction != IRP_MN_QUERY_DIRECTORY) if (Stack->MinorFunction != IRP_MN_QUERY_DIRECTORY)
{ {
@ -195,7 +195,7 @@ NTSTATUS MinixCreate(PDEVICE_OBJECT DeviceObject, PIRP Irp)
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp); PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
PFILE_OBJECT FileObject = Stack->FileObject; PFILE_OBJECT FileObject = Stack->FileObject;
NTSTATUS Status; NTSTATUS Status;
struct minix_inode* result; PMINIX_FSCONTEXT result;
MINIX_DEVICE_EXTENSION* DeviceExt; MINIX_DEVICE_EXTENSION* DeviceExt;
DPRINT("MinixCreate(DeviceObject %x, Irp %x)\n",DeviceObject,Irp); DPRINT("MinixCreate(DeviceObject %x, Irp %x)\n",DeviceObject,Irp);

32
reactos/drivers/fs/minix/inode.c
View file

@ -15,7 +15,7 @@
#include <internal/bitops.h> #include <internal/bitops.h>
#include <ddk/ntifs.h> #include <ddk/ntifs.h>
//#define NDEBUG #define NDEBUG
#include <internal/debug.h> #include <internal/debug.h>
#include "minix.h" #include "minix.h"
@ -106,13 +106,9 @@ NTSTATUS MinixReadInode(PDEVICE_OBJECT DeviceObject,
ULONG ino, ULONG ino,
struct minix_inode* result) struct minix_inode* result)
{ {
PCCB Ccb;
int block; int block;
struct minix_inode* inodes; struct minix_inode* inodes;
NTSTATUS Status;
PVOID BaseAddress; PVOID BaseAddress;
BOOLEAN UptoDate;
PCACHE_SEGMENT* CacheSeg;
DPRINT("MinixReadInode(ino %x, result %x)\n",ino,result); DPRINT("MinixReadInode(ino %x, result %x)\n",ino,result);
@ -121,29 +117,21 @@ NTSTATUS MinixReadInode(PDEVICE_OBJECT DeviceObject,
DPRINT("Reading block %x offset %x\n",block,block*BLOCKSIZE); DPRINT("Reading block %x offset %x\n",block,block*BLOCKSIZE);
DPRINT("Index %x\n",(ino-1)%MINIX_INODES_PER_BLOCK); DPRINT("Index %x\n",(ino-1)%MINIX_INODES_PER_BLOCK);
Status = CcRequestCachePage(DeviceExt->Bcb, BaseAddress = ExAllocatePool(NonPagedPool, PAGESIZE);
block,
&BaseAddress,
&UptoDate,
&CacheSeg);
if (!UptoDate)
{
MinixReadPage(DeviceExt,
PAGE_ROUND_DOWN(block),
BaseAddress);
}
MinixReadPage(DeviceObject,
block,
BaseAddress);
inodes = (struct minix_inode *)(BaseAddress + ((block % 4) * 512)); inodes = (struct minix_inode *)(BaseAddress + ((block % 4) * 512));
memcpy(result,&inodes[(ino-1)%MINIX_INODES_PER_BLOCK], memcpy(result,
&inodes[(ino-1)%MINIX_INODES_PER_BLOCK],
sizeof(struct minix_inode)); sizeof(struct minix_inode));
DPRINT("result->i_uid %x\n",result->i_uid); DPRINT("result->i_uid %x\n",result->i_uid);
DPRINT("result->i_size %x\n",result->i_size); DPRINT("result->i_size %x\n",result->i_size);
CcFreeCacheSegment(DeviceExt->FileObject,
DeviceExt->Bcb,
CacheSeg);
ExFreePool(BaseAddress);
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }

1
reactos/drivers/fs/minix/makefile_rex
View file

@ -38,4 +38,5 @@ minixfs.sys: $(OBJECTS)
- $(RM) temp.exp - $(RM) temp.exp
WIN32_LEAN_AND_MEAN = yes WIN32_LEAN_AND_MEAN = yes
WARNINGS_ARE_ERRORS = yes
include ../../../rules.mak include ../../../rules.mak

25
reactos/drivers/fs/minix/minix.c
View file

@ -5,7 +5,7 @@
* PURPOSE: Minix FSD * PURPOSE: Minix FSD
* PROGRAMMER: David Welch (welch@mcmail.com) * PROGRAMMER: David Welch (welch@mcmail.com)
* UPDATE HISTORY: * UPDATE HISTORY:
*/ 4 */
/* INCLUDES *****************************************************************/ /* INCLUDES *****************************************************************/
@ -421,24 +421,27 @@ NTSTATUS DriverEntry(PDRIVER_OBJECT _DriverObject,
*/ */
{ {
PDEVICE_OBJECT DeviceObject; PDEVICE_OBJECT DeviceObject;
NTSTATUS ret; NTSTATUS Status;
UNICODE_STRING ustr; UNICODE_STRING DeviceName;
ANSI_STRING astr;
DbgPrint("Minix FSD 0.0.1\n"); DbgPrint("Minix FSD 0.0.1\n");
DriverObject = _DriverObject; DriverObject = _DriverObject;
RtlInitAnsiString(&astr,"\\Device\\Minix"); RtlInitUnicodeString(&DeviceName, "\\Device\\Minix");
RtlAnsiStringToUnicodeString(&ustr,&astr,TRUE); Status = IoCreateDevice(DriverObject,
ret = IoCreateDevice(DriverObject,0,&ustr, 0,
FILE_DEVICE_PARALLEL_PORT,0,FALSE,&DeviceObject); &DeviceName,
if (ret!=STATUS_SUCCESS) FILE_DEVICE_FILE_SYSTEM,
0,
FALSE,
&DeviceObject);
if (!NT_SUCCESS(Status))
{ {
return(ret); return(Status);
} }
DeviceObject->Flags=0; DeviceObject->Flags = DO_DIRECT_IO;
DriverObject->MajorFunction[IRP_MJ_CLOSE] = MinixClose; DriverObject->MajorFunction[IRP_MJ_CLOSE] = MinixClose;
DriverObject->MajorFunction[IRP_MJ_CREATE] = MinixCreate; DriverObject->MajorFunction[IRP_MJ_CREATE] = MinixCreate;
DriverObject->MajorFunction[IRP_MJ_READ] = MinixRead; DriverObject->MajorFunction[IRP_MJ_READ] = MinixRead;

15
reactos/drivers/fs/minix/minix.h
View file

@ -78,10 +78,10 @@ struct minix_dir_entry {
BOOLEAN MinixReadSector(IN PDEVICE_OBJECT pDeviceObject, BOOLEAN MinixReadSector(IN PDEVICE_OBJECT pDeviceObject,
IN ULONG DiskSector, IN ULONG DiskSector,
IN UCHAR* Buffer); IN PVOID Buffer);
BOOLEAN MinixWriteSector(IN PDEVICE_OBJECT pDeviceObject, BOOLEAN MinixWriteSector(IN PDEVICE_OBJECT pDeviceObject,
IN ULONG DiskSector, IN ULONG DiskSector,
IN UCHAR* Buffer); IN PVOID Buffer);
#define BLOCKSIZE (1024) #define BLOCKSIZE (1024)
@ -94,12 +94,10 @@ typedef struct
char superblock_buf[BLOCKSIZE]; char superblock_buf[BLOCKSIZE];
struct minix_super_block* sb; struct minix_super_block* sb;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PBCB Bcb;
} MINIX_DEVICE_EXTENSION, *PMINIX_DEVICE_EXTENSION; } MINIX_DEVICE_EXTENSION, *PMINIX_DEVICE_EXTENSION;
typedef struct typedef struct
{ {
PBCB Bcb;
struct minix_inode inode; struct minix_inode inode;
} MINIX_FSCONTEXT, *PMINIX_FSCONTEXT; } MINIX_FSCONTEXT, *PMINIX_FSCONTEXT;
@ -129,9 +127,6 @@ NTSTATUS MinixReadBlock(PDEVICE_OBJECT DeviceObject,
ULONG FileOffset, ULONG FileOffset,
PULONG DiskOffset); PULONG DiskOffset);
BOOLEAN MinixReadPage(PDEVICE_OBJECT DeviceObject,
NTSTATUS MinixRequestCacheBlock(PDEVICE_OBJECT DeviceObject, ULONG Offset,
PBCB Bcb, PVOID Buffer);
ULONG FileOffset,
PVOID* BaseAddress,
PCACHE_SEGMENT* CacheSeg);

4
reactos/drivers/fs/minix/mount.c
View file

@ -44,14 +44,12 @@ VOID MinixMount(PDEVICE_OBJECT DeviceToMount)
DeviceExt->AttachedDevice = IoAttachDeviceToDeviceStack(DeviceObject, DeviceExt->AttachedDevice = IoAttachDeviceToDeviceStack(DeviceObject,
DeviceToMount); DeviceToMount);
DeviceExt->FileObject = IoCreateStreamFileObject(NULL, DeviceObject); DeviceExt->FileObject = IoCreateStreamFileObject(NULL, DeviceObject);
CcInitializeFileCache(DeviceExt->FileObject,
&DeviceExt->Bcb);
} }
NTSTATUS MinixFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp) NTSTATUS MinixFileSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
{ {
PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp); PIO_STACK_LOCATION Stack = IoGetCurrentIrpStackLocation(Irp);
PVPB vpb = Stack->Parameters.Mount.Vpb; // PVPB vpb = Stack->Parameters.Mount.Vpb;
PDEVICE_OBJECT DeviceToMount = Stack->Parameters.Mount.DeviceObject; PDEVICE_OBJECT DeviceToMount = Stack->Parameters.Mount.DeviceObject;
NTSTATUS Status; NTSTATUS Status;
char* superblock_buf; char* superblock_buf;

63
reactos/drivers/fs/minix/rw.c
View file

@ -32,37 +32,24 @@ static NTSTATUS MinixReadFilePage(PDEVICE_OBJECT DeviceObject,
PMINIX_DEVICE_EXTENSION DeviceExt, PMINIX_DEVICE_EXTENSION DeviceExt,
PMINIX_FSCONTEXT FsContext, PMINIX_FSCONTEXT FsContext,
ULONG Offset, ULONG Offset,
PVOID* Buffer, PVOID* Buffer)
PCACHE_SEGMENT* CacheSeg)
{ {
BOOLEAN UptoDate;
NTSTATUS Status; NTSTATUS Status;
ULONG i; ULONG i;
ULONG DiskOffset; ULONG DiskOffset;
Status = CcRequestCachePage(FsContext->Bcb, *Buffer = ExAllocatePool(NonPagedPool, 4096);
Offset,
Buffer, for (i=0; i<4; i++)
&UptoDate,
CacheSeg);
if (!NT_SUCCESS(Status))
{ {
return(Status); Status = MinixReadBlock(DeviceObject,
} DeviceExt,
&FsContext->inode,
if (!UptoDate) Offset + (i * BLOCKSIZE),
{ &DiskOffset);
for (i=0; i<4; i++) MinixReadSector(DeviceObject,
{ DiskOffset / BLOCKSIZE,
Status = MinixReadBlock(DeviceObject, (*Buffer) + (i * BLOCKSIZE));
DeviceExt,
&FsContext->inode,
Offset + (i * BLOCKSIZE),
&DiskOffset);
MinixReadSector(DeviceObject,
DiskOffset / BLOCKSIZE,
(*Buffer) + (i * BLOCKSIZE));
}
} }
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
@ -79,7 +66,6 @@ NTSTATUS MinixRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
PMINIX_FSCONTEXT FsContext = (PMINIX_FSCONTEXT)FileObject->FsContext; PMINIX_FSCONTEXT FsContext = (PMINIX_FSCONTEXT)FileObject->FsContext;
unsigned int i; unsigned int i;
PVOID DiskBuffer; PVOID DiskBuffer;
PCACHE_SEGMENT CacheSeg;
DPRINT("MinixRead(DeviceObject %x, Irp %x)\n",DeviceObject,Irp); DPRINT("MinixRead(DeviceObject %x, Irp %x)\n",DeviceObject,Irp);
@ -113,16 +99,13 @@ NTSTATUS MinixRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
DeviceExt, DeviceExt,
FsContext, FsContext,
CurrentOffset, CurrentOffset,
&DiskBuffer, &DiskBuffer);
&CacheSeg);
memcpy(Buffer, memcpy(Buffer,
DiskBuffer+(Offset%PAGESIZE), DiskBuffer+(Offset%PAGESIZE),
min(PAGESIZE - (Offset%PAGESIZE),Length)); min(PAGESIZE - (Offset%PAGESIZE),Length));
CcReleaseCachePage(FsContext->Bcb, ExFreePool(DiskBuffer);
CacheSeg,
TRUE);
DPRINT("(BLOCKSIZE - (Offset%BLOCKSIZE)) %d\n", DPRINT("(BLOCKSIZE - (Offset%BLOCKSIZE)) %d\n",
(BLOCKSIZE - (Offset%BLOCKSIZE))); (BLOCKSIZE - (Offset%BLOCKSIZE)));
@ -143,14 +126,11 @@ NTSTATUS MinixRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
DeviceExt, DeviceExt,
FsContext, FsContext,
CurrentOffset, CurrentOffset,
&DiskBuffer, &DiskBuffer);
&CacheSeg);
memcpy(Buffer, DiskBuffer, PAGESIZE); memcpy(Buffer, DiskBuffer, PAGESIZE);
CcReleaseCachePage(FsContext->Bcb, ExFreePool(DiskBuffer);
CacheSeg,
TRUE);
CurrentOffset = CurrentOffset + PAGESIZE; CurrentOffset = CurrentOffset + PAGESIZE;
Buffer = Buffer + PAGESIZE; Buffer = Buffer + PAGESIZE;
} }
@ -164,14 +144,11 @@ NTSTATUS MinixRead(PDEVICE_OBJECT DeviceObject, PIRP Irp)
DeviceExt, DeviceExt,
FsContext, FsContext,
CurrentOffset, CurrentOffset,
&DiskBuffer, &DiskBuffer);
&CacheSeg);
memcpy(Buffer, DiskBuffer, (Length%PAGESIZE)); memcpy(Buffer, DiskBuffer, (Length%PAGESIZE));
CcReleaseCachePage(FsContext->Bcb, ExFreePool(DiskBuffer);
CacheSeg,
TRUE);
} }

72
reactos/include/csrss/csrss.h
View file

@ -3,8 +3,46 @@
typedef struct typedef struct
{ {
} CSRSS_CONNECT_PROCESS_REQUEST, PCSRSS_CONNECT_PROCESS_REQUEST;
} CONNECT_INFO, *PCONNECT_INFO;
typedef struct
{
} CSRSS_CONNECT_PROCESS_REPLY, PCSRSS_CONNECT_PROCESS_REPLY;
typedef struct
{
ULONG NewProcessId;
ULONG Flags;
} CSRSS_CREATE_PROCESS_REQUEST, *PCSRSS_CREATE_PROCESS_REQUEST;
typedef struct
{
HANDLE ConsoleHandle;
} CSRSS_CREATE_PROCESS_REPLY, *PCSRSS_CREATE_PROCESS_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
ULONG NrCharactersToWrite;
BYTE Buffer[1];
} CSRSS_WRITE_CONSOLE_REQUEST, *PCSRSS_WRITE_CONSOLE_REQUEST;
typedef struct
{
ULONG NrCharactersWritten;
} CSRSS_WRITE_CONSOLE_REPLY, *PCSRSS_WRITE_CONSOLE_REPLY;
typedef struct
{
HANDLE ConsoleHandle;
ULONG NrCharactersToRead;
} CSRSS_READ_CONSOLE_REQUEST, *PCSRSS_READ_CONSOLE_REQUEST;
typedef struct
{
ULONG NrCharactersRead;
BYTE Buffer[1];
} CSRSS_READ_CONSOLE_REPLY, *PCSRSS_READ_CONSOLE_REPLY;
#define CSRSS_CREATE_PROCESS (0x1) #define CSRSS_CREATE_PROCESS (0x1)
#define CSRSS_TERMINATE_PROCESS (0x2) #define CSRSS_TERMINATE_PROCESS (0x2)
@ -17,27 +55,25 @@ typedef struct
typedef struct typedef struct
{ {
ULONG Type; ULONG Type;
BYTE Data[0x12C]; union
{
CSRSS_CREATE_PROCESS_REQUEST CreateProcessRequest;
CSRSS_CONNECT_PROCESS_REQUEST ConnectRequest;
CSRSS_WRITE_CONSOLE_REQUEST WriteConsoleRequest;
CSRSS_READ_CONSOLE_REQUEST ReadConsoleRequest;
} Data;
} CSRSS_API_REQUEST, *PCSRSS_API_REQUEST; } CSRSS_API_REQUEST, *PCSRSS_API_REQUEST;
typedef struct typedef struct
{ {
NTSTATUS Status; NTSTATUS Status;
ULONG Count; union
HANDLE Handle; {
CSRSS_CREATE_PROCESS_REPLY CreateProcessReply;
CSRSS_CONNECT_PROCESS_REPLY ConnectReply;
CSRSS_WRITE_CONSOLE_REPLY WriteConsoleReply;
CSRSS_READ_CONSOLE_REPLY ReadConsoleReply;
} Data;
} CSRSS_API_REPLY, *PCSRSS_API_REPLY; } CSRSS_API_REPLY, *PCSRSS_API_REPLY;
typedef struct
{
ULONG NewProcessId;
ULONG Flags;
} CSRSS_CREATE_PROCESS_REQUEST, *PCSRSS_CREATE_PROCESS_REQUEST;
BOOL
STDCALL
CsrServerInitialization (
ULONG ArgumentCount,
PWSTR *ArgumentArray
);
#endif /* __INCLUDE_CSRSS_CSRSS_H */ #endif /* __INCLUDE_CSRSS_CSRSS_H */

6
reactos/include/ddk/zw.h
View file

@ -1,5 +1,5 @@
/* $Id: zw.h,v 1.25 2000/01/05 21:56:58 dwelch Exp $ /* $Id: zw.h,v 1.26 2000/03/22 18:35:45 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -1139,10 +1139,12 @@ ZwCreateToken(
* FUNCTION: Returns the callers thread TEB. * FUNCTION: Returns the callers thread TEB.
* RETURNS: The resulting teb. * RETURNS: The resulting teb.
*/ */
NT_TEB * #if 0
NT_TEB *
STDCALL STDCALL
NtCurrentTeb(VOID NtCurrentTeb(VOID
); );
#endif
/* /*
* FUNCTION: Delays the execution of the calling thread. * FUNCTION: Delays the execution of the calling thread.

3
reactos/include/ddk/zwtypes.h
View file

@ -92,7 +92,8 @@ typedef struct _LPCMESSAGE
#define ProcessWx86Information 19 #define ProcessWx86Information 19
#define ProcessHandleCount 20 #define ProcessHandleCount 20
#define ProcessAffinityMask 21 #define ProcessAffinityMask 21
#define MaxProcessInfoClass 22 #define ProcessImageFileName 22
#define MaxProcessInfoClass 23
// thread query / set information class // thread query / set information class
#define ThreadBasicInformation 0 #define ThreadBasicInformation 0

17
reactos/include/internal/teb.h
View file

@ -215,6 +215,21 @@ typedef struct _NT_TEB
#define PEB_STARTUPINFO (0xb0003000) #define PEB_STARTUPINFO (0xb0003000)
#define NtCurrentPeb() ((PPEB)PEB_BASE) //#define NtCurrentPeb() ((PPEB)PEB_BASE)
#define NtCurrentPeb() (NtCurrentTeb()->Peb)
static inline PNT_TEB NtCurrentTeb(VOID)
{
int x;
__asm__ __volatile__("movl %%fs:0x18, %0\n\t"
: "=g" (x)
: /* no inputs */
);
return((PNT_TEB)x);
}
#endif /* __INCLUDE_INTERNAL_TEB */ #endif /* __INCLUDE_INTERNAL_TEB */

29
reactos/include/ntdll/csr.h
View file

@ -1,32 +1,17 @@
/* $Id: csr.h,v 1.1 2000/02/27 02:01:24 ekohl Exp $ /* $Id: csr.h,v 1.2 2000/03/22 18:35:47 dwelch Exp $
* *
*/ */
#ifndef __INCLUDE_NTDLL_CSR_H #ifndef __INCLUDE_NTDLL_CSR_H
#define __INCLUDE_NTDLL_CSR_H #define __INCLUDE_NTDLL_CSR_H
#include <csrss/csrss.h>
/* NTSTATUS STDCALL CsrClientConnectToServer(VOID);
NTSTATUS NTSTATUS STDCALL CsrClientCallServer(PCSRSS_API_REQUEST Request,
STDCALL PCSRSS_API_REPLY Reply,
CsrClientCallServer ( ULONG Length,
ULONG Unknown1, ULONG ReplyLength);
ULONG Unknown2,
ULONG Unknown3,
ULONG Unknown4
);
*/
NTSTATUS
STDCALL
CsrClientConnectToServer (
ULONG Unknown1,
ULONG Unknown2,
ULONG Unknown3,
ULONG Unknown4,
ULONG Unknown5,
ULONG Unknown6
);
#endif /* __INCLUDE_NTDLL_CSR_H */ #endif /* __INCLUDE_NTDLL_CSR_H */

11
reactos/include/structs.h
View file

@ -35,11 +35,6 @@
typedef union _LARGE_INTEGER typedef union _LARGE_INTEGER
{ {
struct
{
DWORD LowPart;
LONG HighPart;
};
struct struct
{ {
DWORD LowPart; DWORD LowPart;
@ -50,11 +45,6 @@ typedef union _LARGE_INTEGER
typedef union _ULARGE_INTEGER typedef union _ULARGE_INTEGER
{ {
struct
{
DWORD LowPart;
DWORD HighPart;
};
struct struct
{ {
DWORD LowPart; DWORD LowPart;
@ -4557,6 +4547,7 @@ typedef struct
/* PE executable header. */ /* PE executable header. */
/* Windows.h now includes pe.h to avoid conflicts! */ /* Windows.h now includes pe.h to avoid conflicts! */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif /* __cplusplus */ #endif /* __cplusplus */

7
reactos/install-system.sh
View file

@ -8,6 +8,7 @@ cp services/fs/vfat/vfatfs.sys $1
cp services/dd/ide/ide.sys $1 cp services/dd/ide/ide.sys $1
cp services/dd/keyboard/keyboard.sys $1/reactos/system32/drivers cp services/dd/keyboard/keyboard.sys $1/reactos/system32/drivers
cp services/dd/blue/blue.sys $1/reactos/system32/drivers cp services/dd/blue/blue.sys $1/reactos/system32/drivers
cp services/dd/vga/miniport/vgamp.sys $1/reactos/system32/drivers #cp services/dd/vga/miniport/vgamp.sys $1/reactos/system32/drivers
cp services/dd/vga/display/vgaddi.dll $1/reactos/system32/drivers #cp services/dd/vga/display/vgaddi.dll $1/reactos/system32/drivers
cp services/dd/vidport/vidport.sys $1/reactos/system32/drivers #cp services/dd/vidport/vidport.sys $1/reactos/system32/drivers
cp services/fs/minix/minixfs.sys $1/reactos/system32/drivers

1
reactos/install.sh
View file

@ -24,3 +24,4 @@ cp apps/lpc/lpcclt.exe $1/reactos/bin
cp apps/thread/thread.exe $1/reactos/bin cp apps/thread/thread.exe $1/reactos/bin
cp apps/event/event.exe $1/reactos/bin cp apps/event/event.exe $1/reactos/bin
cp apps/file/file.exe $1/reactos/bin cp apps/file/file.exe $1/reactos/bin
cp apps/pteb/pteb.exe $1/reactos/bin

11
reactos/lib/kernel32/file/rw.c
View file

@ -1,4 +1,4 @@
/* $Id: rw.c,v 1.8 2000/01/11 17:30:16 ekohl Exp $ /* $Id: rw.c,v 1.9 2000/03/22 18:35:47 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -34,6 +34,15 @@ WINBOOL STDCALL WriteFile(HANDLE hFile,
IO_STATUS_BLOCK IIosb; IO_STATUS_BLOCK IIosb;
PIO_STATUS_BLOCK IoStatusBlock; PIO_STATUS_BLOCK IoStatusBlock;
PLARGE_INTEGER ptrOffset; PLARGE_INTEGER ptrOffset;
if (IsConsoleHandle(hFile))
{
return(WriteConsoleA(hFile,
lpBuffer,
nNumberOfBytesToWrite,
lpNumberOfBytesWritten,
NULL));
}
DPRINT("WriteFile(hFile %x)\n",hFile); DPRINT("WriteFile(hFile %x)\n",hFile);

162
reactos/lib/kernel32/misc/console.c
View file

@ -18,6 +18,9 @@
#include <assert.h> #include <assert.h>
#include <wchar.h> #include <wchar.h>
#include <csrss/csrss.h>
#include <ntdll/csr.h>
#define NDEBUG #define NDEBUG
#include <kernel32/kernel32.h> #include <kernel32/kernel32.h>
@ -96,117 +99,118 @@ WINBASEAPI BOOL WINAPI SetStdHandle(DWORD nStdHandle,
/*-------------------------------------------------------------- /*--------------------------------------------------------------
* WriteConsoleA * WriteConsoleA
*/ */
WINBOOL WINBOOL STDCALL WriteConsoleA(HANDLE hConsoleOutput,
STDCALL CONST VOID *lpBuffer,
WriteConsoleA( DWORD nNumberOfCharsToWrite,
HANDLE hConsoleOutput, LPDWORD lpNumberOfCharsWritten,
CONST VOID *lpBuffer, LPVOID lpReserved)
DWORD nNumberOfCharsToWrite,
LPDWORD lpNumberOfCharsWritten,
LPVOID lpReserved
)
{ {
return WriteFile(hConsoleOutput, lpBuffer, nNumberOfCharsToWrite,lpNumberOfCharsWritten, lpReserved); PCSRSS_API_REQUEST Request;
CSRSS_API_REPLY Reply;
NTSTATUS Status;
Request = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(CSRSS_API_REQUEST) + nNumberOfCharsToWrite);
if (Request == NULL)
{
return(FALSE);
}
Request->Type = CSRSS_WRITE_CONSOLE;
Request->Data.WriteConsoleRequest.ConsoleHandle = hConsoleOutput;
Request->Data.WriteConsoleRequest.NrCharactersToWrite =
nNumberOfCharsToWrite;
// DbgPrint("nNumberOfCharsToWrite %d\n", nNumberOfCharsToWrite);
// DbgPrint("Buffer %s\n", Request->Data.WriteConsoleRequest.Buffer);
memcpy(Request->Data.WriteConsoleRequest.Buffer,
lpBuffer,
nNumberOfCharsToWrite);
Status = CsrClientCallServer(Request,
&Reply,
sizeof(CSRSS_API_REQUEST) +
nNumberOfCharsToWrite,
sizeof(CSRSS_API_REPLY));
if (!NT_SUCCESS(Status))
{
return(FALSE);
}
if (lpNumberOfCharsWritten != NULL)
{
*lpNumberOfCharsWritten =
Reply.Data.WriteConsoleReply.NrCharactersWritten;
}
return(TRUE);
} }
/*-------------------------------------------------------------- /*--------------------------------------------------------------
* ReadConsoleA * ReadConsoleA
*/ */
WINBOOL WINBOOL STDCALL ReadConsoleA(HANDLE hConsoleInput,
STDCALL
ReadConsoleA(HANDLE hConsoleInput,
LPVOID lpBuffer, LPVOID lpBuffer,
DWORD nNumberOfCharsToRead, DWORD nNumberOfCharsToRead,
LPDWORD lpNumberOfCharsRead, LPDWORD lpNumberOfCharsRead,
LPVOID lpReserved) LPVOID lpReserved)
{ {
KEY_EVENT_RECORD KeyEventRecord; CSRSS_API_REQUEST Request;
BOOL stat = TRUE; PCSRSS_API_REPLY Reply;
PCHAR Buffer = (PCHAR)lpBuffer; NTSTATUS Status;
DWORD Result;
int i;
for (i=0; (stat && i<nNumberOfCharsToRead);) Reply = HeapAlloc(GetProcessHeap(),
HEAP_ZERO_MEMORY,
sizeof(CSRSS_API_REPLY) + nNumberOfCharsToRead);
if (Reply == NULL)
{ {
stat = ReadFile(hConsoleInput, return(FALSE);
&KeyEventRecord,
sizeof(KEY_EVENT_RECORD),
&Result,
NULL);
if (stat && KeyEventRecord.bKeyDown && KeyEventRecord.uChar.AsciiChar != 0)
{
Buffer[i] = KeyEventRecord.uChar.AsciiChar;
i++;
}
} }
Request.Type = CSRSS_READ_CONSOLE;
Request.Data.ReadConsoleRequest.ConsoleHandle = hConsoleInput;
Request.Data.ReadConsoleRequest.NrCharactersToRead =
nNumberOfCharsToRead;
Status = CsrClientCallServer(&Request,
Reply,
sizeof(CSRSS_API_REQUEST),
sizeof(CSRSS_API_REPLY) +
nNumberOfCharsToRead);
if (!NT_SUCCESS(Status) || !NT_SUCCESS(Reply->Status))
{
return(FALSE);
}
if (lpNumberOfCharsRead != NULL) if (lpNumberOfCharsRead != NULL)
{ {
*lpNumberOfCharsRead = i; *lpNumberOfCharsRead =
Reply->Data.ReadConsoleReply.NrCharactersRead;
} }
return(stat); memcpy(lpBuffer,
Reply->Data.ReadConsoleReply.Buffer,
Reply->Data.ReadConsoleReply.NrCharactersRead);
return(TRUE);
} }
/*-------------------------------------------------------------- /*--------------------------------------------------------------
* AllocConsole * AllocConsole
*/ */
WINBOOL WINBOOL STDCALL AllocConsole(VOID)
STDCALL
AllocConsole( VOID )
{ {
/* FIXME: add CreateFile error checking */ DbgPrint("AllocConsole() is unimplemented\n");
StdInput = CreateFile("\\\\.\\Keyboard",
FILE_GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
StdOutput = CreateFile("\\\\.\\BlueScreen",
FILE_GENERIC_WRITE|FILE_GENERIC_READ,
0,
NULL,
OPEN_EXISTING,
0,
NULL);
StdError = StdOutput;
return TRUE;
} }
/*-------------------------------------------------------------- /*--------------------------------------------------------------
* FreeConsole * FreeConsole
*/ */
WINBOOL WINBOOL STDCALL FreeConsole(VOID)
STDCALL
FreeConsole( VOID )
{ {
if (StdInput == INVALID_HANDLE_VALUE) DbgPrint("FreeConsole() is unimplemented");
{
SetLastError(0); /* FIXME: What error code? */
return FALSE;
}
SetLastError(ERROR_SUCCESS);
CloseHandle(StdInput);
if (StdError != INVALID_HANDLE_VALUE)
{
if (StdError != StdOutput)
CloseHandle(StdError);
StdError = INVALID_HANDLE_VALUE;
}
CloseHandle(StdOutput);
#ifdef EXTENDED_CONSOLE
CloseHandle(StdAux);
CloseHandle(StdPrint);
#endif
return TRUE; /* FIXME: error check needed? */
} }

16
reactos/lib/kernel32/misc/dllmain.c
View file

@ -1,4 +1,4 @@
/* $Id: dllmain.c,v 1.10 2000/02/27 02:04:06 ekohl Exp $ /* $Id: dllmain.c,v 1.11 2000/03/22 18:35:47 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -41,18 +41,6 @@ WINBOOL STDCALL DllMain(HANDLE hInst,
{ {
NTSTATUS Status; NTSTATUS Status;
DPRINT("DLL_PROCESS_ATTACH\n"); DPRINT("DLL_PROCESS_ATTACH\n");
/*
*
*/
Status = CsrClientConnectToServer(0,0,0,0,0,0);
if (!NT_SUCCESS(Status))
{
DbgPrint("Failed to connect to csrss.exe: expect trouble\n");
/* return FALSE; */
}
AllocConsole();
break; break;
} }
case DLL_PROCESS_DETACH: case DLL_PROCESS_DETACH:
@ -67,4 +55,4 @@ WINBOOL STDCALL DllMain(HANDLE hInst,
return TRUE; return TRUE;
} }
/* EOF */ /* EOF */

11
reactos/lib/kernel32/misc/stubs.c
View file

@ -1,4 +1,4 @@
/* $Id: stubs.c,v 1.12 2000/02/14 22:10:46 ea Exp $ /* $Id: stubs.c,v 1.13 2000/03/22 18:35:47 dwelch Exp $
* *
* KERNEL32.DLL stubs (unimplemented functions) * KERNEL32.DLL stubs (unimplemented functions)
* Remove from this file, if you implement them. * Remove from this file, if you implement them.
@ -3714,15 +3714,6 @@ ShowConsoleCursor (
LPVOID
STDCALL
TlsGetValue (
DWORD dwTlsIndex
)
{
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL;
}
WINBOOL WINBOOL

80
reactos/lib/kernel32/process/create.c
View file

@ -1,4 +1,4 @@
/* $Id: create.c,v 1.24 2000/03/18 19:55:53 ekohl Exp $ /* $Id: create.c,v 1.25 2000/03/22 18:35:48 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -22,6 +22,8 @@
#include <internal/teb.h> #include <internal/teb.h>
#include <ntdll/base.h> #include <ntdll/base.h>
#include <ntdll/rtl.h> #include <ntdll/rtl.h>
#include <csrss/csrss.h>
#include <ntdll/csr.h>
#define NDEBUG #define NDEBUG
#include <kernel32/kernel32.h> #include <kernel32/kernel32.h>
@ -383,10 +385,43 @@ WINBOOL STDCALL CreateProcessW(LPCWSTR lpApplicationName,
ULONG retlen; ULONG retlen;
PRTL_USER_PROCESS_PARAMETERS Ppb; PRTL_USER_PROCESS_PARAMETERS Ppb;
UNICODE_STRING CommandLine_U; UNICODE_STRING CommandLine_U;
CSRSS_API_REQUEST CsrRequest;
CSRSS_API_REPLY CsrReply;
HANDLE ConsoleHandle;
CHAR ImageFileName[8];
PWCHAR s;
PWCHAR e;
ULONG i;
DPRINT("CreateProcessW(lpApplicationName '%S', lpCommandLine '%S')\n", DPRINT("CreateProcessW(lpApplicationName '%S', lpCommandLine '%S')\n",
lpApplicationName,lpCommandLine); lpApplicationName,lpCommandLine);
/*
* Store the image file name for the process
*/
s = wcsrchr(lpApplicationName, '\\');
if (s == NULL)
{
s = lpApplicationName;
}
else
{
s++;
}
e = wcschr(s, '.');
if (e != NULL)
{
*e = 0;
}
for (i = 0; i < 8; i++)
{
ImageFileName[i] = (CHAR)(s[i]);
}
if (e != NULL)
{
*e = 0;
}
/* /*
* Process the application name and command line * Process the application name and command line
*/ */
@ -434,8 +469,7 @@ WINBOOL STDCALL CreateProcessW(LPCWSTR lpApplicationName,
/* /*
* Create a new process * Create a new process
*/ */
Status = NtCreateProcess(&hProcess, Status = NtCreateProcess(&hProcess,
PROCESS_ALL_ACCESS, PROCESS_ALL_ACCESS,
NULL, NULL,
@ -447,8 +481,7 @@ WINBOOL STDCALL CreateProcessW(LPCWSTR lpApplicationName,
/* /*
* Get some information about the process * Get some information about the process
*/ */
ZwQueryInformationProcess(hProcess, ZwQueryInformationProcess(hProcess,
ProcessBasicInformation, ProcessBasicInformation,
&ProcessBasicInfo, &ProcessBasicInfo,
@ -457,21 +490,50 @@ WINBOOL STDCALL CreateProcessW(LPCWSTR lpApplicationName,
DPRINT("ProcessBasicInfo.UniqueProcessId %d\n", DPRINT("ProcessBasicInfo.UniqueProcessId %d\n",
ProcessBasicInfo.UniqueProcessId); ProcessBasicInfo.UniqueProcessId);
lpProcessInformation->dwProcessId = ProcessBasicInfo.UniqueProcessId; lpProcessInformation->dwProcessId = ProcessBasicInfo.UniqueProcessId;
/*
* Tell the csrss server we are creating a new process
*/
CsrRequest.Type = CSRSS_CREATE_PROCESS;
CsrRequest.Data.CreateProcessRequest.NewProcessId =
ProcessBasicInfo.UniqueProcessId;
CsrRequest.Data.CreateProcessRequest.Flags = 0;
Status = CsrClientCallServer(&CsrRequest,
&CsrReply,
sizeof(CSRSS_API_REQUEST),
sizeof(CSRSS_API_REPLY));
if (!NT_SUCCESS(Status) || !NT_SUCCESS(CsrReply.Status))
{
DbgPrint("Failed to tell csrss about new process. Expect trouble.\n");
}
ConsoleHandle = CsrReply.Data.CreateProcessReply.ConsoleHandle;
// DbgPrint("ConsoleHandle %x\n", ConsoleHandle);
/* /*
* Create Process Environment Block * Create Process Environment Block
*/ */
DPRINT("Creating peb\n"); DPRINT("Creating peb\n");
Ppb->ConsoleHandle = ConsoleHandle;
KlInitPeb(hProcess, Ppb); KlInitPeb(hProcess, Ppb);
RtlDestroyProcessParameters (Ppb); RtlDestroyProcessParameters (Ppb);
Status = NtSetInformationProcess(hProcess,
ProcessImageFileName,
ImageFileName,
8);
DPRINT("Creating thread for process\n"); DPRINT("Creating thread for process\n");
lpStartAddress = (LPTHREAD_START_ROUTINE) lpStartAddress = (LPTHREAD_START_ROUTINE)
((PIMAGE_OPTIONAL_HEADER)OPTHDROFFSET(NTDLL_BASE))-> ((PIMAGE_OPTIONAL_HEADER)OPTHDROFFSET(NTDLL_BASE))->
AddressOfEntryPoint + AddressOfEntryPoint +
((PIMAGE_OPTIONAL_HEADER)OPTHDROFFSET(NTDLL_BASE))->ImageBase; ((PIMAGE_OPTIONAL_HEADER)OPTHDROFFSET(NTDLL_BASE))->ImageBase;
/*
* Create the thread for the kernel
*/
hThread = KlCreateFirstThread(hProcess, hThread = KlCreateFirstThread(hProcess,
lpThreadAttributes, lpThreadAttributes,
// Headers.OptionalHeader.SizeOfStackReserve, // Headers.OptionalHeader.SizeOfStackReserve,

64
reactos/lib/kernel32/thread/tls.c
View file

@ -15,56 +15,52 @@
#include <windows.h> #include <windows.h>
#include <kernel32/thread.h> #include <kernel32/thread.h>
#include <string.h> #include <string.h>
#include <ntdll/rtl.h>
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
DWORD STDCALL TlsAlloc(VOID) DWORD STDCALL TlsAlloc(VOID)
{ {
#if 0 PULONG TlsBitmap = NtCurrentPeb()->TlsBitmapBits;
DWORD dwTlsIndex = GetTeb()->dwTlsIndex; ULONG i, j;
void **TlsData = GetTeb()->TlsData;
RtlAcquirePebLock();
if (dwTlsIndex < (sizeof(TlsData) / sizeof(TlsData[0])))
{ for (i = 0; i < 2; i++)
TlsData[dwTlsIndex] = NULL; {
return (dwTlsIndex++); for (j = 0; j < 32; j++)
{
if ((TlsBitmap[i] & (1 << j)) == 0)
{
TlsBitmap[i] = TlsBitmap[i] | (1 << j);
RtlReleasePebLock();
return((i * 32) + j);
}
}
} }
RtlReleasePebLock();
return (0xFFFFFFFFUL); return (0xFFFFFFFFUL);
#endif
} }
WINBOOL STDCALL TlsFree(DWORD dwTlsIndex) WINBOOL STDCALL TlsFree(DWORD dwTlsIndex)
{ {
#if 0 PULONG TlsBitmap = NtCurrentPeb()->TlsBitmapBits;
return (TRUE);
#endif RtlAcquirePebLock();
TlsBitmap[dwTlsIndex / 32] =
TlsBitmap[dwTlsIndex / 32] & ~(1 << (dwTlsIndex % 32));
RtlReleasePebLock();
return(TRUE);
} }
LPVOID STDCALL TlsGetVlue(DWORD dwTlsIndex) LPVOID STDCALL TlsGetValue(DWORD dwTlsIndex)
{ {
#if 0 return(NtCurrentTeb()->TlsSlots[dwTlsIndex]);
void **TlsData = GetTeb()->TlsData;
if (dwTlsIndex < (sizeof(TlsData) / sizeof(TlsData[0])))
{
SetLastError(NO_ERROR);
return (TlsData[dwTlsIndex]);
}
SetLastError(1);
return (NULL);
#endif
} }
WINBOOL STDCALL TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue) WINBOOL STDCALL TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue)
{ {
#if 0 NtCurrentTeb()->TlsSlots[dwTlsIndex] = lpTlsValue;
void **TlsData = GetTeb()->TlsData; return(TRUE);
if (dwTlsIndex < (sizeof(TlsData) / sizeof(TlsData[0])))
{
TlsData[dwTlsIndex] = lpTlsValue;
return (TRUE);
}
return (FALSE);
#endif
} }

34
reactos/lib/ntdll/csr/api.c
View file

@ -1,4 +1,4 @@
/* $Id: api.c,v 1.3 2000/02/27 02:05:06 ekohl Exp $ /* $Id: api.c,v 1.4 2000/03/22 18:35:50 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -23,35 +23,30 @@ static HANDLE WindowsApiPort;
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
NTSTATUS NTSTATUS STDCALL CsrClientCallServer(PCSRSS_API_REQUEST Request,
STDCALL PCSRSS_API_REPLY Reply,
CsrClientCallServer(PCSRSS_API_REQUEST Request, ULONG Length,
PCSRSS_API_REPLY Reply, ULONG ReplyLength)
ULONG Unknown3,
ULONG Unknown4)
{ {
LPCMESSAGE LpcRequest; LPCMESSAGE LpcRequest;
LPCMESSAGE LpcReply; LPCMESSAGE LpcReply;
NTSTATUS Status; NTSTATUS Status;
LpcRequest.ActualMessageLength = MAX_MESSAGE_DATA; // DbgPrint("Length %d\n", Length);
LpcRequest.TotalMessageLength = sizeof(LPCMESSAGE);
memcpy(LpcRequest.MessageData, Request, sizeof(CSRSS_API_REQUEST)); LpcRequest.ActualMessageLength = Length;
LpcRequest.TotalMessageLength = sizeof(LPCMESSAGE) + Length;
memcpy(LpcRequest.MessageData, Request, Length);
Status = NtRequestWaitReplyPort(WindowsApiPort, Status = NtRequestWaitReplyPort(WindowsApiPort,
&LpcRequest, &LpcRequest,
&LpcReply); &LpcReply);
memcpy(Reply, LpcReply.MessageData, ReplyLength);
// DbgPrint("Status %x Reply.Status %x\n", Status, Reply->Status);
return(Status); return(Status);
} }
NTSTATUS NTSTATUS STDCALL CsrClientConnectToServer(VOID)
STDCALL
CsrClientConnectToServer(ULONG Unknown1,
ULONG Unknown2,
ULONG Unknown3,
ULONG Unknown4,
ULONG Unknown5,
ULONG Unknown6)
{ {
NTSTATUS Status; NTSTATUS Status;
UNICODE_STRING PortName; UNICODE_STRING PortName;
@ -77,7 +72,8 @@ CsrClientConnectToServer(ULONG Unknown1,
Request.Type = CSRSS_CONNECT_PROCESS; Request.Type = CSRSS_CONNECT_PROCESS;
Status = CsrClientCallServer(&Request, Status = CsrClientCallServer(&Request,
&Reply, &Reply,
0, 0); sizeof(CSRSS_API_REQUEST),
sizeof(CSRSS_API_REPLY));
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return(Status); return(Status);

4
reactos/lib/ntdll/def/ntdll.def
View file

@ -1,4 +1,4 @@
; $Id: ntdll.def,v 1.47 2000/03/18 13:58:33 ekohl Exp $ ; $Id: ntdll.def,v 1.48 2000/03/22 18:35:50 dwelch Exp $
; ;
; ReactOS Operating System ; ReactOS Operating System
; ;
@ -6,7 +6,7 @@ LIBRARY ntdll.dll
EXPORTS EXPORTS
CsrClientCallServer@16 CsrClientCallServer@16
CsrClientConnectToServer@24 ;CsrClientConnectToServer@24
DbgBreakPoint@0 DbgBreakPoint@0
DbgPrint DbgPrint
DbgUserBreakPoint@0 DbgUserBreakPoint@0

4
reactos/lib/ntdll/def/ntdll.edf
View file

@ -1,4 +1,4 @@
; $Id: ntdll.edf,v 1.36 2000/03/18 13:58:33 ekohl Exp $ ; $Id: ntdll.edf,v 1.37 2000/03/22 18:35:51 dwelch Exp $
; ;
; ReactOS Operating System ; ReactOS Operating System
; ;
@ -6,7 +6,7 @@ LIBRARY ntdll.dll
EXPORTS EXPORTS
CsrClientCallServer=CsrClientCallServer@16 CsrClientCallServer=CsrClientCallServer@16
CsrClientConnectToServer=CsrClientConnectToServer@24 ;CsrClientConnectToServer=CsrClientConnectToServer@24
DbgBreakPoint=DbgBreakPoint@0 DbgBreakPoint=DbgBreakPoint@0
DbgPrint DbgPrint
DbgUserBreakPoint=DbgUserBreakPoint@0 DbgUserBreakPoint=DbgUserBreakPoint@0

13
reactos/lib/ntdll/ldr/startup.c
View file

@ -1,4 +1,4 @@
/* $Id: startup.c,v 1.21 2000/03/18 13:57:02 ekohl Exp $ /* $Id: startup.c,v 1.22 2000/03/22 18:35:51 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -16,6 +16,7 @@
#include <ntdll/ldr.h> #include <ntdll/ldr.h>
#include <ntdll/rtl.h> #include <ntdll/rtl.h>
#include <csrss/csrss.h> #include <csrss/csrss.h>
#include <ntdll/csr.h>
#define NDEBUG #define NDEBUG
#include <ntdll/ntdll.h> #include <ntdll/ntdll.h>
@ -97,6 +98,16 @@ VOID LdrStartup(VOID)
ZwTerminateProcess(NtCurrentProcess(),STATUS_UNSUCCESSFUL); ZwTerminateProcess(NtCurrentProcess(),STATUS_UNSUCCESSFUL);
} }
/*
* Connect to the csrss server
*/
Status = CsrClientConnectToServer();
if (!NT_SUCCESS(Status))
{
DbgPrint("Failed to connect to csrss.exe: expect trouble\n");
// ZwTerminateProcess(NtCurrentProcess(), Status);
}
DbgPrint("Transferring control to image at %x\n",EntryPoint); DbgPrint("Transferring control to image at %x\n",EntryPoint);
Status = EntryPoint(Peb); Status = EntryPoint(Peb);
ZwTerminateProcess(NtCurrentProcess(),Status); ZwTerminateProcess(NtCurrentProcess(),Status);

78
reactos/lib/ntdll/rtl/ppb.c
View file

@ -1,4 +1,4 @@
/* $Id: ppb.c,v 1.5 2000/03/18 13:56:01 ekohl Exp $ /* $Id: ppb.c,v 1.6 2000/03/22 18:35:51 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -75,47 +75,47 @@ RtlCreateProcessParameters (
PUNICODE_STRING RuntimeData PUNICODE_STRING RuntimeData
) )
{ {
NTSTATUS Status = STATUS_SUCCESS; NTSTATUS Status = STATUS_SUCCESS;
PRTL_USER_PROCESS_PARAMETERS Param = NULL; PRTL_USER_PROCESS_PARAMETERS Param = NULL;
ULONG RegionSize = 0; ULONG RegionSize = 0;
ULONG Length = 0; ULONG Length = 0;
PWCHAR Dest; PWCHAR Dest;
UNICODE_STRING EmptyString; UNICODE_STRING EmptyString;
HANDLE CurrentDirectoryHandle; HANDLE CurrentDirectoryHandle;
HANDLE ConsoleHandle; HANDLE ConsoleHandle;
ULONG ConsoleFlags; ULONG ConsoleFlags;
DPRINT ("RtlCreateProcessParameters\n"); DPRINT ("RtlCreateProcessParameters\n");
RtlAcquirePebLock ();
RtlAcquirePebLock (); EmptyString.Length = 0;
EmptyString.MaximumLength = sizeof(WCHAR);
EmptyString.Length = 0; EmptyString.Buffer = L"";
EmptyString.MaximumLength = sizeof(WCHAR);
EmptyString.Buffer = L"";
if (NtCurrentPeb()->ProcessParameters)
{
if (DllPath == NULL)
DllPath = &NtCurrentPeb()->ProcessParameters->DllPath;
if (Environment == NULL)
Environment = NtCurrentPeb()->ProcessParameters->Environment;
if (CurrentDirectory == NULL)
CurrentDirectory = &NtCurrentPeb()->ProcessParameters->CurrentDirectory.DosPath;
CurrentDirectoryHandle = NtCurrentPeb()->ProcessParameters->CurrentDirectory.Handle;
ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
ConsoleFlags = NtCurrentPeb()->ProcessParameters->ConsoleFlags;
}
else
{
if (DllPath == NULL)
DllPath = &EmptyString;
if (CurrentDirectory == NULL)
CurrentDirectory = &EmptyString;
CurrentDirectoryHandle = NULL;
ConsoleHandle = NULL;
ConsoleFlags = 0;
}
if (NtCurrentPeb()->ProcessParameters)
{
if (DllPath == NULL)
DllPath = &NtCurrentPeb()->ProcessParameters->DllPath;
if (Environment == NULL)
Environment = NtCurrentPeb()->ProcessParameters->Environment;
if (CurrentDirectory == NULL)
CurrentDirectory = &NtCurrentPeb()->ProcessParameters->CurrentDirectory.DosPath;
CurrentDirectoryHandle = NtCurrentPeb()->ProcessParameters->CurrentDirectory.Handle;
ConsoleHandle = NtCurrentPeb()->ProcessParameters->ConsoleHandle;
ConsoleFlags = NtCurrentPeb()->ProcessParameters->ConsoleFlags;
}
else
{
if (DllPath == NULL)
DllPath = &EmptyString;
if (CurrentDirectory == NULL)
CurrentDirectory = &EmptyString;
CurrentDirectoryHandle = NULL;
ConsoleHandle = NULL;
ConsoleFlags = 0;
}
if (ImagePathName == NULL) if (ImagePathName == NULL)
ImagePathName = CommandLine; ImagePathName = CommandLine;
if (WindowTitle == NULL) if (WindowTitle == NULL)

55
reactos/lib/ntdll/rtl/process.c
View file

@ -1,4 +1,4 @@
/* $Id: process.c,v 1.17 2000/03/18 13:56:01 ekohl Exp $ /* $Id: process.c,v 1.18 2000/03/22 18:35:51 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -97,18 +97,24 @@ HANDLE STDCALL KlCreateFirstThread(HANDLE ProcessHandle,
static NTSTATUS RtlpMapFile( static NTSTATUS RtlpMapFile(
PRTL_USER_PROCESS_PARAMETERS Ppb, PRTL_USER_PROCESS_PARAMETERS Ppb,
//PUNICODE_STRING ApplicationName, //PUNICODE_STRING ApplicationName,
PHANDLE Section) PHANDLE Section,
PCHAR ImageFileName)
{ {
HANDLE hFile; HANDLE hFile;
IO_STATUS_BLOCK IoStatusBlock; IO_STATUS_BLOCK IoStatusBlock;
OBJECT_ATTRIBUTES ObjectAttributes; OBJECT_ATTRIBUTES ObjectAttributes;
PSECURITY_DESCRIPTOR SecurityDescriptor = NULL; PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
NTSTATUS Status; NTSTATUS Status;
PWCHAR s;
PWCHAR e;
ULONG i;
hFile = NULL; hFile = NULL;
RtlDeNormalizeProcessParams (Ppb); RtlDeNormalizeProcessParams (Ppb);
// DbgPrint("ImagePathName %x\n", Ppb->ImagePathName.Buffer);
InitializeObjectAttributes(&ObjectAttributes, InitializeObjectAttributes(&ObjectAttributes,
// ApplicationName, // ApplicationName,
&(Ppb->ImagePathName), &(Ppb->ImagePathName),
@ -117,7 +123,35 @@ PRTL_USER_PROCESS_PARAMETERS Ppb,
SecurityDescriptor); SecurityDescriptor);
RtlNormalizeProcessParams (Ppb); RtlNormalizeProcessParams (Ppb);
/*
*
*/
// DbgPrint("ImagePathName %x\n", Ppb->ImagePathName.Buffer);
// DbgPrint("ImagePathName %S\n", Ppb->ImagePathName.Buffer);
s = wcsrchr(Ppb->ImagePathName.Buffer, '\\');
if (s == NULL)
{
s = Ppb->ImagePathName.Buffer;
}
else
{
s++;
}
e = wcschr(s, '.');
if (e != NULL)
{
*e = 0;
}
for (i = 0; i < 8; i++)
{
ImageFileName[i] = (CHAR)(s[i]);
}
if (e != NULL)
{
*e = '.';
}
/* /*
* Try to open the executable * Try to open the executable
*/ */
@ -269,12 +303,14 @@ RtlCreateUserProcess (
LPTHREAD_START_ROUTINE lpStartAddress = NULL; LPTHREAD_START_ROUTINE lpStartAddress = NULL;
PROCESS_BASIC_INFORMATION ProcessBasicInfo; PROCESS_BASIC_INFORMATION ProcessBasicInfo;
ULONG retlen; ULONG retlen;
CHAR ImageFileName[8];
DPRINT("RtlCreateUserProcess\n"); DPRINT("RtlCreateUserProcess\n");
// Status = RtlpMapFile(CommandLine, // Status = RtlpMapFile(CommandLine,
Status = RtlpMapFile(Ppb, Status = RtlpMapFile(Ppb,
&hSection); &hSection,
ImageFileName);
/* /*
* Create a new process * Create a new process
@ -305,7 +341,12 @@ RtlCreateUserProcess (
DPRINT("ProcessBasicInfo.UniqueProcessId %d\n", DPRINT("ProcessBasicInfo.UniqueProcessId %d\n",
ProcessBasicInfo.UniqueProcessId); ProcessBasicInfo.UniqueProcessId);
ProcessInfo->ClientId.UniqueProcess = (HANDLE)ProcessBasicInfo.UniqueProcessId; ProcessInfo->ClientId.UniqueProcess = (HANDLE)ProcessBasicInfo.UniqueProcessId;
Status = NtSetInformationProcess(ProcessInfo->ProcessHandle,
ProcessImageFileName,
ImageFileName,
8);
/* /*
* Create Process Environment Block * Create Process Environment Block
*/ */

1
reactos/lib/ntdll/stubs/stubs.c
View file

@ -18,7 +18,6 @@ STUB(CsrAllocateMessagePointer)
STUB(CsrCaptureMessageBuffer) STUB(CsrCaptureMessageBuffer)
STUB(CsrCaptureMessageString) STUB(CsrCaptureMessageString)
STUB(CsrCaptureTimeout) STUB(CsrCaptureTimeout)
STUB(CsrClientConnectToServer)
STUB(CsrFreeCaptureBuffer) STUB(CsrFreeCaptureBuffer)
STUB(CsrIdentifyAlertableThread) STUB(CsrIdentifyAlertableThread)
STUB(CsrNewThread) STUB(CsrNewThread)

341
reactos/ntoskrnl/hal/x86/thread.c
View file

@ -1,341 +0,0 @@
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/hal/x86/thread.c
* PURPOSE: HAL multitasking functions
* PROGRAMMER: David Welch (welch@cwcom.net)
* REVISION HISTORY:
* 27/06/98: Created
*/
/* INCLUDES ****************************************************************/
#include <ddk/ntddk.h>
#include <internal/ntoskrnl.h>
#include <internal/ps.h>
#include <string.h>
#include <internal/string.h>
#include <internal/hal.h>
#include <internal/i386/segment.h>
#include <internal/mmhal.h>
#include <internal/ke.h>
#define NDEBUG
#include <internal/debug.h>
/* GLOBALS ***************************************************************/
#define NR_TASKS 128
#define FIRST_TSS_SELECTOR (KERNEL_DS + 0x8)
#define FIRST_TSS_OFFSET (FIRST_TSS_SELECTOR / 8)
static char KiNullLdt[8] = {0,};
static unsigned int KiNullLdtSel = 0;
static PETHREAD FirstThread = NULL;
/* FUNCTIONS **************************************************************/
VOID HalTaskSwitch(PKTHREAD thread)
/*
* FUNCTION: Switch tasks
* ARGUMENTS:
* thread = Thread to switch to
* NOTE: This function will not return until the current thread is scheduled
* again (possibly never);
*/
{
DPRINT("Scheduling thread %x\n",thread);
DPRINT("Scheduling thread %x\n",thread->Context.nr);
DPRINT("previous task %x reserved1 %x esp0 %x ss0 %x\n",
thread->Context.previous_task,thread->Context.reserved1,
thread->Context.esp0,thread->Context.ss0);
DPRINT("reserved2 %x esp1 %x ss1 %x reserved3 %x esp2 %x ss2 %x\n",
thread->Context.reserved2,thread->Context.esp1,thread->Context.ss1,
thread->Context.reserved3,thread->Context.esp2,thread->Context.ss2);
DPRINT("reserved4 %x cr3 %x eip %x eflags %x eax %x\n",
thread->Context.reserved4,thread->Context.cr3,thread->Context.eip,
thread->Context.eflags,thread->Context.eax);
DPRINT("ecx %x edx %x ebx %x esp %x ebp %x esi %x\n",
thread->Context.ecx,thread->Context.edx,thread->Context.ebx,
thread->Context.esp,thread->Context.ebp,thread->Context.esi);
DPRINT("edi %x es %x reserved5 %x cs %x reserved6 %x\n",
thread->Context.edi,thread->Context.es,thread->Context.reserved5,
thread->Context.cs,thread->Context.reserved6);
DPRINT("ss %x reserved7 %x ds %x reserved8 %x fs %x\n",
thread->Context.ss,thread->Context.reserved7,thread->Context.ds,
thread->Context.reserved8,thread->Context.fs);
DPRINT("reserved9 %x gs %x reserved10 %x ldt %x reserved11 %x\n",
thread->Context.reserved9,thread->Context.gs,
thread->Context.reserved10,thread->Context.ldt,
thread->Context.reserved11);
DPRINT("trap %x iomap_base %x nr %x io_bitmap[0] %x\n",
thread->Context.trap,thread->Context.iomap_base,
thread->Context.nr,thread->Context.io_bitmap[0]);
DPRINT("thread->Context.cr3 %x\n",thread->Context.cr3);
__asm__("pushfl\n\t"
"cli\n\t"
"ljmp %0\n\t"
"popfl\n\t"
: /* No outputs */
: "m" (*(((unsigned char *)(&(thread->Context.nr)))-4) )
: "ax","dx");
}
#define FLAG_NT (1<<14)
#define FLAG_VM (1<<17)
#define FLAG_IF (1<<9)
#define FLAG_IOPL ((1<<12)+(1<<13))
NTSTATUS KeValidateUserContext(PCONTEXT Context)
/*
* FUNCTION: Validates a processor context
* ARGUMENTS:
* Context = Context to validate
* RETURNS: Status
* NOTE: This only validates the context as not violating system security, it
* doesn't guararantee the thread won't crash at some point
* NOTE2: This relies on there only being two selectors which can access
* system space
*/
{
if (Context->Eip >= KERNEL_BASE)
{
return(STATUS_UNSUCCESSFUL);
}
if (Context->SegCs == KERNEL_CS)
{
return(STATUS_UNSUCCESSFUL);
}
if (Context->SegDs == KERNEL_DS)
{
return(STATUS_UNSUCCESSFUL);
}
if (Context->SegEs == KERNEL_DS)
{
return(STATUS_UNSUCCESSFUL);
}
if (Context->SegFs == KERNEL_DS)
{
return(STATUS_UNSUCCESSFUL);
}
if (Context->SegGs == KERNEL_DS)
{
return(STATUS_UNSUCCESSFUL);
}
if ((Context->EFlags & FLAG_IOPL) != 0 ||
(Context->EFlags & FLAG_NT) ||
(Context->EFlags & FLAG_VM) ||
(!(Context->EFlags & FLAG_IF)))
{
return(STATUS_UNSUCCESSFUL);
}
return(STATUS_SUCCESS);
}
NTSTATUS HalReleaseTask(PETHREAD Thread)
/*
* FUNCTION: Releases the resource allocated for a thread by
* HalInitTaskWithContext or HalInitTask
* NOTE: The thread had better not be running when this is called
*/
{
KeFreeGdtSelector(Thread->Tcb.Context.nr);
ExFreePool(Thread->Tcb.Context.KernelStackBase);
if (Thread->Tcb.Context.SavedKernelStackBase != NULL)
{
ExFreePool(Thread->Tcb.Context.SavedKernelStackBase);
}
return(STATUS_SUCCESS);
}
NTSTATUS HalInitTaskWithContext(PETHREAD Thread, PCONTEXT Context)
/*
* FUNCTION: Initialize a task with a user mode context
* ARGUMENTS:
* Thread = Thread to initialize
* Context = Processor context to initialize it with
* RETURNS: Status
*/
{
unsigned int desc;
unsigned int length;
unsigned int base;
PVOID kernel_stack;
NTSTATUS Status;
PVOID stack_start;
ULONG GdtDesc[2];
DPRINT("HalInitTaskWithContext(Thread %x, Context %x)\n",
Thread,Context);
assert(sizeof(hal_thread_state)>=0x68);
if ((Status=KeValidateUserContext(Context))!=STATUS_SUCCESS)
{
return(Status);
}
length = sizeof(hal_thread_state) - 1;
base = (unsigned int)(&(Thread->Tcb.Context));
// kernel_stack = ExAllocatePool(NonPagedPool,PAGESIZE);
kernel_stack = ExAllocatePool(NonPagedPool, 3*PAGESIZE);
/*
* Setup a TSS descriptor
*/
GdtDesc[0] = (length & 0xffff) | ((base & 0xffff) << 16);
GdtDesc[1] = ((base & 0xff0000)>>16) | 0x8900 | (length & 0xf0000)
| (base & 0xff000000);
desc = KeAllocateGdtSelector(GdtDesc);
if (desc == 0)
{
return(STATUS_UNSUCCESSFUL);
}
stack_start = kernel_stack + 4096 - sizeof(CONTEXT);
memcpy(stack_start, Context, sizeof(CONTEXT));
/*
* Initialize the thread context
*/
memset(&Thread->Tcb.Context,0,sizeof(hal_thread_state));
Thread->Tcb.Context.ldt = KiNullLdtSel;
Thread->Tcb.Context.eflags = (1<<1) + (1<<9);
Thread->Tcb.Context.iomap_base = FIELD_OFFSET(hal_thread_state,io_bitmap);
Thread->Tcb.Context.esp0 = (ULONG)stack_start;
Thread->Tcb.Context.ss0 = KERNEL_DS;
Thread->Tcb.Context.esp = (ULONG)stack_start;
Thread->Tcb.Context.ss = KERNEL_DS;
Thread->Tcb.Context.cs = KERNEL_CS;
Thread->Tcb.Context.eip = (ULONG)PsBeginThreadWithContextInternal;
Thread->Tcb.Context.io_bitmap[0] = 0xff;
Thread->Tcb.Context.cr3 = (ULONG)
Thread->ThreadsProcess->Pcb.PageTableDirectory;
Thread->Tcb.Context.ds = KERNEL_DS;
Thread->Tcb.Context.es = KERNEL_DS;
Thread->Tcb.Context.fs = KERNEL_DS;
Thread->Tcb.Context.gs = KERNEL_DS;
Thread->Tcb.Context.nr = desc * 8;
Thread->Tcb.Context.KernelStackBase = kernel_stack;
Thread->Tcb.Context.SavedKernelEsp = 0;
Thread->Tcb.Context.SavedKernelStackBase = NULL;
return(STATUS_SUCCESS);
}
NTSTATUS HalInitTask(PETHREAD thread, PKSTART_ROUTINE fn, PVOID StartContext)
/*
* FUNCTION: Initializes the HAL portion of a thread object
* ARGUMENTS:
* thread = Object describes the thread
* fn = Entrypoint for the thread
* StartContext = parameter to pass to the thread entrypoint
* RETURNS: True if the function succeeded
*/
{
unsigned int desc;
unsigned int length = sizeof(hal_thread_state) - 1;
unsigned int base = (unsigned int)(&(thread->Tcb.Context));
// PULONG KernelStack = ExAllocatePool(NonPagedPool,4096);
PULONG KernelStack;
ULONG GdtDesc[2];
DPRINT("HalInitTask(Thread %x, fn %x, StartContext %x)\n",
thread,fn,StartContext);
DPRINT("thread->ThreadsProcess %x\n",thread->ThreadsProcess);
KernelStack = ExAllocatePool(NonPagedPool, 3*PAGESIZE);
/*
* Make sure
*/
assert(sizeof(hal_thread_state)>=0x68);
/*
* Setup a TSS descriptor
*/
GdtDesc[0] = (length & 0xffff) | ((base & 0xffff) << 16);
GdtDesc[1] = ((base & 0xff0000)>>16) | 0x8900 | (length & 0xf0000)
| (base & 0xff000000);
desc = KeAllocateGdtSelector(GdtDesc);
if (desc == 0)
{
return(STATUS_UNSUCCESSFUL);
}
// DPRINT("sizeof(descriptor) %d\n",sizeof(descriptor));
// DPRINT("desc %d\n",desc);
/*
* Initialize the stack for the thread (including the two arguments to
* the general start routine).
*/
KernelStack[1023] = (unsigned int)StartContext;
KernelStack[1022] = (unsigned int)fn;
KernelStack[1021] = 0;
/*
* Initialize the thread context
*/
memset(&thread->Tcb.Context,0,sizeof(hal_thread_state));
thread->Tcb.Context.ldt = KiNullLdtSel;
thread->Tcb.Context.eflags = (1<<1)+(1<<9);
thread->Tcb.Context.iomap_base = FIELD_OFFSET(hal_thread_state,io_bitmap);
thread->Tcb.Context.esp0 = (ULONG)&KernelStack[1021];
thread->Tcb.Context.ss0 = KERNEL_DS;
thread->Tcb.Context.esp = (ULONG)&KernelStack[1021];
thread->Tcb.Context.ss = KERNEL_DS;
thread->Tcb.Context.cs = KERNEL_CS;
thread->Tcb.Context.eip = (ULONG)PsBeginThread;
thread->Tcb.Context.io_bitmap[0] = 0xff;
thread->Tcb.Context.cr3 = (ULONG)
thread->ThreadsProcess->Pcb.PageTableDirectory;
thread->Tcb.Context.ds = KERNEL_DS;
thread->Tcb.Context.es = KERNEL_DS;
thread->Tcb.Context.fs = KERNEL_DS;
thread->Tcb.Context.gs = KERNEL_DS;
thread->Tcb.Context.nr = desc * 8;
thread->Tcb.Context.KernelStackBase = KernelStack;
thread->Tcb.Context.SavedKernelEsp = 0;
thread->Tcb.Context.SavedKernelStackBase = NULL;
DPRINT("Allocated %x\n",desc*8);
return(STATUS_SUCCESS);
}
void HalInitFirstTask(PETHREAD thread)
/*
* FUNCTION: Called to setup the HAL portion of a thread object for the
* initial thread
*/
{
ULONG base;
ULONG length;
ULONG desc;
ULONG GdtDesc[2];
memset(KiNullLdt, 0, sizeof(KiNullLdt));
base = (unsigned int)&KiNullLdt;
length = sizeof(KiNullLdt) - 1;
GdtDesc[0] = (length & 0xffff) | ((base & 0xffff) << 16);
GdtDesc[1] = ((base & 0xff0000)>>16) | 0x8200 | (length & 0xf0000)
| (base & 0xff000000);
desc = KeAllocateGdtSelector(GdtDesc);
KiNullLdtSel = desc*8;
/*
* Initialize the thread context
*/
HalInitTask(thread,NULL,NULL);
/*
* Load the task register
*/
__asm__("ltr %%ax"
: /* no output */
: "a" (thread->Tcb.Context.nr));
FirstThread = thread;
}

49
reactos/ntoskrnl/ke/i386/exp.c
View file

@ -251,7 +251,8 @@ asmlinkage void exception_handler(unsigned int edi,
DbgPrint("Process: %x\n",PsGetCurrentProcess()); DbgPrint("Process: %x\n",PsGetCurrentProcess());
if (PsGetCurrentProcess() != NULL) if (PsGetCurrentProcess() != NULL)
{ {
DbgPrint("Process id: %x\n", PsGetCurrentProcess()->UniqueProcessId); DbgPrint("Process id: %x <", PsGetCurrentProcess()->UniqueProcessId);
DbgPrint("%.8s>", PsGetCurrentProcess()->ImageFileName);
} }
if (PsGetCurrentThread() != NULL) if (PsGetCurrentThread() != NULL)
{ {
@ -280,32 +281,34 @@ asmlinkage void exception_handler(unsigned int edi,
} }
if ((cs & 0xffff) == KERNEL_CS) if ((cs & 0xffff) == KERNEL_CS)
{ {
DbgPrint("ESP %x\n",esp); DbgPrint("ESP %x\n",esp);
stack = (PULONG) (esp + 24); stack = (PULONG) (esp + 24);
stack = (PULONG)(((ULONG)stack) & (~0x3)); // stack = (PULONG)(((ULONG)stack) & (~0x3));
DbgPrint("Stack:\n"); DbgPrint("stack: %p\n", stack);
for (i = 0; i < 16; i = i + 4)
{ DbgPrint("Stack:\n");
DbgPrint("%.8x %.8x %.8x %.8x\n", for (i = 0; i < 16; i = i + 4)
stack[i], {
stack[i+1], DbgPrint("%.8x %.8x %.8x %.8x\n",
stack[i+2], stack[i],
stack[i+3]); stack[i+1],
} stack[i+2],
DbgPrint("Frames:\n"); stack[i+3]);
for (i = 0; i < 32; i++) }
{ DbgPrint("Frames:\n");
if (stack[i] > ((unsigned int) &stext) && for (i = 0; i < 32; i++)
{
if (stack[i] > ((unsigned int) &stext) &&
!(stack[i] >= ((ULONG)&init_stack) && !(stack[i] >= ((ULONG)&init_stack) &&
stack[i] <= ((ULONG)&init_stack_top))) stack[i] <= ((ULONG)&init_stack_top)))
{ {
// DbgPrint(" %.8x", stack[i]); // DbgPrint(" %.8x", stack[i]);
print_address((PVOID)stack[i]); print_address((PVOID)stack[i]);
DbgPrint(" "); DbgPrint(" ");
} }
} }
} }
else else
{ {
#if 0 #if 0

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

@ -1,4 +1,4 @@
/* $Id: loader.c,v 1.50 2000/03/19 09:14:50 ea Exp $ /* $Id: loader.c,v 1.51 2000/03/22 18:35:56 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -208,6 +208,7 @@ VOID LdrLoadAutoConfigDrivers (VOID)
* VGA Miniport driver * VGA Miniport driver
*/ */
// LdrLoadAutoConfigDriver( L"vgamp.sys" ); moving to win32k // LdrLoadAutoConfigDriver( L"vgamp.sys" ); moving to win32k
// LdrLoadAutoConfigDriver(L"minixfs.sys");
} }
@ -318,7 +319,7 @@ LdrLoadModule(PUNICODE_STRING Filename)
return 0; return 0;
} }
CHECKPOINT; CHECKPOINT;
/* Load driver into memory chunk */ /* Load driver into memory chunk */
Status = ZwReadFile(FileHandle, Status = ZwReadFile(FileHandle,
0, 0, 0, 0, 0, 0, 0, 0,
@ -541,6 +542,7 @@ LdrPEProcessModule(PVOID ModuleLoadBase, PUNICODE_STRING pModuleName)
DbgPrint("Failed to allocate a virtual section for driver\n"); DbgPrint("Failed to allocate a virtual section for driver\n");
return 0; return 0;
} }
DbgPrint("DriverBase: %x\n", DriverBase);
CHECKPOINT; CHECKPOINT;
/* Copy headers over */ /* Copy headers over */
memcpy(DriverBase, ModuleLoadBase, PEOptionalHeader->SizeOfHeaders); memcpy(DriverBase, ModuleLoadBase, PEOptionalHeader->SizeOfHeaders);

11
reactos/ntoskrnl/ps/create.c
View file

@ -1,4 +1,4 @@
/* $Id: create.c,v 1.11 2000/03/16 18:44:57 dwelch Exp $ /* $Id: create.c,v 1.12 2000/03/22 18:35:57 dwelch Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -422,7 +422,7 @@ static NTSTATUS PsCreateTeb (HANDLE ProcessHandle,
PAGE_READWRITE); PAGE_READWRITE);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
DPRINT1 ("TEB allocated at %x\n", TebBase); // DPRINT1 ("TEB allocated at %x\n", TebBase);
break; break;
} }
else else
@ -444,7 +444,8 @@ static NTSTATUS PsCreateTeb (HANDLE ProcessHandle,
{ {
Teb.Peb = Thread->ThreadsProcess->Peb; /* No PEB yet!! */ Teb.Peb = Thread->ThreadsProcess->Peb; /* No PEB yet!! */
} }
// DPRINT1("Teb.Peb %x\n", Teb.Peb);
/* store stack information from InitialTeb */ /* store stack information from InitialTeb */
if (InitialTeb != NULL) if (InitialTeb != NULL)
{ {
@ -488,14 +489,12 @@ static NTSTATUS PsCreateTeb (HANDLE ProcessHandle,
return Status; return Status;
} }
/* FIXME: fs:[0] = TEB */
if (TebPtr != NULL) if (TebPtr != NULL)
{ {
*TebPtr = (PNT_TEB)TebBase; *TebPtr = (PNT_TEB)TebBase;
} }
DPRINT1 ("TEB allocated at %p\n", TebBase); // DPRINT1 ("TEB allocated at %p\n", TebBase);
return Status; return Status;
} }

20
reactos/ntoskrnl/ps/process.c
View file

@ -173,6 +173,8 @@ VOID PsInitProcessManagment(VOID)
InitializeListHead( &KProcess->ThreadListHead ); InitializeListHead( &KProcess->ThreadListHead );
KeReleaseSpinLock(&PsProcessListLock, oldIrql); KeReleaseSpinLock(&PsProcessListLock, oldIrql);
strcpy(SystemProcess->ImageFileName, "SYSTEM");
ObCreateHandle(SystemProcess, ObCreateHandle(SystemProcess,
SystemProcess, SystemProcess,
PROCESS_ALL_ACCESS, PROCESS_ALL_ACCESS,
@ -195,7 +197,8 @@ VOID PiDeleteProcess(PVOID ObjectBody)
static NTSTATUS PsCreatePeb(HANDLE ProcessHandle, static NTSTATUS PsCreatePeb(HANDLE ProcessHandle,
PVOID ImageBase) PVOID ImageBase,
PVOID* RPeb)
{ {
NTSTATUS Status; NTSTATUS Status;
PVOID PebBase; PVOID PebBase;
@ -226,7 +229,9 @@ static NTSTATUS PsCreatePeb(HANDLE ProcessHandle,
&BytesWritten); &BytesWritten);
DPRINT("PsCreatePeb: Peb created at %x\n", PebBase); DPRINT("PsCreatePeb: Peb created at %x\n", PebBase);
*RPeb = PebBase;
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
@ -297,6 +302,7 @@ NTSTATUS STDCALL NtCreateProcess (OUT PHANDLE ProcessHandle,
KIRQL oldIrql; KIRQL oldIrql;
PVOID LdrStartupAddr; PVOID LdrStartupAddr;
PVOID ImageBase; PVOID ImageBase;
PVOID Peb;
DPRINT("NtCreateProcess(ObjectAttributes %x)\n",ObjectAttributes); DPRINT("NtCreateProcess(ObjectAttributes %x)\n",ObjectAttributes);
@ -383,12 +389,14 @@ NTSTATUS STDCALL NtCreateProcess (OUT PHANDLE ProcessHandle,
*/ */
DPRINT("Creating PEB\n"); DPRINT("Creating PEB\n");
Status = PsCreatePeb(*ProcessHandle, Status = PsCreatePeb(*ProcessHandle,
ImageBase); ImageBase,
&Peb);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
DbgPrint("NtCreateProcess() Peb creation failed: Status %x\n",Status); DbgPrint("NtCreateProcess() Peb creation failed: Status %x\n",Status);
return(Status); return(Status);
} }
Process->Peb = Peb;
ObDereferenceObject(Process); ObDereferenceObject(Process);
ObDereferenceObject(ParentProcess); ObDereferenceObject(ParentProcess);
@ -617,6 +625,12 @@ NTSTATUS STDCALL NtSetInformationProcess(IN HANDLE ProcessHandle,
Status = PspAssignPrimaryToken(Process, *ProcessAccessTokenP); Status = PspAssignPrimaryToken(Process, *ProcessAccessTokenP);
break; break;
case ProcessImageFileName:
memcpy(Process->ImageFileName, ProcessInformation, 8);
// DPRINT1("Process->ImageFileName %.8s\n", Process->ImageFileName);
Status = STATUS_SUCCESS;
break;
case ProcessLdtInformation: case ProcessLdtInformation:
case ProcessLdtSize: case ProcessLdtSize:
case ProcessDefaultHardErrorMode: case ProcessDefaultHardErrorMode:

36
reactos/subsys/csrss/api.h
View file

@ -24,28 +24,32 @@ typedef struct
VOID CsrInitProcessData(VOID); VOID CsrInitProcessData(VOID);
NTSTATUS CsrCreateProcess (PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrCreateProcess (PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage); PCSRSS_CREATE_PROCESS_REQUEST Request,
PLPCMESSAGE* Reply);
NTSTATUS CsrTerminateProcess(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrTerminateProcess(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage); PCSRSS_API_REQUEST LpcMessage,
PLPCMESSAGE* Reply);
NTSTATUS CsrWriteConsole(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrWriteConsole(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage, PCSRSS_API_REQUEST LpcMessage,
PULONG CharCount); PLPCMESSAGE* Reply);
NTSTATUS CsrAllocConsole(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrAllocConsole(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage, PCSRSS_API_REQUEST LpcMessage,
PHANDLE ReturnedHandle); PLPCMESSAGE* Reply);
NTSTATUS CsrFreeConsole(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrFreeConsole(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage); PCSRSS_API_REQUEST LpcMessage,
PLPCMESSAGE* Reply);
NTSTATUS CsrReadConsole(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrReadConsole(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage, PCSRSS_API_REQUEST LpcMessage,
PULONG CharCount); PLPCMESSAGE* Reply);
NTSTATUS CsrConnectProcess(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrConnectProcess(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST Request); PCSRSS_API_REQUEST Request,
PLPCMESSAGE* Reply);
/* print.c */ /* print.c */
VOID DisplayString(LPCWSTR lpwString); VOID DisplayString(LPCWSTR lpwString);
@ -59,6 +63,18 @@ extern HANDLE CsrssApiHeap;
/* api/conio.c */ /* api/conio.c */
VOID CsrInitConsole(PCSRSS_PROCESS_DATA ProcessData, VOID CsrInitConsole(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_CONSOLE Console); PCSRSS_CONSOLE Console);
VOID CsrInitConsoleSupport(VOID);
/* api/process.c */ /* api/process.c */
PCSRSS_PROCESS_DATA CsrGetProcessData(ULONG ProcessId); PCSRSS_PROCESS_DATA CsrGetProcessData(ULONG ProcessId);
/* api/handle.c */
NTSTATUS CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
PHANDLE Handle,
PVOID Object);
NTSTATUS CsrGetObject(PCSRSS_PROCESS_DATA ProcessData,
HANDLE Handle,
PVOID* Object);
BOOL STDCALL CsrServerInitialization (ULONG ArgumentCount,
PWSTR *ArgumentArray);

210
reactos/subsys/csrss/api/conio.c
View file

@ -1,4 +1,4 @@
/* $Id: conio.c,v 1.2 1999/12/30 01:51:42 dwelch Exp $ /* $Id: conio.c,v 1.3 2000/03/22 18:35:59 dwelch Exp $
* *
* reactos/subsys/csrss/api/conio.c * reactos/subsys/csrss/api/conio.c
* *
@ -16,78 +16,148 @@
/* GLOBALS *******************************************************************/ /* GLOBALS *******************************************************************/
static HANDLE ConsoleDevice; static HANDLE ConsoleDeviceHandle;
static HANDLE KeyboardDevice; static HANDLE KeyboardDeviceHandle;
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
NTSTATUS CsrAllocConsole(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrAllocConsole(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage, PCSRSS_API_REQUEST LpcMessage,
PHANDLE ReturnedHandle) PLPCMESSAGE* LpcReply)
{ {
PCSRSS_API_REPLY Reply;
(*LpcReply) = RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY,
sizeof(LPCMESSAGE));
(*LpcReply)->ActualMessageLength = sizeof(CSRSS_API_REPLY);
(*LpcReply)->TotalMessageLength = sizeof(LPCMESSAGE);
Reply = (PCSRSS_API_REPLY)((*LpcReply)->MessageData);
Reply->Status = STATUS_NOT_IMPLEMENTED;
return(STATUS_NOT_IMPLEMENTED); return(STATUS_NOT_IMPLEMENTED);
} }
NTSTATUS CsrFreeConsole(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrFreeConsole(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage) PCSRSS_API_REQUEST LpcMessage,
PLPCMESSAGE* LpcReply)
{ {
PCSRSS_API_REPLY Reply;
(*LpcReply) = RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY,
sizeof(LPCMESSAGE));
(*LpcReply)->ActualMessageLength = sizeof(CSRSS_API_REPLY);
(*LpcReply)->TotalMessageLength = sizeof(LPCMESSAGE);
Reply = (PCSRSS_API_REPLY)((*LpcReply)->MessageData);
Reply->Status = STATUS_NOT_IMPLEMENTED;
return(STATUS_NOT_IMPLEMENTED); return(STATUS_NOT_IMPLEMENTED);
} }
NTSTATUS CsrReadConsole(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrReadConsole(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage, PCSRSS_API_REQUEST LpcMessage,
PULONG CharCount) PLPCMESSAGE* LpcReply)
{ {
return(STATUS_NOT_IMPLEMENTED); KEY_EVENT_RECORD KeyEventRecord;
BOOL stat = TRUE;
PCHAR Buffer;
DWORD Result;
int i;
ULONG nNumberOfCharsToRead;
NTSTATUS Status;
IO_STATUS_BLOCK Iosb;
PCSRSS_API_REPLY Reply;
// DbgPrint("CSR: CsrReadConsole()\n");
nNumberOfCharsToRead =
LpcMessage->Data.ReadConsoleRequest.NrCharactersToRead;
// DbgPrint("CSR: NrCharactersToRead %d\n", nNumberOfCharsToRead);
(*LpcReply) = RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY,
sizeof(LPCMESSAGE));
(*LpcReply)->ActualMessageLength = sizeof(CSRSS_API_REPLY) +
nNumberOfCharsToRead;
(*LpcReply)->TotalMessageLength = sizeof(LPCMESSAGE);
Reply = (PCSRSS_API_REPLY)((*LpcReply)->MessageData);
Buffer = Reply->Data.ReadConsoleReply.Buffer;
Status = STATUS_SUCCESS;
for (i=0; (NT_SUCCESS(Status) && i<nNumberOfCharsToRead);)
{
// DbgPrint("CSR: Doing read file (KeyboardDeviceHandle %x)\n",
// KeyboardDeviceHandle);
Status = NtReadFile(KeyboardDeviceHandle,
NULL,
NULL,
NULL,
&Iosb,
&KeyEventRecord,
sizeof(KEY_EVENT_RECORD),
NULL,
0);
if (!NT_SUCCESS(Status))
{
DbgPrint("CSR: Read failed, bailing\n");
}
if (KeyEventRecord.bKeyDown && KeyEventRecord.uChar.AsciiChar != 0)
{
Buffer[i] = KeyEventRecord.uChar.AsciiChar;
//DbgPrint("CSR: Read '%c'\n", Buffer[i]);
i++;
}
}
Reply->Data.ReadConsoleReply.NrCharactersRead = i;
Reply->Status = Status;
return(Status);
} }
NTSTATUS CsrWriteConsole(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrWriteConsole(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST Message, PCSRSS_API_REQUEST Message,
PULONG CharCount) PLPCMESSAGE* LpcReply)
{ {
IO_STATUS_BLOCK Iosb;
NTSTATUS Status; NTSTATUS Status;
PCSRSS_CONSOLE Console; PCSRSS_API_REPLY Reply;
if (ProcessData->Console == NULL) (*LpcReply) = RtlAllocateHeap(CsrssApiHeap,
{ HEAP_ZERO_MEMORY,
return(STATUS_UNSUCCESSFUL); sizeof(LPCMESSAGE));
} (*LpcReply)->ActualMessageLength = sizeof(CSRSS_API_REPLY);
Console = ProcessData->Console; (*LpcReply)->TotalMessageLength = sizeof(LPCMESSAGE);
Reply = (PCSRSS_API_REPLY)((*LpcReply)->MessageData);
// DbgPrint("CSR: CsrWriteConsole()\n");
// DbgPrint("CSR: ConsoleDeviceHandle %x\n", ConsoleDeviceHandle);
// DbgPrint("CSR: NrCharactersToWrite %d\n",
// Message->Data.WriteConsoleRequest.NrCharactersToWrite);
// DbgPrint("CSR: Buffer %s\n",
// Message->Data.WriteConsoleRequest.Buffer);
Status = NtWaitForSingleObject(Console->LockMutant, Status = NtWriteFile(ConsoleDeviceHandle,
TRUE, NULL,
NULL); NULL,
NULL,
&Iosb,
Message->Data.WriteConsoleRequest.Buffer,
Message->Data.WriteConsoleRequest.NrCharactersToWrite,
NULL,
0);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
// DbgPrint("CSR: Write failed\n");
return(Status); return(Status);
} }
if (Status == STATUS_ALERTED || Reply->Data.WriteConsoleReply.NrCharactersWritten = Iosb.Information;
Status == STATUS_USER_APC) Reply->Status = STATUS_SUCCESS;
{ return(STATUS_SUCCESS);
return(Status);
}
if (Console->TopLevel == TRUE)
{
Status = NtReleaseMutant(Console->LockMutant, NULL);
if (!NT_SUCCESS(Status))
{
return(Status);
}
return(Status);
}
else
{
Status = NtReleaseMutant(Console->LockMutant, NULL);
if (!NT_SUCCESS(Status))
{
return(Status);
}
return(Status);
}
} }
VOID CsrInitConsole(PCSRSS_PROCESS_DATA ProcessData, VOID CsrInitConsole(PCSRSS_PROCESS_DATA ProcessData,
@ -95,4 +165,52 @@ VOID CsrInitConsole(PCSRSS_PROCESS_DATA ProcessData,
{ {
} }
VOID CsrInitConsoleSupport(VOID)
{
OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING DeviceName;
NTSTATUS Status;
IO_STATUS_BLOCK Iosb;
DbgPrint("CSR: CsrInitConsoleSupport()\n");
RtlInitUnicodeString(&DeviceName, L"\\??\\BlueScreen");
InitializeObjectAttributes(&ObjectAttributes,
&DeviceName,
0,
NULL,
NULL);
Status = NtOpenFile(&ConsoleDeviceHandle,
FILE_ALL_ACCESS,
&ObjectAttributes,
&Iosb,
0,
FILE_SYNCHRONOUS_IO_ALERT);
if (!NT_SUCCESS(Status))
{
DbgPrint("CSR: Failed to open console. Expect problems.\n");
}
// DbgPrint("CSR: ConsoleDeviceHandle %x\n", ConsoleDeviceHandle);
RtlInitUnicodeString(&DeviceName, L"\\??\\Keyboard");
InitializeObjectAttributes(&ObjectAttributes,
&DeviceName,
0,
NULL,
NULL);
Status = NtOpenFile(&KeyboardDeviceHandle,
FILE_ALL_ACCESS,
&ObjectAttributes,
&Iosb,
0,
FILE_SYNCHRONOUS_IO_ALERT);
if (!NT_SUCCESS(Status))
{
DbgPrint("CSR: Failed to open keyboard. Expect problems.\n");
for(;;);
}
DbgPrint("CSR: KeyboardDeviceHandle %x\n", KeyboardDeviceHandle);
}
/* EOF */ /* EOF */

6
reactos/subsys/csrss/api/handle.c
View file

@ -1,4 +1,4 @@
/* $Id: handle.c,v 1.2 1999/12/30 01:51:42 dwelch Exp $ /* $Id: handle.c,v 1.3 2000/03/22 18:36:00 dwelch Exp $
* *
* reactos/subsys/csrss/api/handle.c * reactos/subsys/csrss/api/handle.c
* *
@ -11,7 +11,7 @@
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include "csrss.h" #include <csrss/csrss.h>
#include "api.h" #include "api.h"
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
@ -51,7 +51,7 @@ NTSTATUS CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
sizeof(HANDLE)); sizeof(HANDLE));
if (NewBlock == NULL) if (NewBlock == NULL)
{ {
return(STATUS_NO_MORE_MEMORY); return(STATUS_UNSUCCESSFUL);
} }
RtlCopyMemory(NewBlock, RtlCopyMemory(NewBlock,
ProcessData->HandleTable, ProcessData->HandleTable,

78
reactos/subsys/csrss/api/process.c
View file

@ -1,4 +1,4 @@
/* $Id: process.c,v 1.5 2000/02/27 02:12:07 ekohl Exp $ /* $Id: process.c,v 1.6 2000/03/22 18:36:00 dwelch Exp $
* *
* reactos/subsys/csrss/api/process.c * reactos/subsys/csrss/api/process.c
* *
@ -30,13 +30,14 @@ VOID CsrInitProcessData(VOID)
{ {
ProcessData[i] = NULL; ProcessData[i] = NULL;
} }
NrProcess = 256;
} }
PCSRSS_PROCESS_DATA CsrGetProcessData(ULONG ProcessId) PCSRSS_PROCESS_DATA CsrGetProcessData(ULONG ProcessId)
{ {
ULONG i; ULONG i;
for (i=0; i<256/*NrProcess*/; i++) for (i=0; i<NrProcess; i++)
{ {
if (ProcessData[i] && if (ProcessData[i] &&
ProcessData[i]->ProcessId == ProcessId) ProcessData[i]->ProcessId == ProcessId)
@ -44,30 +45,45 @@ PCSRSS_PROCESS_DATA CsrGetProcessData(ULONG ProcessId)
return(ProcessData[i]); return(ProcessData[i]);
} }
} }
ProcessData[i] = RtlAllocateHeap(CsrssApiHeap, for (i=0; i<NrProcess; i++)
HEAP_ZERO_MEMORY,
sizeof(CSRSS_PROCESS_DATA));
if (ProcessData[i] == NULL)
{ {
return(NULL); if (ProcessData[i] == NULL)
{
ProcessData[i] = RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY,
sizeof(CSRSS_PROCESS_DATA));
if (ProcessData[i] == NULL)
{
return(NULL);
}
ProcessData[i]->ProcessId = ProcessId;
return(ProcessData[i]);
}
} }
ProcessData[i]->ProcessId = ProcessId; DbgPrint("CSR: CsrGetProcessData() failed\n");
return(ProcessData[i]); return(NULL);
} }
NTSTATUS CsrCreateProcess (PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrCreateProcess (PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage) PCSRSS_CREATE_PROCESS_REQUEST Request,
PLPCMESSAGE* LpcReply)
{ {
PCSRSS_CREATE_PROCESS_REQUEST Request;
PCSRSS_PROCESS_DATA NewProcessData; PCSRSS_PROCESS_DATA NewProcessData;
PCSRSS_API_REPLY Reply;
Request = (PCSRSS_CREATE_PROCESS_REQUEST)LpcMessage->Data; (*LpcReply) = RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY,
sizeof(LPCMESSAGE));
(*LpcReply)->ActualMessageLength = sizeof(CSRSS_API_REPLY);
(*LpcReply)->TotalMessageLength = sizeof(LPCMESSAGE);
Reply = (PCSRSS_API_REPLY)((*LpcReply)->MessageData);
NewProcessData = CsrGetProcessData(Request->NewProcessId); NewProcessData = CsrGetProcessData(Request->NewProcessId);
if (NewProcessData == NULL) if (NewProcessData == NULL)
{ {
Reply->Status = STATUS_NO_MEMORY;
return(STATUS_NO_MEMORY); return(STATUS_NO_MEMORY);
} }
@ -91,18 +107,50 @@ NTSTATUS CsrCreateProcess (PCSRSS_PROCESS_DATA ProcessData,
NewProcessData->Console = ProcessData->Console; NewProcessData->Console = ProcessData->Console;
} }
return(STATUS_NOT_IMPLEMENTED); CsrInsertObject(NewProcessData,
&Reply->Data.CreateProcessReply.ConsoleHandle,
NewProcessData->Console);
DbgPrint("CSR: ConsoleHandle %x\n",
Reply->Data.CreateProcessReply.ConsoleHandle);
DisplayString(L"CSR: Did CreateProcess successfully\n");
return(STATUS_SUCCESS);
} }
NTSTATUS CsrTerminateProcess(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrTerminateProcess(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST LpcMessage) PCSRSS_API_REQUEST LpcMessage,
PLPCMESSAGE* LpcReply)
{ {
PCSRSS_API_REPLY Reply;
(*LpcReply) = (PLPCMESSAGE)RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY,
sizeof(LPCMESSAGE));
(*LpcReply)->ActualMessageLength = sizeof(CSRSS_API_REPLY);
(*LpcReply)->TotalMessageLength = sizeof(LPCMESSAGE);
Reply = (PCSRSS_API_REPLY)((*LpcReply)->MessageData);
Reply->Status = STATUS_NOT_IMPLEMENTED;
return(STATUS_NOT_IMPLEMENTED); return(STATUS_NOT_IMPLEMENTED);
} }
NTSTATUS CsrConnectProcess(PCSRSS_PROCESS_DATA ProcessData, NTSTATUS CsrConnectProcess(PCSRSS_PROCESS_DATA ProcessData,
PCSRSS_API_REQUEST Request) PCSRSS_API_REQUEST Request,
PLPCMESSAGE* LpcReply)
{ {
PCSRSS_API_REPLY Reply;
(*LpcReply) = RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY,
sizeof(LPCMESSAGE));
(*LpcReply)->ActualMessageLength = sizeof(CSRSS_API_REPLY);
(*LpcReply)->TotalMessageLength = sizeof(LPCMESSAGE);
Reply = (PCSRSS_API_REPLY)((*LpcReply)->MessageData);
Reply->Status = STATUS_SUCCESS;
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }

69
reactos/subsys/csrss/api/wapi.c
View file

@ -1,4 +1,4 @@
/* $Id: wapi.c,v 1.4 2000/02/29 23:57:46 ea Exp $ /* $Id: wapi.c,v 1.5 2000/03/22 18:36:00 dwelch Exp $
* *
* reactos/subsys/csrss/api/wapi.c * reactos/subsys/csrss/api/wapi.c
* *
@ -28,8 +28,8 @@ static void Thread_Api2(HANDLE ServerPort)
PLPCMESSAGE LpcReply; PLPCMESSAGE LpcReply;
LPCMESSAGE LpcRequest; LPCMESSAGE LpcRequest;
PCSRSS_API_REQUEST Request; PCSRSS_API_REQUEST Request;
CSRSS_API_REPLY Reply;
PCSRSS_PROCESS_DATA ProcessData; PCSRSS_PROCESS_DATA ProcessData;
PCSRSS_API_REPLY Reply;
LpcReply = NULL; LpcReply = NULL;
@ -43,58 +43,78 @@ static void Thread_Api2(HANDLE ServerPort)
{ {
DisplayString(L"CSR: NtReplyWaitReceivePort failed\n"); DisplayString(L"CSR: NtReplyWaitReceivePort failed\n");
} }
if (LpcReply != NULL)
{
RtlFreeHeap(CsrssApiHeap,
0,
LpcReply);
}
Request = (PCSRSS_API_REQUEST)LpcRequest.MessageData; Request = (PCSRSS_API_REQUEST)LpcRequest.MessageData;
LpcReply = NULL;
Reply = NULL;
ProcessData = CsrGetProcessData(LpcRequest.ClientProcessId); ProcessData = CsrGetProcessData(LpcRequest.ClientProcessId);
DisplayString(L"CSR: Received request\n"); // DisplayString(L"CSR: Received request\n");
switch (Request->Type) switch (Request->Type)
{ {
case CSRSS_CREATE_PROCESS: case CSRSS_CREATE_PROCESS:
Reply.Status = CsrCreateProcess(ProcessData, Status = CsrCreateProcess(ProcessData,
Request); &Request->Data.CreateProcessRequest,
&LpcReply);
break; break;
case CSRSS_TERMINATE_PROCESS: case CSRSS_TERMINATE_PROCESS:
Reply.Status = CsrTerminateProcess(ProcessData, Status = CsrTerminateProcess(ProcessData,
Request); Request,
&LpcReply);
break; break;
case CSRSS_WRITE_CONSOLE: case CSRSS_WRITE_CONSOLE:
Reply.Status = CsrWriteConsole(ProcessData, Status = CsrWriteConsole(ProcessData,
Request, Request,
&Reply.Count); &LpcReply);
break; break;
case CSRSS_READ_CONSOLE: case CSRSS_READ_CONSOLE:
Reply.Status = CsrReadConsole(ProcessData, Status = CsrReadConsole(ProcessData,
Request, Request,
&Reply.Count); &LpcReply);
break; break;
case CSRSS_ALLOC_CONSOLE: case CSRSS_ALLOC_CONSOLE:
Reply.Status = CsrAllocConsole(ProcessData, Status = CsrAllocConsole(ProcessData,
Request, Request,
&Reply.Handle); &LpcReply);
break; break;
case CSRSS_FREE_CONSOLE: case CSRSS_FREE_CONSOLE:
Reply.Status = CsrFreeConsole(ProcessData, Status = CsrFreeConsole(ProcessData,
Request); Request,
&LpcReply);
break; break;
case CSRSS_CONNECT_PROCESS: case CSRSS_CONNECT_PROCESS:
Reply.Status = CsrConnectProcess(ProcessData, Status = CsrConnectProcess(ProcessData,
Request); Request,
&LpcReply);
break;
default: default:
Reply.Status = STATUS_NOT_IMPLEMENTED; LpcReply = RtlAllocateHeap(CsrssApiHeap,
HEAP_ZERO_MEMORY,
sizeof(LPCMESSAGE));
Reply = (PCSRSS_API_REPLY)(LpcReply->MessageData);
Reply->Status = STATUS_NOT_IMPLEMENTED;
} }
LpcReply = &LpcRequest; Reply = (PCSRSS_API_REPLY)(LpcReply->MessageData);
RtlCopyMemory(LpcReply->MessageData, &Reply, sizeof(Reply)); if (Reply->Status == STATUS_SUCCESS)
{
// DisplayString(L"CSR: Returning STATUS_SUCCESS\n");
}
} }
} }
@ -125,7 +145,8 @@ void Thread_Api(PVOID PortHandle)
} }
CsrInitProcessData(); CsrInitProcessData();
CsrInitConsoleSupport();
for (;;) for (;;)
{ {
Status = NtListenPort(PortHandle, &Request); Status = NtListenPort(PortHandle, &Request);

30
reactos/subsys/csrss/csrss.c
View file

@ -1,4 +1,4 @@
/* $Id: csrss.c,v 1.5 2000/02/27 02:11:54 ekohl Exp $ /* $Id: csrss.c,v 1.6 2000/03/22 18:35:58 dwelch Exp $
* *
* csrss.c - Client/Server Runtime subsystem * csrss.c - Client/Server Runtime subsystem
* *
@ -35,6 +35,8 @@
#include <ntdll/rtl.h> #include <ntdll/rtl.h>
#include <csrss/csrss.h> #include <csrss/csrss.h>
#include "api.h"
VOID PrintString (char* fmt, ...); VOID PrintString (char* fmt, ...);
/* Native process' entry point */ /* Native process' entry point */
@ -47,7 +49,11 @@ VOID NtProcessStartup(PPEB Peb)
ULONG argc = 0; ULONG argc = 0;
int i = 0; int i = 0;
int afterlastspace = 0; int afterlastspace = 0;
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE CsrssInitEvent;
UNICODE_STRING UnicodeString;
NTSTATUS Status;
DisplayString(L"Client/Server Runtime Subsystem\n"); DisplayString(L"Client/Server Runtime Subsystem\n");
ProcParams = RtlNormalizeProcessParams (Peb->ProcessParameters); ProcParams = RtlNormalizeProcessParams (Peb->ProcessParameters);
@ -85,11 +91,29 @@ VOID NtProcessStartup(PPEB Peb)
ArgBuffer[i] = L'\0'; ArgBuffer[i] = L'\0';
argv[argc-1] = &(ArgBuffer[afterlastspace]); argv[argc-1] = &(ArgBuffer[afterlastspace]);
} }
RtlInitUnicodeString(&UnicodeString,
L"\\CsrssInitDone");
InitializeObjectAttributes(&ObjectAttributes,
&UnicodeString,
EVENT_ALL_ACCESS,
0,
NULL);
Status = NtOpenEvent(&CsrssInitEvent,
EVENT_ALL_ACCESS,
&ObjectAttributes);
if (!NT_SUCCESS(Status))
{
DbgPrint("CSR: Failed to open csrss notification event\n");
}
if (CsrServerInitialization (argc, argv) == TRUE) if (CsrServerInitialization (argc, argv) == TRUE)
{ {
DisplayString( L"CSR: Subsystem initialized.\n" ); DisplayString( L"CSR: Subsystem initialized.\n" );
NtSetEvent(CsrssInitEvent,
NULL);
RtlFreeHeap (Peb->ProcessHeap, RtlFreeHeap (Peb->ProcessHeap,
0, argv); 0, argv);
RtlFreeHeap (Peb->ProcessHeap, RtlFreeHeap (Peb->ProcessHeap,

4
reactos/subsys/csrss/init.c
View file

@ -1,4 +1,4 @@
/* $Id: init.c,v 1.6 2000/02/29 23:57:45 ea Exp $ /* $Id: init.c,v 1.7 2000/03/22 18:35:58 dwelch Exp $
* *
* reactos/subsys/csrss/init.c * reactos/subsys/csrss/init.c
* *
@ -101,7 +101,7 @@ CsrServerInitialization (
PrintString("CSR: Unable to parse the command line (Status: %x)\n", Status); PrintString("CSR: Unable to parse the command line (Status: %x)\n", Status);
return(FALSE); return(FALSE);
} }
/* NEW NAMED PORT: \ApiPort */ /* NEW NAMED PORT: \ApiPort */
RtlInitUnicodeString(&PortName, L"\\Windows\\ApiPort"); RtlInitUnicodeString(&PortName, L"\\Windows\\ApiPort");
InitializeObjectAttributes(&ObAttributes, InitializeObjectAttributes(&ObAttributes,

4
reactos/subsys/csrss/makefile
View file

@ -1,4 +1,4 @@
# $Id: makefile,v 1.5 2000/02/27 02:11:54 ekohl Exp $ # $Id: makefile,v 1.6 2000/03/22 18:35:58 dwelch Exp $
# #
# CSRSS: Client/server runtime subsystem # CSRSS: Client/server runtime subsystem
# #
@ -8,7 +8,7 @@ TARGET=csrss
BASE_CFLAGS = -I../../include -I. BASE_CFLAGS = -I../../include -I.
OBJECTS_API = api/process.o api/wapi.o api/conio.o OBJECTS_API = api/process.o api/wapi.o api/conio.o api/handle.o
OBJECTS_SBAPI = OBJECTS_SBAPI =

276
reactos/subsys/smss/init.c
View file

@ -1,4 +1,4 @@
/* $Id: init.c,v 1.15 2000/02/27 15:47:17 ekohl Exp $ /* $Id: init.c,v 1.16 2000/03/22 18:36:00 dwelch Exp $
* *
* init.c - Session Manager initialization * init.c - Session Manager initialization
* *
@ -34,7 +34,7 @@
#define NDEBUG #define NDEBUG
/* uncomment to run csrss.exe */ /* uncomment to run csrss.exe */
//#define RUN_CSRSS #define RUN_CSRSS
/* GLOBAL VARIABLES *********************************************************/ /* GLOBAL VARIABLES *********************************************************/
@ -155,147 +155,169 @@ SmSetEnvironmentVariables (VOID)
} }
BOOL BOOL InitSessionManager (HANDLE Children[])
InitSessionManager (
HANDLE Children[]
)
{ {
NTSTATUS Status; NTSTATUS Status;
UNICODE_STRING UnicodeString; UNICODE_STRING UnicodeString;
OBJECT_ATTRIBUTES ObjectAttributes; OBJECT_ATTRIBUTES ObjectAttributes;
UNICODE_STRING CmdLineW; UNICODE_STRING CmdLineW;
UNICODE_STRING CurrentDirectoryW; UNICODE_STRING CurrentDirectoryW;
PRTL_USER_PROCESS_PARAMETERS ProcessParameters; PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
RTL_USER_PROCESS_INFO ProcessInfo; RTL_USER_PROCESS_INFO ProcessInfo;
HANDLE CsrssInitEvent;
/* Create the "\SmApiPort" object (LPC) */
RtlInitUnicodeString (&UnicodeString, /* Create the "\SmApiPort" object (LPC) */
L"\\SmApiPort"); RtlInitUnicodeString (&UnicodeString,
InitializeObjectAttributes (&ObjectAttributes, L"\\SmApiPort");
&UnicodeString, InitializeObjectAttributes (&ObjectAttributes,
0xff, &UnicodeString,
NULL, 0xff,
NULL); NULL,
NULL);
Status = NtCreatePort (&SmApiPort,
&ObjectAttributes, Status = NtCreatePort (&SmApiPort,
0, &ObjectAttributes,
0, 0,
0); 0,
0);
if (!NT_SUCCESS(Status))
{
return FALSE;
}
if (!NT_SUCCESS(Status))
{
return FALSE;
}
#ifndef NDEBUG #ifndef NDEBUG
DisplayString (L"SM: \\SmApiPort created...\n"); DisplayString (L"SM: \\SmApiPort created...\n");
#endif #endif
/* Create two threads for "\SmApiPort" */
RtlCreateUserThread (NtCurrentProcess (),
NULL,
FALSE,
0,
NULL,
NULL,
(PTHREAD_START_ROUTINE)SmApiThread,
(PVOID)SmApiPort,
NULL,
NULL);
/* Create two threads for "\SmApiPort" */ RtlCreateUserThread (NtCurrentProcess (),
RtlCreateUserThread (NtCurrentProcess (), NULL,
NULL, FALSE,
FALSE, 0,
0, NULL,
NULL, NULL,
NULL, (PTHREAD_START_ROUTINE)SmApiThread,
(PTHREAD_START_ROUTINE)SmApiThread, (PVOID)SmApiPort,
(PVOID)SmApiPort, NULL,
NULL, NULL);
NULL);
/* Create the system environment */
RtlCreateUserThread (NtCurrentProcess (), Status = RtlCreateEnvironment (TRUE,
NULL, &SmSystemEnvironment);
FALSE, if (!NT_SUCCESS(Status))
0, return FALSE;
NULL,
NULL,
(PTHREAD_START_ROUTINE)SmApiThread,
(PVOID)SmApiPort,
NULL,
NULL);
/* Create the system environment */
Status = RtlCreateEnvironment (TRUE,
&SmSystemEnvironment);
if (!NT_SUCCESS(Status))
return FALSE;
#ifndef NDEBUG #ifndef NDEBUG
DisplayString (L"SM: System Environment created\n"); DisplayString (L"SM: System Environment created\n");
#endif #endif
/* FIXME: Define symbolic links to kernel devices (MS-DOS names) */ /* FIXME: Define symbolic links to kernel devices (MS-DOS names) */
/* FIXME: Run all programs in the boot execution list */ /* FIXME: Run all programs in the boot execution list */
/* FIXME: Process the file rename list */ /* FIXME: Process the file rename list */
/* FIXME: Load the well known DLLs */ /* FIXME: Load the well known DLLs */
#if 0 #if 0
/* Create paging files */ /* Create paging files */
SmCreatePagingFiles (); SmCreatePagingFiles ();
#endif #endif
#if 0 #if 0
/* Load missing registry hives */ /* Load missing registry hives */
NtInitializeRegistry (FALSE); NtInitializeRegistry (FALSE);
#endif #endif
/* Set environment variables from registry */
SmSetEnvironmentVariables ();
/* Set environment variables from registry */ /* Load the kernel mode driver win32k.sys */
SmSetEnvironmentVariables (); RtlInitUnicodeString (&CmdLineW,
L"\\??\\C:\\reactos\\system32\\drivers\\win32k.sys");
/* Load the kernel mode driver win32k.sys */ Status = NtLoadDriver (&CmdLineW);
RtlInitUnicodeString (&CmdLineW,
L"\\??\\C:\\reactos\\system32\\drivers\\win32k.sys"); if (!NT_SUCCESS(Status))
Status = NtLoadDriver (&CmdLineW); {
return FALSE;
if (!NT_SUCCESS(Status)) }
{
return FALSE;
}
#ifdef RUN_CSRSS #ifdef RUN_CSRSS
/* Start the Win32 subsystem (csrss.exe) */ RtlInitUnicodeString(&UnicodeString,
DisplayString (L"SM: Executing csrss.exe\n"); L"\\CsrssInitDone");
InitializeObjectAttributes(&ObjectAttributes,
&UnicodeString,
EVENT_ALL_ACCESS,
0,
NULL);
Status = NtCreateEvent(&CsrssInitEvent,
EVENT_ALL_ACCESS,
&ObjectAttributes,
TRUE,
FALSE);
if (!NT_SUCCESS(Status))
{
DbgPrint("Failed to create csrss notification event\n");
}
/* Start the Win32 subsystem (csrss.exe) */
DisplayString (L"SM: Executing csrss.exe\n");
RtlInitUnicodeString (&UnicodeString,
L"\\??\\C:\\reactos\\system32\\csrss.exe");
/* initialize current directory */
RtlInitUnicodeString (&CurrentDirectoryW,
L"C:\\reactos\\system32\\");
RtlCreateProcessParameters (&ProcessParameters,
&UnicodeString,
NULL,
&CurrentDirectoryW,
NULL,
SmSystemEnvironment,
NULL,
NULL,
NULL,
NULL);
RtlInitUnicodeString (&UnicodeString, Status = RtlCreateUserProcess (&UnicodeString,
L"\\??\\C:\\reactos\\system32\\csrss.exe"); 0,
ProcessParameters,
/* initialize current directory */ NULL,
RtlInitUnicodeString (&CurrentDirectoryW, NULL,
L"C:\\reactos\\system32\\"); FALSE,
0,
RtlCreateProcessParameters (&ProcessParameters, 0,
&UnicodeString,
NULL,
&CurrentDirectoryW,
NULL,
SmSystemEnvironment,
NULL,
NULL,
NULL,
NULL);
Status = RtlCreateUserProcess (&UnicodeString,
0, 0,
ProcessParameters, &ProcessInfo);
NULL,
NULL, RtlDestroyProcessParameters (ProcessParameters);
FALSE,
0, if (!NT_SUCCESS(Status))
0, {
0, DisplayString (L"SM: Loading csrss.exe failed!\n");
&ProcessInfo); return FALSE;
}
RtlDestroyProcessParameters (ProcessParameters);
DbgPrint("SM: Waiting for csrss\n");
if (!NT_SUCCESS(Status)) NtWaitForSingleObject(CsrssInitEvent,
{ FALSE,
DisplayString (L"SM: Loading csrss.exe failed!\n"); NULL);
return FALSE; DbgPrint("SM: Finished waiting for csrss\n");
}
Children[CHILD_CSRSS] = ProcessInfo.ProcessHandle; Children[CHILD_CSRSS] = ProcessInfo.ProcessHandle;
#endif /* RUN_CSRSS */ #endif /* RUN_CSRSS */