Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-02 10:45:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

some __stdcall fixes in ntoskrnl and ntdll

Browse source 
svn path=/trunk/; revision=629
This commit is contained in:
Emanuele Aliberti 1999-08-29 06:59:11 +00:00
parent 5aaaad5c93
commit fa3a5c2c71
35 changed files with 3547 additions and 1632 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

535
reactos/include/ddk/exfuncs.h
View file

@ -1,16 +1,53 @@
#ifndef _NTOS_EXFUNCS_H
#define _NTOS_EXFUNCS_H
/* EXECUTIVE ROUTINES ******************************************************/ /* EXECUTIVE ROUTINES ******************************************************/
VOID ExAcquireFastMutex(PFAST_MUTEX FastMutex); VOID
VOID ExAcquireFastMutexUnsafe(PFAST_MUTEX FastMutex); ExAcquireFastMutex (
PFAST_MUTEX FastMutex
BOOLEAN ExAcquireResourceExclusive(PERESOURCE Resource, BOOLEAN Wait); );
BOOLEAN ExAcquireResourceExclusiveLite(PERESOURCE Resource, BOOLEAN Wait); VOID
BOOLEAN ExAcquireResourceSharedLite(PERESOURCE Resource, BOOLEAN Wait); ExAcquireFastMutexUnsafe (
BOOLEAN ExAcquireSharedStarveExclusive(PERESOURCE Resource, BOOLEAN Wait); PFAST_MUTEX FastMutex
BOOLEAN ExAcquireSharedWaitForExclusive(PERESOURCE Resource, BOOLEAN Wait); );
PVOID ExAllocateFromNPagedLookasideList(PNPAGED_LOOKASIDE_LIST LookSide); BOOLEAN
PVOID ExAllocateFromPagedLookasideList(PPAGED_LOOKASIDE_LIST LookSide); ExAcquireResourceExclusive (
PVOID ExAllocateFromZone(PZONE_HEADER Zone); PERESOURCE Resource,
BOOLEAN Wait
);
BOOLEAN
ExAcquireResourceExclusiveLite (
PERESOURCE Resource,
BOOLEAN Wait
);
BOOLEAN
ExAcquireResourceSharedLite (
PERESOURCE Resource,
BOOLEAN Wait
);
BOOLEAN
ExAcquireSharedStarveExclusive (
PERESOURCE Resource,
BOOLEAN Wait
);
BOOLEAN
ExAcquireSharedWaitForExclusive (
PERESOURCE Resource,
BOOLEAN Wait
);
PVOID
ExAllocateFromNPagedLookasideList (
PNPAGED_LOOKASIDE_LIST LookSide
);
PVOID
ExAllocateFromPagedLookasideList (
PPAGED_LOOKASIDE_LIST LookSide
);
PVOID
ExAllocateFromZone (
PZONE_HEADER Zone
);
/* /*
* FUNCTION: Allocates memory from the nonpaged pool * FUNCTION: Allocates memory from the nonpaged pool
@ -20,133 +57,371 @@ PVOID ExAllocateFromZone(PZONE_HEADER Zone);
* RETURNS: * RETURNS:
* the address of the block if it succeeds * the address of the block if it succeeds
*/ */
PVOID ExAllocatePool(POOL_TYPE PoolType, ULONG size); PVOID
ExAllocatePool (
POOL_TYPE PoolType,
ULONG size
);
PVOID ExAllocatePoolWithQuota(POOL_TYPE PoolType, ULONG NumberOfBytes); PVOID
PVOID ExAllocatePoolWithQuotaTag(POOL_TYPE PoolType, ULONG NumberOfBytes, ExAllocatePoolWithQuota (
ULONG Tag); POOL_TYPE PoolType,
PVOID ExAllocatePoolWithTag(POOL_TYPE PoolType, ULONG NumberOfBytes, ULONG NumberOfBytes
ULONG Tag); );
VOID ExConvertExclusiveToSharedLite(PERESOURCE Resource); PVOID
VOID ExDeleteNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside); ExAllocatePoolWithQuotaTag (
VOID ExDeletePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside); POOL_TYPE PoolType,
NTSTATUS ExDeleteResource(PERESOURCE Resource); ULONG NumberOfBytes,
NTSTATUS ExDeleteResourceLite(PERESOURCE Resource); ULONG Tag
NTSTATUS ExExtendZone(PZONE_HEADER Zone, PVOID Segment, ULONG SegmentSize); );
PVOID
ExAllocatePoolWithTag (
POOL_TYPE PoolType,
ULONG NumberOfBytes,
ULONG Tag
);
VOID
ExConvertExclusiveToSharedLite (
PERESOURCE Resource
);
VOID
ExDeleteNPagedLookasideList (
PNPAGED_LOOKASIDE_LIST Lookaside
);
VOID
ExDeletePagedLookasideList (
PPAGED_LOOKASIDE_LIST Lookaside
);
NTSTATUS
ExDeleteResource (
PERESOURCE Resource
);
NTSTATUS
ExDeleteResourceLite (
PERESOURCE Resource
);
NTSTATUS
ExExtendZone (
PZONE_HEADER Zone,
PVOID Segment,
ULONG SegmentSize
);
/* /*
* FUNCTION: Releases previously allocated memory * FUNCTION: Releases previously allocated memory
* ARGUMENTS: * ARGUMENTS:
* block = block to free * block = block to free
*/ */
VOID ExFreePool(PVOID block); VOID
ExFreePool (
PVOID block
);
VOID ExFreeToNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside, VOID
PVOID Entry); ExFreeToNPagedLookasideList (
VOID ExFreeToPagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside, PNPAGED_LOOKASIDE_LIST Lookaside,
PVOID Entry); PVOID Entry
PVOID ExFreeToZone(PZONE_HEADER Zone, PVOID Block); );
ERESOURCE_THREAD ExGetCurrentResourceThread(VOID); VOID
ULONG ExGetExclusiveWaiterCount(PERESOURCE Resource); ExFreeToPagedLookasideList (
ULONG ExGetSharedWaiterCount(PERESOURCE Resource); PPAGED_LOOKASIDE_LIST Lookaside,
VOID ExInitializeFastMutex(PFAST_MUTEX FastMutex); PVOID Entry
VOID ExInitializeNPagedLookasideList(PNPAGED_LOOKASIDE_LIST Lookaside, );
PALLOCATE_FUNCTION Allocate, PVOID
PFREE_FUNCTION Free, ExFreeToZone (
ULONG Flags, PZONE_HEADER Zone,
ULONG Size, PVOID Block
ULONG Tag, );
USHORT Depth); ERESOURCE_THREAD
VOID ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside, ExGetCurrentResourceThread (
PALLOCATE_FUNCTION Allocate, VOID
PFREE_FUNCTION Free, );
ULONG Flags, ULONG
ULONG Size, ExGetExclusiveWaiterCount (
ULONG Tag, PERESOURCE Resource
USHORT Depth); );
NTSTATUS ExInitializeResource(PERESOURCE Resource); ULONG
NTSTATUS ExInitializeResourceLite(PERESOURCE Resource); ExGetSharedWaiterCount (
VOID ExInitializeSListHead(PSLIST_HEADER SListHead); PERESOURCE Resource
VOID ExInitializeWorkItem(PWORK_QUEUE_ITEM Item, );
PWORKER_THREAD_ROUTINE Routine, VOID
PVOID Context); ExInitializeFastMutex (
NTSTATUS ExInitializeZone(PZONE_HEADER Zone, PFAST_MUTEX FastMutex
ULONG BlockSize, );
PVOID InitialSegment, VOID
ULONG InitialSegmentSize); ExInitializeNPagedLookasideList (
LARGE_INTEGER ExInterlockedAddLargeInteger(PLARGE_INTEGER Addend, PNPAGED_LOOKASIDE_LIST Lookaside,
LARGE_INTEGER Increment, PALLOCATE_FUNCTION Allocate,
PKSPIN_LOCK Lock); PFREE_FUNCTION Free,
ULONG ExInterlockedAddUlong(PULONG Addend, ULONG Increment, PKSPIN_LOCK Lock); ULONG Flags,
ULONG Size,
ULONG Tag,
USHORT Depth
);
VOID
ExInitializePagedLookasideList (
PPAGED_LOOKASIDE_LIST Lookaside,
PALLOCATE_FUNCTION Allocate,
PFREE_FUNCTION Free,
ULONG Flags,
ULONG Size,
ULONG Tag,
USHORT Depth
);
NTSTATUS
ExInitializeResource (
PERESOURCE Resource
);
NTSTATUS
ExInitializeResourceLite (
PERESOURCE Resource
);
VOID
ExInitializeSListHead (
PSLIST_HEADER SListHead
);
VOID
ExInitializeWorkItem (
PWORK_QUEUE_ITEM Item,
PWORKER_THREAD_ROUTINE Routine,
PVOID Context
);
NTSTATUS
ExInitializeZone (
PZONE_HEADER Zone,
ULONG BlockSize,
PVOID InitialSegment,
ULONG InitialSegmentSize
);
LARGE_INTEGER
ExInterlockedAddLargeInteger (
PLARGE_INTEGER Addend,
LARGE_INTEGER Increment,
PKSPIN_LOCK Lock
);
ULONG
ExInterlockedAddUlong (
PULONG Addend,
ULONG Increment,
PKSPIN_LOCK Lock
);
VOID ExInterlockedRemoveEntryList(PLIST_ENTRY ListHead, PLIST_ENTRY Entry, VOID
PKSPIN_LOCK Lock); ExInterlockedRemoveEntryList (
VOID RemoveEntryFromList(PLIST_ENTRY ListHead, PLIST_ENTRY Entry); PLIST_ENTRY ListHead,
PLIST_ENTRY ExInterlockedRemoveHeadList(PLIST_ENTRY Head, PKSPIN_LOCK Lock); PLIST_ENTRY Entry,
PKSPIN_LOCK Lock
PLIST_ENTRY ExInterlockedInsertTailList(PLIST_ENTRY ListHead, );
PLIST_ENTRY ListEntry, VOID
PKSPIN_LOCK Lock); RemoveEntryFromList (
PLIST_ENTRY ListHead,
PLIST_ENTRY ExInterlockedInsertHeadList(PLIST_ENTRY ListHead, PLIST_ENTRY Entry
PLIST_ENTRY ListEntry, );
PKSPIN_LOCK Lock); PLIST_ENTRY
ExInterlockedRemoveHeadList (
VOID ExQueueWorkItem(PWORK_QUEUE_ITEM WorkItem, PLIST_ENTRY Head,
WORK_QUEUE_TYPE QueueType); PKSPIN_LOCK Lock
VOID ExRaiseStatus(NTSTATUS Status); );
VOID ExReinitializeResourceLite(PERESOURCE Resource); PLIST_ENTRY
VOID ExReleaseFastMutex(PFAST_MUTEX Mutex); ExInterlockedInsertTailList (
VOID ExReleaseFastMutexUnsafe(PFAST_MUTEX Mutex); PLIST_ENTRY ListHead,
VOID ExReleaseResource(PERESOURCE Resource); PLIST_ENTRY ListEntry,
VOID ExReleaseResourceForThread(PERESOURCE Resource, PKSPIN_LOCK Lock
ERESOURCE_THREAD ResourceThreadId); );
VOID ExReleaseResourceForThreadLite(PERESOURCE Resource, PLIST_ENTRY
ERESOURCE_THREAD ResourceThreadId); ExInterlockedInsertHeadList (
VOID ExSystemTimeToLocalTime(PLARGE_INTEGER SystemTime, PLIST_ENTRY ListHead,
PLARGE_INTEGER LocalTime); PLIST_ENTRY ListEntry,
BOOLEAN ExTryToAcquireFastMutex(PFAST_MUTEX FastMutex); PKSPIN_LOCK Lock
BOOLEAN ExTryToAcquireResourceExclusiveLite(PERESOURCE Resource); );
PVOID InterlockedCompareExchange(PVOID* Destination, VOID
PVOID Exchange, ExQueueWorkItem (
PVOID Comperand); PWORK_QUEUE_ITEM WorkItem,
LONG InterlockedDecrement(PLONG Addend); WORK_QUEUE_TYPE QueueType
LONG InterlockedExchange(PLONG Target, LONG Value); );
LONG InterlockedExchangeAdd(PLONG Addend, LONG Value); VOID
LONG InterlockedIncrement(PLONG Addend); ExRaiseStatus (
NTSTATUS Status
PVOID ExInterlockedAllocateFromZone(PZONE_HEADER Zone, PKSPIN_LOCK Lock); );
PVOID ExInterlockedFreeToZone(PZONE_HEADER Zone, PVOID Block, VOID
PKSPIN_LOCK Lock); ExReinitializeResourceLite (
NTSTATUS ExInterlockedExtendZone(PZONE_HEADER Zone, PVOID Segment, PERESOURCE Resource
ULONG SegmentSize, PKSPIN_LOCK Lock); );
PSINGLE_LIST_ENTRY ExInterlockedPopEntryList(PSINGLE_LIST_ENTRY ListHead, VOID
PKSPIN_LOCK Lock); ExReleaseFastMutex (
PSINGLE_LIST_ENTRY ExInterlockedPushEntryList(PSINGLE_LIST_ENTRY ListHead, PFAST_MUTEX Mutex
PSINGLE_LIST_ENTRY ListEntry, );
PKSPIN_LOCK Lock); VOID
PSINGLE_LIST_ENTRY ExInterlockedPushEntrySList(PSLIST_HEADER ListHead, ExReleaseFastMutexUnsafe (
PSINGLE_LIST_ENTRY ListEntry, PFAST_MUTEX Mutex
PKSPIN_LOCK Lock); );
PSINGLE_LIST_ENTRY ExInterlockedPopEntrySList(PSLIST_HEADER ListHead, VOID
PKSPIN_LOCK Lock); ExReleaseResource (
BOOLEAN ExIsFullZone(PZONE_HEADER Zone); PERESOURCE Resource
BOOLEAN ExIsObjectInFirstZoneSegment(PZONE_HEADER Zone, PVOID Object); );
VOID ExLocalTimeToSystemTime(PLARGE_INTEGER LocalTime, VOID
PLARGE_INTEGER SystemTime); ExReleaseResourceForThread (
PERESOURCE Resource,
typedef unsigned int (exception_hook)(CONTEXT* c, unsigned int exp); ERESOURCE_THREAD ResourceThreadId
unsigned int ExHookException(exception_hook fn, unsigned int exp); );
VOID
INTERLOCKED_RESULT ExInterlockedDecrementLong(PLONG Addend, ExReleaseResourceForThreadLite (
PKSPIN_LOCK Lock); PERESOURCE Resource,
ULONG ExInterlockedExchangeUlong(PULONG Target, ERESOURCE_THREAD ResourceThreadId
ULONG Value, );
PKSPIN_LOCK Lock); VOID
INTERLOCKED_RESULT ExInterlockedIncrementLong(PLONG Addend, ExSystemTimeToLocalTime (
PKSPIN_LOCK Lock); PLARGE_INTEGER SystemTime,
BOOLEAN ExIsResourceAcquiredExclusiveLite(PERESOURCE Resource); PLARGE_INTEGER LocalTime
ULONG ExIsResourceAcquiredSharedLite(PERESOURCE Resource); );
USHORT ExQueryDepthSListHead(PSLIST_HEADER SListHead); BOOLEAN
ExTryToAcquireFastMutex (
PFAST_MUTEX FastMutex
);
BOOLEAN
ExTryToAcquireResourceExclusiveLite (
PERESOURCE Resource
);
/*
LONG
FASTCALL
InterlockedCompareExchange (
PLONG Target,
LONG Value,
LONG Reference
);
*/
PVOID
FASTCALL
InterlockedCompareExchange (
PVOID * Destination,
PVOID Exchange,
PVOID Comperand
);
#ifdef _GNU_H_WINDOWS_H
#ifdef InterlockedDecrement
#undef InterlockedDecrement
#undef InterlockedExchange
#undef InterlockedExchangeAdd
#undef InterlockedIncrement
#endif /* def InterlockedDecrement */
#endif /* def _GNU_H_WINDOWS_H */
LONG
FASTCALL
InterlockedDecrement (
PLONG Addend
);
LONG
FASTCALL
InterlockedExchange (
PLONG Target,
LONG Value
);
LONG
FASTCALL
InterlockedExchangeAdd (
PLONG Addend,
LONG Value
);
LONG
FASTCALL
InterlockedIncrement (
PLONG Addend
);
/*---*/
PVOID
ExInterlockedAllocateFromZone (
PZONE_HEADER Zone,
PKSPIN_LOCK Lock
);
PVOID
ExInterlockedFreeToZone (
PZONE_HEADER Zone,
PVOID Block,
PKSPIN_LOCK Lock
);
NTSTATUS
ExInterlockedExtendZone (
PZONE_HEADER Zone,
PVOID Segment,
ULONG SegmentSize,
PKSPIN_LOCK Lock
);
PSINGLE_LIST_ENTRY
ExInterlockedPopEntryList (
PSINGLE_LIST_ENTRY ListHead,
PKSPIN_LOCK Lock
);
PSINGLE_LIST_ENTRY
ExInterlockedPushEntryList (
PSINGLE_LIST_ENTRY ListHead,
PSINGLE_LIST_ENTRY ListEntry,
PKSPIN_LOCK Lock
);
PSINGLE_LIST_ENTRY
ExInterlockedPushEntrySList (
PSLIST_HEADER ListHead,
PSINGLE_LIST_ENTRY ListEntry,
PKSPIN_LOCK Lock
);
PSINGLE_LIST_ENTRY
ExInterlockedPopEntrySList (
PSLIST_HEADER ListHead,
PKSPIN_LOCK Lock
);
BOOLEAN
ExIsFullZone (
PZONE_HEADER Zone
);
BOOLEAN
ExIsObjectInFirstZoneSegment (
PZONE_HEADER Zone,
PVOID Object
);
VOID
ExLocalTimeToSystemTime (
PLARGE_INTEGER LocalTime,
PLARGE_INTEGER SystemTime
);
typedef
unsigned int
(exception_hook) (
CONTEXT * c,
unsigned int exp
);
unsigned int
ExHookException (
exception_hook fn,
unsigned int exp
);
INTERLOCKED_RESULT
ExInterlockedDecrementLong (
PLONG Addend,
PKSPIN_LOCK Lock
);
ULONG
ExInterlockedExchangeUlong (
PULONG Target,
ULONG Value,
PKSPIN_LOCK Lock
);
INTERLOCKED_RESULT
ExInterlockedIncrementLong (
PLONG Addend,
PKSPIN_LOCK Lock
);
BOOLEAN
ExIsResourceAcquiredExclusiveLite (
PERESOURCE Resource
);
ULONG
ExIsResourceAcquiredSharedLite (
PERESOURCE Resource
);
USHORT
ExQueryDepthSListHead (
PSLIST_HEADER SListHead
);
#endif /* ndef _NTOS_EXFUNCS_H */

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

@ -370,6 +370,7 @@ IoCreateNotificationEvent (
); );
NTSTATUS NTSTATUS
STDCALL
IoCreateSymbolicLink ( IoCreateSymbolicLink (
PUNICODE_STRING SymbolicLinkName, PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName PUNICODE_STRING DeviceName
@ -382,6 +383,7 @@ IoCreateSynchronizationEvent (
); );
NTSTATUS NTSTATUS
STDCALL
IoCreateUnprotectedSymbolicLink ( IoCreateUnprotectedSymbolicLink (
PUNICODE_STRING SymbolicLinkName, PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName PUNICODE_STRING DeviceName
@ -404,6 +406,7 @@ IoDeleteDevice (
); );
NTSTATUS NTSTATUS
STDCALL
IoDeleteSymbolicLink ( IoDeleteSymbolicLink (
PUNICODE_STRING SymbolicLinkName PUNICODE_STRING SymbolicLinkName
); );

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

@ -20,6 +20,11 @@ extern "C"
#include <windows.h> #include <windows.h>
/* GCC can not handle __fastcall */
#ifndef FASTCALL
#define FASTCALL STDCALL
#endif
#include <internal/id.h> #include <internal/id.h>
#include <ddk/status.h> #include <ddk/status.h>
#include <ddk/ntdef.h> #include <ddk/ntdef.h>

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

@ -200,6 +200,7 @@ RtlCharToInteger (
); );
NTSTATUS NTSTATUS
STDCALL
RtlCheckRegistryKey ( RtlCheckRegistryKey (
ULONG RelativeTo, ULONG RelativeTo,
PWSTR Path PWSTR Path
@ -263,6 +264,7 @@ RtlCopyUnicodeString (
); );
NTSTATUS NTSTATUS
STDCALL
RtlCreateRegistryKey ( RtlCreateRegistryKey (
ULONG RelativeTo, ULONG RelativeTo,
PWSTR Path PWSTR Path
@ -275,6 +277,7 @@ RtlCreateSecurityDescriptor (
); );
NTSTATUS NTSTATUS
STDCALL
RtlDeleteRegistryValue ( RtlDeleteRegistryValue (
ULONG RelativeTo, ULONG RelativeTo,
PWSTR Path, PWSTR Path,
@ -575,6 +578,7 @@ RtlMoveMemory (
); );
NTSTATUS NTSTATUS
STDCALL
RtlQueryRegistryValues ( RtlQueryRegistryValues (
ULONG RelativeTo, ULONG RelativeTo,
PWSTR Path, PWSTR Path,
@ -713,6 +717,7 @@ RtlValidSecurityDescriptor (
); );
NTSTATUS NTSTATUS
STDCALL
RtlWriteRegistryValue ( RtlWriteRegistryValue (
ULONG RelativeTo, ULONG RelativeTo,
PWSTR Path, PWSTR Path,
@ -768,6 +773,7 @@ RtlUnlockHeap (
); );
UINT UINT
STDCALL
RtlCompactHeap ( RtlCompactHeap (
HANDLE hheap, HANDLE hheap,
DWORD flags DWORD flags

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

@ -1,4 +1,4 @@
/* $Id: zw.h,v 1.17 1999/07/22 21:29:46 ekohl Exp $ /* $Id: zw.h,v 1.18 1999/08/29 06:58:59 ea Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
@ -4143,21 +4143,21 @@ ZwSetHighWaitLowEventPair(
NTSTATUS NTSTATUS
STDCALL STDCALL
NtSetInformationFile( NtSetInformationFile(
IN HANDLE FileHandle, IN HANDLE FileHandle,
IN PIO_STATUS_BLOCK IoStatusBlock, IN PIO_STATUS_BLOCK IoStatusBlock,
IN PVOID FileInformation, IN PVOID FileInformation,
IN ULONG Length, IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass IN FILE_INFORMATION_CLASS FileInformationClass
); );
NTSTATUS NTSTATUS
STDCALL STDCALL
ZwSetInformationFile( ZwSetInformationFile(
IN HANDLE FileHandle, IN HANDLE FileHandle,
IN PIO_STATUS_BLOCK IoStatusBlock, IN PIO_STATUS_BLOCK IoStatusBlock,
IN PVOID FileInformation, IN PVOID FileInformation,
IN ULONG Length, IN ULONG Length,
IN FILE_INFORMATION_CLASS FileInformationClass IN FILE_INFORMATION_CLASS FileInformationClass
); );

40
reactos/include/ntdll/rtl.h
View file

@ -1,10 +1,36 @@
VOID WINAPI __RtlInitHeap(PVOID base, ULONG minsize, ULONG maxsize); VOID
WINAPI
__RtlInitHeap (
PVOID base,
ULONG minsize,
ULONG maxsize
);
#define HEAP_BASE (0xa0000000) #define HEAP_BASE (0xa0000000)
VOID RtlDeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection); VOID
VOID RtlEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection); RtlDeleteCriticalSection (
VOID RtlInitializeCriticalSection(LPCRITICAL_SECTION pcritical); LPCRITICAL_SECTION lpCriticalSection
VOID RtlLeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection); );
WINBOOL RtlTryEntryCriticalSection(LPCRITICAL_SECTION lpCriticalSection); VOID
DWORD WINAPI RtlCompactHeap( HANDLE heap, DWORD flags ); RtlEnterCriticalSection (
LPCRITICAL_SECTION lpCriticalSection
);
VOID
RtlInitializeCriticalSection (
LPCRITICAL_SECTION pcritical
);
VOID
RtlLeaveCriticalSection (
LPCRITICAL_SECTION lpCriticalSection
);
WINBOOL
RtlTryEntryCriticalSection (
LPCRITICAL_SECTION lpCriticalSection
);
UINT
STDCALL
RtlCompactHeap (
HANDLE heap,
DWORD flags
);

2
reactos/include/reactos/resource.h
View file

@ -7,7 +7,7 @@
#define RES_UINT_FV_MINOR 0 #define RES_UINT_FV_MINOR 0
#define RES_UINT_FV_REVISION 14 #define RES_UINT_FV_REVISION 14
/* Build number as YYYYMMDD */ /* Build number as YYYYMMDD */
#define RES_UINT_FV_BUILD 19990717 #define RES_UINT_FV_BUILD 19990828
/* ReactOS Product Version UINTs */ /* ReactOS Product Version UINTs */

39
reactos/lib/kernel32/file/find.c
View file

@ -1,4 +1,5 @@
/* /* $Id: find.c,v 1.21 1999/08/29 06:59:01 ea 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
* FILE: lib/kernel32/file/find.c * FILE: lib/kernel32/file/find.c
@ -178,7 +179,10 @@ HANDLE STDCALL InternalFindFirstFile(LPCWSTR lpFileName,
return(IData); return(IData);
} }
HANDLE FindFirstFileA(LPCTSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData)
HANDLE
STDCALL
FindFirstFileA(LPCTSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData)
{ {
WCHAR lpFileNameW[MAX_PATH]; WCHAR lpFileNameW[MAX_PATH];
ULONG i; ULONG i;
@ -227,7 +231,10 @@ HANDLE FindFirstFileA(LPCTSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData)
return(IData); return(IData);
} }
WINBOOL FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATA lpFindFileData)
WINBOOL
STDCALL
FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATA lpFindFileData)
{ {
PWIN32_FIND_DATA_ASCII Ret; PWIN32_FIND_DATA_ASCII Ret;
PKERNEL32_FIND_FILE_DATA IData; PKERNEL32_FIND_FILE_DATA IData;
@ -265,7 +272,10 @@ WINBOOL FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATA lpFindFileData)
return(TRUE); return(TRUE);
} }
BOOL FindClose(HANDLE hFindFile)
BOOL
STDCALL
FindClose(HANDLE hFindFile)
{ {
PKERNEL32_FIND_FILE_DATA IData; PKERNEL32_FIND_FILE_DATA IData;
@ -282,8 +292,13 @@ BOOL FindClose(HANDLE hFindFile)
return(TRUE); return(TRUE);
} }
HANDLE STDCALL FindFirstFileW(LPCWSTR lpFileName,
LPWIN32_FIND_DATA lpFindFileData) HANDLE
STDCALL
FindFirstFileW (
LPCWSTR lpFileName,
LPWIN32_FIND_DATA lpFindFileData
)
{ {
PWIN32_FIND_DATA_UNICODE Ret; PWIN32_FIND_DATA_UNICODE Ret;
PKERNEL32_FIND_FILE_DATA IData; PKERNEL32_FIND_FILE_DATA IData;
@ -299,8 +314,13 @@ HANDLE STDCALL FindFirstFileW(LPCWSTR lpFileName,
return(IData); return(IData);
} }
WINBOOL STDCALL FindNextFileW(HANDLE hFindFile,
LPWIN32_FIND_DATA lpFindFileData) WINBOOL
STDCALL
FindNextFileW (
HANDLE hFindFile,
LPWIN32_FIND_DATA lpFindFileData
)
{ {
PWIN32_FIND_DATA_UNICODE Ret; PWIN32_FIND_DATA_UNICODE Ret;
PKERNEL32_FIND_FILE_DATA IData; PKERNEL32_FIND_FILE_DATA IData;
@ -320,3 +340,6 @@ WINBOOL STDCALL FindNextFileW(HANDLE hFindFile,
return(TRUE); return(TRUE);
} }
/* EOF */

219
reactos/lib/kernel32/file/lfile.c
View file

@ -1,4 +1,5 @@
/* /* $Id: lfile.c,v 1.4 1999/08/29 06:59:01 ea 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
* FILE: lib/kernel32/file/lfile.c * FILE: lib/kernel32/file/lfile.c
@ -16,67 +17,104 @@
long _hread( long
HFILE hFile, STDCALL
LPVOID lpBuffer, _hread(
long lBytes HFILE hFile,
) LPVOID lpBuffer,
long lBytes
)
{ {
DWORD NumberOfBytesRead; DWORD NumberOfBytesRead;
if ( ReadFile((HANDLE)hFile,(LPVOID)lpBuffer,(DWORD)lBytes,&NumberOfBytesRead, NULL) == FALSE )
if (ReadFile(
(HANDLE) hFile,
(LPVOID) lpBuffer,
(DWORD) lBytes,
& NumberOfBytesRead,
NULL
) == FALSE)
{
return -1; return -1;
else
return NumberOfBytesRead;
}
UINT STDCALL _lread(HFILE fd,LPVOID buffer,UINT count)
{
return _hread(fd,buffer, count);
}
long _hwrite(
HFILE hFile,
LPCSTR lpBuffer,
long lBytes
)
{
DWORD NumberOfBytesWritten;
if ( lBytes == 0 ) {
if ( SetEndOfFile((HANDLE) hFile ) == FALSE )
return -1;
else
return 0;
} }
if ( WriteFile((HANDLE)hFile,(LPVOID)lpBuffer,(DWORD)lBytes, &NumberOfBytesWritten,NULL) == FALSE ) return NumberOfBytesRead;
return -1;
else
return NumberOfBytesWritten;
} }
/*
//19990828.EA: aliased in DEF
UINT
STDCALL
_lread (
HFILE fd,
LPVOID buffer,
UINT count
)
{
return _hread(
fd,
buffer,
count
);
}
*/
long
STDCALL
_hwrite (
HFILE hFile,
LPCSTR lpBuffer,
long lBytes
)
{
DWORD NumberOfBytesWritten;
if (lBytes == 0)
{
if ( SetEndOfFile((HANDLE) hFile ) == FALSE )
{
return -1;
}
return 0;
}
if ( WriteFile(
(HANDLE) hFile,
(LPVOID) lpBuffer,
(DWORD) lBytes,
& NumberOfBytesWritten,
NULL
) == FALSE )
{
return -1;
}
return NumberOfBytesWritten;
}
/*
//19990828.EA: aliased in DEF
UINT UINT
STDCALL STDCALL
_lwrite( _lwrite(
HFILE hFile, HFILE hFile,
LPCSTR lpBuffer, LPCSTR lpBuffer,
UINT uBytes UINT uBytes
) )
{ {
return _hwrite(hFile,lpBuffer,uBytes); return _hwrite(hFile,lpBuffer,uBytes);
} }
*/
HFILE
STDCALL
_lopen (
HFILE _lopen( LPCSTR lpPathName, int iReadWrite ) LPCSTR lpPathName,
int iReadWrite
)
{ {
DWORD dwAccessMask = 0; DWORD dwAccessMask = 0;
DWORD dwShareMode = 0; DWORD dwShareMode = 0;
@ -87,31 +125,39 @@ HFILE _lopen( LPCSTR lpPathName, int iReadWrite )
else if ( (iReadWrite & OF_WRITE ) == OF_WRITE ) else if ( (iReadWrite & OF_WRITE ) == OF_WRITE )
dwAccessMask = GENERIC_WRITE; dwAccessMask = GENERIC_WRITE;
if ((iReadWrite & OF_SHARE_COMPAT) == OF_SHARE_COMPAT )
dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE;
else if ((iReadWrite & OF_SHARE_DENY_NONE) == OF_SHARE_DENY_NONE)
dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE;
if ((iReadWrite & OF_SHARE_COMPAT) == OF_SHARE_COMPAT ) else if ((iReadWrite & OF_SHARE_DENY_READ) == OF_SHARE_DENY_READ)
dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE; dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_DELETE;
else if ((iReadWrite & OF_SHARE_DENY_NONE) == OF_SHARE_DENY_NONE) else if ((iReadWrite & OF_SHARE_DENY_WRITE) == OF_SHARE_DENY_WRITE )
dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE; dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
else if ((iReadWrite & OF_SHARE_DENY_READ) == OF_SHARE_DENY_READ) else if ((iReadWrite & OF_SHARE_EXCLUSIVE) == OF_SHARE_EXCLUSIVE)
dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_DELETE; dwShareMode = 0;
else if ((iReadWrite & OF_SHARE_DENY_WRITE) == OF_SHARE_DENY_WRITE )
dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
else if ((iReadWrite & OF_SHARE_EXCLUSIVE) == OF_SHARE_EXCLUSIVE)
dwShareMode = 0;
SetLastError(0); SetLastError(0);
return (HFILE) CreateFileA( lpPathName,dwAccessMask,dwShareMode, return (HFILE) CreateFileA(
NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL); lpPathName,
dwAccessMask,
dwShareMode,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
} }
HFILE _lcreat( LPCSTR lpPathName, int iAttribute ) HFILE
STDCALL
_lcreat (
LPCSTR lpPathName,
int iAttribute
)
{ {
DWORD FileAttributes = 0; DWORD FileAttributes = 0;
@ -125,28 +171,47 @@ HFILE _lcreat( LPCSTR lpPathName, int iAttribute )
else if ( iAttribute == 4 ) else if ( iAttribute == 4 )
FileAttributes |= FILE_ATTRIBUTE_SYSTEM; FileAttributes |= FILE_ATTRIBUTE_SYSTEM;
return(HFILE) CreateFileA( lpPathName,GENERIC_ALL,FILE_SHARE_READ|FILE_SHARE_WRITE, return (HFILE) CreateFileA(
NULL,CREATE_ALWAYS,iAttribute ,NULL); lpPathName,
GENERIC_ALL,
(FILE_SHARE_READ | FILE_SHARE_WRITE),
NULL,
CREATE_ALWAYS,
iAttribute,
NULL
);
} }
int _lclose( int
HFILE hFile STDCALL
) _lclose (
HFILE hFile
)
{ {
if ( CloseHandle((HANDLE)hFile) ) if ( CloseHandle((HANDLE)hFile) )
{
return 0; return 0;
else }
return -1; return -1;
} }
LONG _llseek(
HFILE hFile, LONG
LONG lOffset, STDCALL
int iOrigin _llseek(
) HFILE hFile,
LONG lOffset,
int iOrigin
)
{ {
return SetFilePointer((HANDLE) hFile, lOffset, NULL,(DWORD)iOrigin ); return SetFilePointer(
(HANDLE) hFile,
lOffset,
NULL,
(DWORD) iOrigin
);
} }
/* EOF */

6
reactos/lib/kernel32/kernel32.edf
View file

@ -1,4 +1,4 @@
; $Id: kernel32.edf,v 1.1 1999/07/17 23:10:20 ea Exp $ ; $Id: kernel32.edf,v 1.2 1999/08/29 06:59:01 ea Exp $
; ;
; kernel32.edf ; kernel32.edf
; ;
@ -649,8 +649,8 @@ _lclose=_lclose@4
_lcreat=_lcreat@8 _lcreat=_lcreat@8
_llseek=_llseek@12 _llseek=_llseek@12
_lopen=_lopen@8 _lopen=_lopen@8
_lread=_lread@12 _lread=_hread@12
_lwrite=_lwrite@12 _lwrite=_hwrite@12
lstrcat=lstrcatA@8 lstrcat=lstrcatA@8
lstrcatA=lstrcatA@8 lstrcatA=lstrcatA@8
lstrcatW=lstrcatW@8 lstrcatW=lstrcatW@8

17
reactos/lib/kernel32/mem/heap.c
View file

@ -1,4 +1,5 @@
/* /* $Id: heap.c,v 1.15 1999/08/29 06:59:01 ea Exp $
*
* kernel/heap.c * kernel/heap.c
* Copyright (C) 1996, Onno Hovers, All rights reserved * Copyright (C) 1996, Onno Hovers, All rights reserved
* *
@ -117,9 +118,17 @@ BOOL WINAPI HeapUnlock(HANDLE hheap)
* NT uses this function to compact moveable blocks and other things * * NT uses this function to compact moveable blocks and other things *
* Here it does not compact, but it finds the largest free region * * Here it does not compact, but it finds the largest free region *
*********************************************************************/ *********************************************************************/
UINT HeapCompact(HANDLE hheap, DWORD flags) UINT
STDCALL
HeapCompact (
HANDLE hheap,
DWORD flags
)
{ {
return(RtlCompactHeap(hheap, flags)); return RtlCompactHeap(
hheap,
flags
);
} }
/********************************************************************* /*********************************************************************
@ -140,3 +149,5 @@ BOOL WINAPI HeapValidate(HANDLE hheap, DWORD flags, LPCVOID pmem)
return(RtlValidateHeap(hheap, flags, (PVOID)pmem)); return(RtlValidateHeap(hheap, flags, (PVOID)pmem));
} }
/* EOF */

32
reactos/lib/kernel32/misc/error.c
View file

@ -1,3 +1,8 @@
/* $Id: error.c,v 1.11 1999/08/29 06:59:02 ea Exp $
*
* reactos/lib/kernel32/misc/error.c
*
*/
#include <windows.h> #include <windows.h>
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#include <ddk/ntddbeep.h> #include <ddk/ntddbeep.h>
@ -9,26 +14,39 @@
static DWORD LastError=0; static DWORD LastError=0;
VOID SetLastError(DWORD dwErrorCode) VOID
STDCALL
SetLastError (
DWORD dwErrorCode
)
{ {
LastError = dwErrorCode; /* FIXME: it is per thread */
LastError = dwErrorCode;
} }
DWORD GetLastError(VOID) DWORD
STDCALL
GetLastError (VOID)
{ {
return(LastError); /* FIXME: it is per thread */
return LastError;
} }
BOOL __ErrorReturnFalse(ULONG ErrorCode)
BOOL
__ErrorReturnFalse (ULONG ErrorCode)
{ {
return(FALSE); return(FALSE);
} }
PVOID __ErrorReturnNull(ULONG ErrorCode)
PVOID
__ErrorReturnNull (ULONG ErrorCode)
{ {
return(NULL); return(NULL);
} }
WINBOOL WINBOOL
STDCALL STDCALL
Beep (DWORD dwFreq, DWORD dwDuration) Beep (DWORD dwFreq, DWORD dwDuration)
@ -65,3 +83,5 @@ Beep (DWORD dwFreq, DWORD dwDuration)
return TRUE; return TRUE;
} }
/* EOF */

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

@ -1,4 +1,5 @@
/* $Id: stubs.c,v 1.2 1999/07/17 23:10:20 ea Exp $ /* $Id: stubs.c,v 1.3 1999/08/29 06:59:03 ea 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.
*/ */
@ -3443,17 +3444,6 @@ RegisterConsoleVDM (
} }
WINBOOL
STDCALL
RegisterWaitForInputIdle (
DWORD Unknown0
)
{
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
WINBOOL WINBOOL
STDCALL STDCALL
RegisterWowBaseHandlers ( RegisterWowBaseHandlers (

26
reactos/lib/kernel32/process/lib.c
View file

@ -1,4 +1,5 @@
/* /* $Id: lib.c,v 1.3 1999/08/29 06:59:03 ea 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
* FILE: lib/kernel32/proc/proc.c * FILE: lib/kernel32/proc/proc.c
@ -23,20 +24,37 @@
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
HINSTANCE LoadLibraryW(LPCWSTR lpLibFileName) HINSTANCE
STDCALL
LoadLibraryW (
LPCWSTR lpLibFileName
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return(NULL); return(NULL);
} }
HINSTANCE LoadLibraryA(LPCSTR lpLibFileName)
HINSTANCE
STDCALL
LoadLibraryA (
LPCSTR lpLibFileName
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return(NULL); return(NULL);
} }
BOOL STDCALL FreeLibrary(HMODULE hLibModule)
BOOL
STDCALL
FreeLibrary (
HMODULE hLibModule
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return(FALSE); return(FALSE);
} }
/* EOF */

240
reactos/lib/kernel32/process/proc.c
View file

@ -1,4 +1,5 @@
/* /* $Id: proc.c,v 1.19 1999/08/29 06:59:03 ea 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
* FILE: lib/kernel32/proc/proc.c * FILE: lib/kernel32/proc/proc.c
@ -49,44 +50,79 @@ typedef struct _WSTARTUPINFO {
WaitForInputIdleType lpfnGlobalRegisterWaitForInputIdle; WaitForInputIdleType lpfnGlobalRegisterWaitForInputIdle;
VOID RegisterWaitForInputIdle(WaitForInputIdleType lpfnRegisterWaitForInputIdle); VOID
STDCALL
RegisterWaitForInputIdle (
WaitForInputIdleType lpfnRegisterWaitForInputIdle
);
/* FUNCTIONS ****************************************************************/ /* FUNCTIONS ****************************************************************/
WINBOOL STDCALL GetProcessId(HANDLE hProcess, LPDWORD lpProcessId); WINBOOL
STDCALL
GetProcessId (
HANDLE hProcess,
LPDWORD lpProcessId
);
FARPROC GetProcAddress(HMODULE hModule, LPCSTR lpProcName)
FARPROC
STDCALL
GetProcAddress (
HMODULE hModule,
LPCSTR lpProcName
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return(NULL); return NULL;
} }
WINBOOL STDCALL GetProcessTimes(HANDLE hProcess,
LPFILETIME lpCreationTime, WINBOOL
LPFILETIME lpExitTime, STDCALL
LPFILETIME lpKernelTime, GetProcessTimes (
LPFILETIME lpUserTime) HANDLE hProcess,
LPFILETIME lpCreationTime,
LPFILETIME lpExitTime,
LPFILETIME lpKernelTime,
LPFILETIME lpUserTime
)
{ {
dprintf("GetProcessTimes is unimplemented\n"); dprintf("GetProcessTimes is unimplemented\n");
return(FALSE); return FALSE;
} }
HANDLE STDCALL GetCurrentProcess(VOID)
HANDLE
STDCALL
GetCurrentProcess (VOID)
{ {
return (HANDLE)NtCurrentProcess(); return (HANDLE) NtCurrentProcess();
} }
HANDLE STDCALL GetCurrentThread(VOID)
HANDLE
STDCALL
GetCurrentThread (VOID)
{ {
return (HANDLE)NtCurrentThread(); return (HANDLE) NtCurrentThread();
} }
DWORD STDCALL GetCurrentProcessId(VOID)
DWORD
STDCALL
GetCurrentProcessId (VOID)
{ {
return (DWORD)(GetTeb()->Cid).UniqueProcess; return (DWORD) (GetTeb()->Cid).UniqueProcess;
} }
WINBOOL STDCALL GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode)
WINBOOL
STDCALL
GetExitCodeProcess (
HANDLE hProcess,
LPDWORD lpExitCode
)
{ {
NTSTATUS errCode; NTSTATUS errCode;
PROCESS_BASIC_INFORMATION ProcessBasic; PROCESS_BASIC_INFORMATION ProcessBasic;
@ -106,7 +142,13 @@ WINBOOL STDCALL GetExitCodeProcess(HANDLE hProcess, LPDWORD lpExitCode)
return TRUE; return TRUE;
} }
WINBOOL STDCALL GetProcessId(HANDLE hProcess, LPDWORD lpProcessId )
WINBOOL
STDCALL
GetProcessId (
HANDLE hProcess,
LPDWORD lpProcessId
)
{ {
NTSTATUS errCode; NTSTATUS errCode;
PROCESS_BASIC_INFORMATION ProcessBasic; PROCESS_BASIC_INFORMATION ProcessBasic;
@ -126,7 +168,13 @@ WINBOOL STDCALL GetProcessId(HANDLE hProcess, LPDWORD lpProcessId )
return TRUE; return TRUE;
} }
PWSTR InternalAnsiToUnicode(PWSTR Out, LPCSTR In, ULONG MaxLength)
PWSTR
InternalAnsiToUnicode (
PWSTR Out,
LPCSTR In,
ULONG MaxLength
)
{ {
ULONG i; ULONG i;
@ -148,9 +196,14 @@ PWSTR InternalAnsiToUnicode(PWSTR Out, LPCSTR In, ULONG MaxLength)
} }
} }
HANDLE STDCALL OpenProcess(DWORD dwDesiredAccess,
WINBOOL bInheritHandle, HANDLE
DWORD dwProcessId) STDCALL
OpenProcess (
DWORD dwDesiredAccess,
WINBOOL bInheritHandle,
DWORD dwProcessId
)
{ {
NTSTATUS errCode; NTSTATUS errCode;
HANDLE ProcessHandle; HANDLE ProcessHandle;
@ -183,7 +236,13 @@ HANDLE STDCALL OpenProcess(DWORD dwDesiredAccess,
return ProcessHandle; return ProcessHandle;
} }
UINT WinExec (LPCSTR lpCmdLine, UINT uCmdShow)
UINT
STDCALL
WinExec (
LPCSTR lpCmdLine,
UINT uCmdShow
)
{ {
STARTUPINFO StartupInfo; STARTUPINFO StartupInfo;
PROCESS_INFORMATION ProcessInformation; PROCESS_INFORMATION ProcessInformation;
@ -217,27 +276,45 @@ UINT WinExec (LPCSTR lpCmdLine, UINT uCmdShow)
} }
VOID
VOID RegisterWaitForInputIdle(WaitForInputIdleType STDCALL
lpfnRegisterWaitForInputIdle) RegisterWaitForInputIdle (
WaitForInputIdleType lpfnRegisterWaitForInputIdle
)
{ {
lpfnGlobalRegisterWaitForInputIdle = lpfnRegisterWaitForInputIdle; lpfnGlobalRegisterWaitForInputIdle = lpfnRegisterWaitForInputIdle;
return; return;
} }
DWORD STDCALL WaitForInputIdle(HANDLE hProcess,
DWORD dwMilliseconds) DWORD
STDCALL
WaitForInputIdle (
HANDLE hProcess,
DWORD dwMilliseconds
)
{ {
return 0; return 0;
} }
VOID STDCALL Sleep(DWORD dwMilliseconds)
VOID
STDCALL
Sleep (
DWORD dwMilliseconds
)
{ {
SleepEx(dwMilliseconds,FALSE); SleepEx (dwMilliseconds, FALSE);
return; return;
} }
DWORD STDCALL SleepEx(DWORD dwMilliseconds, BOOL bAlertable)
DWORD
STDCALL
SleepEx (
DWORD dwMilliseconds,
BOOL bAlertable
)
{ {
TIME Interval; TIME Interval;
NTSTATUS errCode; NTSTATUS errCode;
@ -245,14 +322,20 @@ DWORD STDCALL SleepEx(DWORD dwMilliseconds, BOOL bAlertable)
Interval.QuadPart = dwMilliseconds * 1000; Interval.QuadPart = dwMilliseconds * 1000;
errCode = NtDelayExecution(bAlertable,&Interval); errCode = NtDelayExecution(bAlertable,&Interval);
if ( !NT_SUCCESS(errCode) ) { if ( !NT_SUCCESS(errCode) )
{
SetLastError(RtlNtStatusToDosError(errCode)); SetLastError(RtlNtStatusToDosError(errCode));
return -1; return -1;
} }
return 0; return 0;
} }
VOID STDCALL GetStartupInfoW(LPSTARTUPINFO _lpStartupInfo)
VOID
STDCALL
GetStartupInfoW (
LPSTARTUPINFO _lpStartupInfo
)
{ {
NT_PEB *pPeb = NtCurrentPeb(); NT_PEB *pPeb = NtCurrentPeb();
LPWSTARTUPINFO lpStartupInfo = (LPWSTARTUPINFO)_lpStartupInfo; LPWSTARTUPINFO lpStartupInfo = (LPWSTARTUPINFO)_lpStartupInfo;
@ -305,7 +388,11 @@ VOID STDCALL GetStartupInfoW(LPSTARTUPINFO _lpStartupInfo)
} }
VOID STDCALL GetStartupInfoA(LPSTARTUPINFO lpStartupInfo) VOID
STDCALL
GetStartupInfoA (
LPSTARTUPINFO lpStartupInfo
)
{ {
NT_PEB *pPeb = NtCurrentPeb(); NT_PEB *pPeb = NtCurrentPeb();
ULONG i = 0; ULONG i = 0;
@ -355,26 +442,50 @@ VOID STDCALL GetStartupInfoA(LPSTARTUPINFO lpStartupInfo)
return; return;
} }
BOOL STDCALL FlushInstructionCache(HANDLE hProcess,
LPCVOID lpBaseAddress, BOOL
DWORD dwSize) STDCALL
FlushInstructionCache (
HANDLE hProcess,
LPCVOID lpBaseAddress,
DWORD dwSize
)
{ {
NTSTATUS errCode; NTSTATUS errCode;
errCode = NtFlushInstructionCache(hProcess,(PVOID)lpBaseAddress,dwSize);
if (!NT_SUCCESS(errCode)) errCode = NtFlushInstructionCache(
{ hProcess,
SetLastError(RtlNtStatusToDosError(errCode)); (PVOID) lpBaseAddress,
return FALSE; dwSize
} );
return TRUE; if (!NT_SUCCESS(errCode))
{
SetLastError(RtlNtStatusToDosError(errCode));
return FALSE;
}
return TRUE;
} }
VOID STDCALL ExitProcess(UINT uExitCode)
VOID
STDCALL
ExitProcess (
UINT uExitCode
)
{ {
NtTerminateProcess(NtCurrentProcess(), uExitCode); NtTerminateProcess(
NtCurrentProcess(),
uExitCode
);
} }
WINBOOL STDCALL TerminateProcess(HANDLE hProcess, UINT uExitCode)
WINBOOL
STDCALL
TerminateProcess (
HANDLE hProcess,
UINT uExitCode
)
{ {
NTSTATUS errCode; NTSTATUS errCode;
errCode = NtTerminateProcess(hProcess, uExitCode); errCode = NtTerminateProcess(hProcess, uExitCode);
@ -386,7 +497,12 @@ WINBOOL STDCALL TerminateProcess(HANDLE hProcess, UINT uExitCode)
return TRUE; return TRUE;
} }
VOID STDCALL FatalAppExitA(UINT uAction, LPCSTR lpMessageText) VOID
STDCALL
FatalAppExitA (
UINT uAction,
LPCSTR lpMessageText
)
{ {
WCHAR MessageTextW[MAX_PATH]; WCHAR MessageTextW[MAX_PATH];
UINT i; UINT i;
@ -404,7 +520,15 @@ VOID STDCALL FatalAppExitA(UINT uAction, LPCSTR lpMessageText)
VOID STDCALL FatalAppExitW(UINT uAction, LPCWSTR lpMessageText) VOID
STDCALL
FatalAppExitW (
UINT uAction,
LPCWSTR lpMessageText
)
{ {
return; return;
} }
/* EOF */

30
reactos/lib/kernel32/synch/critical.c
View file

@ -1,4 +1,5 @@
/* /* $Id: critical.c,v 1.5 1999/08/29 06:59:03 ea 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
* FILE: lib/kernel32/sync/critical.c * FILE: lib/kernel32/sync/critical.c
@ -15,29 +16,46 @@
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
VOID DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
VOID
STDCALL
DeleteCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
VOID EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
VOID
STDCALL
EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
VOID InitializeCriticalSection(LPCRITICAL_SECTION pcritical)
VOID
STDCALL
InitializeCriticalSection(LPCRITICAL_SECTION pcritical)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
VOID LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
VOID
STDCALL
LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
WINBOOL TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
WINBOOL
STDCALL
TryEnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return(FALSE); return(FALSE);
} }
/* EOF */

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

@ -1,3 +1,7 @@
; $Id: ntdll.def,v 1.13 1999/08/29 06:59:04 ea Exp $
;
; ReactOS Operating System
;
EXPORTS EXPORTS
InitializeObjectAttributes InitializeObjectAttributes
NtAcceptConnectPort@24 NtAcceptConnectPort@24

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

@ -1,3 +1,7 @@
; $Id: ntdll.edf,v 1.4 1999/08/29 06:59:04 ea Exp $
;
; ReactOS Operating System
;
EXPORTS EXPORTS
InitializeObjectAttributes InitializeObjectAttributes
NtAcceptConnectPort=NtAcceptConnectPort@24 NtAcceptConnectPort=NtAcceptConnectPort@24

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

@ -1,4 +1,5 @@
/* /* $Id: startup.c,v 1.9 1999/08/29 06:59:04 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: lib/ntdll/ldr/startup.c * FILE: lib/ntdll/ldr/startup.c
@ -9,6 +10,7 @@
/* INCLUDES *****************************************************************/ /* INCLUDES *****************************************************************/
#include <reactos/config.h>
#define WIN32_NO_PEHDR #define WIN32_NO_PEHDR
#include <windows.h> #include <windows.h>
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
@ -18,7 +20,9 @@
#include <ntdll/ldr.h> #include <ntdll/ldr.h>
#include <ntdll/rtl.h> #include <ntdll/rtl.h>
#ifndef DBG_NTDLL_LDR_STARTUP
#define NDEBUG #define NDEBUG
#endif
#include <ntdll/ntdll.h> #include <ntdll/ntdll.h>
/* GLOBALS *******************************************************************/ /* GLOBALS *******************************************************************/
@ -30,8 +34,11 @@ extern HANDLE __ProcessHeap;
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
NTSTATUS LdrMapNTDllForProcess(HANDLE ProcessHandle, NTSTATUS
PHANDLE PtrNTDllSectionHandle) LdrMapNTDllForProcess (
HANDLE ProcessHandle,
PHANDLE PtrNTDllSectionHandle
)
{ {
ULONG InitialViewSize; ULONG InitialViewSize;
NTSTATUS Status; NTSTATUS Status;
@ -125,3 +132,6 @@ VOID LdrStartup(HANDLE SectionHandle,
Status = EntryPoint(); Status = EntryPoint();
ZwTerminateProcess(NtCurrentProcess(),Status); ZwTerminateProcess(NtCurrentProcess(),Status);
} }
/* EOF */

1235
reactos/lib/ntdll/ldr/utils.c
View file

File diff suppressed because it is too large Load diff

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

@ -1,4 +1,5 @@
/* /* $Id: registry.c,v 1.18 1999/08/29 06:59:05 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/cm/registry.c * FILE: ntoskrnl/cm/registry.c
@ -363,13 +364,16 @@ CHECKPOINT;
NTSTATUS NTSTATUS
NtCreateKey(OUT PHANDLE KeyHandle, STDCALL
IN ACCESS_MASK DesiredAccess, NtCreateKey (
IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PHANDLE KeyHandle,
IN ULONG TitleIndex, IN ACCESS_MASK DesiredAccess,
IN PUNICODE_STRING Class, IN POBJECT_ATTRIBUTES ObjectAttributes,
IN ULONG CreateOptions, IN ULONG TitleIndex,
OUT PULONG Disposition) IN PUNICODE_STRING Class,
IN ULONG CreateOptions,
OUT PULONG Disposition
)
{ {
#if PROTO_REG #if PROTO_REG
PWSTR KeyNameBuf; PWSTR KeyNameBuf;
@ -455,7 +459,10 @@ NtCreateKey(OUT PHANDLE KeyHandle,
NTSTATUS NTSTATUS
NtDeleteKey(IN HANDLE KeyHandle) STDCALL
NtDeleteKey (
IN HANDLE KeyHandle
)
{ {
#ifdef PROTO_REG #ifdef PROTO_REG
NTSTATUS Status; NTSTATUS Status;
@ -489,12 +496,15 @@ NtDeleteKey(IN HANDLE KeyHandle)
NTSTATUS NTSTATUS
NtEnumerateKey(IN HANDLE KeyHandle, STDCALL
IN ULONG Index, NtEnumerateKey (
IN KEY_INFORMATION_CLASS KeyInformationClass, IN HANDLE KeyHandle,
OUT PVOID KeyInformation, IN ULONG Index,
IN ULONG Length, IN KEY_INFORMATION_CLASS KeyInformationClass,
OUT PULONG ResultLength) OUT PVOID KeyInformation,
IN ULONG Length,
OUT PULONG ResultLength
)
{ {
#ifdef PROTO_REG #ifdef PROTO_REG
NTSTATUS Status; NTSTATUS Status;
@ -637,7 +647,9 @@ NtEnumerateKey(IN HANDLE KeyHandle,
#endif #endif
} }
NTSTATUS NTSTATUS
STDCALL
NtEnumerateValueKey ( NtEnumerateValueKey (
IN HANDLE KeyHandle, IN HANDLE KeyHandle,
IN ULONG Index, IN ULONG Index,
@ -654,8 +666,12 @@ NtEnumerateValueKey (
#endif #endif
} }
NTSTATUS NTSTATUS
NtFlushKey(IN HANDLE KeyHandle) STDCALL
NtFlushKey (
IN HANDLE KeyHandle
)
{ {
#ifdef PROTO_REG #ifdef PROTO_REG
return STATUS_SUCCESS; return STATUS_SUCCESS;
@ -664,10 +680,14 @@ NtFlushKey(IN HANDLE KeyHandle)
#endif #endif
} }
NTSTATUS NTSTATUS
NtOpenKey(OUT PHANDLE KeyHandle, STDCALL
IN ACCESS_MASK DesiredAccess, NtOpenKey (
IN POBJECT_ATTRIBUTES ObjectAttributes) OUT PHANDLE KeyHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes
)
{ {
#ifdef PROTO_REG #ifdef PROTO_REG
NTSTATUS Status; NTSTATUS Status;
@ -757,7 +777,9 @@ NtOpenKey(OUT PHANDLE KeyHandle,
#endif #endif
} }
NTSTATUS NTSTATUS
STDCALL
NtQueryKey ( NtQueryKey (
IN HANDLE KeyHandle, IN HANDLE KeyHandle,
IN KEY_INFORMATION_CLASS KeyInformationClass, IN KEY_INFORMATION_CLASS KeyInformationClass,
@ -895,7 +917,9 @@ NtQueryKey (
#endif #endif
} }
NTSTATUS NTSTATUS
STDCALL
NtQueryValueKey ( NtQueryValueKey (
IN HANDLE KeyHandle, IN HANDLE KeyHandle,
IN PUNICODE_STRING ValueName, IN PUNICODE_STRING ValueName,
@ -1024,7 +1048,9 @@ NtQueryValueKey (
#endif #endif
} }
NTSTATUS NTSTATUS
STDCALL
NtSetValueKey ( NtSetValueKey (
IN HANDLE KeyHandle, IN HANDLE KeyHandle,
IN PUNICODE_STRING ValueName, IN PUNICODE_STRING ValueName,
@ -1088,7 +1114,8 @@ NtSetValueKey (
#endif #endif
} }
NTSTATUS STDCALL NTSTATUS
STDCALL
NtDeleteValueKey ( NtDeleteValueKey (
IN HANDLE KeyHandle, IN HANDLE KeyHandle,
IN PUNICODE_STRING ValueName IN PUNICODE_STRING ValueName
@ -1246,6 +1273,7 @@ NtInitializeRegistry (
NTSTATUS NTSTATUS
STDCALL
RtlCheckRegistryKey ( RtlCheckRegistryKey (
ULONG RelativeTo, ULONG RelativeTo,
PWSTR Path PWSTR Path
@ -1256,6 +1284,7 @@ RtlCheckRegistryKey (
NTSTATUS NTSTATUS
STDCALL
RtlCreateRegistryKey ( RtlCreateRegistryKey (
IN ULONG RelativeTo, IN ULONG RelativeTo,
IN PWSTR Path IN PWSTR Path
@ -1266,6 +1295,7 @@ RtlCreateRegistryKey (
NTSTATUS NTSTATUS
STDCALL
RtlDeleteRegistryValue ( RtlDeleteRegistryValue (
IN ULONG RelativeTo, IN ULONG RelativeTo,
IN PWSTR Path, IN PWSTR Path,
@ -1277,6 +1307,7 @@ RtlDeleteRegistryValue (
NTSTATUS NTSTATUS
STDCALL
RtlQueryRegistryValues ( RtlQueryRegistryValues (
IN ULONG RelativeTo, IN ULONG RelativeTo,
IN PWSTR Path, IN PWSTR Path,
@ -1290,6 +1321,7 @@ RtlQueryRegistryValues (
NTSTATUS NTSTATUS
STDCALL
RtlWriteRegistryValue ( RtlWriteRegistryValue (
ULONG RelativeTo, ULONG RelativeTo,
PWSTR Path, PWSTR Path,
@ -2690,4 +2722,4 @@ CmiReleaseBlock(PREGISTRY_FILE RegistryFile,
#endif #endif
/* EOF */

49
reactos/ntoskrnl/ex/interlck.c
View file

@ -1,4 +1,5 @@
/* /* $Id: interlck.c,v 1.2 1999/08/29 06:59:06 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/ex/interlck.c * FILE: ntoskrnl/ex/interlck.c
@ -16,28 +17,46 @@
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
INTERLOCKED_RESULT ExInterlockedDecrementLong(PLONG Addend, INTERLOCKED_RESULT
PKSPIN_LOCK Lock) ExInterlockedDecrementLong (
PLONG Addend,
PKSPIN_LOCK Lock
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
ULONG ExInterlockedExchangeUlong(PULONG Target,
ULONG Value, ULONG
PKSPIN_LOCK Lock) ExInterlockedExchangeUlong (
PULONG Target,
ULONG Value,
PKSPIN_LOCK Lock
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
ULONG ExInterlockedAddUlong(PULONG Addend,
ULONG Increment, ULONG
PKSPIN_LOCK Lock) ExInterlockedAddUlong (
PULONG Addend,
ULONG Increment,
PKSPIN_LOCK Lock
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
INTERLOCKED_RESULT ExInterlockedIncrementLong(PLONG Addend,
PKSPIN_LOCK Lock) INTERLOCKED_RESULT
ExInterlockedIncrementLong (
PLONG Addend,
PKSPIN_LOCK Lock
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
/* EOF */

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

@ -1,4 +1,5 @@
/* /* $Id: device.c,v 1.10 1999/08/29 06:59:06 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/io/device.c * FILE: ntoskrnl/io/device.c
@ -33,20 +34,32 @@ NtUnloadDriver (
} }
/**********************************************************************
* NAME EXPORTED
* NtLoadDriver
*
* DESCRIPTION
* Loads a device driver.
*
* ARGUMENTS
* DriverServiceName
* Name of the service to load (registry key).
*
* RETURN VALUE
* Status.
*
* REVISIONS
*/
NTSTATUS NTSTATUS
STDCALL
NtLoadDriver ( NtLoadDriver (
PUNICODE_STRING DriverServiceName PUNICODE_STRING DriverServiceName
) )
/*
* FUNCTION: Loads a driver
* ARGUMENTS:
* DriverServiceName = Name of the service to load (registry key)
* RETURNS: Status
*/
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
NTSTATUS NTSTATUS
IoAttachDeviceByPointer ( IoAttachDeviceByPointer (
PDEVICE_OBJECT SourceDevice, PDEVICE_OBJECT SourceDevice,
@ -307,3 +320,6 @@ NTSTATUS IoCreateDevice(PDRIVER_OBJECT DriverObject,
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
/* EOF */

137
reactos/ntoskrnl/io/file.c
View file

@ -1,4 +1,5 @@
/* /* $Id: file.c,v 1.9 1999/08/29 06:59:06 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/io/file.c * FILE: ntoskrnl/io/file.c
@ -89,7 +90,9 @@ NtQueryInformationFile (
return(Status); return(Status);
} }
NTSTATUS NTSTATUS
STDCALL
NtSetInformationFile ( NtSetInformationFile (
HANDLE FileHandle, HANDLE FileHandle,
PIO_STATUS_BLOCK IoStatusBlock, PIO_STATUS_BLOCK IoStatusBlock,
@ -98,65 +101,100 @@ NtSetInformationFile (
FILE_INFORMATION_CLASS FileInformationClass FILE_INFORMATION_CLASS FileInformationClass
) )
{ {
NTSTATUS Status; NTSTATUS Status;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PIRP Irp; PIRP Irp;
PIO_STACK_LOCATION StackPtr; PIO_STACK_LOCATION StackPtr;
KEVENT Event; KEVENT Event;
DPRINT("NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n", DPRINT(
FileHandle, "NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n",
IoStatusBlock, FileHandle,
FileInformation, IoStatusBlock,
Length, FileInformation,
FileInformationClass); Length,
FileInformationClass
);
/* Get the file object from the file handle */ /* Get the file object from the file handle */
Status = ObReferenceObjectByHandle(FileHandle, Status = ObReferenceObjectByHandle(
FILE_WRITE_ATTRIBUTES, FileHandle,
IoFileType, FILE_WRITE_ATTRIBUTES,
UserMode, IoFileType,
(PVOID *) &FileObject, UserMode,
NULL); (PVOID *) & FileObject,
if (!NT_SUCCESS(Status)) NULL
{ );
return Status; if (!NT_SUCCESS(Status))
} {
DPRINT("FileObject %x\n", FileObject); return Status;
}
DPRINT("FileObject %x\n", FileObject);
/* initialize an event object to wait on for the request */ /*
KeInitializeEvent(&Event, NotificationEvent, FALSE); * Initialize an event object to wait
* on for the request.
*/
KeInitializeEvent(
& Event,
NotificationEvent,
FALSE
);
/*
* Build the IRP to be sent to the driver
* for the request.
*/
Irp = IoBuildSynchronousFsdRequest(
IRP_MJ_SET_INFORMATION,
FileObject->DeviceObject,
FileInformation,
Length,
0,
& Event,
IoStatusBlock
);
/* build the IRP to be sent to the driver for the request */ StackPtr = IoGetNextIrpStackLocation(Irp);
Irp = IoBuildSynchronousFsdRequest(IRP_MJ_SET_INFORMATION, StackPtr->FileObject = FileObject;
FileObject->DeviceObject, StackPtr->Parameters.SetFile.Length = Length;
FileInformation, StackPtr->Parameters.SetFile.FileInformationClass =
Length, FileInformationClass;
0,
&Event,
IoStatusBlock);
StackPtr = IoGetNextIrpStackLocation(Irp);
StackPtr->FileObject = FileObject;
StackPtr->Parameters.SetFile.Length = Length;
StackPtr->Parameters.SetFile.FileInformationClass = FileInformationClass;
/* Pass the IRP to the FSD (and wait for it if required) */ /*
DPRINT("FileObject->DeviceObject %x\n", FileObject->DeviceObject); * Pass the IRP to the FSD (and wait for
Status = IoCallDriver(FileObject->DeviceObject, Irp); * it if required)
if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO)) */
{ DPRINT("FileObject->DeviceObject %x\n", FileObject->DeviceObject);
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); Status = IoCallDriver(
Status = Irp->IoStatus.Status; FileObject->DeviceObject,
} Irp
);
if ( (Status == STATUS_PENDING)
&& (FileObject->Flags & FO_SYNCHRONOUS_IO)
)
{
KeWaitForSingleObject(
& Event,
Executive,
KernelMode,
FALSE,
NULL
);
Status = Irp->IoStatus.Status;
}
return Status; return Status;
} }
PGENERIC_MAPPING IoGetFileObjectGenericMapping(VOID)
PGENERIC_MAPPING
IoGetFileObjectGenericMapping(VOID)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
NTSTATUS NTSTATUS
STDCALL STDCALL
NtQueryAttributesFile ( NtQueryAttributesFile (
@ -210,3 +248,4 @@ NtSetEaFile (
} }
/* EOF */

370
reactos/ntoskrnl/io/rw.c
View file

@ -1,4 +1,5 @@
/* /* $Id: rw.c,v 1.26 1999/08/29 06:59:06 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/io/rw.c * FILE: ntoskrnl/io/rw.c
@ -21,7 +22,22 @@
/* FUNCTIONS ***************************************************************/ /* FUNCTIONS ***************************************************************/
/**********************************************************************
* NAME EXPORTED
* NtReadFile
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
STDCALL
NtReadFile ( NtReadFile (
HANDLE FileHandle, HANDLE FileHandle,
HANDLE EventHandle, HANDLE EventHandle,
@ -34,94 +50,142 @@ NtReadFile (
PULONG Key PULONG Key
) )
{ {
NTSTATUS Status; NTSTATUS Status;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PIRP Irp; PIRP Irp;
PIO_STACK_LOCATION StackPtr; PIO_STACK_LOCATION StackPtr;
PKEVENT ptrEvent = NULL; PKEVENT ptrEvent = NULL;
KEVENT Event; KEVENT Event;
DPRINT("NtReadFile(FileHandle %x Buffer %x Length %x ByteOffset %x, " DPRINT(
"IoStatusBlock %x)\n", "NtReadFile(FileHandle %x Buffer %x Length %x ByteOffset %x, "
FileHandle,Buffer,Length,ByteOffset,IoStatusBlock); "IoStatusBlock %x)\n",
FileHandle,
Buffer,
Length,
ByteOffset,
IoStatusBlock
);
assert_irql(PASSIVE_LEVEL); assert_irql(PASSIVE_LEVEL);
Status = ObReferenceObjectByHandle(FileHandle, Status = ObReferenceObjectByHandle(
FILE_READ_DATA, FileHandle,
IoFileType, FILE_READ_DATA,
UserMode, IoFileType,
(PVOID *) &FileObject, UserMode,
NULL); (PVOID *) & FileObject,
if (!NT_SUCCESS(Status)) NULL
{ );
DPRINT("NtReadFile() = %x\n",Status);
return(Status);
}
DPRINT("ByteOffset %x FileObject->CurrentByteOffset %d\n",
ByteOffset,
FileObject->CurrentByteOffset.LowPart);
if (ByteOffset==NULL)
{
ByteOffset = &(FileObject->CurrentByteOffset);
}
if (EventHandle != NULL)
{
Status = ObReferenceObjectByHandle(EventHandle,
SYNCHRONIZE,
ExEventType,
UserMode,
(PVOID *)ptrEvent,
NULL);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return(Status); DPRINT("NtReadFile() = %x\n",Status);
} return Status;
} }
else
{ DPRINT(
KeInitializeEvent(&Event,NotificationEvent,FALSE); "ByteOffset %x FileObject->CurrentByteOffset %d\n",
ptrEvent = &Event; ByteOffset,
} FileObject->CurrentByteOffset.LowPart
);
if (ByteOffset == NULL)
{
ByteOffset = & (FileObject->CurrentByteOffset);
}
if (EventHandle != NULL)
{
Status = ObReferenceObjectByHandle(
EventHandle,
SYNCHRONIZE,
ExEventType,
UserMode,
(PVOID *) ptrEvent,
NULL
);
if (!NT_SUCCESS(Status))
{
return Status;
}
}
else
{
KeInitializeEvent(
& Event,
NotificationEvent,
FALSE
);
ptrEvent = & Event;
}
DPRINT("FileObject %x\n",FileObject); DPRINT("FileObject %x\n",FileObject);
Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
FileObject->DeviceObject, Irp = IoBuildSynchronousFsdRequest(
Buffer, IRP_MJ_READ,
Length, FileObject->DeviceObject,
ByteOffset, Buffer,
ptrEvent, Length,
IoStatusBlock); ByteOffset,
ptrEvent,
IoStatusBlock
);
Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine; Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext; Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
StackPtr = IoGetNextIrpStackLocation(Irp); StackPtr = IoGetNextIrpStackLocation(Irp);
StackPtr->FileObject = FileObject; StackPtr->FileObject = FileObject;
if (Key!=NULL) if (Key != NULL)
{ {
StackPtr->Parameters.Read.Key = *Key; StackPtr->Parameters.Read.Key = *Key;
} }
else else
{ {
StackPtr->Parameters.Read.Key = 0; StackPtr->Parameters.Read.Key = 0;
} }
Status = IoCallDriver(FileObject->DeviceObject, Irp); Status = IoCallDriver(
if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO)) FileObject->DeviceObject,
{ Irp
KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL); );
Status = IoStatusBlock->Status; if (
} (Status == STATUS_PENDING)
DPRINT("NtReadFile() = %x\n",Status); && (FileObject->Flags & FO_SYNCHRONOUS_IO)
assert_irql(PASSIVE_LEVEL); )
return(Status); {
KeWaitForSingleObject(
& Event,
Executive,
KernelMode,
FALSE,
NULL
);
Status = IoStatusBlock->Status;
}
DPRINT("NtReadFile() = %x\n",Status);
assert_irql(PASSIVE_LEVEL);
return Status;
} }
/**********************************************************************
* NAME EXPORTED
* NtWriteFile
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
STDCALL
NtWriteFile ( NtWriteFile (
HANDLE FileHandle, HANDLE FileHandle,
HANDLE EventHandle, HANDLE EventHandle,
@ -134,63 +198,101 @@ NtWriteFile (
PULONG Key PULONG Key
) )
{ {
NTSTATUS Status; NTSTATUS Status;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PIRP Irp; PIRP Irp;
PIO_STACK_LOCATION StackPtr; PIO_STACK_LOCATION StackPtr;
KEVENT Event; KEVENT Event;
DPRINT("NtWriteFile(FileHandle %x, Buffer %x, Length %d)\n", DPRINT(
FileHandle,Buffer,Length); "NtWriteFile(FileHandle %x, Buffer %x, Length %d)\n",
FileHandle,
Buffer,
Length
);
Status = ObReferenceObjectByHandle(FileHandle, Status = ObReferenceObjectByHandle(
FILE_WRITE_DATA, FileHandle,
IoFileType, FILE_WRITE_DATA,
UserMode, IoFileType,
(PVOID *) &FileObject, UserMode,
NULL); (PVOID *) & FileObject,
if (!NT_SUCCESS(Status)) NULL
{ );
return(Status); if (!NT_SUCCESS(Status))
} {
if (ByteOffset==NULL) return Status;
{ }
ByteOffset = &(FileObject->CurrentByteOffset); if (ByteOffset == NULL)
} {
ByteOffset = & (FileObject->CurrentByteOffset);
}
KeInitializeEvent(&Event,NotificationEvent,FALSE); KeInitializeEvent(
Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE, & Event,
FileObject->DeviceObject, NotificationEvent,
Buffer, FALSE
Length, );
ByteOffset, Irp = IoBuildSynchronousFsdRequest(
&Event, IRP_MJ_WRITE,
IoStatusBlock); FileObject->DeviceObject,
Buffer,
Length,
ByteOffset,
& Event,
IoStatusBlock
);
Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine; Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext; Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
DPRINT("FileObject->DeviceObject %x\n",FileObject->DeviceObject); DPRINT("FileObject->DeviceObject %x\n",FileObject->DeviceObject);
StackPtr = IoGetNextIrpStackLocation(Irp);
StackPtr->FileObject = FileObject; StackPtr = IoGetNextIrpStackLocation(Irp);
if (Key!=NULL) StackPtr->FileObject = FileObject;
{ if (Key != NULL)
StackPtr->Parameters.Write.Key = *Key; {
} StackPtr->Parameters.Write.Key = *Key;
else }
{ else
StackPtr->Parameters.Write.Key = 0; {
} StackPtr->Parameters.Write.Key = 0;
Status = IoCallDriver(FileObject->DeviceObject,Irp); }
if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO)) Status = IoCallDriver(
{ FileObject->DeviceObject,
KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL); Irp
Status = Irp->IoStatus.Status; );
} if (
return(Status); (Status == STATUS_PENDING)
&& (FileObject->Flags & FO_SYNCHRONOUS_IO)
)
{
KeWaitForSingleObject(
& Event,
Executive,
KernelMode,
FALSE,
NULL
);
Status = Irp->IoStatus.Status;
}
return Status;
} }
/**********************************************************************
* NAME EXPORTED
* NtReadFileScatter
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
STDCALL STDCALL
NtReadFileScatter ( NtReadFileScatter (
@ -209,6 +311,19 @@ NtReadFileScatter (
} }
/**********************************************************************
* NAME EXPORTED
* NtWriteFileGather
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
STDCALL STDCALL
NtWriteFileGather ( NtWriteFileGather (
@ -225,3 +340,6 @@ NtWriteFileGather (
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
/* EOF */

514
reactos/ntoskrnl/io/symlink.c
View file

@ -1,4 +1,5 @@
/* /* $Id: symlink.c,v 1.9 1999/08/29 06:59:08 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/io/symlink.c * FILE: ntoskrnl/io/symlink.c
@ -19,197 +20,400 @@
/* GLOBALS ******************************************************************/ /* GLOBALS ******************************************************************/
typedef struct typedef
struct
{ {
CSHORT Type; CSHORT Type;
CSHORT Size; CSHORT Size;
UNICODE_STRING TargetName; UNICODE_STRING TargetName;
OBJECT_ATTRIBUTES Target; OBJECT_ATTRIBUTES Target;
} SYMLNK_OBJECT, *PSYMLNK_OBJECT; } SYMLNK_OBJECT, *PSYMLNK_OBJECT;
POBJECT_TYPE IoSymbolicLinkType = NULL;
POBJECT_TYPE
IoSymbolicLinkType = NULL;
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
NTSTATUS IopCreateSymbolicLink(PVOID Object,
PVOID Parent,
PWSTR RemainingPath,
POBJECT_ATTRIBUTES ObjectAttributes)
{
if (Parent != NULL && RemainingPath != NULL)
{
ObAddEntryDirectory(Parent, Object, RemainingPath+1);
}
return(STATUS_SUCCESS);
}
PVOID IopParseSymbolicLink(PVOID Object,
PWSTR* RemainingPath)
{
NTSTATUS Status;
PSYMLNK_OBJECT SymlinkObject = (PSYMLNK_OBJECT)Object;
PVOID ReturnedObject;
Status = ObReferenceObjectByName(SymlinkObject->Target.ObjectName,
0,
NULL,
STANDARD_RIGHTS_REQUIRED,
NULL,
UserMode,
NULL,
&ReturnedObject);
if (NT_SUCCESS(Status))
{
return(ReturnedObject);
}
return(NULL);
}
VOID IoInitSymbolicLinkImplementation(VOID)
{
ANSI_STRING AnsiString;
IoSymbolicLinkType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
IoSymbolicLinkType->TotalObjects = 0;
IoSymbolicLinkType->TotalHandles = 0;
IoSymbolicLinkType->MaxObjects = ULONG_MAX;
IoSymbolicLinkType->MaxHandles = ULONG_MAX;
IoSymbolicLinkType->PagedPoolCharge = 0;
IoSymbolicLinkType->NonpagedPoolCharge = sizeof(SYMLNK_OBJECT);
IoSymbolicLinkType->Dump = NULL;
IoSymbolicLinkType->Open = NULL;
IoSymbolicLinkType->Close = NULL;
IoSymbolicLinkType->Delete = NULL;
IoSymbolicLinkType->Parse = IopParseSymbolicLink;
IoSymbolicLinkType->Security = NULL;
IoSymbolicLinkType->QueryName = NULL;
IoSymbolicLinkType->OkayToClose = NULL;
IoSymbolicLinkType->Create = IopCreateSymbolicLink;
RtlInitAnsiString(&AnsiString,"Symbolic Link");
RtlAnsiStringToUnicodeString(&IoSymbolicLinkType->TypeName,
&AnsiString,TRUE);
}
/**********************************************************************
* NAME INTERNAL
* IopCreateSymbolicLink
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURNN VALUE
* Status.
*
* REVISIONS
*/
NTSTATUS NTSTATUS
IopCreateSymbolicLink (
PVOID Object,
PVOID Parent,
PWSTR RemainingPath,
POBJECT_ATTRIBUTES ObjectAttributes
)
{
if ( (Parent != NULL)
&& (RemainingPath != NULL)
)
{
ObAddEntryDirectory(
Parent,
Object,
RemainingPath + 1
);
}
return STATUS_SUCCESS;
}
/**********************************************************************
* NAME INTERNAL
* IopParseSymbolicLink
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURNN VALUE
*
* REVISIONS
*/
PVOID
IopParseSymbolicLink (
PVOID Object,
PWSTR * RemainingPath
)
{
NTSTATUS Status;
PSYMLNK_OBJECT SymlinkObject = (PSYMLNK_OBJECT) Object;
PVOID ReturnedObject;
Status = ObReferenceObjectByName(
SymlinkObject->Target.ObjectName,
0,
NULL,
STANDARD_RIGHTS_REQUIRED,
NULL,
UserMode,
NULL,
& ReturnedObject
);
if (NT_SUCCESS(Status))
{
return ReturnedObject;
}
return NULL;
}
/**********************************************************************
* NAME INTERNAL
* IoInitSymbolicLinkImplementation
*
* DESCRIPTION
*
* ARGUMENTS
* None.
*
* RETURNN VALUE
* None.
*
* REVISIONS
*/
VOID
IoInitSymbolicLinkImplementation (VOID)
{
ANSI_STRING AnsiString;
IoSymbolicLinkType = ExAllocatePool(
NonPagedPool,
sizeof (OBJECT_TYPE)
);
IoSymbolicLinkType->TotalObjects = 0;
IoSymbolicLinkType->TotalHandles = 0;
IoSymbolicLinkType->MaxObjects = ULONG_MAX;
IoSymbolicLinkType->MaxHandles = ULONG_MAX;
IoSymbolicLinkType->PagedPoolCharge = 0;
IoSymbolicLinkType->NonpagedPoolCharge = sizeof (SYMLNK_OBJECT);
IoSymbolicLinkType->Dump = NULL;
IoSymbolicLinkType->Open = NULL;
IoSymbolicLinkType->Close = NULL;
IoSymbolicLinkType->Delete = NULL;
IoSymbolicLinkType->Parse = IopParseSymbolicLink;
IoSymbolicLinkType->Security = NULL;
IoSymbolicLinkType->QueryName = NULL;
IoSymbolicLinkType->OkayToClose = NULL;
IoSymbolicLinkType->Create = IopCreateSymbolicLink;
RtlInitAnsiString(
& AnsiString,
"Symbolic Link"
);
RtlAnsiStringToUnicodeString(
& IoSymbolicLinkType->TypeName,
& AnsiString,
TRUE
);
}
/**********************************************************************
* NAME EXPORTED
* NtOpenSymbolicLinkObject
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS
STDCALL
NtOpenSymbolicLinkObject ( NtOpenSymbolicLinkObject (
OUT PHANDLE LinkHandle, OUT PHANDLE LinkHandle,
IN ACCESS_MASK DesiredAccess, IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes IN POBJECT_ATTRIBUTES ObjectAttributes
) )
{ {
NTSTATUS Status; NTSTATUS Status;
PVOID Object; PVOID Object;
Status = ObReferenceObjectByName(ObjectAttributes->ObjectName, Status = ObReferenceObjectByName(
ObjectAttributes->Attributes, ObjectAttributes->ObjectName,
NULL, ObjectAttributes->Attributes,
DesiredAccess, NULL,
NULL, DesiredAccess,
UserMode, NULL,
NULL, UserMode,
&Object); NULL,
if (!NT_SUCCESS(Status)) & Object
{ );
return(Status); if (!NT_SUCCESS(Status))
} {
return Status;
}
Status = ObCreateHandle(PsGetCurrentProcess(), Status = ObCreateHandle(
Object, PsGetCurrentProcess(),
DesiredAccess, Object,
FALSE, DesiredAccess,
LinkHandle); FALSE,
if (!NT_SUCCESS(Status)) LinkHandle
{ );
return(Status); if (!NT_SUCCESS(Status))
} {
return Status;
}
return(STATUS_SUCCESS); return STATUS_SUCCESS;
} }
/**********************************************************************
* NAME EXPORTED
* NtQuerySymbolicLinkObject
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
STDCALL
NtQuerySymbolicLinkObject ( NtQuerySymbolicLinkObject (
IN HANDLE LinkHandle, IN HANDLE LinkHandle,
IN OUT PUNICODE_STRING LinkTarget, IN OUT PUNICODE_STRING LinkTarget,
OUT PULONG ReturnedLength OPTIONAL OUT PULONG ReturnedLength OPTIONAL
) )
{ {
PSYMLNK_OBJECT SymlinkObject; PSYMLNK_OBJECT SymlinkObject;
NTSTATUS Status; NTSTATUS Status;
Status = ObReferenceObjectByHandle(LinkHandle, Status = ObReferenceObjectByHandle(
SYMBOLIC_LINK_QUERY, LinkHandle,
IoSymbolicLinkType, SYMBOLIC_LINK_QUERY,
UserMode, IoSymbolicLinkType,
(PVOID*)&SymlinkObject, UserMode,
NULL); (PVOID *) & SymlinkObject,
if (Status != STATUS_SUCCESS) NULL
{ );
return(Status); if (Status != STATUS_SUCCESS)
} {
return Status;
}
RtlCopyUnicodeString(LinkTarget,SymlinkObject->Target.ObjectName); RtlCopyUnicodeString(
if (ReturnedLength!=NULL) LinkTarget,
{ SymlinkObject->Target.ObjectName
*ReturnedLength=SymlinkObject->Target.Length; );
} if (ReturnedLength != NULL)
ObDereferenceObject(SymlinkObject); {
return(STATUS_SUCCESS); *ReturnedLength = SymlinkObject->Target.Length;
} }
ObDereferenceObject(SymlinkObject);
NTSTATUS IoCreateUnprotectedSymbolicLink(PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName) return STATUS_SUCCESS;
{
return(IoCreateSymbolicLink(SymbolicLinkName,DeviceName));
}
NTSTATUS IoCreateSymbolicLink(PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName)
{
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE SymbolicLinkHandle;
PSYMLNK_OBJECT SymbolicLink;
assert_irql(PASSIVE_LEVEL);
DPRINT("IoCreateSymbolicLink(SymbolicLinkName %w, DeviceName %w)\n",
SymbolicLinkName->Buffer,DeviceName->Buffer);
InitializeObjectAttributes(&ObjectAttributes,SymbolicLinkName,0,NULL,NULL);
SymbolicLink = ObCreateObject(&SymbolicLinkHandle,
SYMBOLIC_LINK_ALL_ACCESS,
&ObjectAttributes,
IoSymbolicLinkType);
if (SymbolicLink == NULL)
{
return(STATUS_UNSUCCESSFUL);
}
ZwClose(SymbolicLinkHandle);
SymbolicLink->TargetName.Length = 0;
SymbolicLink->TargetName.MaximumLength =
((wcslen(DeviceName->Buffer) + 1) * sizeof(WCHAR));
SymbolicLink->TargetName.Buffer = ExAllocatePool(NonPagedPool,
SymbolicLink->TargetName.MaximumLength);
RtlCopyUnicodeString(&(SymbolicLink->TargetName), DeviceName);
DPRINT("DeviceName %w\n", SymbolicLink->TargetName.Buffer);
InitializeObjectAttributes(&(SymbolicLink->Target),
&(SymbolicLink->TargetName),0,NULL,NULL);
DPRINT("%s() = STATUS_SUCCESS\n",__FUNCTION__);
return(STATUS_SUCCESS);
} }
/**********************************************************************
* NAME EXPORTED
* IoCreateUnprotectedSymbolicLink
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
IoDeleteSymbolicLink(PUNICODE_STRING DeviceName) STDCALL
IoCreateUnprotectedSymbolicLink (
PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName
)
{
return IoCreateSymbolicLink(
SymbolicLinkName,
DeviceName
);
}
/**********************************************************************
* NAME EXPORTED
* IoCreateSymbolicLink
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS
STDCALL
IoCreateSymbolicLink (
PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName
)
{
OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE SymbolicLinkHandle;
PSYMLNK_OBJECT SymbolicLink;
assert_irql(PASSIVE_LEVEL);
DPRINT(
"IoCreateSymbolicLink(SymbolicLinkName %w, DeviceName %w)\n",
SymbolicLinkName->Buffer,
DeviceName->Buffer
);
InitializeObjectAttributes(
& ObjectAttributes,
SymbolicLinkName,
0,
NULL,
NULL
);
SymbolicLink = ObCreateObject(
& SymbolicLinkHandle,
SYMBOLIC_LINK_ALL_ACCESS,
& ObjectAttributes,
IoSymbolicLinkType
);
if (SymbolicLink == NULL)
{
return STATUS_UNSUCCESSFUL;
}
ZwClose(SymbolicLinkHandle);
SymbolicLink->TargetName.Length = 0;
SymbolicLink->TargetName.MaximumLength =
((wcslen(DeviceName->Buffer) + 1) * sizeof(WCHAR));
SymbolicLink->TargetName.Buffer =
ExAllocatePool(
NonPagedPool,
SymbolicLink->TargetName.MaximumLength
);
RtlCopyUnicodeString(
& (SymbolicLink->TargetName),
DeviceName
);
DPRINT("DeviceName %w\n", SymbolicLink->TargetName.Buffer);
InitializeObjectAttributes(
& (SymbolicLink->Target),
& (SymbolicLink->TargetName),
0,
NULL,
NULL
);
DPRINT("%s() = STATUS_SUCCESS\n",__FUNCTION__);
return STATUS_SUCCESS;
}
/**********************************************************************
* NAME EXPORTED
* IoDeleteSymbolicLink
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS
STDCALL
IoDeleteSymbolicLink (
PUNICODE_STRING DeviceName
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
/**********************************************************************
* NAME (EXPORTED as Zw)
* NtCreateSymbolicLinkObject
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
STDCALL STDCALL
NtCreateSymbolicLinkObject ( NtCreateSymbolicLinkObject (
@ -222,3 +426,5 @@ NtCreateSymbolicLinkObject (
UNIMPLEMENTED; UNIMPLEMENTED;
} }
/* EOF */

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

@ -1,4 +1,5 @@
/* /* $Id: main.c,v 1.22 1999/08/29 06:59:10 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/main.c * FILE: ntoskrnl/ke/main.c
@ -107,13 +108,13 @@ extern int edata;
extern int end; extern int end;
static char * INIData = static char * INIData =
"[HKEY_LOCAL_MACHINE\HARDWARE]\r\n" "[HKEY_LOCAL_MACHINE\\HARDWARE]\r\n"
"\r\n" "\r\n"
"[HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP]\r\n" "[HKEY_LOCAL_MACHINE\\HARDWARE\\DEVICEMAP]\r\n"
"\r\n" "\r\n"
"[HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\AtDisk]\r\n" "[HKEY_LOCAL_MACHINE\\HARDWARE\\DEVICEMAP\\AtDisk]\r\n"
"\r\n" "\r\n"
"[HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\AtDisk\Controller 0]\r\n" "[HKEY_LOCAL_MACHINE\\HARDWARE\\DEVICEMAP\\AtDisk\\Controller 0]\r\n"
"Controller Address=dword:000001f0\r\n" "Controller Address=dword:000001f0\r\n"
"Controller Interrupt=dword:0000000e\r\n" "Controller Interrupt=dword:0000000e\r\n"
"\r\n" "\r\n"
@ -148,7 +149,7 @@ asmlinkage void _main(boot_param* _bp)
*/ */
HalInitConsole(&bp); HalInitConsole(&bp);
DbgPrint("Starting ReactOS "KERNEL_VERSION"\n"); DbgPrint("Starting ReactOS "KERNEL_VERSION" (Build "__DATE__", "__TIME__")\n");
start = KERNEL_BASE + PAGE_ROUND_UP(bp.module_length[0]); start = KERNEL_BASE + PAGE_ROUND_UP(bp.module_length[0]);
if (start < ((int)&end)) if (start < ((int)&end))
@ -214,3 +215,5 @@ asmlinkage void _main(boot_param* _bp)
PsTerminateSystemThread(STATUS_SUCCESS); PsTerminateSystemThread(STATUS_SUCCESS);
} }
/* EOF */

370
reactos/ntoskrnl/mm/section.c
View file

@ -1,4 +1,5 @@
/* /* $Id: section.c,v 1.14 1999/08/29 06:59:10 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/section.c * FILE: ntoskrnl/mm/section.c
@ -179,39 +180,110 @@ NtCreateSection (
} }
/**********************************************************************
* NAME
* NtOpenSection
*
* DESCRIPTION
*
* ARGUMENTS
* SectionHandle
*
* DesiredAccess
*
* ObjectAttributes
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
STDCALL
NtOpenSection ( NtOpenSection (
PHANDLE SectionHandle, PHANDLE SectionHandle,
ACCESS_MASK DesiredAccess, ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes POBJECT_ATTRIBUTES ObjectAttributes
) )
{ {
PVOID Object; PVOID Object;
NTSTATUS Status; NTSTATUS Status;
*SectionHandle = 0; *SectionHandle = 0;
Status = ObReferenceObjectByName(ObjectAttributes->ObjectName, Status = ObReferenceObjectByName(
ObjectAttributes->Attributes, ObjectAttributes->ObjectName,
NULL, ObjectAttributes->Attributes,
DesiredAccess, NULL,
MmSectionType, DesiredAccess,
UserMode, MmSectionType,
NULL, UserMode,
&Object); NULL,
if (!NT_SUCCESS(Status)) & Object
{ );
return(Status); if (!NT_SUCCESS(Status))
} {
return Status;
}
Status = ObCreateHandle(PsGetCurrentProcess(), Status = ObCreateHandle(
Object, PsGetCurrentProcess(),
DesiredAccess, Object,
FALSE, DesiredAccess,
SectionHandle); FALSE,
return(Status); SectionHandle
);
return Status;
} }
/**********************************************************************
* NAME EXPORTED
* NtMapViewOfSection
*
* DESCRIPTION
* Maps a view of a section into the virtual address space of a
* process.
*
* ARGUMENTS
* SectionHandle
* Handle of the section.
*
* ProcessHandle
* Handle of the process.
*
* BaseAddress
* Desired base address (or NULL) on entry;
* Actual base address of the view on exit.
*
* ZeroBits
* Number of high order address bits that must be zero.
*
* CommitSize
* Size in bytes of the initially committed section of
* the view.
*
* SectionOffset
* Offset in bytes from the beginning of the section
* to the beginning of the view.
*
* ViewSize
* Desired length of map (or zero to map all) on entry
* Actual length mapped on exit.
*
* InheritDisposition
* Specified how the view is to be shared with
* child processes.
*
* AllocateType
* Type of allocation for the pages.
*
* Protect
* Protection for the committed region of the view.
*
* RETURN VALUE
* Status.
*/
NTSTATUS NTSTATUS
STDCALL STDCALL
NtMapViewOfSection ( NtMapViewOfSection (
@ -226,137 +298,158 @@ NtMapViewOfSection (
ULONG AllocationType, ULONG AllocationType,
ULONG Protect ULONG Protect
) )
/*
* FUNCTION: Maps a view of a section into the virtual address space of a
* process
* ARGUMENTS:
* SectionHandle = Handle of the section
* ProcessHandle = Handle of the process
* BaseAddress = Desired base address (or NULL) on entry
* Actual base address of the view on exit
* ZeroBits = Number of high order address bits that must be zero
* CommitSize = Size in bytes of the initially committed section of
* the view
* SectionOffset = Offset in bytes from the beginning of the section
* to the beginning of the view
* ViewSize = Desired length of map (or zero to map all) on entry
* Actual length mapped on exit
* InheritDisposition = Specified how the view is to be shared with
* child processes
* AllocateType = Type of allocation for the pages
* Protect = Protection for the committed region of the view
* RETURNS: Status
*/
{ {
PSECTION_OBJECT Section; PSECTION_OBJECT Section;
PEPROCESS Process; PEPROCESS Process;
MEMORY_AREA* Result; MEMORY_AREA * Result;
NTSTATUS Status; NTSTATUS Status;
DPRINT("NtMapViewOfSection(Section:%08lx, Process:%08lx,\n" DPRINT(
" Base:%08lx, ZeroBits:%08lx, CommitSize:%08lx,\n" "NtMapViewOfSection(Section:%08lx, Process:%08lx,\n"
" SectionOffs:%08lx, *ViewSize:%08lx, InheritDisp:%08lx,\n" " Base:%08lx, ZeroBits:%08lx, CommitSize:%08lx,\n"
" AllocType:%08lx, Protect:%08lx)\n", " SectionOffs:%08lx, *ViewSize:%08lx, InheritDisp:%08lx,\n"
SectionHandle, " AllocType:%08lx, Protect:%08lx)\n",
ProcessHandle, SectionHandle,
BaseAddress, ProcessHandle,
ZeroBits, BaseAddress,
CommitSize, ZeroBits,
SectionOffset, CommitSize,
*ViewSize, SectionOffset,
InheritDisposition, *ViewSize,
AllocationType, InheritDisposition,
Protect); AllocationType,
DPRINT(" *Base:%08lx\n", *BaseAddress); Protect
);
Status = ObReferenceObjectByHandle(SectionHandle, DPRINT(" *Base:%08lx\n", *BaseAddress);
SECTION_MAP_READ,
MmSectionType,
UserMode,
(PVOID*)&Section,
NULL);
if (Status != STATUS_SUCCESS)
{
DPRINT("ObReference failed rc=%x\n",Status);
return(Status);
}
DPRINT("Section %x\n",Section); Status = ObReferenceObjectByHandle(
SectionHandle,
SECTION_MAP_READ,
MmSectionType,
UserMode,
(PVOID *) & Section,
NULL
);
if (Status != STATUS_SUCCESS)
{
DPRINT("ObReference failed rc=%x\n",Status);
return Status;
}
Status = ObReferenceObjectByHandle(ProcessHandle, DPRINT("Section %x\n",Section);
PROCESS_VM_OPERATION,
PsProcessType, Status = ObReferenceObjectByHandle(
UserMode, ProcessHandle,
(PVOID*)&Process, PROCESS_VM_OPERATION,
NULL); PsProcessType,
if (Status != STATUS_SUCCESS) UserMode,
{ (PVOID *) & Process,
NULL
);
if (Status != STATUS_SUCCESS)
{
ObDereferenceObject(Section);
return Status;
}
DPRINT("ViewSize %x\n",ViewSize);
if ((*ViewSize) > Section->MaximumSize.u.LowPart)
{
(*ViewSize) = Section->MaximumSize.u.LowPart;
}
Status = MmCreateMemoryArea(
UserMode,
Process,
MEMORY_AREA_SECTION_VIEW_COMMIT,
BaseAddress,
* ViewSize,
Protect,
& Result
);
if (!NT_SUCCESS(Status))
{
DPRINT("NtMapViewOfSection() = %x\n",Status);
ObDereferenceObject(Process);
ObDereferenceObject(Section);
return Status;
}
Result->Data.SectionData.Section = Section;
DPRINT("SectionOffset %x\n",SectionOffset);
if (SectionOffset == NULL)
{
Result->Data.SectionData.ViewOffset = 0;
}
else
{
Result->Data.SectionData.ViewOffset =
SectionOffset->u.LowPart;
}
DPRINT("*BaseAddress %x\n",*BaseAddress);
ObDereferenceObject(Process);
ObDereferenceObject(Section); ObDereferenceObject(Section);
return(Status);
} return STATUS_SUCCESS;
DPRINT("ViewSize %x\n",ViewSize);
if ((*ViewSize) > Section->MaximumSize.u.LowPart)
{
(*ViewSize) = Section->MaximumSize.u.LowPart;
}
Status = MmCreateMemoryArea(UserMode,
Process,
MEMORY_AREA_SECTION_VIEW_COMMIT,
BaseAddress,
*ViewSize,
Protect,
&Result);
if (!NT_SUCCESS(Status))
{
DPRINT("NtMapViewOfSection() = %x\n",Status);
ObDereferenceObject(Process);
ObDereferenceObject(Section);
return(Status);
}
Result->Data.SectionData.Section = Section;
DPRINT("SectionOffset %x\n",SectionOffset);
if (SectionOffset == NULL)
{
Result->Data.SectionData.ViewOffset = 0;
}
else
{
Result->Data.SectionData.ViewOffset = SectionOffset->u.LowPart;
}
DPRINT("*BaseAddress %x\n",*BaseAddress);
ObDereferenceObject(Process);
ObDereferenceObject(Section);
return(STATUS_SUCCESS);
} }
/**********************************************************************
* NAME EXPORTED
* NtUnmapViewOfSection
*
* DESCRIPTION
*
* ARGUMENTS
* ProcessHandle
*
* BaseAddress
*
* RETURN VALUE
* Status.
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
STDCALL
NtUnmapViewOfSection ( NtUnmapViewOfSection (
HANDLE ProcessHandle, HANDLE ProcessHandle,
PVOID BaseAddress PVOID BaseAddress
) )
{ {
PEPROCESS Process; PEPROCESS Process;
NTSTATUS Status; NTSTATUS Status;
Status = ObReferenceObjectByHandle(ProcessHandle, Status = ObReferenceObjectByHandle(
PROCESS_VM_OPERATION, ProcessHandle,
PsProcessType, PROCESS_VM_OPERATION,
UserMode, PsProcessType,
(PVOID*)&Process, UserMode,
NULL); (PVOID *) & Process,
if (Status != STATUS_SUCCESS) NULL
{ );
return(Status); if (Status != STATUS_SUCCESS)
} {
Status = MmFreeMemoryArea(Process,BaseAddress,0,TRUE); return Status;
ObDereferenceObject(Process); }
return(Status); Status = MmFreeMemoryArea(
Process,
BaseAddress,
0,
TRUE
);
ObDereferenceObject(Process);
return Status;
} }
@ -395,3 +488,6 @@ NtExtendSection (
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
/* EOF */

4
reactos/ntoskrnl/ntoskrnl.def
View file

@ -1,4 +1,4 @@
; $Id: ntoskrnl.def,v 1.15 1999/08/17 12:01:38 ekohl Exp $ ; $Id: ntoskrnl.def,v 1.16 1999/08/29 06:59:05 ea Exp $
; ;
; reactos/ntoskrnl/ntoskrnl.def ; reactos/ntoskrnl/ntoskrnl.def
; ;
@ -104,7 +104,7 @@ IoConnectInterrupt
IoCreateController IoCreateController
IoCreateDevice IoCreateDevice
IoCreateStreamFileObject IoCreateStreamFileObject
IoCreateSymbolicLink IoCreateSymbolicLink@8
IoDeleteController IoDeleteController
IoDeleteDevice IoDeleteDevice
IoDisconnectInterrupt IoDisconnectInterrupt

14
reactos/ntoskrnl/ntoskrnl.edf
View file

@ -1,4 +1,4 @@
; $Id: ntoskrnl.edf,v 1.3 1999/08/17 12:01:39 ekohl Exp $ ; $Id: ntoskrnl.edf,v 1.4 1999/08/29 06:59:05 ea Exp $
; ;
; reactos/ntoskrnl/ntoskrnl.def ; reactos/ntoskrnl/ntoskrnl.def
; ;
@ -104,7 +104,7 @@ IoConnectInterrupt
IoCreateController IoCreateController
IoCreateDevice IoCreateDevice
IoCreateStreamFileObject IoCreateStreamFileObject
IoCreateSymbolicLink IoCreateSymbolicLink=IoCreateSymbolicLink@8
IoDeleteController IoDeleteController
IoDeleteDevice IoDeleteDevice
IoDisconnectInterrupt IoDisconnectInterrupt
@ -129,7 +129,7 @@ NtAllocateUuids=NtAllocateUuids@12
NtAllocateVirtualMemory=NtAllocateVirtualMemory@24 NtAllocateVirtualMemory=NtAllocateVirtualMemory@24
;NtBuildNumber <--- variable? ;NtBuildNumber <--- variable?
NtClose=NtClose@4 NtClose=NtClose@4
;NtConnectPort=;NtConnectPort@32 ;NtConnectPort@32
NtConnectPort=NtConnectPort@8 NtConnectPort=NtConnectPort@8
NtCreateEvent=NtCreateEvent@20 NtCreateEvent=NtCreateEvent@20
NtCreateFile=NtCreateFile@44 NtCreateFile=NtCreateFile@44
@ -155,13 +155,13 @@ NtQueryEaFile=NtQueryEaFile@36
NtQueryInformationFile=NtQueryInformationFile@20 NtQueryInformationFile=NtQueryInformationFile@20
NtQueryInformationProcess=NtQueryInformationProcess@20 NtQueryInformationProcess=NtQueryInformationProcess@20
NtQueryInformationToken=NtQueryInformationToken@20 NtQueryInformationToken=NtQueryInformationToken@20
;NtQueryOleDirectoryFile=;NtQueryOleDirectoryFile@ <--- ? ;NtQueryOleDirectoryFile@ <--- ?
NtQuerySecurityObject=NtQuerySecurityObject@20 NtQuerySecurityObject=NtQuerySecurityObject@20
NtQueryVolumeInformationFile=NtQueryVolumeInformationFile@20 NtQueryVolumeInformationFile=NtQueryVolumeInformationFile@20
NtReadFile=NtReadFile@36 NtReadFile=NtReadFile@36
;NtRequestPort=;NtRequestPort@8 ;NtRequestPort@8
NtRequestPort=NtRequestPort@20 NtRequestPort=NtRequestPort@20
;NtRequestWaitReplyPort=;NtRequestWaitReplyPort@8 ;NtRequestWaitReplyPort@8
NtRequestWaitReplyPort=NtRequestWaitReplyPort@0 NtRequestWaitReplyPort=NtRequestWaitReplyPort@0
NtSetEvent=NtSetEvent@8 NtSetEvent=NtSetEvent@8
NtSetInformationFile=NtSetInformationFile@20 NtSetInformationFile=NtSetInformationFile@20
@ -169,7 +169,7 @@ NtSetInformationProcess=NtSetInformationProcess@16
NtSetInformationThread=NtSetInformationThread@16 NtSetInformationThread=NtSetInformationThread@16
NtSetSecurityObject=NtSetSecurityObject@12 NtSetSecurityObject=NtSetSecurityObject@12
NtUnlockFile=NtUnlockFile@20 NtUnlockFile=NtUnlockFile@20
;NtVdmControl=;NtVdmControl@8 <--- ? ;NtVdmControl@8 <--- ?
NtWaitForSingleObject=NtWaitForSingleObject@12 NtWaitForSingleObject=NtWaitForSingleObject@12
NtWriteFile=NtWriteFile@36 NtWriteFile=NtWriteFile@36
RtlAnsiStringToUnicodeString RtlAnsiStringToUnicodeString

452
reactos/ntoskrnl/ob/dirobj.c
View file

@ -1,4 +1,5 @@
/* /* $Id: dirobj.c,v 1.5 1999/08/29 06:59:10 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/ob/dirobj.c * FILE: ntoskrnl/ob/dirobj.c
@ -22,50 +23,107 @@
/* FUNCTIONS **************************************************************/ /* FUNCTIONS **************************************************************/
/**********************************************************************
* NAME EXPORTED
* NtOpenDirectoryObject
*
* DESCRIPTION
* Opens a namespace directory object.
*
* ARGUMENTS
* DirectoryHandle (OUT)
* Variable which receives the directory handle.
*
* DesiredAccess
* Desired access to the directory.
*
* ObjectAttributes
* Structure describing the directory.
*
* RETURN VALUE
* Status.
*
* NOTES
* Undocumented.
*/
NTSTATUS NTSTATUS
STDCALL
NtOpenDirectoryObject ( NtOpenDirectoryObject (
PHANDLE DirectoryHandle, PHANDLE DirectoryHandle,
ACCESS_MASK DesiredAccess, ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes POBJECT_ATTRIBUTES ObjectAttributes
) )
/*
* FUNCTION: Opens a namespace directory object
* ARGUMENTS:
* DirectoryHandle (OUT) = Variable which receives the directory handle
* DesiredAccess = Desired access to the directory
* ObjectAttributes = Structure describing the directory
* RETURNS: Status
* NOTES: Undocumented
*/
{ {
PVOID Object; PVOID Object;
NTSTATUS Status; NTSTATUS Status;
*DirectoryHandle = 0; *DirectoryHandle = 0;
Status = ObReferenceObjectByName(ObjectAttributes->ObjectName, Status = ObReferenceObjectByName(
ObjectAttributes->Attributes, ObjectAttributes->ObjectName,
NULL, ObjectAttributes->Attributes,
DesiredAccess, NULL,
ObDirectoryType, DesiredAccess,
UserMode, ObDirectoryType,
NULL, UserMode,
&Object); NULL,
if (!NT_SUCCESS(Status)) & Object
{ );
return(Status); if (!NT_SUCCESS(Status))
} {
return Status;
}
Status = ObCreateHandle(PsGetCurrentProcess(), Status = ObCreateHandle(
Object, PsGetCurrentProcess(),
DesiredAccess, Object,
FALSE, DesiredAccess,
DirectoryHandle); FALSE,
return(STATUS_SUCCESS); DirectoryHandle
);
return STATUS_SUCCESS;
} }
/**********************************************************************
* NAME EXPORTED
* NtQueryDirectoryObject
*
* DESCRIPTION
* Reads information from a namespace directory.
*
* ARGUMENTS
* DirObjInformation (OUT)
* Buffer to hold the data read.
*
* BufferLength
* Size of the buffer in bytes.
*
* GetNextIndex
* If TRUE then set ObjectIndex to the index of the
* next object.
* If FALSE then set ObjectIndex to the number of
* objects in the directory.
*
* IgnoreInputIndex
* If TRUE start reading at index 0.
* If FALSE start reading at the index specified
* by object index.
*
* ObjectIndex
* Zero based index into the directory, interpretation
* depends on IgnoreInputIndex and GetNextIndex.
*
* DataWritten (OUT)
* Caller supplied storage for the number of bytes
* written (or NULL).
*
* RETURN VALUE
* Status.
*/
NTSTATUS NTSTATUS
STDCALL
NtQueryDirectoryObject ( NtQueryDirectoryObject (
IN HANDLE DirObjHandle, IN HANDLE DirObjHandle,
OUT POBJDIR_INFORMATION DirObjInformation, OUT POBJDIR_INFORMATION DirObjInformation,
@ -75,114 +133,149 @@ NtQueryDirectoryObject (
IN OUT PULONG ObjectIndex, IN OUT PULONG ObjectIndex,
OUT PULONG DataWritten OPTIONAL OUT PULONG DataWritten OPTIONAL
) )
/*
* FUNCTION: Reads information from a namespace directory
* ARGUMENTS:
* DirObjInformation (OUT) = Buffer to hold the data read
* BufferLength = Size of the buffer in bytes
* GetNextIndex = If TRUE then set ObjectIndex to the index of the
* next object
* If FALSE then set ObjectIndex to the number of
* objects in the directory
* IgnoreInputIndex = If TRUE start reading at index 0
* If FALSE start reading at the index specified
* by object index
* ObjectIndex = Zero based index into the directory, interpretation
* depends on IgnoreInputIndex and GetNextIndex
* DataWritten (OUT) = Caller supplied storage for the number of bytes
* written (or NULL)
* RETURNS: Status
*/
{ {
PDIRECTORY_OBJECT dir = NULL; PDIRECTORY_OBJECT dir = NULL;
ULONG EntriesToRead; ULONG EntriesToRead;
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
POBJECT_HEADER current; POBJECT_HEADER current;
ULONG i=0; ULONG i=0;
ULONG EntriesToSkip; ULONG EntriesToSkip;
NTSTATUS Status; NTSTATUS Status;
DPRINT(
"NtQueryDirectoryObject(DirObjHandle %x)\n",
DirObjHandle
);
DPRINT(
"dir %x namespc_root %x\n",
dir,
HEADER_TO_BODY(&(namespc_root.hdr))
);
DPRINT("NtQueryDirectoryObject(DirObjHandle %x)\n",DirObjHandle); // assert_irql(PASSIVE_LEVEL);
DPRINT("dir %x namespc_root %x\n",dir,HEADER_TO_BODY(&(namespc_root.hdr)));
// assert_irql(PASSIVE_LEVEL); Status = ObReferenceObjectByHandle(
DirObjHandle,
DIRECTORY_QUERY,
ObDirectoryType,
UserMode,
(PVOID *) & dir,
NULL
);
if (Status != STATUS_SUCCESS)
{
return Status;
}
EntriesToRead = BufferLength / sizeof (OBJDIR_INFORMATION);
*DataWritten = 0;
Status = ObReferenceObjectByHandle(DirObjHandle, DPRINT("EntriesToRead %d\n",EntriesToRead);
DIRECTORY_QUERY,
ObDirectoryType,
UserMode,
(PVOID*)&dir,
NULL);
if (Status != STATUS_SUCCESS)
{
return(Status);
}
EntriesToRead = BufferLength / sizeof(OBJDIR_INFORMATION); current_entry = dir->head.Flink;
*DataWritten = 0;
DPRINT("EntriesToRead %d\n",EntriesToRead); /*
* Optionally, skip over some entries at the start of the directory
current_entry = dir->head.Flink; */
if (!IgnoreInputIndex)
/* {
* Optionally, skip over some entries at the start of the directory CHECKPOINT;
*/
if (!IgnoreInputIndex)
{
CHECKPOINT;
EntriesToSkip = *ObjectIndex; EntriesToSkip = *ObjectIndex;
while ( i<EntriesToSkip && current_entry!=NULL) while ( (i < EntriesToSkip) && (current_entry != NULL))
{ {
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
} }
} }
DPRINT("DirObjInformation %x\n",DirObjInformation); DPRINT("DirObjInformation %x\n",DirObjInformation);
/* /*
* Read the maximum entries possible into the buffer * Read the maximum entries possible into the buffer
*/ */
while ( i<EntriesToRead && current_entry!=(&(dir->head))) while ( (i < EntriesToRead) && (current_entry != (&(dir->head))))
{ {
current = CONTAINING_RECORD(current_entry,OBJECT_HEADER,Entry); current = CONTAINING_RECORD(
DPRINT("Scanning %w\n",current->Name.Buffer); current_entry,
DirObjInformation[i].ObjectName.Buffer = OBJECT_HEADER,
ExAllocatePool(NonPagedPool,(current->Name.Length+1)*2); Entry
DirObjInformation[i].ObjectName.Length = current->Name.Length; );
DirObjInformation[i].ObjectName.MaximumLength = current->Name.Length; DPRINT(
DPRINT("DirObjInformation[i].ObjectName.Buffer %x\n", "Scanning %w\n",
DirObjInformation[i].ObjectName.Buffer); current->Name.Buffer
RtlCopyUnicodeString(&DirObjInformation[i].ObjectName, );
&(current->Name));
i++; DirObjInformation[i].ObjectName.Buffer =
current_entry = current_entry->Flink; ExAllocatePool(
(*DataWritten) = (*DataWritten) + sizeof(OBJDIR_INFORMATION); NonPagedPool,
(current->Name.Length + 1) * 2
);
DirObjInformation[i].ObjectName.Length =
current->Name.Length;
DirObjInformation[i].ObjectName.MaximumLength =
current->Name.Length;
DPRINT(
"DirObjInformation[i].ObjectName.Buffer %x\n",
DirObjInformation[i].ObjectName.Buffer
);
RtlCopyUnicodeString(
& DirObjInformation[i].ObjectName,
& (current->Name)
);
i++;
current_entry = current_entry->Flink;
(*DataWritten) = (*DataWritten) + sizeof (OBJDIR_INFORMATION);
CHECKPOINT;
}
CHECKPOINT; CHECKPOINT;
}
CHECKPOINT;
/* /*
* Optionally, count the number of entries in the directory * Optionally, count the number of entries in the directory
*/ */
if (GetNextIndex) if (GetNextIndex)
{ {
*ObjectIndex=i; *ObjectIndex = i;
} }
else else
{ {
while ( current_entry!=(&(dir->head)) ) while ( current_entry != (&(dir->head)) )
{ {
current_entry=current_entry->Flink; current_entry = current_entry->Flink;
i++; i++;
} }
*ObjectIndex=i; *ObjectIndex = i;
} }
return(STATUS_SUCCESS); return STATUS_SUCCESS;
} }
/**********************************************************************
* NAME (EXPORTED as Zw)
* NtCreateDirectoryObject
*
* DESCRIPTION
* Creates or opens a directory object (a container for other
* objects).
*
* ARGUMENTS
* DirectoryHandle (OUT)
* Caller supplied storage for the handle of the
* directory.
*
* DesiredAccess
* Access desired to the directory.
*
* ObjectAttributes
* Object attributes initialized with
* InitializeObjectAttributes.
*
* RETURN VALUE
* Status.
*/
NTSTATUS NTSTATUS
STDCALL STDCALL
NtCreateDirectoryObject ( NtCreateDirectoryObject (
@ -190,56 +283,77 @@ NtCreateDirectoryObject (
ACCESS_MASK DesiredAccess, ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes POBJECT_ATTRIBUTES ObjectAttributes
) )
/*
* FUNCTION: Creates or opens a directory object (a container for other
* objects)
* ARGUMENTS:
* DirectoryHandle (OUT) = Caller supplied storage for the handle
* of the directory
* DesiredAccess = Access desired to the directory
* ObjectAttributes = Object attributes initialized with
* InitializeObjectAttributes
* RETURNS: Status
*/
{ {
PDIRECTORY_OBJECT dir; PDIRECTORY_OBJECT dir;
dir = ObCreateObject(DirectoryHandle, dir = ObCreateObject(
DesiredAccess, DirectoryHandle,
ObjectAttributes, DesiredAccess,
ObDirectoryType); ObjectAttributes,
return(STATUS_SUCCESS); ObDirectoryType
);
return STATUS_SUCCESS;
} }
VOID InitializeObjectAttributes(POBJECT_ATTRIBUTES InitializedAttributes,
PUNICODE_STRING ObjectName, /**********************************************************************
ULONG Attributes, * NAME (MACRO in DDK)
HANDLE RootDirectory, * InitializeObjectAttributes
PSECURITY_DESCRIPTOR SecurityDescriptor) *
/* * DESCRIPTION
* FUNCTION: Sets up a parameter of type OBJECT_ATTRIBUTES for a * Sets up a parameter of type OBJECT_ATTRIBUTES for a
* subsequent call to ZwCreateXXX or ZwOpenXXX * subsequent call to ZwCreateXXX or ZwOpenXXX.
* ARGUMENTS: *
* InitializedAttributes (OUT) = Caller supplied storage for the * ARGUMENTS
* object attributes * InitializedAttributes (OUT)
* ObjectName = Full path name for object * Caller supplied storage for the object attributes.
* Attributes = Attributes for the object *
* RootDirectory = Where the object should be placed or NULL * ObjectName
* SecurityDescriptor = Ignored * Full path name for object.
*
* Attributes
* Attributes for the object.
*
* RootDirectory
* Where the object should be placed or NULL.
*
* SecurityDescriptor
* Ignored.
* *
* NOTE: * NOTE
* Either ObjectName is a fully qualified pathname or a path relative * Either ObjectName is a fully qualified pathname or a path
* to RootDirectory * relative to RootDirectory.
*/ */
VOID
InitializeObjectAttributes (
POBJECT_ATTRIBUTES InitializedAttributes,
PUNICODE_STRING ObjectName,
ULONG Attributes,
HANDLE RootDirectory,
PSECURITY_DESCRIPTOR SecurityDescriptor
)
{ {
DPRINT("InitializeObjectAttributes(InitializedAttributes %x " DPRINT(
"ObjectName %x Attributes %x RootDirectory %x)\n", "InitializeObjectAttributes(InitializedAttributes %x "
InitializedAttributes,ObjectName,Attributes,RootDirectory); "ObjectName %x Attributes %x RootDirectory %x)\n",
InitializedAttributes->Length=sizeof(OBJECT_ATTRIBUTES); InitializedAttributes,
InitializedAttributes->RootDirectory=RootDirectory; ObjectName,
InitializedAttributes->ObjectName=ObjectName; Attributes,
InitializedAttributes->Attributes=Attributes; RootDirectory
InitializedAttributes->SecurityDescriptor=SecurityDescriptor; );
InitializedAttributes->SecurityQualityOfService=NULL; InitializedAttributes->Length =
sizeof (OBJECT_ATTRIBUTES);
InitializedAttributes->RootDirectory =
RootDirectory;
InitializedAttributes->ObjectName =
ObjectName;
InitializedAttributes->Attributes =
Attributes;
InitializedAttributes->SecurityDescriptor =
SecurityDescriptor;
InitializedAttributes->SecurityQualityOfService =
NULL;
} }
/* EOF */

108
reactos/ntoskrnl/ob/handle.c
View file

@ -1,4 +1,5 @@
/* /* $Id: handle.c,v 1.11 1999/08/29 06:59:11 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/ob/handle.c * FILE: ntoskrnl/ob/handle.c
@ -35,7 +36,10 @@ typedef struct
/* FUNCTIONS ***************************************************************/ /* FUNCTIONS ***************************************************************/
static PHANDLE_REP ObpGetObjectByHandle(PEPROCESS Process,
static
PHANDLE_REP
ObpGetObjectByHandle(PEPROCESS Process,
HANDLE h) HANDLE h)
/* /*
* FUNCTION: Get the data structure for a handle * FUNCTION: Get the data structure for a handle
@ -70,6 +74,7 @@ static PHANDLE_REP ObpGetObjectByHandle(PEPROCESS Process,
return(&(blk->handles[handle%HANDLE_BLOCK_ENTRIES])); return(&(blk->handles[handle%HANDLE_BLOCK_ENTRIES]));
} }
NTSTATUS NTSTATUS
STDCALL STDCALL
NtDuplicateObject ( NtDuplicateObject (
@ -150,7 +155,9 @@ NtDuplicateObject (
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
VOID ObDeleteHandleTable(PEPROCESS Process)
VOID
ObDeleteHandleTable(PEPROCESS Process)
/* /*
* FUNCTION: Deletes the handle table associated with a process * FUNCTION: Deletes the handle table associated with a process
*/ */
@ -185,7 +192,9 @@ VOID ObDeleteHandleTable(PEPROCESS Process)
} }
} }
VOID ObCreateHandleTable(PEPROCESS Parent,
VOID
ObCreateHandleTable(PEPROCESS Parent,
BOOLEAN Inherit, BOOLEAN Inherit,
PEPROCESS Process) PEPROCESS Process)
/* /*
@ -207,7 +216,9 @@ VOID ObCreateHandleTable(PEPROCESS Parent,
} }
} }
VOID ObDeleteHandle(HANDLE Handle)
VOID
ObDeleteHandle(HANDLE Handle)
{ {
PHANDLE_REP Rep; PHANDLE_REP Rep;
@ -218,7 +229,9 @@ VOID ObDeleteHandle(HANDLE Handle)
DPRINT("Finished ObDeleteHandle()\n"); DPRINT("Finished ObDeleteHandle()\n");
} }
NTSTATUS ObCreateHandle(PEPROCESS Process,
NTSTATUS
ObCreateHandle(PEPROCESS Process,
PVOID ObjectBody, PVOID ObjectBody,
ACCESS_MASK GrantedAccess, ACCESS_MASK GrantedAccess,
BOOLEAN Inherit, BOOLEAN Inherit,
@ -289,7 +302,8 @@ NTSTATUS ObCreateHandle(PEPROCESS Process,
} }
NTSTATUS ObReferenceObjectByHandle(HANDLE Handle, NTSTATUS
ObReferenceObjectByHandle(HANDLE Handle,
ACCESS_MASK DesiredAccess, ACCESS_MASK DesiredAccess,
POBJECT_TYPE ObjectType, POBJECT_TYPE ObjectType,
KPROCESSOR_MODE AccessMode, KPROCESSOR_MODE AccessMode,
@ -378,46 +392,66 @@ NTSTATUS ObReferenceObjectByHandle(HANDLE Handle,
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
NTSTATUS NtClose(HANDLE Handle)
/* /**********************************************************************
* FUNCTION: Closes a handle reference to an object * NAME EXPORTED
* ARGUMENTS: * NtClose
* Handle = handle to close *
* RETURNS: Status * DESCRIPTION
* Closes a handle reference to an object.
*
* ARGUMENTS
* Handle
* Handle to close.
*
* RETURN VALUE
* Status.
*/ */
NTSTATUS
STDCALL
NtClose(HANDLE Handle)
{ {
PVOID ObjectBody; PVOID ObjectBody;
POBJECT_HEADER Header; POBJECT_HEADER Header;
PHANDLE_REP HandleRep; PHANDLE_REP HandleRep;
assert_irql(PASSIVE_LEVEL); assert_irql(PASSIVE_LEVEL);
DPRINT("NtClose(Handle %x)\n",Handle); DPRINT("NtClose(Handle %x)\n",Handle);
HandleRep = ObpGetObjectByHandle(PsGetCurrentProcess(), HandleRep = ObpGetObjectByHandle(
Handle); PsGetCurrentProcess(),
if (HandleRep == NULL) Handle
{ );
return(STATUS_INVALID_HANDLE); if (HandleRep == NULL)
} {
ObjectBody = HandleRep->ObjectBody; return STATUS_INVALID_HANDLE;
}
ObjectBody = HandleRep->ObjectBody;
HandleRep->ObjectBody = NULL; HandleRep->ObjectBody = NULL;
Header = BODY_TO_HEADER(ObjectBody); Header = BODY_TO_HEADER(ObjectBody);
Header->RefCount++; Header->RefCount++;
Header->HandleCount--; Header->HandleCount--;
if (Header->ObjectType != NULL && if ( (Header->ObjectType != NULL)
Header->ObjectType->Close != NULL) && (Header->ObjectType->Close != NULL)
{ )
Header->ObjectType->Close(ObjectBody, Header->HandleCount); {
} Header->ObjectType->Close(
ObjectBody,
Header->HandleCount
);
}
Header->RefCount--; Header->RefCount--;
ObPerformRetentionChecks(Header); ObPerformRetentionChecks(Header);
return(STATUS_SUCCESS); return STATUS_SUCCESS;
} }
/* EOF */

66
reactos/ntoskrnl/ob/ntobj.c
View file

@ -1,4 +1,5 @@
/* /* $Id: ntobj.c,v 1.5 1999/08/29 06:59:11 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/ob/ntobj.c * FILE: ntoskrnl/ob/ntobj.c
@ -47,39 +48,60 @@ NtQueryObject (
} }
VOID ObMakeTemporaryObject(PVOID ObjectBody) VOID
ObMakeTemporaryObject (
PVOID ObjectBody
)
{ {
POBJECT_HEADER ObjectHeader; POBJECT_HEADER ObjectHeader;
ObjectHeader = BODY_TO_HEADER(ObjectBody); ObjectHeader = BODY_TO_HEADER(ObjectBody);
ObjectHeader->Permanent = FALSE; ObjectHeader->Permanent = FALSE;
} }
/**********************************************************************
* NAME EXPORTED
* NtMakeTemporaryObject
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*/
NTSTATUS NTSTATUS
STDCALL
NtMakeTemporaryObject ( NtMakeTemporaryObject (
HANDLE Handle HANDLE Handle
) )
{ {
PVOID Object; PVOID Object;
NTSTATUS Status; NTSTATUS Status;
POBJECT_HEADER ObjectHeader; POBJECT_HEADER ObjectHeader;
Status = ObReferenceObjectByHandle(Handle, Status = ObReferenceObjectByHandle(
0, Handle,
NULL, 0,
KernelMode, NULL,
&Object, KernelMode,
NULL); & Object,
if (Status != STATUS_SUCCESS) NULL
{ );
return(Status); if (Status != STATUS_SUCCESS)
} {
return Status;
}
ObjectHeader = BODY_TO_HEADER(Object); ObjectHeader = BODY_TO_HEADER(Object);
ObjectHeader->Permanent = FALSE; ObjectHeader->Permanent = FALSE;
ObDereferenceObject(Object); ObDereferenceObject(Object);
return(STATUS_SUCCESS); return STATUS_SUCCESS;
} }
/* EOF */

219
reactos/ntoskrnl/ps/thread.c
View file

@ -1,4 +1,5 @@
/* /* $Id: thread.c,v 1.25 1999/08/29 06:59:11 ea Exp $
*
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel * PROJECT: ReactOS kernel
* FILE: ntoskrnl/ps/thread.c * FILE: ntoskrnl/ps/thread.c
@ -117,100 +118,129 @@ VOID PsBeginThread(PKSTART_ROUTINE StartRoutine, PVOID StartContext)
KeBugCheck(0); KeBugCheck(0);
} }
static PETHREAD PsScanThreadList(KPRIORITY Priority) static
PETHREAD
PsScanThreadList (
KPRIORITY Priority
)
{ {
PLIST_ENTRY current_entry; PLIST_ENTRY current_entry;
PETHREAD current; PETHREAD current;
PETHREAD oldest = NULL; PETHREAD oldest = NULL;
ULONG oldest_time = 0; ULONG oldest_time = 0;
// DPRINT("PsScanThreadList(Priority %d)\n",Priority); // DPRINT("PsScanThreadList(Priority %d)\n",Priority);
current_entry = PriorityListHead[THREAD_PRIORITY_MAX+Priority].Flink; current_entry =
while (current_entry != &PriorityListHead[THREAD_PRIORITY_MAX+Priority]) PriorityListHead[THREAD_PRIORITY_MAX + Priority].Flink;
{
current = CONTAINING_RECORD(current_entry,ETHREAD,Tcb.Entry);
if (current->Tcb.State == THREAD_STATE_TERMINATED && while (current_entry != &PriorityListHead[THREAD_PRIORITY_MAX+Priority])
current != CurrentThread) {
{ current = CONTAINING_RECORD(
PsReleaseThread(current); current_entry,
} ETHREAD,
Tcb.Entry
);
if (current->Tcb.State == THREAD_STATE_RUNNABLE) if ( (current->Tcb.State == THREAD_STATE_TERMINATED)
{ && (current != CurrentThread)
if (oldest == NULL || oldest_time > current->Tcb.LastTick) )
{ {
oldest = current; PsReleaseThread(current);
oldest_time = current->Tcb.LastTick; }
}
} if (current->Tcb.State == THREAD_STATE_RUNNABLE)
current_entry = current_entry->Flink; {
} if ( (oldest == NULL)
// DPRINT("PsScanThreadList() = %x\n",oldest); || (oldest_time > current->Tcb.LastTick)
return(oldest); )
{
oldest = current;
oldest_time = current->Tcb.LastTick;
}
}
current_entry = current_entry->Flink;
}
// DPRINT("PsScanThreadList() = %x\n",oldest);
return oldest;
} }
VOID PsDispatchThread(VOID)
VOID
PsDispatchThread (VOID)
{ {
KPRIORITY CurrentPriority; KPRIORITY CurrentPriority;
PETHREAD Candidate; PETHREAD Candidate;
KIRQL irql; KIRQL irql;
LARGE_INTEGER TickCount; LARGE_INTEGER TickCount;
if (!DoneInitYet)
{
return;
}
if (!DoneInitYet) KeAcquireSpinLock(
{ & ThreadListLock,
return; & irql
} );
KeAcquireSpinLock(&ThreadListLock, &irql); DPRINT("PsDispatchThread() Current %x\n",CurrentThread);
DPRINT("PsDispatchThread() Current %x\n",CurrentThread);
if (CurrentThread->Tcb.State==THREAD_STATE_RUNNING) if (CurrentThread->Tcb.State == THREAD_STATE_RUNNING)
{ {
CurrentThread->Tcb.State=THREAD_STATE_RUNNABLE; CurrentThread->Tcb.State = THREAD_STATE_RUNNABLE;
} }
for (CurrentPriority=THREAD_PRIORITY_TIME_CRITICAL; for ( CurrentPriority = THREAD_PRIORITY_TIME_CRITICAL;
CurrentPriority>=THREAD_PRIORITY_IDLE; (CurrentPriority >= THREAD_PRIORITY_IDLE);
CurrentPriority--) CurrentPriority--
{ )
Candidate = PsScanThreadList(CurrentPriority); {
if (Candidate == CurrentThread) Candidate = PsScanThreadList(CurrentPriority);
{ if (Candidate == CurrentThread)
DPRINT("Scheduling current thread\n"); {
KeQueryTickCount(&TickCount); DPRINT("Scheduling current thread\n");
CurrentThread->Tcb.LastTick = TickCount.u.LowPart; KeQueryTickCount(&TickCount);
CurrentThread->Tcb.State = THREAD_STATE_RUNNING; CurrentThread->Tcb.LastTick = TickCount.u.LowPart;
KeReleaseSpinLock(&ThreadListLock,irql); CurrentThread->Tcb.State = THREAD_STATE_RUNNING;
return; KeReleaseSpinLock(
} & ThreadListLock,
if (Candidate != NULL) irql
{ );
DPRINT("Scheduling %x\n",Candidate); return;
}
if (Candidate != NULL)
{
DPRINT("Scheduling %x\n",Candidate);
Candidate->Tcb.State = THREAD_STATE_RUNNING;
Candidate->Tcb.State = THREAD_STATE_RUNNING; KeQueryTickCount(&TickCount);
CurrentThread->Tcb.LastTick = TickCount.u.LowPart;
KeQueryTickCount(&TickCount); CurrentThread = Candidate;
CurrentThread->Tcb.LastTick = TickCount.u.LowPart;
CurrentThread = Candidate; HalTaskSwitch(&CurrentThread->Tcb);
KeReleaseSpinLock(
HalTaskSwitch(&CurrentThread->Tcb); & ThreadListLock,
KeReleaseSpinLock(&ThreadListLock, irql); irql
return; );
} return;
} }
DbgPrint("CRITICAL: No threads are runnable\n"); }
KeBugCheck(0); DbgPrint("CRITICAL: No threads are runnable\n");
KeBugCheck(0);
} }
NTSTATUS PsInitializeThread(HANDLE ProcessHandle,
PETHREAD* ThreadPtr, NTSTATUS
PHANDLE ThreadHandle, PsInitializeThread (
ACCESS_MASK DesiredAccess, HANDLE ProcessHandle,
POBJECT_ATTRIBUTES ThreadAttributes) PETHREAD * ThreadPtr,
PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ThreadAttributes
)
{ {
PETHREAD Thread; PETHREAD Thread;
NTSTATUS Status; NTSTATUS Status;
@ -273,7 +303,9 @@ NTSTATUS PsInitializeThread(HANDLE ProcessHandle,
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
VOID PsResumeThread(PETHREAD Thread)
VOID
PsResumeThread(PETHREAD Thread)
{ {
DPRINT("PsResumeThread(Thread %x)\n",Thread); DPRINT("PsResumeThread(Thread %x)\n",Thread);
Thread->Tcb.SuspendCount--; Thread->Tcb.SuspendCount--;
@ -286,7 +318,9 @@ VOID PsResumeThread(PETHREAD Thread)
DPRINT("Finished PsResumeThread()\n"); DPRINT("Finished PsResumeThread()\n");
} }
VOID PsSuspendThread(PETHREAD Thread)
VOID
PsSuspendThread(PETHREAD Thread)
{ {
DPRINT("PsSuspendThread(Thread %x)\n",Thread); DPRINT("PsSuspendThread(Thread %x)\n",Thread);
Thread->Tcb.SuspendCount++; Thread->Tcb.SuspendCount++;
@ -300,12 +334,16 @@ VOID PsSuspendThread(PETHREAD Thread)
} }
} }
VOID PiDeleteThread(PVOID ObjectBody)
VOID
PiDeleteThread(PVOID ObjectBody)
{ {
DbgPrint("PiDeleteThread(ObjectBody %x)\n",ObjectBody); DbgPrint("PiDeleteThread(ObjectBody %x)\n",ObjectBody);
} }
VOID PsInitThreadManagment(VOID)
VOID
PsInitThreadManagment(VOID)
/* /*
* FUNCTION: Initialize thread managment * FUNCTION: Initialize thread managment
*/ */
@ -354,7 +392,9 @@ VOID PsInitThreadManagment(VOID)
DoneInitYet = TRUE; DoneInitYet = TRUE;
} }
NTSTATUS NTSTATUS
STDCALL
NtCreateThread ( NtCreateThread (
PHANDLE ThreadHandle, PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess, ACCESS_MASK DesiredAccess,
@ -400,7 +440,9 @@ NtCreateThread (
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
NTSTATUS PsCreateSystemThread(PHANDLE ThreadHandle,
NTSTATUS
PsCreateSystemThread(PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess, ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ObjectAttributes, POBJECT_ATTRIBUTES ObjectAttributes,
HANDLE ProcessHandle, HANDLE ProcessHandle,
@ -454,12 +496,16 @@ NTSTATUS PsCreateSystemThread(PHANDLE ThreadHandle,
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
LONG KeSetBasePriorityThread(PKTHREAD Thread, LONG Increment)
LONG
KeSetBasePriorityThread(PKTHREAD Thread, LONG Increment)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
KPRIORITY KeSetPriorityThread(PKTHREAD Thread, KPRIORITY Priority)
KPRIORITY
KeSetPriorityThread(PKTHREAD Thread, KPRIORITY Priority)
{ {
KPRIORITY OldPriority; KPRIORITY OldPriority;
OldPriority = Thread->BasePriority; OldPriority = Thread->BasePriority;
@ -638,3 +684,6 @@ NtYieldExecution(VOID)
PsDispatchThread(); PsDispatchThread();
return(STATUS_SUCCESS); return(STATUS_SUCCESS);
} }
/* EOF */

258
reactos/ntoskrnl/rtl/interlck.c
View file

@ -1,58 +1,210 @@
/* $Id: interlck.c,v 1.3 1999/08/29 06:59:11 ea Exp $
*
* reactos/ntoskrnl/rtl/interlck.c
*
* FIXME: change decorated names when __fastcall will be available
* (for both egcs 1.1.2 and gcc 2.95 FASTCALL == STDCALL).
*/
#include <reactos/config.h>
#include <ntos.h>
#include <internal/debug.h>
void InterlockedIncrement(void);
__asm__("\n\t.global _InterlockedIncrement\n\t" /**********************************************************************
"_InterlockedIncrement:\n\t" * FASTCALL: @InterlockedIncrement@0
"pushl %ebp\n\t" * STDCALL : _InterlockedIncrement@4
"movl %esp,%ebp\n\t" */
"pushl %ebx\n\t" LONG
"movl $1,%eax\n\t" FASTCALL
"movl 8(%ebp),%ebx\n\t" InterlockedIncrement (
"xaddl %eax,(%ebx)\n\t" PLONG Addend
"popl %ebx\n\t" );
"movl %ebp,%esp\n\t" __asm__(
"popl %ebp\n\t" "\n\t.global _InterlockedIncrement@4\n\t"
"ret\n\t"); "_InterlockedIncrement@4:\n\t"
"pushl %ebp\n\t"
"movl %esp,%ebp\n\t"
"pushl %ebx\n\t"
"movl $1,%eax\n\t"
"movl 8(%ebp),%ebx\n\t"
"xaddl %eax,(%ebx)\n\t"
"popl %ebx\n\t"
"movl %ebp,%esp\n\t"
"popl %ebp\n\t"
"ret $4\n\t"
);
/*
__asm__(
#ifndef CONFIG_USE_FASTCALL
".global _InterlockedIncrement@4\n"
"\t_InterlockedIncrement@4:\n"
"\tmovl 4(%esp), %ecx\n"
#else
".global @InterlockedIncrement@0\n"
"\t@InterlockedIncrement@0:\n"
#endif
"\tmov $1, %eax\n"
"\txadd %ecx, %eax\n"
"\tinc %eax\n\n"
#ifndef CONFIG_USE_FASTCALL
"\tret $4\n"
#endif
);
*/
void InterlockedDecrement(void); /**********************************************************************
__asm__("\n\t.global _InterlockedDecrement\n\t" * FASTCALL: @InterlockedDecrement@0
"_InterlockedDecrement:\n\t" * STDCALL : _InterlockedDecrement@4
"movl $0xffffffff,%eax\n\t" */
"movl 4(%esp),%ebx\n\t" LONG
"xaddl %eax,(%ebx)\n\t" FASTCALL
"decl %eax\n\t" InterlockedDecrement (
"ret\n\t"); PLONG Addend
);
void InterlockedExchange(void); __asm__(
__asm__("\n\t.global _InterlockedExchange\n\t" "\n\t.global _InterlockedDecrement@4\n\t"
"_InterlockedExchange:\n\t" "_InterlockedDecrement@4:\n\t"
"pushl %ebp\n\t" "movl $0xffffffff,%eax\n\t"
"movl %esp,%ebp\n\t" "movl 4(%esp),%ebx\n\t"
"pushl %eax\n\t" "xaddl %eax,(%ebx)\n\t"
"pushl %ebx\n\t" "decl %eax\n\t"
"movl 12(%ebp),%eax\n\t" "ret $4\n\t"
"movl 8(%ebp),%ebx\n\t" );
"xchgl %eax,(%ebx)\n\t"
"popl %ebx\n\t" /**********************************************************************
"popl %eax\n\t" * FASTCALL: @InterlockedExchange@0
"movl %ebp,%esp\n\t" * STDCALL : _InterlockedExchange@8
"popl %ebp\n\t" */
"ret\n\t"); LONG
FASTCALL
InterlockedExchange (
PLONG Target,
LONG Value
);
__asm__(
"\n\t.global _InterlockedExchange@8\n\t"
"_InterlockedExchange@8:\n\t"
"pushl %ebp\n\t"
"movl %esp,%ebp\n\t"
"pushl %eax\n\t"
"pushl %ebx\n\t"
"movl 12(%ebp),%eax\n\t"
"movl 8(%ebp),%ebx\n\t"
"xchgl %eax,(%ebx)\n\t"
"popl %ebx\n\t"
"popl %eax\n\t"
"movl %ebp,%esp\n\t"
"popl %ebp\n\t"
"ret $8\n\t"
);
/*
__asm__(
#ifndef CONFIG_USE_FASTCALL
".global _InterlockedExchange@8\n"
"_InterlockedExchange@8:\n"
"\tmovl 4(%esp), %ecx\n"
"\tmovl 8(%esp), %edx\n"
#else
".global @InterlockedExchange@0\n"
"@InterlockedExchange@0:\n"
#endif
"\tmovl %ecx, %eax\n"
"__InterlockedExchange_Loop:\n"
"\tlock\n"
"\tcmpxchg %ecx, %edx\n"
"\tjne __InterlockedExchange_Loop\n"
#ifndef CONFIG_USE_FASTCALL
"\tmovl %ecx, 4(%esp)\n"
"\tret $8\n"
#else
"\tret\n"
#endif
);
*/
void InterlockedExchangeAdd(void);
__asm__("\n\t.global _InterlockedExchangeAdd\n\t"
"_InterlockedExchangeAdd:\n\t"
"movl 8(%esp),%eax\n\t"
"movl 4(%esp),%ebx\n\t"
"xaddl %eax,(%ebx)\n\t"
"ret\n\t");
void InterlockedCompareExchange(void); /**********************************************************************
__asm__("\n\t.global _InterlockedCompareExchange\n\t" * FASTCALL: @InterlockedExchangeAdd@0
"_InterlockedCompareExchange:\n\t" * STDCALL : _InterlockedExchangeAdd@8
"movl 12(%esp),%eax\n\t" */
"movl 8(%esp),%edx\n\t" LONG
"movl 4(%esp),%ebx\n\t" FASTCALL
"cmpxchg %edx,(%ebx)\n\t" InterlockedExchangeAdd (
"movl %edx,%eax\n\t" PLONG Addend,
"ret\n\t"); LONG Value
);
__asm__(
"\n\t.global _InterlockedExchangeAdd@8\n\t"
"_InterlockedExchangeAdd@8:\n\t"
"movl 8(%esp),%eax\n\t"
"movl 4(%esp),%ebx\n\t"
"xaddl %eax,(%ebx)\n\t"
"ret $8\n\t"
);
/*
__asm__(
#ifndef CONFIG_USE_FASTCALL
".global _InterlockedExchangeAdd@8\n"
"\t_InterlockedExchangeAdd@8:\n"
"\tmovl 4(%esp), %ecx\n"
"\tmovl 8(%esp), %edx\n"
#else
".global @InterlockedExchangeAdd@0\n"
"\t@InterlockedExchangeAdd@0:\n"
#endif
"\txadd %edx, %ecx\n"
"\tmovl %edx, %eax\n"
#ifndef CONFIG_USE_FASTCALL
"\tret $8\n"
#else
"\tret\n"
#endif
);
*/
/**********************************************************************
* FASTCALL: @InterlockedCompareExchange@4
* STDCALL : _InterlockedCompareExchange@12
*/
PVOID
FASTCALL
InterlockedCompareExchange (
PVOID * Destination,
PVOID Exchange,
PVOID Comperand
);
__asm__(
"\n\t.global _InterlockedCompareExchange@12\n\t"
"_InterlockedCompareExchange@12:\n\t"
"movl 12(%esp),%eax\n\t"
"movl 8(%esp),%edx\n\t"
"movl 4(%esp),%ebx\n\t"
"cmpxchg %edx,(%ebx)\n\t"
"movl %edx,%eax\n\t"
"ret $12\n\t"
);
/*
__asm__(
#ifndef CONFIG_USE_FASTCALL
".global _InterlockedCompareExchange@12\n"
"\t_InterlockedCompareExchange@12:\n"
"\tmovl 4(%esp), %ecx\n"
"\tmovl 8(%esp), %edx\n"
"\tmovl 12(%esp), %eax\n"
#else
".global @InterlockedCompareExchange@4\n"
"\t@InterlockedCompareExchange@4:\n"
"\tmovl 4(%esp), %eax\n"
#endif
"\tcmpxchg %ecx, %edx\n"
#ifndef CONFIG_USE_FASTCALL
"\tret $12\n"
#else
"\tret $4\n"
#endif
*/
/* EOF */