void main()\r
{ \r
NtDisplayString("Hello world\n");\r
- ExitThread(0);\r
+ ExitProcess(0);\r
}\r
}\r
cmd = line;\r
\r
- debug_printf("cmd '%s' tail '%s'\n",cmd,tail);\r
+// debug_printf("cmd '%s' tail '%s'\n",cmd,tail);\r
\r
if (cmd==NULL)\r
{\r
line++;\r
}\r
} while (!(KeyEvent.bKeyDown && KeyEvent.AsciiChar == '\n'));\r
+ ReadFile(KeyboardHandle,\r
+ &KeyEvent,\r
+ sizeof(KEY_EVENT_RECORD),\r
+ &Result,\r
+ NULL);\r
line--;\r
*line = 0;\r
}\r
CHECKPOINT;
DPRINT("KbdDpcRoutine(DeviceObject %x, Irp %x)\n",
- DeviceObject,Irp);
+ DeviceObject,Irp);
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp,IO_NO_INCREMENT);
ProcessScanCode(thisKey,isDown);
- DPRINT("Key: '%c'\n",VirtualToAscii(ScanToVirtual(thisKey),isDown));
+// DbgPrint("Key: %c\n",VirtualToAscii(ScanToVirtual(thisKey),isDown));
+// DbgPrint("Key: %x\n",ScanToVirtual(thisKey));
+ if (ScanToVirtual(thisKey)==0x2a)
+ {
+ KeBugCheck(0);
+ }
if (CurrentIrp!=NULL)
{
-
-
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
- * FILE: services/fs/vfat/blockdev.c
- * PURPOSE: Temporary sector reading support
- * PROGRAMMER: David Welch (welch@mcmail.com)
- * UPDATE HISTORY:
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ddk/ntddk.h>
-#include <internal/string.h>
-#include <wstring.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-#include "vfat.h"
-//#include "dbgpool.c"
-/* FUNCTIONS ***************************************************************/
-
-BOOLEAN VFATReadSectors(IN PDEVICE_OBJECT pDeviceObject,
- IN ULONG DiskSector,
- IN ULONG SectorCount,
- IN UCHAR* Buffer)
-{
- LARGE_INTEGER sectorNumber;
- PIRP irp;
- IO_STATUS_BLOCK ioStatus;
- KEVENT event;
- NTSTATUS status;
- ULONG sectorSize;
- PULONG mbr;
-
- DPRINT("VFATReadSector(pDeviceObject %x, DiskSector %d,count %d, Buffer %x)\n",
- pDeviceObject,DiskSector,SectorCount,Buffer);
-
- SET_LARGE_INTEGER_LOW_PART(sectorNumber, DiskSector << 9);
- SET_LARGE_INTEGER_HIGH_PART(sectorNumber, DiskSector >> 23);
-
- KeInitializeEvent(&event, NotificationEvent, FALSE);
-
- sectorSize = BLOCKSIZE*SectorCount;
-
-DPRINT("SectorCount=%d,sectorSize=%d,BLOCKSIZE=%d\n",SectorCount,sectorSize,BLOCKSIZE);
- mbr = ExAllocatePool(NonPagedPool, sectorSize);
- if (!mbr) {
- return FALSE;
- }
-
- irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
- pDeviceObject,
- mbr,
- sectorSize,
- §orNumber,
- &event,
- &ioStatus );
-
- if (!irp) {
- DbgPrint("READ failed!!!\n");
- ExFreePool(mbr);
- return FALSE;
- }
-
- status = IoCallDriver(pDeviceObject,
- irp);
-
- if (status == STATUS_PENDING) {
- KeWaitForSingleObject(&event,
- Suspended,
- KernelMode,
- FALSE,
- NULL);
- status = ioStatus.Status;
- }
-
- if (!NT_SUCCESS(status)) {
- DbgPrint("IO failed!!! VFATREadSectors : Error code: %x\n", status);
- DbgPrint("(pDeviceObject %x, DiskSector %x, Buffer %x, offset 0x%x%x)\n",
- pDeviceObject,
- DiskSector,
- Buffer,
- GET_LARGE_INTEGER_HIGH_PART(sectorNumber),
- GET_LARGE_INTEGER_LOW_PART(sectorNumber));
- ExFreePool(mbr);
- return FALSE;
- }
-
- RtlCopyMemory(Buffer,mbr,sectorSize);
-
- ExFreePool(mbr);
- return TRUE;
-}
-
-BOOLEAN VFATWriteSectors(IN PDEVICE_OBJECT pDeviceObject,
- IN ULONG DiskSector,
- IN ULONG SectorCount,
- IN UCHAR* Buffer)
-{
- LARGE_INTEGER sectorNumber;
- PIRP irp;
- IO_STATUS_BLOCK ioStatus;
- KEVENT event;
- NTSTATUS status;
- ULONG sectorSize;
- PULONG mbr;
-
- DPRINT("VFATWriteSector(pDeviceObject %x, DiskSector %d, count %d, Buffer %x)\n",
- pDeviceObject,DiskSector,SectorCount,Buffer);
- SET_LARGE_INTEGER_LOW_PART(sectorNumber, DiskSector << 9);
- SET_LARGE_INTEGER_HIGH_PART(sectorNumber, DiskSector >> 23);
-
- KeInitializeEvent(&event, NotificationEvent, FALSE);
-
- sectorSize = BLOCKSIZE*SectorCount;
-
- mbr = ExAllocatePool(NonPagedPool, sectorSize);
-
- if (!mbr) {
- return FALSE;
- }
- memcpy(mbr,Buffer,sectorSize);
-
- DPRINT("Building synchronous FSD Request...\n");
- irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE,
- pDeviceObject,
- mbr,
- sectorSize,
- §orNumber,
- &event,
- &ioStatus );
-
- if (!irp) {
- DbgPrint("WRITE failed!!!\n");
- ExFreePool(mbr);
- return FALSE;
- }
-
- DPRINT("Calling IO Driver...\n");
- status = IoCallDriver(pDeviceObject,
- irp);
-
- DPRINT("Waiting for IO Operation...\n");
- if (status == STATUS_PENDING) {
- KeWaitForSingleObject(&event,
- Suspended,
- KernelMode,
- FALSE,
- NULL);
- DPRINT("Getting IO Status...\n");
- status = ioStatus.Status;
- }
-
- if (!NT_SUCCESS(status)) {
- DbgPrint("IO failed!!! VFATWriteSectors : Error code: %x\n", status);
- ExFreePool(mbr);
- return FALSE;
- }
-
- DPRINT("Copying memory...\n");
- RtlCopyMemory(Buffer,mbr,sectorSize);
-
- ExFreePool(mbr);
- DPRINT("Block request succeeded\n");
- return TRUE;
-}
-
-
+/*\r
+ * COPYRIGHT: See COPYING in the top level directory\r
+ * PROJECT: ReactOS kernel\r
+ * FILE: services/fs/vfat/blockdev.c\r
+ * PURPOSE: Temporary sector reading support\r
+ * PROGRAMMER: David Welch (welch@mcmail.com)\r
+ * UPDATE HISTORY: \r
+ */\r
+\r
+/* INCLUDES *****************************************************************/\r
+\r
+#include <ddk/ntddk.h>\r
+#include <internal/string.h>\r
+#include <wstring.h>\r
+\r
+#define NDEBUG\r
+#include <internal/debug.h>\r
+\r
+#include "vfat.h"\r
+\r
+/* FUNCTIONS ***************************************************************/\r
+\r
+BOOLEAN VFATReadSectors(IN PDEVICE_OBJECT pDeviceObject,\r
+ IN ULONG DiskSector,\r
+ IN ULONG SectorCount,\r
+ IN UCHAR* Buffer)\r
+{\r
+ LARGE_INTEGER sectorNumber;\r
+ PIRP irp;\r
+ IO_STATUS_BLOCK ioStatus;\r
+ KEVENT event;\r
+ NTSTATUS status;\r
+ ULONG sectorSize;\r
+ \r
+ SET_LARGE_INTEGER_LOW_PART(sectorNumber, DiskSector << 9);\r
+ SET_LARGE_INTEGER_HIGH_PART(sectorNumber, DiskSector >> 23);\r
+ KeInitializeEvent(&event, NotificationEvent, FALSE);\r
+ sectorSize = BLOCKSIZE * SectorCount;\r
+\r
+ /* FIXME: this routine does not need to alloc mem and copy */\r
+\r
+\r
+ DPRINT("VFATReadSector(pDeviceObject %x, DiskSector %d, Buffer %x)\n",\r
+ pDeviceObject,\r
+ DiskSector,\r
+ Buffer);\r
+ DPRINT("sectorNumber %08lx:%08lx sectorSize %ld\n", \r
+ (unsigned long int)GET_LARGE_INTEGER_HIGH_PART(sectorNumber),\r
+ (unsigned long int)GET_LARGE_INTEGER_LOW_PART(sectorNumber),\r
+ sectorSize);\r
+\r
+\r
+ DPRINT("Building synchronous FSD Request...\n");\r
+ irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,\r
+ pDeviceObject,\r
+ Buffer,\r
+ sectorSize,\r
+ §orNumber,\r
+ &event,\r
+ &ioStatus );\r
+\r
+ if (!irp) {\r
+ DbgPrint("READ failed!!!\n");\r
+ return FALSE;\r
+ }\r
+\r
+ DPRINT("Calling IO Driver...\n");\r
+ status = IoCallDriver(pDeviceObject,\r
+ irp);\r
+\r
+ DPRINT("Waiting for IO Operation...\n");\r
+ if (status == STATUS_PENDING) {\r
+ KeWaitForSingleObject(&event,\r
+ Suspended,\r
+ KernelMode,\r
+ FALSE,\r
+ NULL);\r
+ DPRINT("Getting IO Status...\n");\r
+ status = ioStatus.Status;\r
+ }\r
+\r
+ if (!NT_SUCCESS(status)) {\r
+ DbgPrint("IO failed!!! VFATREadSectors : Error code: %x\n", status);\r
+ DbgPrint("(pDeviceObject %x, DiskSector %x, Buffer %x, offset 0x%x%x)\n",\r
+ pDeviceObject,\r
+ DiskSector,\r
+ Buffer,\r
+ GET_LARGE_INTEGER_HIGH_PART(sectorNumber),\r
+ GET_LARGE_INTEGER_LOW_PART(sectorNumber));\r
+ return FALSE;\r
+ }\r
+\r
+ DPRINT("Copying memory...\n");\r
+ DPRINT("Block request succeeded\n");\r
+ return TRUE;\r
+}\r
+\r
+BOOLEAN VFATWriteSectors(IN PDEVICE_OBJECT pDeviceObject,\r
+ IN ULONG DiskSector,\r
+ IN ULONG SectorCount,\r
+ IN UCHAR* Buffer)\r
+{\r
+ LARGE_INTEGER sectorNumber;\r
+ PIRP irp;\r
+ IO_STATUS_BLOCK ioStatus;\r
+ KEVENT event;\r
+ NTSTATUS status;\r
+ ULONG sectorSize;\r
+ PULONG mbr;\r
+ \r
+ DPRINT("VFATWriteSector(pDeviceObject %x, DiskSector %d, Buffer %x)\n",\r
+ pDeviceObject,DiskSector,Buffer);\r
+\r
+ SET_LARGE_INTEGER_LOW_PART(sectorNumber, DiskSector << 9);\r
+ SET_LARGE_INTEGER_HIGH_PART(sectorNumber, DiskSector >> 23);\r
+\r
+ KeInitializeEvent(&event, NotificationEvent, FALSE);\r
+\r
+ sectorSize = BLOCKSIZE*SectorCount;\r
+\r
+ mbr = ExAllocatePool(NonPagedPool, sectorSize);\r
+\r
+ if (!mbr) {\r
+ return FALSE;\r
+ }\r
+\r
+\r
+ DPRINT("Building synchronous FSD Request...\n");\r
+ irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE,\r
+ pDeviceObject,\r
+ mbr,\r
+ sectorSize,\r
+ §orNumber,\r
+ &event,\r
+ &ioStatus );\r
+\r
+ if (!irp) {\r
+ DbgPrint("WRITE failed!!!\n");\r
+ ExFreePool(mbr);\r
+ return FALSE;\r
+ }\r
+\r
+ DPRINT("Calling IO Driver...\n");\r
+ status = IoCallDriver(pDeviceObject,\r
+ irp);\r
+\r
+ DPRINT("Waiting for IO Operation...\n");\r
+ if (status == STATUS_PENDING) {\r
+ KeWaitForSingleObject(&event,\r
+ Suspended,\r
+ KernelMode,\r
+ FALSE,\r
+ NULL);\r
+ DPRINT("Getting IO Status...\n");\r
+ status = ioStatus.Status;\r
+ }\r
+\r
+ if (!NT_SUCCESS(status)) {\r
+ DbgPrint("IO failed!!! VFATWriteSectors : Error code: %x\n", status);\r
+ ExFreePool(mbr);\r
+ return FALSE;\r
+ }\r
+\r
+ DPRINT("Copying memory...\n");\r
+ RtlCopyMemory(Buffer,mbr,sectorSize);\r
+\r
+ ExFreePool(mbr);\r
+ DPRINT("Block request succeeded\n");\r
+ return TRUE;\r
+}\r
+\r
Block=(PUSHORT)DeviceExt->FAT;
CurrentCluster = Block[CurrentCluster];
if (CurrentCluster >= 0xfff8 && CurrentCluster <= 0xffff)
- CurrentCluster = 0xffffffff;
+ CurrentCluster = 0xffffffff;
DPRINT("Returning %x\n",CurrentCluster);
return(CurrentCluster);
}
Status = FindFile(DeviceExt,Fcb,ParentFcb,current,NULL,NULL);
if (Status != STATUS_SUCCESS)
{
- /* FIXME: should the VfatFCB be freed here? */
+ if (Fcb != NULL)
+ {
+ ExFreePool(Fcb);
+ }
+ if (ParentFcb != NULL)
+ {
+ ExFreePool(ParentFcb);
+ }
return(Status);
}
Temp = Fcb;
*/
{
BootSector* Boot;
-
+
Boot = ExAllocatePool(NonPagedPool,512);
VFATReadSectors(DeviceToMount, 0, 1, (UCHAR *)Boot);
-#ifndef __INCLUDE_DDK_PSTYPES_H
-#define __INCLUDE_DDK_PSTYPES_H
-
-#undef WIN32_LEAN_AND_MEAN
-#include <windows.h> // might be redundant
-#include <kernel32/heap.h>
-#include <kernel32/atom.h>
-#include <internal/hal.h>
-
-#ifndef TLS_MINIMUM_AVAILABLE
- #define TLS_MINIMUM_AVAILABLE (64)
-#endif
-#ifndef MAX_PATH
- #define MAX_PATH (260)
-#endif
-
-typedef NTSTATUS (*PKSTART_ROUTINE)(PVOID StartContext);
-
-typedef struct _STACK_INFORMATION
-{
- PVOID BaseAddress;
- PVOID UpperAddress;
-} STACK_INFORMATION, *PSTACK_INFORMATION;
-
-typedef struct linux_sigcontext {
- int sc_gs;
- int sc_fs;
- int sc_es;
- int sc_ds;
- int sc_edi;
- int sc_esi;
- int sc_ebp;
- int sc_esp;
- int sc_ebx;
- int sc_edx;
- int sc_ecx;
- int sc_eax;
- int sc_trapno;
- int sc_err;
- int sc_eip;
- int sc_cs;
- int sc_eflags;
- int sc_esp_at_signal;
- int sc_ss;
- int sc_387;
- int sc_mask;
- int sc_cr2;
-} TRAP_FRAME, *PTRAP_FRAME;
-
-typedef ULONG THREADINFOCLASS;
-
-typedef struct _STARTUPINFOW {
- DWORD cb;
- WCHAR WindowTitle[MAX_PATH];
- WCHAR ImageFile[MAX_PATH];
- WCHAR CommandLine[MAX_PATH];
- WCHAR DllPath[MAX_PATH];
- LPWSTR Reserved[MAX_PATH];
- LPWSTR Desktop[MAX_PATH];
- LPWSTR Title[MAX_PATH];
- DWORD dwX;
- DWORD dwY;
- DWORD dwXSize;
- DWORD dwYSize;
- DWORD dwXCountChars;
- DWORD dwYCountChars;
- DWORD dwFillAttribute;
- DWORD dwFlags;
- WORD wShowWindow;
- WORD cbReserved2;
- unsigned char * lpReserved2;
- HANDLE hStdInput;
- HANDLE hStdOutput;
- HANDLE hStdError;
-} PROCESSINFOW, *PPROCESSINFOW;
-
-
-
-typedef struct _LDR {
- UCHAR Initialized;
- UCHAR InInitializationOrderModuleList;
- PVOID InLoadOrderModuleList;
- PVOID InMemoryOrderModuleList;
-} LDR, *PLDR;
-
-
-typedef struct _NT_PEB
-{
- UCHAR InheritedAddressSpace;
- UCHAR ReadImageFileExecOptions;
- UCHAR BeingDebugged;
- LONG ImageBaseAddress;
- LDR Ldr;
-
- WORD NumberOfProcessors;
- WORD NtGlobalFlag;
-
- PPROCESSINFOW StartupInfo;
- PHEAP ProcessHeap;
- ATOMTABLE LocalAtomTable;
- LPCRITICAL_SECTION CriticalSection;
- DWORD CriticalSectionTimeout;
- WORD MajorVersion;
- WORD MinorVersion;
- WORD BuildNumber;
- WORD PlatformId;
-} NT_PEB, *PNT_PEB;
-
-typedef struct _CLIENT_ID
-{
- HANDLE UniqueProcess;
- HANDLE UniqueThread;
-} CLIENT_ID, *PCLIENT_ID;
-
-typedef struct _NT_TIB {
- struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList;
- PVOID StackBase;
- PVOID StackLimit;
- PVOID SubSystemTib;
- union {
- PVOID FiberData;
- ULONG Version;
- } Fib;
- PVOID ArbitraryUserPointer;
- struct _NT_TIB *Self;
-} NT_TIB, *PNT_TIB;
-
-typedef struct _NT_TEB
-{
-
- NT_TIB Tib;
- CLIENT_ID Cid;
- HANDLE RPCHandle;
- PVOID TlsData[TLS_MINIMUM_AVAILABLE];
- DWORD dwTlsIndex;
- NT_PEB *Peb;
- DWORD LastErrorCode;
- NTSTATUS LastStatusValue;
- DWORD LockCount;
- UCHAR HardErrorMode;
-
-} NT_TEB;
-
-typedef struct _KTHREAD
-{
- DISPATCHER_HEADER DispatcherHeader;
- TIME ElapsedTime;
- TIME KernelTime;
- TIME UserTime;
- STACK_INFORMATION StackInformation;
- PVOID ServiceDescriptorTable; // points to KeServiceDescriptorTable
- KAFFINITY Affinity;
- KPRIORITY CurrentPriority;
- KPRIORITY BasePriority;
- ULONG Quantum;
- UCHAR ThreadState; //Thread state is a typeless enum, otherwise it should be const integer
- ULONG FreezeCount;
- LONG SuspendCount;
- PTRAP_FRAME TrapFrame;
- PVOID *Tls;
- KWAIT_BLOCK WaitBlock[4];
- struct _KMUTANT* MutantList;
- PLIST_ENTRY ApcList;
- UCHAR KernelApcDisable;
- KTIMER TimerBlock;
- KDEVICE_QUEUE DeviceQueue;
- NT_TEB* Teb;
-
- /*
- * PURPOSE: CPU state
- * NOTE: I have temporarily added this to give somewhere to store
- * cpu state when the thread isn't running
- */
- hal_thread_state Context;
- LIST_ENTRY Entry;
- ULONG LastTick;
-} KTHREAD, *PKTHREAD;
-
-
-// According to documentation the stack should have a commited [ 1 page ] and
-// a reserved part [ 1 M ] but can be specified otherwise in the image file.
-
-typedef struct _INITIAL_TEB {
- PVOID StackBase;
- PVOID StackLimit;
- PVOID StackCommit;
- PVOID StackCommitMax;
- PVOID StackReserved;
-} INITIAL_TEB, *PINITIAL_TEB;
-
-
-
-
-
-
-// TopLevelIrp can be one of the following values:
-// FIXME I belong somewhere else
-
-#define FSRTL_FSP_TOP_LEVEL_IRP (0x01)
-#define FSRTL_CACHE_TOP_LEVEL_IRP (0x02)
-#define FSRTL_MOD_WRITE_TOP_LEVEL_IRP (0x03)
-#define FSRTL_FAST_IO_TOP_LEVEL_IRP (0x04)
-#define FSRTL_MAX_TOP_LEVEL_IRP_FLAG (0x04)
-
-typedef struct _TOP_LEVEL_IRP
-{
- PIRP TopLevelIrp;
- ULONG TopLevelIrpConst;
-} TOP_LEVEL_IRP;
-
-typedef struct _ETHREAD {
- KTHREAD Tcb;
- TIME CreateTime;
- TIME ExitTime;
- NTSTATUS ExitStatus;
- LIST_ENTRY PostBlockList;
- LIST_ENTRY TerminationPortList;
- ULONG ActiveTimerListLock;
- PVOID ActiveTimerListHead;
- CLIENT_ID Cid;
- PLARGE_INTEGER LpcReplySemaphore;
- PVOID LpcReplyMessage;
- PLARGE_INTEGER LpcReplyMessageId;
- PVOID ImpersonationInfo;
- LIST_ENTRY IrpList; //
- TOP_LEVEL_IRP TopLevelIrp;
- ULONG ReadClusterSize;
- UCHAR ForwardClusterOnly;
- UCHAR DisablePageFaultClustering;
- UCHAR DeadThread;
- UCHAR HasTerminated;
- ACCESS_MASK GrantedAccess;
- struct _EPROCESS* ThreadsProcess;
- PKSTART_ROUTINE StartAddress;
- LPTHREAD_START_ROUTINE Win32StartAddress; // Should Specify a win32 start func
- UCHAR LpcExitThreadCalled;
- UCHAR HardErrorsAreDisabled;
-} ETHREAD, *PETHREAD;
-
-
-typedef struct _KPROCESS
-{
- DISPATCHER_HEADER DispatcherHeader;
- PVOID PageTableDirectory; // FIXME: I shoud point to a PTD
- TIME ElapsedTime;
- TIME KernelTime;
- TIME UserTime;
- LIST_ENTRY InMemoryList;
- LIST_ENTRY SwappedOutList;
- KSPIN_LOCK SpinLock;
- KAFFINITY Affinity;
- ULONG StackCount;
- KPRIORITY BasePriority;
- ULONG DefaultThreadQuantum;
- UCHAR ProcessState;
- ULONG ThreadSeed;
- UCHAR DisableBoost;
-
- /*
- * Added by David Welch (welch@mcmail.com)
- */
- LIST_ENTRY MemoryAreaList;
- HANDLE_TABLE HandleTable;
-} KPROCESS, *PKPROCESS;
-
-typedef struct _EPROCESS
-{
- KPROCESS Pcb;
-} EPROCESS, *PEPROCESS;
-
-#endif /* __INCLUDE_DDK_PSTYPES_H */
+#ifndef __INCLUDE_DDK_PSTYPES_H\r
+#define __INCLUDE_DDK_PSTYPES_H\r
+\r
+#undef WIN32_LEAN_AND_MEAN\r
+#include <windows.h> // might be redundant\r
+#include <kernel32/heap.h>\r
+#include <kernel32/atom.h>\r
+#include <internal/hal.h>\r
+\r
+#ifndef TLS_MINIMUM_AVAILABLE\r
+ #define TLS_MINIMUM_AVAILABLE (64)\r
+#endif\r
+#ifndef MAX_PATH\r
+ #define MAX_PATH (260)\r
+#endif\r
+\r
+typedef NTSTATUS (*PKSTART_ROUTINE)(PVOID StartContext);\r
+\r
+typedef struct _STACK_INFORMATION \r
+{\r
+ PVOID BaseAddress;\r
+ PVOID UpperAddress;\r
+} STACK_INFORMATION, *PSTACK_INFORMATION;\r
+\r
+typedef struct linux_sigcontext {\r
+ int sc_gs;\r
+ int sc_fs;\r
+ int sc_es;\r
+ int sc_ds;\r
+ int sc_edi;\r
+ int sc_esi;\r
+ int sc_ebp;\r
+ int sc_esp;\r
+ int sc_ebx;\r
+ int sc_edx;\r
+ int sc_ecx;\r
+ int sc_eax;\r
+ int sc_trapno;\r
+ int sc_err;\r
+ int sc_eip;\r
+ int sc_cs;\r
+ int sc_eflags;\r
+ int sc_esp_at_signal;\r
+ int sc_ss;\r
+ int sc_387;\r
+ int sc_mask;\r
+ int sc_cr2;\r
+} TRAP_FRAME, *PTRAP_FRAME;\r
+\r
+typedef ULONG THREADINFOCLASS;\r
+\r
+typedef struct _STARTUPINFOW { \r
+ DWORD cb; \r
+ WCHAR WindowTitle[MAX_PATH];\r
+ WCHAR ImageFile[MAX_PATH]; \r
+ WCHAR CommandLine[MAX_PATH];\r
+ WCHAR DllPath[MAX_PATH];\r
+ LPWSTR Reserved[MAX_PATH]; \r
+ LPWSTR Desktop[MAX_PATH]; \r
+ LPWSTR Title[MAX_PATH]; \r
+ DWORD dwX; \r
+ DWORD dwY; \r
+ DWORD dwXSize; \r
+ DWORD dwYSize; \r
+ DWORD dwXCountChars; \r
+ DWORD dwYCountChars; \r
+ DWORD dwFillAttribute; \r
+ DWORD dwFlags; \r
+ WORD wShowWindow; \r
+ WORD cbReserved2; \r
+ unsigned char * lpReserved2; \r
+ HANDLE hStdInput; \r
+ HANDLE hStdOutput; \r
+ HANDLE hStdError; \r
+} PROCESSINFOW, *PPROCESSINFOW; \r
+\r
+\r
+\r
+typedef struct _LDR {\r
+ UCHAR Initialized;\r
+ UCHAR InInitializationOrderModuleList;\r
+ PVOID InLoadOrderModuleList;\r
+ PVOID InMemoryOrderModuleList;\r
+} LDR, *PLDR;\r
+\r
+\r
+typedef struct _NT_PEB\r
+{\r
+ UCHAR InheritedAddressSpace;\r
+ UCHAR ReadImageFileExecOptions;\r
+ UCHAR BeingDebugged;\r
+ LONG ImageBaseAddress; \r
+ LDR Ldr;\r
+\r
+ WORD NumberOfProcessors;\r
+ WORD NtGlobalFlag;\r
+\r
+ PPROCESSINFOW StartupInfo;\r
+ PHEAP ProcessHeap; \r
+ ATOMTABLE LocalAtomTable;\r
+ LPCRITICAL_SECTION CriticalSection;\r
+ DWORD CriticalSectionTimeout; \r
+ WORD MajorVersion; \r
+ WORD MinorVersion; \r
+ WORD BuildNumber; \r
+ WORD PlatformId; \r
+} NT_PEB, *PNT_PEB; \r
+\r
+typedef struct _CLIENT_ID \r
+{\r
+ HANDLE UniqueProcess;\r
+ HANDLE UniqueThread;\r
+} CLIENT_ID, *PCLIENT_ID;\r
+\r
+typedef struct _NT_TIB {\r
+ struct _EXCEPTION_REGISTRATION_RECORD *ExceptionList;\r
+ PVOID StackBase;\r
+ PVOID StackLimit;\r
+ PVOID SubSystemTib;\r
+ union {\r
+ PVOID FiberData;\r
+ ULONG Version;\r
+ } Fib;\r
+ PVOID ArbitraryUserPointer;\r
+ struct _NT_TIB *Self;\r
+} NT_TIB, *PNT_TIB;\r
+\r
+typedef struct _NT_TEB\r
+{\r
+\r
+ NT_TIB Tib; \r
+ CLIENT_ID Cid;\r
+ HANDLE RPCHandle;\r
+ PVOID TlsData[TLS_MINIMUM_AVAILABLE];\r
+ DWORD dwTlsIndex;\r
+ NT_PEB *Peb; \r
+ DWORD LastErrorCode;\r
+ NTSTATUS LastStatusValue; \r
+ DWORD LockCount;\r
+ UCHAR HardErrorMode;\r
+ \r
+} NT_TEB;\r
+\r
+typedef struct _KTHREAD \r
+{\r
+ DISPATCHER_HEADER DispatcherHeader;\r
+ TIME ElapsedTime;\r
+ TIME KernelTime;\r
+ TIME UserTime;\r
+ STACK_INFORMATION StackInformation;\r
+ PVOID ServiceDescriptorTable; // points to KeServiceDescriptorTable\r
+ KAFFINITY Affinity;\r
+ KPRIORITY CurrentPriority;\r
+ KPRIORITY BasePriority;\r
+ ULONG Quantum;\r
+ UCHAR ThreadState; //Thread state is a typeless enum, otherwise it should be const integer\r
+ ULONG FreezeCount;\r
+ LONG SuspendCount;\r
+ PTRAP_FRAME TrapFrame; \r
+ PVOID *Tls;\r
+ KWAIT_BLOCK WaitBlock[4]; \r
+ struct _KMUTANT* MutantList;\r
+ PLIST_ENTRY ApcList;\r
+ UCHAR KernelApcDisable;\r
+ KTIMER TimerBlock;\r
+ KDEVICE_QUEUE DeviceQueue;\r
+ NT_TEB* Teb;\r
+ \r
+ /*\r
+ * PURPOSE: CPU state\r
+ * NOTE: I have temporarily added this to give somewhere to store\r
+ * cpu state when the thread isn't running\r
+ */\r
+ hal_thread_state Context;\r
+ LIST_ENTRY Entry;\r
+ ULONG LastTick;\r
+} KTHREAD, *PKTHREAD;\r
+\r
+\r
+// According to documentation the stack should have a commited [ 1 page ] and\r
+// a reserved part [ 1 M ] but can be specified otherwise in the image file.\r
+\r
+typedef struct _INITIAL_TEB {\r
+ PVOID StackBase;\r
+ PVOID StackLimit;\r
+ PVOID StackCommit;\r
+ PVOID StackCommitMax;\r
+ PVOID StackReserved;\r
+} INITIAL_TEB, *PINITIAL_TEB;\r
+\r
+\r
+\r
+\r
+\r
+\r
+// TopLevelIrp can be one of the following values:\r
+// FIXME I belong somewhere else\r
+\r
+#define FSRTL_FSP_TOP_LEVEL_IRP (0x01)\r
+#define FSRTL_CACHE_TOP_LEVEL_IRP (0x02)\r
+#define FSRTL_MOD_WRITE_TOP_LEVEL_IRP (0x03)\r
+#define FSRTL_FAST_IO_TOP_LEVEL_IRP (0x04)\r
+#define FSRTL_MAX_TOP_LEVEL_IRP_FLAG (0x04)\r
+\r
+typedef struct _TOP_LEVEL_IRP\r
+{\r
+ PIRP TopLevelIrp;\r
+ ULONG TopLevelIrpConst;\r
+} TOP_LEVEL_IRP;\r
+\r
+typedef struct _ETHREAD {\r
+ KTHREAD Tcb;\r
+ TIME CreateTime;\r
+ TIME ExitTime;\r
+ NTSTATUS ExitStatus;\r
+ LIST_ENTRY PostBlockList;\r
+ LIST_ENTRY TerminationPortList; \r
+ ULONG ActiveTimerListLock;\r
+ PVOID ActiveTimerListHead;\r
+ CLIENT_ID Cid;\r
+ PLARGE_INTEGER LpcReplySemaphore;\r
+ PVOID LpcReplyMessage;\r
+ PLARGE_INTEGER LpcReplyMessageId;\r
+ PVOID ImpersonationInfo;\r
+ LIST_ENTRY IrpList; //\r
+ TOP_LEVEL_IRP TopLevelIrp;\r
+ ULONG ReadClusterSize;\r
+ UCHAR ForwardClusterOnly;\r
+ UCHAR DisablePageFaultClustering;\r
+ UCHAR DeadThread;\r
+ UCHAR HasTerminated;\r
+ ACCESS_MASK GrantedAccess;\r
+ struct _EPROCESS* ThreadsProcess;\r
+ PKSTART_ROUTINE StartAddress;\r
+ LPTHREAD_START_ROUTINE Win32StartAddress; // Should Specify a win32 start func\r
+ UCHAR LpcExitThreadCalled;\r
+ UCHAR HardErrorsAreDisabled;\r
+} ETHREAD, *PETHREAD;\r
+\r
+\r
+typedef struct _KPROCESS \r
+{\r
+ DISPATCHER_HEADER DispatcherHeader;\r
+ PVOID PageTableDirectory; // FIXME: I shoud point to a PTD\r
+ TIME ElapsedTime;\r
+ TIME KernelTime;\r
+ TIME UserTime;\r
+ LIST_ENTRY InMemoryList; \r
+ LIST_ENTRY SwappedOutList; \r
+ KSPIN_LOCK SpinLock;\r
+ KAFFINITY Affinity;\r
+ ULONG StackCount;\r
+ KPRIORITY BasePriority;\r
+ ULONG DefaultThreadQuantum;\r
+ UCHAR ProcessState;\r
+ ULONG ThreadSeed;\r
+ UCHAR DisableBoost;\r
+ \r
+ /*\r
+ * Added by David Welch (welch@mcmail.com)\r
+ */\r
+ LIST_ENTRY MemoryAreaList;\r
+ HANDLE_TABLE HandleTable;\r
+} KPROCESS, *PKPROCESS;\r
+\r
+typedef struct _EPROCESS\r
+{\r
+ KPROCESS Pcb;\r
+} EPROCESS, *PEPROCESS;\r
+\r
+#define PROCESS_STATE_TERMINATED (1)\r
+#define PROCESS_STATE_ACTIVE (2)\r
+\r
+#endif /* __INCLUDE_DDK_PSTYPES_H */\r
-#ifndef __INCLUDE_INTERNAL_PSMGR_H
-#define __INCLUDE_INTERNAL_PSMGR_H
-
-#include <internal/hal.h>
-
-extern PEPROCESS SystemProcess;
-extern HANDLE SystemProcessHandle;
-
-extern POBJECT_TYPE PsThreadType;
-extern POBJECT_TYPE PsProcessType;
-
-void PsInitThreadManagment(void);
-VOID PsInitProcessManagment(VOID);
-VOID PsInitIdleThread(VOID);
-VOID PsDispatchThread(VOID);
-
-/*
- * PURPOSE: Thread states
- */
-enum
-{
- /*
- * PURPOSE: Don't touch
- */
- THREAD_STATE_INVALID,
-
- /*
- * PURPOSE: Waiting to be dispatched
- */
- THREAD_STATE_RUNNABLE,
-
- /*
- * PURPOSE: Currently running
- */
- THREAD_STATE_RUNNING,
-
- /*
- * PURPOSE: Doesn't want to run
- */
- THREAD_STATE_SUSPENDED,
-
- /*
- * Waiting to be freed
- */
- THREAD_STATE_TERMINATED,
-};
-
-/*
- * Functions the HAL must provide
- */
-
-void HalInitFirstTask(PETHREAD thread);
-BOOLEAN HalInitTask(PETHREAD thread, PKSTART_ROUTINE fn, PVOID StartContext);
-void HalTaskSwitch(PKTHREAD thread);
-NTSTATUS HalInitTaskWithContext(PETHREAD Thread, PCONTEXT Context);
-
-#endif
+#ifndef __INCLUDE_INTERNAL_PSMGR_H\r
+#define __INCLUDE_INTERNAL_PSMGR_H\r
+\r
+#include <internal/hal.h>\r
+\r
+extern PEPROCESS SystemProcess;\r
+extern HANDLE SystemProcessHandle;\r
+\r
+extern POBJECT_TYPE PsThreadType;\r
+extern POBJECT_TYPE PsProcessType;\r
+\r
+void PsInitThreadManagment(void);\r
+VOID PsInitProcessManagment(VOID);\r
+VOID PsInitIdleThread(VOID);\r
+VOID PsDispatchThread(VOID);\r
+VOID PiTerminateProcessThreads(PEPROCESS Process, NTSTATUS ExitStatus);\r
+\r
+/*\r
+ * PURPOSE: Thread states\r
+ */\r
+enum\r
+{\r
+ /*\r
+ * PURPOSE: Don't touch \r
+ */\r
+ THREAD_STATE_INVALID,\r
+ \r
+ /*\r
+ * PURPOSE: Waiting to be dispatched\r
+ */\r
+ THREAD_STATE_RUNNABLE,\r
+ \r
+ /*\r
+ * PURPOSE: Currently running\r
+ */\r
+ THREAD_STATE_RUNNING,\r
+ \r
+ /*\r
+ * PURPOSE: Doesn't want to run\r
+ */\r
+ THREAD_STATE_SUSPENDED,\r
+ \r
+ /*\r
+ * Waiting to be freed\r
+ */\r
+ THREAD_STATE_TERMINATED,\r
+};\r
+\r
+/*\r
+ * Functions the HAL must provide\r
+ */\r
+\r
+void HalInitFirstTask(PETHREAD thread);\r
+BOOLEAN HalInitTask(PETHREAD thread, PKSTART_ROUTINE fn, PVOID StartContext);\r
+void HalTaskSwitch(PKTHREAD thread);\r
+NTSTATUS HalInitTaskWithContext(PETHREAD Thread, PCONTEXT Context);\r
+\r
+#endif\r
#include <windows.h>
+#ifdef NDEBUG
+#define DPRINT(args...)
+#else
+#define DPRINT(args...) do { dprintf("(KERNEL32:%s:%d) ",__FILE__,__LINE__); dprintf(args); } while(0);
+#endif
+
void dprintf(char* fmt, ...);
void aprintf(char* fmt, ...);
-/*
- * Adapted from linux for the reactos kernel, march 1998 -- David Welch
- * Added wide character string functions, june 1998 -- Boudewijn Dekker
- * Removed extern specifier from ___wcstok, june 1998 -- Boudewijn Dekker
- * Added wcsicmp and wcsnicmp -- Boudewijn Dekker
- */
-
-#ifndef _LINUX_WSTRING_H_
-#define _LINUX_WSTRING_H_
-
-#include <types.h> /* for size_t */
-
-typedef unsigned short wchar_t;
-
-#ifndef NULL
-#define NULL ((void *) 0)
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-extern wchar_t * ___wcstok;
-extern wchar_t * wcscpy(wchar_t *,const wchar_t *);
-extern wchar_t * wcsncpy(wchar_t *,const wchar_t *, __kernel_size_t);
-extern wchar_t * wcscat(wchar_t *, const wchar_t *);
-extern wchar_t * wcsncat(wchar_t *, const wchar_t *, __kernel_size_t);
-extern int wcscmp(const wchar_t *,const wchar_t *);
-extern int wcsncmp(const wchar_t *,const wchar_t *,__kernel_size_t);
-wchar_t* wcschr(const wchar_t* str, wchar_t ch);
-extern wchar_t * wcsrchr(const wchar_t *,wchar_t);
-extern wchar_t * wcspbrk(const wchar_t *,const wchar_t *);
-extern wchar_t * wcstok(wchar_t *,const wchar_t *);
-extern wchar_t * wcsstr(const wchar_t *,const wchar_t *);
-extern size_t wcsnlen(const wchar_t * s, size_t count);
-extern int wcsicmp(const wchar_t* cs,const wchar_t * ct);
-extern int wcsnicmp(const wchar_t* cs,const wchar_t * ct, size_t count);
-extern size_t wcscspn(const wchar_t *, const wchar_t *);
-extern size_t wcslen(const wchar_t *);
-extern size_t wcsspn(const wchar_t *, const wchar_t *);
-
-extern unsigned long wstrlen(PWSTR);
-WCHAR wtoupper(WCHAR c);
-WCHAR wtolower(WCHAR c);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
+/*\r
+ * Adapted from linux for the reactos kernel, march 1998 -- David Welch\r
+ * Added wide character string functions, june 1998 -- Boudewijn Dekker\r
+ * Removed extern specifier from ___wcstok, june 1998 -- Boudewijn Dekker\r
+ * Added wcsicmp and wcsnicmp -- Boudewijn Dekker\r
+ */\r
+\r
+#ifndef _LINUX_WSTRING_H_\r
+#define _LINUX_WSTRING_H_\r
+\r
+#include <types.h> /* for size_t */\r
+\r
+typedef unsigned short wchar_t;\r
+\r
+#ifndef NULL\r
+#define NULL ((void *) 0)\r
+#endif\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+wchar_t* wstrdup(const wchar_t* src);\r
+extern wchar_t * ___wcstok;\r
+extern wchar_t * wcscpy(wchar_t *,const wchar_t *);\r
+extern wchar_t * wcsncpy(wchar_t *,const wchar_t *, __kernel_size_t);\r
+extern wchar_t * wcscat(wchar_t *, const wchar_t *);\r
+extern wchar_t * wcsncat(wchar_t *, const wchar_t *, __kernel_size_t);\r
+extern int wcscmp(const wchar_t *,const wchar_t *);\r
+extern int wcsncmp(const wchar_t *,const wchar_t *,__kernel_size_t);\r
+wchar_t* wcschr(const wchar_t* str, wchar_t ch);\r
+extern wchar_t * wcsrchr(const wchar_t *,wchar_t);\r
+extern wchar_t * wcspbrk(const wchar_t *,const wchar_t *);\r
+extern wchar_t * wcstok(wchar_t *,const wchar_t *);\r
+extern wchar_t * wcsstr(const wchar_t *,const wchar_t *);\r
+extern size_t wcsnlen(const wchar_t * s, size_t count);\r
+extern int wcsicmp(const wchar_t* cs,const wchar_t * ct);\r
+extern int wcsnicmp(const wchar_t* cs,const wchar_t * ct, size_t count);\r
+extern size_t wcscspn(const wchar_t *, const wchar_t *);\r
+extern size_t wcslen(const wchar_t *);\r
+extern size_t wcsspn(const wchar_t *, const wchar_t *);\r
+\r
+extern unsigned long wstrlen(PWSTR);\r
+WCHAR wtoupper(WCHAR c);\r
+WCHAR wtolower(WCHAR c);\r
+ \r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+#endif \r
+\r
--- /dev/null
+;\r
+; crtdll.def\r
+;\r
+; Exports from crtdll.dll from Windows 95 SYSTEM directory. Hopefully this\r
+; should also work with the crtdll provided with Windows NT.\r
+;\r
+; Contributors:\r
+; Created by Colin Peters <colin@bird.fu.is.saga-u.ac.jp>\r
+;\r
+; THIS SOFTWARE IS NOT COPYRIGHTED\r
+;\r
+; This source code is offered for use in the public domain. You may\r
+; use, modify or distribute it freely.\r
+;\r
+; This code is distributed in the hope that it will be useful but\r
+; WITHOUT ANY WARRANTY. ALL WARRENTIES, EXPRESS OR IMPLIED ARE HEREBY\r
+; DISCLAMED. This includes but is not limited to warrenties of\r
+; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\r
+;\r
+; $Revision: 1.1 $\r
+; $Author: dwelch $\r
+; $Date: 1999/01/04 23:01:18 $\r
+;\r
+; These three functions appear to be name mangled in some way, so GCC is\r
+; probably not going to be able to use them in any case.\r
+;\r
+; ??2@YAPAXI@Z\r
+; ??3@YAXPAX@Z\r
+; ?_set_new_handler@@YAP6AHI@ZP6AHI@Z@Z\r
+;\r
+; These are functions for which I have not yet written prototypes or\r
+; otherwise set up (they are still included below though unlike those\r
+; first three).\r
+;\r
+; _CIacos\r
+; _CIasin\r
+; _CIatan\r
+; _CIatan2\r
+; _CIcos\r
+; _CIcosh\r
+; _CIexp\r
+; _CIfmod\r
+; _CIlog\r
+; _CIlog10\r
+; _CIpow\r
+; _CIsin\r
+; _CIsinh\r
+; _CIsqrt\r
+; _CItan\r
+; _CItanh\r
+; __dllonexit\r
+; __mb_cur_max_dll\r
+; __threadhandle\r
+; __threadid\r
+; _abnormal_termination\r
+; _acmdln_dll\r
+; _aexit_rtn_dll\r
+; _amsg_exit\r
+; _commit\r
+; _commode_dll\r
+; _cpumode_dll\r
+; _ctype\r
+; _daylight_dll\r
+; _environ_dll\r
+; _expand\r
+; _fcloseall\r
+; _filbuf\r
+; _fileinfo_dll\r
+; _flsbuf\r
+; _flushall\r
+; _fmode_dll\r
+; _fpieee_flt\r
+; _fsopen\r
+; _ftol\r
+; _getdiskfree\r
+; _getdllprocaddr\r
+; _getdrive\r
+; _getdrives\r
+; _getsystime\r
+; _getw\r
+; _initterm\r
+; _ismbbalnum\r
+; _ismbbalpha\r
+; _ismbbgraph\r
+; _ismbbkalnum\r
+; _ismbbkana\r
+; _ismbbkpunct\r
+; _ismbblead\r
+; _ismbbprint\r
+; _ismbbpunct\r
+; _ismbbtrail\r
+; _ismbcalpha\r
+; _ismbcdigit\r
+; _ismbchira\r
+; _ismbckata\r
+; _ismbcl0\r
+; _ismbcl1\r
+; _ismbcl2\r
+; _ismbclegal\r
+; _ismbclower\r
+; _ismbcprint\r
+; _ismbcspace\r
+; _ismbcsymbol\r
+; _ismbcupper\r
+; _ismbslead\r
+; _ismbstrail\r
+; _lfind\r
+; _loaddll\r
+; _lrotl\r
+; _lrotr\r
+; _lsearch\r
+; _makepath\r
+; _matherr\r
+; _mbbtombc\r
+; _mbbtype\r
+; _mbccpy\r
+; _mbcjistojms\r
+; _mbcjmstojis\r
+; _mbclen\r
+; _mbctohira\r
+; _mbctokata\r
+; _mbctolower\r
+; _mbctombb\r
+; _mbctoupper\r
+; _mbctype\r
+; _mbsbtype\r
+; _mbscat\r
+; _mbscmp\r
+; _mbscpy\r
+; _mbscspn\r
+; _mbsdec\r
+; _mbsdup\r
+; _mbsicmp\r
+; _mbsinc\r
+; _mbslen\r
+; _mbslwr\r
+; _mbsnbcat\r
+; _mbsnbcmp\r
+; _mbsnbcnt\r
+; _mbsnbcpy\r
+; _mbsnbicmp\r
+; _mbsnbset\r
+; _mbsnccnt\r
+; _mbsncmp\r
+; _mbsncpy\r
+; _mbsnextc\r
+; _mbsnicmp\r
+; _mbsninc\r
+; _mbsnset\r
+; _mbspbrk\r
+; _mbsrchr\r
+; _mbsrev\r
+; _mbsset\r
+; _mbsspn\r
+; _mbsspnp\r
+; _mbsstr\r
+; _mbstrlen\r
+; _mbsupr\r
+; _onexit\r
+; _osver_dll\r
+; _osversion_dll\r
+; _pctype_dll\r
+; _purecall\r
+; _putw\r
+; _pwctype_dll\r
+; _rmtmp\r
+; _rotl\r
+; _rotr\r
+; _setsystime\r
+; _snprintf\r
+; _snwprintf\r
+; _splitpath\r
+; _strdate\r
+; _strdec\r
+; _strinc\r
+; _strncnt\r
+; _strnextc\r
+; _strninc\r
+; _strspnp\r
+; _strtime\r
+; _tempnam\r
+; _timezone_dll\r
+; _tzname\r
+; _tzset\r
+; _ultoa\r
+; _unloaddll\r
+; _vsnprintf\r
+; _vsnwprintf\r
+; _winmajor_dll\r
+; _winminor_dll\r
+; _winver_dll\r
+; _wtoi\r
+; _wtol\r
+;\r
+EXPORTS\r
+_CIacos\r
+_CIasin\r
+_CIatan\r
+_CIatan2\r
+_CIcos\r
+_CIcosh\r
+_CIexp\r
+_CIfmod\r
+_CIlog\r
+_CIlog10\r
+_CIpow\r
+_CIsin\r
+_CIsinh\r
+_CIsqrt\r
+_CItan\r
+_CItanh\r
+_HUGE_dll\r
+_XcptFilter\r
+__GetMainArgs\r
+__argc_dll\r
+__argv_dll\r
+__dllonexit\r
+__doserrno\r
+__fpecode\r
+__isascii\r
+__iscsym\r
+__iscsymf\r
+__mb_cur_max_dll\r
+__pxcptinfoptrs\r
+__threadhandle\r
+__threadid\r
+__toascii\r
+_abnormal_termination\r
+_access\r
+_acmdln_dll\r
+_aexit_rtn_dll\r
+_amsg_exit\r
+_assert\r
+_basemajor_dll\r
+_baseminor_dll\r
+_baseversion_dll\r
+_beep\r
+_beginthread\r
+_c_exit\r
+_cabs\r
+_cexit\r
+_cgets\r
+_chdir\r
+_chdrive\r
+_chgsign\r
+_chmod\r
+_chsize\r
+_clearfp\r
+_close\r
+_commit\r
+_commode_dll\r
+_control87\r
+_controlfp\r
+_copysign\r
+_cprintf\r
+_cpumode_dll\r
+_cputs\r
+_creat\r
+_cscanf\r
+_ctype\r
+_cwait\r
+_daylight_dll\r
+_dup\r
+_dup2\r
+_ecvt\r
+_endthread\r
+_environ_dll\r
+_eof\r
+_errno\r
+_except_handler2\r
+_execl\r
+_execle\r
+_execlp\r
+_execlpe\r
+_execv\r
+_execve\r
+_execvp\r
+_execvpe\r
+_exit\r
+_expand\r
+_fcloseall\r
+_fcvt\r
+_fdopen\r
+_fgetchar\r
+_fgetwchar\r
+_filbuf\r
+_fileinfo_dll\r
+_filelength\r
+_fileno\r
+_findclose\r
+_findfirst\r
+_findnext\r
+_finite\r
+_flsbuf\r
+_flushall\r
+_fmode_dll\r
+_fpclass\r
+_fpieee_flt\r
+_fpreset\r
+_fputchar\r
+_fputwchar\r
+_fsopen\r
+_fstat\r
+_ftime\r
+_ftol\r
+_fullpath\r
+_futime\r
+_gcvt\r
+_get_osfhandle\r
+_getch\r
+_getche\r
+_getcwd\r
+_getdcwd\r
+_getdiskfree\r
+_getdllprocaddr\r
+_getdrive\r
+_getdrives\r
+_getpid\r
+_getsystime\r
+_getw\r
+_global_unwind2\r
+_heapchk\r
+_heapmin\r
+_heapset\r
+_heapwalk\r
+_hypot\r
+_initterm\r
+_iob\r
+_isatty\r
+_isctype\r
+_ismbbalnum\r
+_ismbbalpha\r
+_ismbbgraph\r
+_ismbbkalnum\r
+_ismbbkana\r
+_ismbbkpunct\r
+_ismbblead\r
+_ismbbprint\r
+_ismbbpunct\r
+_ismbbtrail\r
+_ismbcalpha\r
+_ismbcdigit\r
+_ismbchira\r
+_ismbckata\r
+_ismbcl0\r
+_ismbcl1\r
+_ismbcl2\r
+_ismbclegal\r
+_ismbclower\r
+_ismbcprint\r
+_ismbcspace\r
+_ismbcsymbol\r
+_ismbcupper\r
+_ismbslead\r
+_ismbstrail\r
+_isnan\r
+_itoa\r
+_j0\r
+_j1\r
+_jn\r
+_kbhit\r
+_lfind\r
+_loaddll\r
+_local_unwind2\r
+_locking\r
+_logb\r
+_lrotl\r
+_lrotr\r
+_lsearch\r
+_lseek\r
+_ltoa\r
+_makepath\r
+_matherr\r
+_mbbtombc\r
+_mbbtype\r
+_mbccpy\r
+_mbcjistojms\r
+_mbcjmstojis\r
+_mbclen\r
+_mbctohira\r
+_mbctokata\r
+_mbctolower\r
+_mbctombb\r
+_mbctoupper\r
+_mbctype\r
+_mbsbtype\r
+_mbscat\r
+_mbschr\r
+_mbscmp\r
+_mbscpy\r
+_mbscspn\r
+_mbsdec\r
+_mbsdup\r
+_mbsicmp\r
+_mbsinc\r
+_mbslen\r
+_mbslwr\r
+_mbsnbcat\r
+_mbsnbcmp\r
+_mbsnbcnt\r
+_mbsnbcpy\r
+_mbsnbicmp\r
+_mbsnbset\r
+_mbsncat\r
+_mbsnccnt\r
+_mbsncmp\r
+_mbsncpy\r
+_mbsnextc\r
+_mbsnicmp\r
+_mbsninc\r
+_mbsnset\r
+_mbspbrk\r
+_mbsrchr\r
+_mbsrev\r
+_mbsset\r
+_mbsspn\r
+_mbsspnp\r
+_mbsstr\r
+_mbstok\r
+_mbstrlen\r
+_mbsupr\r
+_memccpy\r
+_memicmp\r
+_mkdir\r
+_mktemp\r
+_msize\r
+_nextafter\r
+_onexit\r
+_open\r
+_open_osfhandle\r
+_osmajor_dll\r
+_osminor_dll\r
+_osmode_dll\r
+_osver_dll\r
+_osversion_dll\r
+_pclose\r
+_pctype_dll\r
+_pgmptr_dll\r
+_pipe\r
+_popen\r
+_purecall\r
+_putch\r
+_putenv\r
+_putw\r
+_pwctype_dll\r
+_read\r
+_rmdir\r
+_rmtmp\r
+_rotl\r
+_rotr\r
+_scalb\r
+_searchenv\r
+_seterrormode\r
+_setjmp\r
+_setmode\r
+_setsystime\r
+_sleep\r
+_snprintf\r
+_snwprintf\r
+_sopen\r
+_spawnl\r
+_spawnle\r
+_spawnlp\r
+_spawnlpe\r
+_spawnv\r
+_spawnve\r
+_spawnvp\r
+_spawnvpe\r
+_splitpath\r
+_stat\r
+_statusfp\r
+_strcmpi\r
+_strdate\r
+_strdec\r
+_strdup\r
+_strerror\r
+_stricmp\r
+_stricoll\r
+_strinc\r
+_strlwr\r
+_strncnt\r
+_strnextc\r
+_strnicmp\r
+_strninc\r
+_strnset\r
+_strrev\r
+_strset\r
+_strspnp\r
+_strtime\r
+_strupr\r
+_swab\r
+_sys_errlist\r
+_sys_nerr_dll\r
+_tell\r
+_tempnam\r
+_timezone_dll\r
+_tolower\r
+_toupper\r
+_tzname\r
+_tzset\r
+_ultoa\r
+_umask\r
+_ungetch\r
+_unlink\r
+_unloaddll\r
+_utime\r
+_vsnprintf\r
+_vsnwprintf\r
+_wcsdup\r
+_wcsicmp\r
+_wcsicoll\r
+_wcslwr\r
+_wcsnicmp\r
+_wcsnset\r
+_wcsrev\r
+_wcsset\r
+_wcsupr\r
+_winmajor_dll\r
+_winminor_dll\r
+_winver_dll\r
+_write\r
+_wtoi\r
+_wtol\r
+_y0\r
+_y1\r
+_yn\r
+abort\r
+abs\r
+acos\r
+asctime\r
+asin\r
+atan\r
+atan2\r
+atexit\r
+atof\r
+atoi\r
+atol\r
+bsearch\r
+calloc\r
+ceil\r
+clearerr\r
+clock\r
+cos\r
+cosh\r
+ctime\r
+difftime\r
+div\r
+exit\r
+exp\r
+fabs\r
+fclose\r
+feof\r
+ferror\r
+fflush\r
+fgetc\r
+fgetpos\r
+fgets\r
+fgetwc\r
+floor\r
+fmod\r
+fopen\r
+fprintf\r
+fputc\r
+fputs\r
+fputwc\r
+fread\r
+free\r
+freopen\r
+frexp\r
+fscanf\r
+fseek\r
+fsetpos\r
+ftell\r
+fwprintf\r
+fwrite\r
+fwscanf\r
+getc\r
+getchar\r
+getenv\r
+gets\r
+gmtime\r
+is_wctype\r
+isalnum\r
+isalpha\r
+iscntrl\r
+isdigit\r
+isgraph\r
+isleadbyte\r
+islower\r
+isprint\r
+ispunct\r
+isspace\r
+isupper\r
+iswalnum\r
+iswalpha\r
+iswascii\r
+iswcntrl\r
+iswctype\r
+iswdigit\r
+iswgraph\r
+iswlower\r
+iswprint\r
+iswpunct\r
+iswspace\r
+iswupper\r
+iswxdigit\r
+isxdigit\r
+labs\r
+ldexp\r
+ldiv\r
+localeconv\r
+localtime\r
+log\r
+log10\r
+longjmp\r
+malloc\r
+mblen\r
+mbstowcs\r
+mbtowc\r
+memchr\r
+memcmp\r
+memcpy\r
+memmove\r
+memset\r
+mktime\r
+modf\r
+perror\r
+pow\r
+printf\r
+putc\r
+putchar\r
+puts\r
+qsort\r
+raise\r
+rand\r
+realloc\r
+remove\r
+rename\r
+rewind\r
+scanf\r
+setbuf\r
+setlocale\r
+setvbuf\r
+signal\r
+sin\r
+sinh\r
+sprintf\r
+sqrt\r
+srand\r
+sscanf\r
+strcat\r
+strchr\r
+strcmp\r
+strcoll\r
+strcpy\r
+strcspn\r
+strerror\r
+strftime\r
+strlen\r
+strncat\r
+strncmp\r
+strncpy\r
+strpbrk\r
+strrchr\r
+strspn\r
+strstr\r
+strtod\r
+strtok\r
+strtol\r
+strtoul\r
+strxfrm\r
+swprintf\r
+swscanf\r
+system\r
+tan\r
+tanh\r
+time\r
+tmpfile\r
+tmpnam\r
+tolower\r
+toupper\r
+towlower\r
+towupper\r
+ungetc\r
+ungetwc\r
+vfprintf\r
+vfwprintf\r
+vprintf\r
+vsprintf\r
+vswprintf\r
+vwprintf\r
+wcscat\r
+wcschr\r
+wcscmp\r
+wcscoll\r
+wcscpy\r
+wcscspn\r
+wcsftime\r
+wcslen\r
+wcsncat\r
+wcsncmp\r
+wcsncpy\r
+wcspbrk\r
+wcsrchr\r
+wcsspn\r
+wcsstr\r
+wcstod\r
+wcstok\r
+wcstol\r
+wcstombs\r
+wcstoul\r
+wcsxfrm\r
+wctomb\r
+wprintf\r
+wscanf\r
OBJECTS = $(STRING_OBJECTS) $(STDIO_OBJECTS) $(STDLIB_OBJECTS)
crtdll.a: $(OBJECTS)
- $(AR) vrcs crtdll.a $(OBJECTS)
+ $(AR) rcs crtdll.a $(OBJECTS)
dummy:
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
* FILE: lib/kernel32/file/create.c
- * PURPOSE: Directory functions
+ * PURPOSE: File create/open functions
* PROGRAMMER: Ariadne ( ariadne@xs4all.nl)
- GetTempFileName is modified from WINE [ Alexandre Juiliard ]
+ * GetTempFileName is modified from WINE [ Alexandre Juiliard ]
* UPDATE HISTORY:
* Created 01/11/98
*/
+/* INCLUDES *****************************************************************/
-#undef WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <ddk/ntddk.h>
#include <wstring.h>
#include <kernel32/li.h>
#include <ddk/rtl.h>
+#define NDEBUG
+#include <kernel32/kernel32.h>
+
+/* FUNCTIONS ****************************************************************/
+
HANDLE STDCALL CreateFileA(LPCSTR lpFileName,
DWORD dwDesiredAccess,
DWORD dwShareMode,
WCHAR FileNameW[MAX_PATH];
ULONG i = 0;
- OutputDebugStringA("CreateFileA\n");
+ DPRINT("CreateFileA\n");
while ((*lpFileName)!=0 && i < MAX_PATH)
{
UINT Len = 0;
WCHAR CurrentDir[MAX_PATH];
- OutputDebugStringA("CreateFileW\n");
+ DPRINT("CreateFileW\n");
if (!(dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED))
{
PathNameW[3] = '\\';
PathNameW[4] = 0;
- dprintf("Name %w\n",PathNameW);
+ DPRINT("Name %w\n",PathNameW);
if (lpFileName[0] != L'\\' && lpFileName[1] != L':')
{
Len = GetCurrentDirectoryW(MAX_PATH,CurrentDir);
- dprintf("CurrentDir %w\n",CurrentDir);
+ DPRINT("CurrentDir %w\n",CurrentDir);
lstrcatW(PathNameW,CurrentDir);
- dprintf("Name %w\n",PathNameW);
+ DPRINT("Name %w\n",PathNameW);
}
lstrcatW(PathNameW,lpFileName);
- dprintf("Name %w\n",PathNameW);
+ DPRINT("Name %w\n",PathNameW);
FileNameString.Length = lstrlenW( PathNameW)*sizeof(WCHAR);
* PROJECT: ReactOS system libraries
* FILE: lib/kernel32/file/curdir.c
* PURPOSE: Current directory functions
- * PROGRAMMER: David Welch (welch@mcmail.com)
* UPDATE HISTORY:
* Created 30/09/98
*/
#include <windows.h>
+#define NDEBUG
+#include <kernel32/kernel32.h>
+
/* GLOBALS *******************************************************************/
{
UINT uSize;
- dprintf("CurrentDirectoryW %w\n",CurrentDirectoryW);
+ DPRINT("CurrentDirectoryW %w\n",CurrentDirectoryW);
if ( lpBuffer == NULL )
return 0;
if ( nBufferLength > uSize )
lstrcpynW(lpBuffer,CurrentDirectoryW,uSize);
- dprintf("GetCurrentDirectoryW() = %w\n",lpBuffer);
+ DPRINT("GetCurrentDirectoryW() = %w\n",lpBuffer);
return uSize;
}
{
UINT i;
- dprintf("SetCurrentDirectoryA(lpPathName %s)\n",lpPathName);
+ DPRINT("SetCurrentDirectoryA(lpPathName %s)\n",lpPathName);
if ( lpPathName == NULL )
return FALSE;
}
CurrentDirectoryW[i] = 0;
- dprintf("CurrentDirectoryW = '%w'\n",CurrentDirectoryW);
+ DPRINT("CurrentDirectoryW = '%w'\n",CurrentDirectoryW);
return(TRUE);
}
-WINBOOL
-STDCALL
-SetCurrentDirectoryW(
- LPCWSTR lpPathName
- )
+WINBOOL STDCALL SetCurrentDirectoryW(LPCWSTR lpPathName)
{
if ( lpPathName == NULL )
return FALSE;
#include <wstring.h>\r
#include <ddk/ntddk.h>\r
\r
+#define NDEBUG\r
+#include <kernel32/kernel32.h>\r
+\r
/* TYPES ********************************************************************/\r
\r
typedef struct _KERNEL32_FIND_FILE_DATA\r
TRUE,\r
&(IData->PatternStr),\r
FALSE);\r
- dprintf("Found %w\n",IData->FileInfo.FileName);\r
+ DPRINT("Found %w\n",IData->FileInfo.FileName);\r
lpFindFileData->dwFileAttributes = IData->FileInfo.FileAttributes;\r
if (Status != STATUS_SUCCESS)\r
{\r
UNICODE_STRING DirectoryNameStr;\r
IO_STATUS_BLOCK IoStatusBlock;\r
\r
- dprintf("FindFirstFileW(lpFileName %w, lpFindFileData %x)\n",\r
+ DPRINT("FindFirstFileW(lpFileName %w, lpFindFileData %x)\n",\r
lpFileName, lpFindFileData);\r
\r
GetCurrentDirectoryW(MAX_PATH, CurrentDirectory);\r
Directory[2] = '?';\r
Directory[3] = '\\';\r
Directory[4] = 0;\r
- dprintf("Directory %w\n",Directory);\r
+ DPRINT("Directory %w\n",Directory);\r
wcscat(Directory, CurrentDirectory);\r
- dprintf("Directory %w\n",Directory);\r
+ DPRINT("Directory %w\n",Directory);\r
wcscat(Directory, lpFileName);\r
- dprintf("Directory %w\n",Directory);\r
+ DPRINT("Directory %w\n",Directory);\r
End = wcsrchr(Directory, '\\');\r
*End = 0;\r
\r
wcscpy(Pattern, End+1);\r
\r
- dprintf("Directory %w Pattern %w\n",Directory,Pattern);\r
+ DPRINT("Directory %w Pattern %w\n",Directory,Pattern);\r
\r
IData = HeapAlloc(GetProcessHeap(), \r
HEAP_ZERO_MEMORY, \r
TRUE,\r
&(IData->PatternStr),\r
FALSE);\r
- dprintf("Found %w\n",IData->FileInfo.FileName);\r
+ DPRINT("Found %w\n",IData->FileInfo.FileName);\r
\r
lpFindFileData->dwFileAttributes = IData->FileInfo.FileAttributes;\r
return(IData);\r
* Put the type definitions of the heap in a seperate header. Boudewijn Dekker
*/
-#include <kernel32/proc.h>
+/* INCLUDES *****************************************************************/
+
+#define NDEBUG
#include <kernel32/kernel32.h>
+
+#include <kernel32/proc.h>
#include <kernel32/heap.h>
#include <internal/string.h>
+/* GLOBALS ******************************************************************/
static HEAP_BUCKET __HeapDefaultBuckets[]=
{
PHEAP __ProcessHeap = NULL;
+/* FUNCTIONS ****************************************************************/
+
static BOOL __HeapCommit(PHEAP pheap, LPVOID start, LPVOID end);
static BOOL __HeapDecommit(PHEAP pheap, LPVOID start, LPVOID end);
static LPVOID __HeapAlloc(PHEAP pheap, ULONG flags, ULONG size, ULONG tag);
*********************************************************************/
static BOOL __HeapCommit(PHEAP pheap, LPVOID start, LPVOID end)
{
- dprintf("__HeapCommit( 0x%lX, 0x%lX, 0x%lX)\n",
- (ULONG) pheap, (ULONG) start, (ULONG) end);
+ DPRINT("__HeapCommit( 0x%lX, 0x%lX, 0x%lX)\n",
+ (ULONG) pheap, (ULONG) start, (ULONG) end);
if(end >= pheap->LastBlock)
pheap->LastBlock=end;
*********************************************************************/
static BOOL __HeapDecommit(PHEAP pheap, LPVOID start, LPVOID end)
{
- dprintf("__HeapDecommit( 0x%lX, 0x%lX, 0x%lX)\n",
+ DPRINT("__HeapDecommit( 0x%lX, 0x%lX, 0x%lX)\n",
(ULONG) pheap, (ULONG) start, (ULONG) end);
#ifdef NOT
__VirtualDump();
ULONG freesize;
ULONG allocsize;
- dprintf("__HeapAlloc(pheap %x, flags %x, size %d, tag %x)\n",
+ DPRINT("__HeapAlloc(pheap %x, flags %x, size %d, tag %x)\n",
pheap,flags,size,tag);
pfree=&(pheap->Start);
*/
if(size==0)
{
- dprintf("__HeapReAlloc: freeing memory\n");
+ DPRINT("__HeapReAlloc: freeing memory\n");
__HeapFree(pheap, flags, pold);
return NULL;
}
#endif
else if(newsize < allocsize )
{
- dprintf("__HeapReAlloc: shrinking memory\n");
+ DPRINT("__HeapReAlloc: shrinking memory\n");
/* free remaining region of memory */
prealloc->Size=size | HEAP_NORMAL_TAG;
pnext=HEAP_NEXT(prealloc);
}
else if(newsize == allocsize )
{
- dprintf("__HeapReAlloc: no changes\n");
+ DPRINT("__HeapReAlloc: no changes\n");
/* nothing to do */
prealloc->Size= size | HEAP_NORMAL_TAG;
return pold;
if(((LPVOID) pnext< pheap->End)&& HEAP_ISFREE(pnext) &&
(HEAP_SIZE(pnext) + HEAP_ADMIN_SIZE >=newsize-allocsize))
{
- dprintf("__HeapReAlloc: joining memory\n");
+ DPRINT("__HeapReAlloc: joining memory\n");
oldsize=HEAP_SIZE(prealloc);
prealloc->Size=size | HEAP_NORMAL_TAG;
{
if((flags&HEAP_REALLOC_IN_PLACE_ONLY)==0)
{
- dprintf("__HeapReAlloc: allocating new memory\n");
+ DPRINT("__HeapReAlloc: allocating new memory\n");
/* alloc a new piece of memory */
oldsize=HEAP_SIZE(prealloc);
pmem=__HeapAlloc(pheap, flags, size, HEAP_NORMAL_TAG);
{
PHEAP pheap=(PHEAP) base;
- dprintf("__HeapPrepare(base %x, minsize %d, maxsize %d, flags %x)\n",
+ DPRINT("__HeapPrepare(base %x, minsize %d, maxsize %d, flags %x)\n",
base,minsize,maxsize,flags);
pheap->Magic=MAGIC_HEAP;
PHEAP pheap=hheap;
LPVOID retval;
- aprintf("HeapAlloc( 0x%lX, 0x%lX, 0x%lX )\n",
+ DPRINT("HeapAlloc( 0x%lX, 0x%lX, 0x%lX )\n",
(ULONG) hheap, flags, (ULONG) size );
#ifdef NOT
HeapValidate(hheap, 0, 0);
if( (flags | pheap->Flags) & HEAP_NO_SERIALIZE )
LeaveCriticalSection(&(pheap->Synchronize));
- aprintf("HeapAlloc returns 0x%lX\n", (ULONG) retval);
+ DPRINT("HeapAlloc returns 0x%lX\n", (ULONG) retval);
return retval;
}
PHEAP_BLOCK pfree=((PHEAP_BLOCK)ptr-1);
LPVOID retval;
- aprintf("HeapReAlloc( 0x%lX, 0x%lX, 0x%lX, 0x%lX )\n",
+ DPRINT("HeapReAlloc( 0x%lX, 0x%lX, 0x%lX, 0x%lX )\n",
(ULONG) hheap, flags, (ULONG) ptr, size );
#ifdef NOT
HeapValidate(hheap, 0, 0);
PHEAP_BLOCK pfree=(PHEAP_BLOCK)((LPVOID)ptr-HEAP_ADMIN_SIZE);
BOOL retval;
- aprintf("HeapFree( 0x%lX, 0x%lX, 0x%lX )\n",
+ DPRINT("HeapFree( 0x%lX, 0x%lX, 0x%lX )\n",
(ULONG) hheap, flags, (ULONG) ptr );
#ifdef NOT
HeapValidate(hheap, 0, 0);
*********************************************************************/
HANDLE WINAPI GetProcessHeap(VOID)
{
- aprintf("GetProcessHeap()\n");
+ DPRINT("GetProcessHeap()\n");
return (HANDLE) __ProcessHeap;
}
DWORD retval;
PHEAP pheap;
- aprintf("GetProcessHeaps( %u, 0x%lX )\n", maxheaps, (ULONG) phandles );
+ DPRINT("GetProcessHeaps( %u, 0x%lX )\n", maxheaps, (ULONG) phandles );
pheap= __ProcessHeap;
retval=0;
{
PHEAP pheap=hheap;
- aprintf("HeapLock( 0x%lX )\n", (ULONG) hheap );
+ DPRINT("HeapLock( 0x%lX )\n", (ULONG) hheap );
EnterCriticalSection(&(pheap->Synchronize));
return TRUE;
{
PHEAP pheap=hheap;
- aprintf("HeapUnlock( 0x%lX )\n", (ULONG) hheap );
+ DPRINT("HeapUnlock( 0x%lX )\n", (ULONG) hheap );
LeaveCriticalSection(&(pheap->Synchronize));
return TRUE;
PHEAP_BLOCK palloc=((PHEAP_BLOCK)pmem-1);
DWORD retval=0;
- aprintf("HeapSize( 0x%lX, 0x%lX, 0x%lX )\n",
+ DPRINT("HeapSize( 0x%lX, 0x%lX, 0x%lX )\n",
(ULONG) hheap, flags, (ULONG) pmem );
if(pheap->Magic!=MAGIC_HEAP)
pnext=HEAP_NEXT(pcheck);
if((pprev)&&(HEAP_PREV(pcheck)!=pprev))
{
- dprintf("HeapValidate: linked list invalid, region 0x%lX,"
+ DPRINT("HeapValidate: linked list invalid, region 0x%lX,"
" previous region 0x%lX, list says 0x%lX\n",
(ULONG)pcheck, (ULONG)pprev, (ULONG) HEAP_PREV(pcheck));
return FALSE;
pnextfrag=(PHEAP_FRAGMENT)((LPVOID)pfrag+add);
if(pfrag->Magic!=HEAP_FRAG_MAGIC)
{
- dprintf("HeapValidate: fragment %d magic invalid, region 0x%lX,"
+ DPRINT("HeapValidate: fragment %d magic invalid, region 0x%lX,"
" previous region 0x%lX\n", i, (ULONG)pcheck, (ULONG)pprev);
return FALSE;
}
if(pfrag->Number!=i)
{
- dprintf("HeapValidate: fragment %d number invalid, region 0x%lX,"
+ DPRINT("HeapValidate: fragment %d number invalid, region 0x%lX,"
" previous region 0x%lX\n", i, (ULONG)pcheck, (ULONG)pprev);
return FALSE;
}
number++;
if(pfrag->Sub!=psub)
{
- dprintf("HeapValidate: fragment %d suballoc invalid, region 0x%lX,"
+ DPRINT("HeapValidate: fragment %d suballoc invalid, region 0x%lX,"
" previous region 0x%lX\n", i, (ULONG)pcheck, (ULONG)pprev);
return FALSE;
}
}
if(number!=psub->NumberFree)
{
- dprintf("HeapValidate: invalid number of free fragments, region 0x%lX,"
+ DPRINT("HeapValidate: invalid number of free fragments, region 0x%lX,"
" previous region 0x%lX\n", (ULONG)pcheck, (ULONG)pprev);
return FALSE;
}
- dprintf("HeapValidate: [0x%08lX-0x%08lX] suballocated,"
+ DPRINT("HeapValidate: [0x%08lX-0x%08lX] suballocated,"
" bucket size=%d, bitmap=0x%08lX\n",
(ULONG) pcheck, (ULONG) pnext, pbucket->Size, psub->Bitmap);
}
{
if(HEAP_RSIZE(pcheck)!=HEAP_SIZE(pcheck))
{
- dprintf("HeapValidate: invalid size of free region 0x%lX,"
+ DPRINT("HeapValidate: invalid size of free region 0x%lX,"
" previous region 0x%lX\n",
(ULONG) pcheck, (ULONG) pprev);
return FALSE;
}
- dprintf("HeapValidate: [0x%08lX-0x%08lX] free\n",
+ DPRINT("HeapValidate: [0x%08lX-0x%08lX] free\n",
(ULONG) pcheck, (ULONG) pnext );
}
else if(HEAP_ISNORMAL(pcheck))
{
- dprintf("HeapValidate: [0x%08lX-0x%08lX] allocated\n",
+ DPRINT("HeapValidate: [0x%08lX-0x%08lX] allocated\n",
(ULONG) pcheck, (ULONG) pnext );
}
else
{
- dprintf("HeapValidate: invalid tag %x, region 0x%lX,"
+ DPRINT("HeapValidate: invalid tag %x, region 0x%lX,"
" previous region 0x%lX\n", pcheck->Size>>28,
(ULONG)pcheck, (ULONG)pprev);
return FALSE;
#include <windows.h>
+
+#define NDEBUG
#include <kernel32/kernel32.h>
VOID CopyMemory(PVOID Destination, CONST VOID* Source, DWORD Length)
{
DWORD i;
- dprintf("CopyMemory(Destination %x, Source %x, Length %d)\n",
+ DPRINT("CopyMemory(Destination %x, Source %x, Length %d)\n",
Destination,Source,Length);
for (i=0; i<Length; i++)
return TRUE;
}
-VOID
-STDCALL
-ExitProcess(
- UINT uExitCode
- )
-{
-
- NtTerminateProcess(
- NtCurrentProcess() ,
- uExitCode
- );
-
-
+VOID STDCALL ExitProcess(UINT uExitCode)
+{
+ NtTerminateProcess(NtCurrentProcess() ,uExitCode);
}
VOID
return WaitForSingleObjectEx(hHandle,dwMilliseconds,FALSE);
}
-DWORD
-STDCALL
-WaitForSingleObjectEx(
- HANDLE hHandle,
- DWORD dwMilliseconds,
- BOOL bAlertable
- )
+DWORD STDCALL WaitForSingleObjectEx(HANDLE hHandle,
+ DWORD dwMilliseconds,
+ BOOL bAlertable)
{
-
- NTSTATUS errCode;
- LARGE_INTEGER Time;
- DWORD retCode;
-
+
+ NTSTATUS errCode;
+ PLARGE_INTEGER TimePtr;
+ LARGE_INTEGER Time;
+ DWORD retCode;
+
+ if (dwMilliseconds == INFINITE)
+ {
+ TimePtr = NULL;
+ }
+ else
+ {
SET_LARGE_INTEGER_LOW_PART(Time,dwMilliseconds);
+ TimePtr = &Time;
+ }
- errCode = NtWaitForSingleObject(
- hHandle,
- (BOOLEAN) bAlertable,
- &Time
- );
-
- retCode = RtlNtStatusToDosError(errCode);
- SetLastError(retCode);
- return retCode;
-
-
-
+ errCode = NtWaitForSingleObject(hHandle,
+ (BOOLEAN) bAlertable,
+ TimePtr);
+
+ retCode = RtlNtStatusToDosError(errCode);
+ SetLastError(retCode);
+ return retCode;
}
DWORD
return retCode;
-}
\ No newline at end of file
+}
VOID KeDumpStackFrames(ULONG DummyArg)
{
- PULONG Stack = ((PULONG)&DummyArg)[-1];
+ PULONG Stack = &((&DummyArg)[-1]);
ULONG i;
+ Stack = (PVOID)(((ULONG)Stack) & (~0x3));
+
DbgPrint("Frames:\n");
- for (i=0; i<32; i++)
+ for (i=0; i<1024; i++)
{
- if (Stack[i] > KERNEL_BASE)
+ if (Stack[i] > KERNEL_BASE && Stack[i] < ((ULONG)&etext))
{
DbgPrint("%.8x ",Stack[i]);
}
+ if (Stack[i] == 0xceafbeef)
+ {
+ DbgPrint("IRQ ");
+ }
}
DbgPrint("\n");
}
push ds
push es
+ mov eax,0xceafbeef
+ push eax
+
;
; Load DS
;
; Restore stack, registers and return to interrupted routine
;
pop eax
+
+ pop eax
+
pop es
pop ds
popa
;
pusha
push ds
+ push es
+
+ mov eax,0xceafbeef
+ push eax
;
; Load DS
;
mov ax,KERNEL_DS
mov ds,ax
+ mov es,ax
;
; Mask the related vector at the PIC
; Restore stack, registers and return to the interrupted routine
;
pop eax
+
+ pop eax
+
+ pop es
pop ds
popa
iret
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/io/create.c
* PURPOSE: Handling file create/open apis
- * PROGRAMMER: David Welch (welch@mcmail.com)
+ * PROGRAMMER: David Welch (welch@cwcom.net)
* UPDATE HISTORY:
* 24/05/98: Created
*/
if (Status != STATUS_SUCCESS && Status != STATUS_FS_QUERY_REQUIRED)
{
DPRINT("%s() = Failed to find object\n",__FUNCTION__);
+ ObDereferenceObject(FileObject);
ZwClose(*FileHandle);
*FileHandle=0;
return(STATUS_UNSUCCESSFUL);
FileObject->Flags = FileObject->Flags | FO_DIRECT_DEVICE_OPEN;
FileObject->FileName.Buffer = ExAllocatePool(NonPagedPool,
ObjectAttributes->ObjectName->Length);
- FileObject->FileName.Length = ObjectAttributes->Length;
+ FileObject->FileName.Length = ObjectAttributes->ObjectName->Length;
RtlCopyUnicodeString(&(FileObject->FileName),
ObjectAttributes->ObjectName);
}
if (DeviceObject->DeviceType != FILE_DEVICE_FILE_SYSTEM &&
DeviceObject->DeviceType != FILE_DEVICE_DISK)
{
- CHECKPOINT;
+ ObDereferenceObject(FileObject);
ZwClose(*FileHandle);
*FileHandle=0;
return(STATUS_UNSUCCESSFUL);
Status = IoTryToMountStorageDevice(DeviceObject);
if (Status!=STATUS_SUCCESS)
{
- CHECKPOINT;
+ ObDereferenceObject(FileObject);
ZwClose(*FileHandle);
*FileHandle=0;
return(Status);
}
DPRINT("Remainder %x\n",Remainder);
DPRINT("Remainder %w\n",Remainder);
- FileObject->FileName.Buffer = ExAllocatePool(NonPagedPool,
- wstrlen(Remainder));
- RtlInitUnicodeString(&(FileObject->FileName),Remainder);
+ DPRINT("FileObject->FileName.Buffer %w\n",FileObject->FileName.Buffer);
+ RtlInitUnicodeString(&(FileObject->FileName),wstrdup(Remainder));
DPRINT("FileObject->FileName.Buffer %x %w\n",
FileObject->FileName.Buffer,FileObject->FileName.Buffer);
}
CHECKPOINT;
+ DPRINT("FileObject->FileName.Buffer %x\n",FileObject->FileName.Buffer);
if (CreateOptions & FILE_SYNCHRONOUS_IO_ALERT)
{
Irp = IoAllocateIrp(DeviceObject->StackSize, FALSE);
if (Irp==NULL)
{
+ ExFreePool(FileObject->FileName.Buffer);
+ ObDereferenceObject(FileObject);
ZwClose(*FileHandle);
*FileHandle=0;
return(STATUS_UNSUCCESSFUL);
if (Status!=STATUS_SUCCESS)
{
+ DPRINT("FileObject->FileName.Buffer %x\n",FileObject->FileName.Buffer);
+ ExFreePool(FileObject->FileName.Buffer);
+ ObDereferenceObject(FileObject);
ZwClose(*FileHandle);
*FileHandle=0;
}
PIO_STACK_LOCATION StackPtr;
KEVENT Event;
+ assert(KeGetCurrentIrql()==PASSIVE_LEVEL);
+
DPRINT("ZwReadFile(FileHandle %x Buffer %x Length %x ByteOffset %x, "
"IoStatusBlock %x)\n",
- FileHandle,Buffer,Length,ByteOffset,IoStatusBlock);
+ FileHandle,Buffer,Length,ByteOffset,IoStatusBlock);
Status = ObReferenceObjectByHandle(FileHandle,
FILE_READ_DATA,
NULL);
if (Status != STATUS_SUCCESS)
{
+ DPRINT("ZwReadFile() =");
+ DbgPrintErrorMessage(Status);
return(Status);
}
assert(FileObject != NULL);
{
DeviceObject->Timer = ExAllocatePool(NonPagedPool,sizeof(IO_TIMER));
KeInitializeTimer(&(DeviceObject->Timer->timer));
- KeInitializeDpc(&(DeviceObject->Timer->dpc),(PKDEFERRED_ROUTINE)TimerRoutine,Context);
+ KeInitializeDpc(&(DeviceObject->Timer->dpc),
+ (PKDEFERRED_ROUTINE)TimerRoutine,Context);
return(STATUS_SUCCESS);
}
* level than DISPATCH_LEVEL
*/
{
- KeExpireTimers();
+ if (irq == 0)
+ {
+ KeExpireTimers();
+ }
KeDrainDpcQueue();
PsDispatchThread();
}
PLIST_ENTRY current_entry;
PKDPC current;
KIRQL oldlvl;
-
+
+ DPRINT("KeDrainDpcQueue()\n");
+
KeAcquireSpinLockAtDpcLevel(&DpcQueueLock);
KeRaiseIrql(HIGH_LEVEL,&oldlvl);
current_entry = RemoveHeadList(&DpcQueueHead);
}
-NTSTATUS
-KeAddThreadTimeout(PKTHREAD Thread, PLARGE_INTEGER Interval)
+NTSTATUS KeAddThreadTimeout(PKTHREAD Thread, PLARGE_INTEGER Interval)
{
- assert(Thread != NULL);
- assert(Interval != NULL);
+ assert(Thread != NULL);
+ assert(Interval != NULL);
- KeInitializeTimer(&(Thread->TimerBlock));
- KeSetTimer(&(Thread->TimerBlock),*Interval,NULL);
+ DPRINT("KeAddThreadTimeout(Thread %x, Interval %x)\n",Thread,Interval);
+
+ KeInitializeTimer(&(Thread->TimerBlock));
+ KeSetTimer(&(Thread->TimerBlock),*Interval,NULL);
- return STATUS_SUCCESS;
+ DPRINT("Thread->TimerBlock.entry.Flink %x\n",
+ Thread->TimerBlock.entry.Flink);
+
+ return STATUS_SUCCESS;
}
{
KIRQL oldlvl;
+ DPRINT("KeSetTimerEx(Timer %x)\n",Timer);
+
KeAcquireSpinLock(&timer_list_lock,&oldlvl);
Timer->dpc=Dpc;
if (Timer->running)
{
KeReleaseSpinLock(&timer_list_lock,oldlvl);
-
return TRUE;
}
+ DPRINT("Inserting %x in list\n",&Timer->entry);
+ DPRINT("Timer->entry.Flink %x\n",Timer->entry.Flink);
+ Timer->running=TRUE;
InsertTailList(&timer_list_head,&Timer->entry);
KeReleaseSpinLock(&timer_list_lock,oldlvl);
{
KIRQL oldlvl;
+ DPRINT("KeCancelTimer(Timer %x)\n",Timer);
+
KeAcquireSpinLock(&timer_list_lock,&oldlvl);
if (!Timer->running)
{
+ KeReleaseSpinLock(&timer_list_lock,oldlvl);
return FALSE;
}
RemoveEntryList(&Timer->entry);
+ Timer->running = FALSE;
KeReleaseSpinLock(&timer_list_lock,oldlvl);
return TRUE;
static void HandleExpiredTimer(PKTIMER current)
{
+ DPRINT("HandleExpiredTime(current %x)\n",current);
if (current->dpc!=NULL)
{
DPRINT("current->dpc->DeferredRoutine %x\n",
current->dpc->DeferredContext,
current->dpc->SystemArgument1,
current->dpc->SystemArgument2);
+ DPRINT("Finished dpc routine\n");
}
current->signaled=TRUE;
if (current->period != 0)
PKTIMER current = CONTAINING_RECORD(current_entry,KTIMER,entry);
KIRQL oldlvl;
+ DPRINT("KeExpireTimers()\n");
+ DPRINT("&timer_list_head %x\n",&timer_list_head);
+ DPRINT("current_entry %x\n",current_entry);
+ DPRINT("current_entry->Flink %x\n",current_entry->Flink);
+ DPRINT("current_entry->Flink->Flink %x\n",current_entry->Flink->Flink);
+
KeAcquireSpinLock(&timer_list_lock,&oldlvl);
while (current_entry!=(&timer_list_head))
current = CONTAINING_RECORD(current_entry,KTIMER,entry);
}
KeReleaseSpinLock(&timer_list_lock,oldlvl);
+ DPRINT("Finished KeExpireTimers()\n");
}
extern unsigned int nr_used_blocks;
}
// sprintf(str,"%.8u %.8u",EiFreeNonPagedPool,ticks);
memset(str, 0, sizeof(str));
- sprintf(str,"%.8u %.8u",EiNrUsedBlocks,KiTimerTicks);
+// sprintf(str,"%.8u %.8u",EiNrUsedBlocks,KiTimerTicks);
// sprintf(str,"%.8u %.8u",EiFreeNonPagedPool,EiUsedNonPagedPool);
+ sprintf(str,"%.8u %.8u",PiNrThreads,KiTimerTicks);
for (i=0;i<17;i++)
{
*vidmem=str[i];
// hdr->WaitListHead.Flink,hdr->WaitListHead.Blink);
KeReleaseDispatcherDatabaseLock(FALSE);
PsSuspendThread(PsGetCurrentThread());
+
+ if (Timeout!=NULL)
+ {
+ KeCancelTimer(&KeGetCurrentThread()->TimerBlock);
+ }
return(STATUS_SUCCESS);
}
#include <ddk/ntddk.h>\r
\r
\r
-#if 1\r
+#if 0\r
#define VALIDATE_POOL validate_kernel_pool()\r
#else\r
#define VALIDATE_POOL\r
\r
if (current->magic != BLOCK_HDR_MAGIC)\r
{\r
- DbgPrint("Bad block magic (probable pool corruption)\n");\r
+ DbgPrint("Bad block magic (probable pool corruption) at %x\n",\r
+ current);\r
KeBugCheck(KBUG_POOL_FREE_LIST_CORRUPT);\r
}\r
\r
\r
if (current->magic != BLOCK_HDR_MAGIC)\r
{\r
- DbgPrint("Bad block magic (probable pool corruption)\n");\r
+ DbgPrint("Bad block magic (probable pool corruption) at %x\n",\r
+ current);\r
KeBugCheck(KBUG_POOL_FREE_LIST_CORRUPT);\r
}\r
if (base_addr < (kernel_pool_base) ||\r
{\r
if (current->magic != BLOCK_HDR_MAGIC)\r
{\r
- DbgPrint("Bad block magic (probable pool corruption)\n");\r
+ DbgPrint("Bad block magic (probable pool corruption) at %x\n",\r
+ current);\r
KeBugCheck(KBUG_POOL_FREE_LIST_CORRUPT);\r
}\r
\r
\r
if (blk->magic != BLOCK_HDR_MAGIC)\r
{\r
- DbgPrint("ExFreePool of non-allocated address\n");\r
- for(;;);\r
+ DbgPrint("ExFreePool of non-allocated address %x\n",block);\r
+ KeBugCheck(0);\r
return;\r
}\r
\r
current->next);\r
if (current->magic != BLOCK_HDR_MAGIC)\r
{\r
- DbgPrint("Bad block magic (probable pool corruption)\n");\r
+ DbgPrint("Bad block magic (probable pool corruption) at %x\n",\r
+ current);\r
KeBugCheck(KBUG_POOL_FREE_LIST_CORRUPT);\r
}\r
if (current->size>=size)\r
ACCESS_MASK DesiredAccess,\r
POBJECT_ATTRIBUTES ObjectAttributes,\r
POBJECT_TYPE Type)\r
+/*\r
+ * FUNCTION: Creates a new object\r
+ */\r
{\r
POBJECT_HEADER hdr = NULL;\r
PWSTR path;\r
*/\r
{\r
PWSTR temp_name;\r
- extern unsigned long long ticks;\r
\r
DPRINT("ObInitializeObjectHeader(id %x name %w obj %x)\n",Type,\r
name,ObjectHeader);\r
\r
- ObjectHeader->HandleCount = 0;\r
- ObjectHeader->RefCount = 0;\r
+ ObjectHeader->HandleCount = 1;\r
+ ObjectHeader->RefCount = 1;\r
ObjectHeader->ObjectType = Type;\r
ObjectHeader->Permanent = FALSE;\r
if (name==NULL)\r
#include <ddk/ntddk.h>
+#define NDEBUG
#include <internal/debug.h>
/* GLOBALS *******************************************************************/
for(;;)
{
-// DbgPrint("Idling.... ");
+ DPRINT("Idling.... DpcQueueSize %d\n",DpcQueueSize);
if (DpcQueueSize > 0)
{
KeRaiseIrql(DISPATCH_LEVEL,&oldlvl);
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS kernel
- * FILE: ntoskrnl/ps/kill.c
- * PURPOSE: Terminating a thread
- * PROGRAMMER: David Welch (welch@mcmail.com)
- * UPDATE HISTORY:
- * Created 22/05/98
- */
-
-/* INCLUDES *****************************************************************/
-
-#include <ddk/ntddk.h>
-#include <internal/ps.h>
-
-#define NDEBUG
-#include <internal/debug.h>
-
-/* GLBOALS *******************************************************************/
-
-extern ULONG PiNrThreads;
-
-/* FUNCTIONS *****************************************************************/
-
-NTSTATUS STDCALL NtTerminateThread(IN HANDLE ThreadHandle,
- IN NTSTATUS ExitStatus)
-{
- return(ZwTerminateThread(ThreadHandle,ExitStatus));
-}
-
-NTSTATUS STDCALL ZwTerminateThread(IN HANDLE ThreadHandle,
- IN NTSTATUS ExitStatus)
-{
- PETHREAD Thread;
- NTSTATUS Status;
-
- Status = ObReferenceObjectByHandle(ThreadHandle,
- THREAD_TERMINATE,
- PsThreadType,
- UserMode,
- (PVOID*)&Thread,
- NULL);
- if (Status != STATUS_SUCCESS)
- {
- return(Status);
- }
-
- if (Thread == PsGetCurrentThread())
- {
- PsTerminateSystemThread(ExitStatus);
- }
- else
- {
- UNIMPLEMENTED;
- }
-}
-
-VOID PsReleaseThread(PETHREAD Thread)
-{
- DPRINT("PsReleaseThread(Thread %x)\n",Thread);
-
- RemoveEntryList(&Thread->Tcb.Entry);
- ObDereferenceObject(Thread);
-}
-
-
-NTSTATUS PsTerminateSystemThread(NTSTATUS ExitStatus)
-/*
- * FUNCTION: Terminates the current thread
- * ARGUMENTS:
- * ExitStatus = Status to pass to the creater
- * RETURNS: Doesn't
- */
-{
- KIRQL oldlvl;
- PETHREAD CurrentThread;
-
- PiNrThreads--;
-
- CurrentThread = PsGetCurrentThread();
-
- CurrentThread->ExitStatus = ExitStatus;
-
- DPRINT("terminating %x\n",CurrentThread);
- ObDereferenceObject(CurrentThread->ThreadsProcess);
- KeRaiseIrql(DISPATCH_LEVEL,&oldlvl);
- CurrentThread->Tcb.ThreadState = THREAD_STATE_TERMINATED;
- ZwYieldExecution();
- for(;;);
-}
-
-NTSTATUS STDCALL NtRegisterThreadTerminatePort(HANDLE TerminationPort)
-{
- return(ZwRegisterThreadTerminatePort(TerminationPort));
-}
-
-NTSTATUS STDCALL ZwRegisterThreadTerminatePort(HANDLE TerminationPort)
-{
- UNIMPLEMENTED;
-}
+/*\r
+ * COPYRIGHT: See COPYING in the top level directory\r
+ * PROJECT: ReactOS kernel\r
+ * FILE: ntoskrnl/ps/kill.c\r
+ * PURPOSE: Terminating a thread\r
+ * PROGRAMMER: David Welch (welch@mcmail.com)\r
+ * UPDATE HISTORY:\r
+ * Created 22/05/98\r
+ */\r
+\r
+/* INCLUDES *****************************************************************/\r
+\r
+#include <ddk/ntddk.h>\r
+#include <internal/ps.h>\r
+\r
+#define NDEBUG\r
+#include <internal/debug.h>\r
+\r
+/* GLBOALS *******************************************************************/\r
+\r
+extern ULONG PiNrThreads;\r
+\r
+/* FUNCTIONS *****************************************************************/\r
+\r
+NTSTATUS STDCALL NtTerminateProcess(IN HANDLE ProcessHandle,\r
+ IN NTSTATUS ExitStatus)\r
+{\r
+ return(ZwTerminateProcess(ProcessHandle,ExitStatus));\r
+}\r
+\r
+NTSTATUS STDCALL ZwTerminateProcess(IN HANDLE ProcessHandle,\r
+ IN NTSTATUS ExitStatus)\r
+{\r
+ PETHREAD Thread;\r
+ NTSTATUS Status;\r
+ PEPROCESS Process;\r
+ KIRQL oldlvl;\r
+\r
+ Status = ObReferenceObjectByHandle(ProcessHandle,\r
+ PROCESS_TERMINATE,\r
+ PsProcessType,\r
+ UserMode,\r
+ (PVOID*)&Process,\r
+ NULL);\r
+ if (Status != STATUS_SUCCESS)\r
+ {\r
+ return(Status);\r
+ }\r
+\r
+ PiTerminateProcessThreads(Process, ExitStatus);\r
+ KeRaiseIrql(DISPATCH_LEVEL, &oldlvl);\r
+ KeDispatcherObjectWakeAll(&Process->Pcb.DispatcherHeader);\r
+ Process->Pcb.ProcessState = PROCESS_STATE_TERMINATED;\r
+ if (PsGetCurrentThread()->ThreadsProcess == Process)\r
+ {\r
+ KeLowerIrql(oldlvl);\r
+ PsTerminateSystemThread(ExitStatus);\r
+ }\r
+ KeLowerIrql(oldlvl);\r
+ return(STATUS_SUCCESS);\r
+}\r
+\r
+\r
+NTSTATUS STDCALL NtTerminateThread(IN HANDLE ThreadHandle,\r
+ IN NTSTATUS ExitStatus)\r
+{\r
+ return(ZwTerminateThread(ThreadHandle,ExitStatus));\r
+}\r
+\r
+NTSTATUS STDCALL ZwTerminateThread(IN HANDLE ThreadHandle, \r
+ IN NTSTATUS ExitStatus)\r
+{\r
+ PETHREAD Thread;\r
+ NTSTATUS Status;\r
+ \r
+ Status = ObReferenceObjectByHandle(ThreadHandle,\r
+ THREAD_TERMINATE,\r
+ PsThreadType,\r
+ UserMode,\r
+ (PVOID*)&Thread,\r
+ NULL);\r
+ if (Status != STATUS_SUCCESS)\r
+ {\r
+ return(Status);\r
+ }\r
+\r
+ PsTerminateThread(Thread);\r
+}\r
+\r
+VOID PsTerminateThread(PETHREAD Thread, NTSTATUS ExitStatus)\r
+{\r
+ if (Thread == PsGetCurrentThread())\r
+ {\r
+ PsTerminateSystemThread(ExitStatus);\r
+ }\r
+ else\r
+ {\r
+ UNIMPLEMENTED;\r
+ }\r
+}\r
+\r
+VOID PsReleaseThread(PETHREAD Thread)\r
+{\r
+ DPRINT("PsReleaseThread(Thread %x)\n",Thread);\r
+ \r
+ RemoveEntryList(&Thread->Tcb.Entry);\r
+ ObDereferenceObject(Thread);\r
+}\r
+\r
+\r
+NTSTATUS PsTerminateSystemThread(NTSTATUS ExitStatus)\r
+/*\r
+ * FUNCTION: Terminates the current thread\r
+ * ARGUMENTS:\r
+ * ExitStatus = Status to pass to the creater\r
+ * RETURNS: Doesn't\r
+ */\r
+{\r
+ KIRQL oldlvl;\r
+ PETHREAD CurrentThread;\r
+ \r
+ PiNrThreads--;\r
+ \r
+ CurrentThread = PsGetCurrentThread();\r
+ \r
+ CurrentThread->ExitStatus = ExitStatus;\r
+ \r
+ DPRINT("terminating %x\n",CurrentThread);\r
+ ObDereferenceObject(CurrentThread->ThreadsProcess);\r
+ KeRaiseIrql(DISPATCH_LEVEL,&oldlvl);\r
+ CurrentThread->Tcb.ThreadState = THREAD_STATE_TERMINATED;\r
+ ZwYieldExecution();\r
+ for(;;);\r
+}\r
+\r
+NTSTATUS STDCALL NtRegisterThreadTerminatePort(HANDLE TerminationPort)\r
+{\r
+ return(ZwRegisterThreadTerminatePort(TerminationPort));\r
+}\r
+\r
+NTSTATUS STDCALL ZwRegisterThreadTerminatePort(HANDLE TerminationPort)\r
+{\r
+ UNIMPLEMENTED;\r
+}\r
DbgPrint("ZwCreateProcess() non-NULL SectionHandle\n");\r
return(STATUS_UNSUCCESSFUL);\r
}\r
- \r
- return(STATUS_SUCCESS);\r
-}\r
\r
+ Process->Pcb.ProcessState = PROCESS_STATE_ACTIVE;\r
\r
-NTSTATUS STDCALL NtTerminateProcess(IN HANDLE ProcessHandle,\r
- IN NTSTATUS ExitStatus)\r
-{\r
- return(ZwTerminateProcess(ProcessHandle,ExitStatus));\r
-}\r
-\r
-NTSTATUS STDCALL ZwTerminateProcess(IN HANDLE ProcessHandle,\r
- IN NTSTATUS ExitStatus)\r
-{\r
- UNIMPLEMENTED;\r
+ return(STATUS_SUCCESS);\r
}\r
\r
\r
UNIMPLEMENTED;\r
}\r
\r
-NTSTATUS STDCALL NtQueryInformationProcess(\r
- IN HANDLE ProcessHandle,\r
+NTSTATUS STDCALL NtQueryInformationProcess(IN HANDLE ProcessHandle,\r
IN CINT ProcessInformationClass,\r
OUT PVOID ProcessInformation,\r
IN ULONG ProcessInformationLength,\r
ReturnLength));\r
}\r
\r
-NTSTATUS STDCALL ZwQueryInformationProcess(\r
- IN HANDLE ProcessHandle,\r
+NTSTATUS STDCALL ZwQueryInformationProcess(IN HANDLE ProcessHandle,\r
IN CINT ProcessInformationClass,\r
OUT PVOID ProcessInformation,\r
IN ULONG ProcessInformationLength,\r
return(Status);\r
}\r
\r
-NTSTATUS\r
-STDCALL\r
-NtSetInformationProcess(\r
- IN HANDLE ProcessHandle,\r
- IN CINT ProcessInformationClass,\r
- IN PVOID ProcessInformation,\r
- IN ULONG ProcessInformationLength\r
- )\r
+NTSTATUS STDCALL NtSetInformationProcess(IN HANDLE ProcessHandle,\r
+ IN CINT ProcessInformationClass,\r
+ IN PVOID ProcessInformation,\r
+ IN ULONG ProcessInformationLength)\r
{\r
return(ZwSetInformationProcess(ProcessHandle,\r
ProcessInformationClass,\r
ProcessInformationLength));\r
}\r
\r
-NTSTATUS\r
-STDCALL\r
-ZwSetInformationProcess(\r
- IN HANDLE ProcessHandle,\r
- IN CINT ProcessInformationClass,\r
- IN PVOID ProcessInformation,\r
- IN ULONG ProcessInformationLength\r
- )\r
+NTSTATUS STDCALL ZwSetInformationProcess(IN HANDLE ProcessHandle,\r
+ IN CINT ProcessInformationClass,\r
+ IN PVOID ProcessInformation,\r
+ IN ULONG ProcessInformationLength)\r
{\r
UNIMPLEMENTED;\r
}\r
static LIST_ENTRY PriorityListHead[NR_THREAD_PRIORITY_LEVELS]={{NULL,NULL},};\r
static BOOLEAN DoneInitYet = FALSE;\r
ULONG PiNrThreads = 0;\r
+ULONG PiNrRunnableThreads = 0;\r
\r
static PETHREAD CurrentThread = NULL;\r
\r
return((PETHREAD)KeGetCurrentThread());\r
}\r
\r
+VOID PiTerminateProcessThreads(PEPROCESS Process, NTSTATUS ExitStatus)\r
+{\r
+ KIRQL oldlvl;\r
+ PLIST_ENTRY current_entry;\r
+ PETHREAD current;\r
+ ULONG i;\r
+\r
+ KeAcquireSpinLock(&ThreadListLock, &oldlvl);\r
+\r
+ for (i=0; i<NR_THREAD_PRIORITY_LEVELS; i++)\r
+ {\r
+ current_entry = PriorityListHead[i].Flink;\r
+ while (current_entry != &PriorityListHead[i])\r
+ {\r
+ current = CONTAINING_RECORD(current_entry,ETHREAD,Tcb.Entry);\r
+ if (current->ThreadsProcess == Process &&\r
+ current != PsGetCurrentThread())\r
+ {\r
+ PsTerminateThread(current, ExitStatus);\r
+ }\r
+ current_entry = current_entry->Flink;\r
+ }\r
+ }\r
+\r
+ KeReleaseSpinLock(&ThreadListLock, oldlvl);\r
+}\r
+\r
static VOID PsInsertIntoThreadList(KPRIORITY Priority, PETHREAD Thread)\r
{\r
KIRQL oldlvl;\r
Candidate = PsScanThreadList(CurrentPriority);\r
if (Candidate == CurrentThread)\r
{\r
-// DbgPrint("Scheduling current thread\n");\r
+ DPRINT("Scheduling current thread\n");\r
KeQueryTickCount(&TickCount);\r
CurrentThread->Tcb.LastTick = GET_LARGE_INTEGER_LOW_PART(TickCount);\r
CurrentThread->Tcb.ThreadState = THREAD_STATE_RUNNING;\r
}\r
if (Candidate != NULL)\r
{ \r
-// DbgPrint("Scheduling %x\n",Candidate);\r
+ DPRINT("Scheduling %x\n",Candidate);\r
\r
Candidate->Tcb.ThreadState = THREAD_STATE_RUNNING;\r
\r
return;\r
}\r
}\r
+ DbgPrint("CRITICAL: No threads are runnable\n");\r
+ KeBugCheck(0);\r
}\r
\r
NTSTATUS PsInitializeThread(HANDLE ProcessHandle, \r
NULL);\r
if (Status != STATUS_SUCCESS)\r
{\r
+ DPRINT("Failed at %s:%d\n",__FILE__,__LINE__);\r
return(Status);\r
}\r
}\r
#include <ddk/ntddk.h>
#include <wstring.h>
+#define NDEBUG
#include <internal/debug.h>
wchar_t * ___wcstok = NULL;
/* FUNCTIONS *****************************************************************/
+wchar_t* wstrdup(const wchar_t* src)
+{
+ wchar_t* dest;
+
+ dest = ExAllocatePool(NonPagedPool, (wstrlen(src)+1)*2);
+ wcscpy(dest,src);
+ return(dest);
+}
+
wchar_t *
wcscat(wchar_t *dest, const wchar_t *src)
{
wchar_t* wcscpy(wchar_t* str1, const wchar_t* str2)
{
wchar_t* s = str1;
- DbgPrint("wcscpy(str1 %w, str2 %w)\n",str1,str2);
+ DPRINT("wcscpy(str1 %w, str2 %w)\n",str1,str2);
while ((*str2)!=0)
{
*s = *str2;
s++;
str2++;
}
+ *s = 0;
return(str1);
}
projects / reactos.git / commitdiff