Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-04 19:54:58 +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

495
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, );
PVOID
ExFreeToZone (
PZONE_HEADER Zone,
PVOID Block
);
ERESOURCE_THREAD
ExGetCurrentResourceThread (
VOID
);
ULONG
ExGetExclusiveWaiterCount (
PERESOURCE Resource
);
ULONG
ExGetSharedWaiterCount (
PERESOURCE Resource
);
VOID
ExInitializeFastMutex (
PFAST_MUTEX FastMutex
);
VOID
ExInitializeNPagedLookasideList (
PNPAGED_LOOKASIDE_LIST Lookaside,
PALLOCATE_FUNCTION Allocate, PALLOCATE_FUNCTION Allocate,
PFREE_FUNCTION Free, PFREE_FUNCTION Free,
ULONG Flags, ULONG Flags,
ULONG Size, ULONG Size,
ULONG Tag, ULONG Tag,
USHORT Depth); USHORT Depth
VOID ExInitializePagedLookasideList(PPAGED_LOOKASIDE_LIST Lookaside, );
VOID
ExInitializePagedLookasideList (
PPAGED_LOOKASIDE_LIST Lookaside,
PALLOCATE_FUNCTION Allocate, PALLOCATE_FUNCTION Allocate,
PFREE_FUNCTION Free, PFREE_FUNCTION Free,
ULONG Flags, ULONG Flags,
ULONG Size, ULONG Size,
ULONG Tag, ULONG Tag,
USHORT Depth); USHORT Depth
NTSTATUS ExInitializeResource(PERESOURCE Resource); );
NTSTATUS ExInitializeResourceLite(PERESOURCE Resource); NTSTATUS
VOID ExInitializeSListHead(PSLIST_HEADER SListHead); ExInitializeResource (
VOID ExInitializeWorkItem(PWORK_QUEUE_ITEM Item, PERESOURCE Resource
);
NTSTATUS
ExInitializeResourceLite (
PERESOURCE Resource
);
VOID
ExInitializeSListHead (
PSLIST_HEADER SListHead
);
VOID
ExInitializeWorkItem (
PWORK_QUEUE_ITEM Item,
PWORKER_THREAD_ROUTINE Routine, PWORKER_THREAD_ROUTINE Routine,
PVOID Context); PVOID Context
NTSTATUS ExInitializeZone(PZONE_HEADER Zone, );
NTSTATUS
ExInitializeZone (
PZONE_HEADER Zone,
ULONG BlockSize, ULONG BlockSize,
PVOID InitialSegment, PVOID InitialSegment,
ULONG InitialSegmentSize); ULONG InitialSegmentSize
LARGE_INTEGER ExInterlockedAddLargeInteger(PLARGE_INTEGER Addend, );
LARGE_INTEGER
ExInterlockedAddLargeInteger (
PLARGE_INTEGER Addend,
LARGE_INTEGER Increment, LARGE_INTEGER Increment,
PKSPIN_LOCK Lock); PKSPIN_LOCK Lock
ULONG ExInterlockedAddUlong(PULONG Addend, ULONG 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, );
VOID
RemoveEntryFromList (
PLIST_ENTRY ListHead,
PLIST_ENTRY Entry
);
PLIST_ENTRY
ExInterlockedRemoveHeadList (
PLIST_ENTRY Head,
PKSPIN_LOCK Lock
);
PLIST_ENTRY
ExInterlockedInsertTailList (
PLIST_ENTRY ListHead,
PLIST_ENTRY ListEntry, PLIST_ENTRY ListEntry,
PKSPIN_LOCK Lock); PKSPIN_LOCK Lock
);
PLIST_ENTRY ExInterlockedInsertHeadList(PLIST_ENTRY ListHead, PLIST_ENTRY
ExInterlockedInsertHeadList (
PLIST_ENTRY ListHead,
PLIST_ENTRY ListEntry, PLIST_ENTRY ListEntry,
PKSPIN_LOCK Lock); PKSPIN_LOCK Lock
);
VOID ExQueueWorkItem(PWORK_QUEUE_ITEM WorkItem, VOID
WORK_QUEUE_TYPE QueueType); ExQueueWorkItem (
VOID ExRaiseStatus(NTSTATUS Status); PWORK_QUEUE_ITEM WorkItem,
VOID ExReinitializeResourceLite(PERESOURCE Resource); WORK_QUEUE_TYPE QueueType
VOID ExReleaseFastMutex(PFAST_MUTEX Mutex); );
VOID ExReleaseFastMutexUnsafe(PFAST_MUTEX Mutex); VOID
VOID ExReleaseResource(PERESOURCE Resource); ExRaiseStatus (
VOID ExReleaseResourceForThread(PERESOURCE Resource, NTSTATUS Status
ERESOURCE_THREAD ResourceThreadId); );
VOID ExReleaseResourceForThreadLite(PERESOURCE Resource, VOID
ERESOURCE_THREAD ResourceThreadId); ExReinitializeResourceLite (
VOID ExSystemTimeToLocalTime(PLARGE_INTEGER SystemTime, PERESOURCE Resource
PLARGE_INTEGER LocalTime); );
BOOLEAN ExTryToAcquireFastMutex(PFAST_MUTEX FastMutex); VOID
BOOLEAN ExTryToAcquireResourceExclusiveLite(PERESOURCE Resource); ExReleaseFastMutex (
PVOID InterlockedCompareExchange(PVOID* Destination, PFAST_MUTEX Mutex
);
VOID
ExReleaseFastMutexUnsafe (
PFAST_MUTEX Mutex
);
VOID
ExReleaseResource (
PERESOURCE Resource
);
VOID
ExReleaseResourceForThread (
PERESOURCE Resource,
ERESOURCE_THREAD ResourceThreadId
);
VOID
ExReleaseResourceForThreadLite (
PERESOURCE Resource,
ERESOURCE_THREAD ResourceThreadId
);
VOID
ExSystemTimeToLocalTime (
PLARGE_INTEGER SystemTime,
PLARGE_INTEGER LocalTime
);
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 Exchange,
PVOID Comperand); PVOID Comperand
LONG InterlockedDecrement(PLONG Addend); );
LONG InterlockedExchange(PLONG Target, LONG Value); #ifdef _GNU_H_WINDOWS_H
LONG InterlockedExchangeAdd(PLONG Addend, LONG Value); #ifdef InterlockedDecrement
LONG InterlockedIncrement(PLONG Addend); #undef InterlockedDecrement
#undef InterlockedExchange
PVOID ExInterlockedAllocateFromZone(PZONE_HEADER Zone, PKSPIN_LOCK Lock); #undef InterlockedExchangeAdd
PVOID ExInterlockedFreeToZone(PZONE_HEADER Zone, PVOID Block, #undef InterlockedIncrement
PKSPIN_LOCK Lock); #endif /* def InterlockedDecrement */
NTSTATUS ExInterlockedExtendZone(PZONE_HEADER Zone, PVOID Segment, #endif /* def _GNU_H_WINDOWS_H */
ULONG SegmentSize, PKSPIN_LOCK Lock); LONG
PSINGLE_LIST_ENTRY ExInterlockedPopEntryList(PSINGLE_LIST_ENTRY ListHead, FASTCALL
PKSPIN_LOCK Lock); InterlockedDecrement (
PSINGLE_LIST_ENTRY ExInterlockedPushEntryList(PSINGLE_LIST_ENTRY ListHead, 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, PSINGLE_LIST_ENTRY ListEntry,
PKSPIN_LOCK Lock); PKSPIN_LOCK Lock
PSINGLE_LIST_ENTRY ExInterlockedPushEntrySList(PSLIST_HEADER ListHead, );
PSINGLE_LIST_ENTRY
ExInterlockedPushEntrySList (
PSLIST_HEADER ListHead,
PSINGLE_LIST_ENTRY ListEntry, PSINGLE_LIST_ENTRY ListEntry,
PKSPIN_LOCK Lock); PKSPIN_LOCK Lock
PSINGLE_LIST_ENTRY ExInterlockedPopEntrySList(PSLIST_HEADER ListHead, );
PKSPIN_LOCK Lock); PSINGLE_LIST_ENTRY
BOOLEAN ExIsFullZone(PZONE_HEADER Zone); ExInterlockedPopEntrySList (
BOOLEAN ExIsObjectInFirstZoneSegment(PZONE_HEADER Zone, PVOID Object); PSLIST_HEADER ListHead,
VOID ExLocalTimeToSystemTime(PLARGE_INTEGER LocalTime, PKSPIN_LOCK Lock
PLARGE_INTEGER SystemTime); );
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); typedef
unsigned int ExHookException(exception_hook fn, unsigned int exp); unsigned int
(exception_hook) (
INTERLOCKED_RESULT ExInterlockedDecrementLong(PLONG Addend, CONTEXT * c,
PKSPIN_LOCK Lock); unsigned int exp
ULONG ExInterlockedExchangeUlong(PULONG Target, );
unsigned int
ExHookException (
exception_hook fn,
unsigned int exp
);
INTERLOCKED_RESULT
ExInterlockedDecrementLong (
PLONG Addend,
PKSPIN_LOCK Lock
);
ULONG
ExInterlockedExchangeUlong (
PULONG Target,
ULONG Value, ULONG Value,
PKSPIN_LOCK Lock); PKSPIN_LOCK Lock
INTERLOCKED_RESULT ExInterlockedIncrementLong(PLONG Addend, );
PKSPIN_LOCK Lock); INTERLOCKED_RESULT
BOOLEAN ExIsResourceAcquiredExclusiveLite(PERESOURCE Resource); ExInterlockedIncrementLong (
ULONG ExIsResourceAcquiredSharedLite(PERESOURCE Resource); PLONG Addend,
USHORT ExQueryDepthSListHead(PSLIST_HEADER SListHead); 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

2
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

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 */

143
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,47 +17,84 @@
long _hread( long
STDCALL
_hread(
HFILE hFile, HFILE hFile,
LPVOID lpBuffer, LPVOID lpBuffer,
long lBytes 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; return NumberOfBytesRead;
} }
UINT STDCALL _lread(HFILE fd,LPVOID buffer,UINT count)
/*
//19990828.EA: aliased in DEF
UINT
STDCALL
_lread (
HFILE fd,
LPVOID buffer,
UINT count
)
{ {
return _hread(fd,buffer, count); return _hread(
fd,
buffer,
count
);
} }
*/
long _hwrite( long
STDCALL
_hwrite (
HFILE hFile, HFILE hFile,
LPCSTR lpBuffer, LPCSTR lpBuffer,
long lBytes long lBytes
) )
{ {
DWORD NumberOfBytesWritten; DWORD NumberOfBytesWritten;
if ( lBytes == 0 ) {
if (lBytes == 0)
{
if ( SetEndOfFile((HANDLE) hFile ) == FALSE ) if ( SetEndOfFile((HANDLE) hFile ) == FALSE )
{
return -1; return -1;
else }
return 0; return 0;
} }
if ( WriteFile((HANDLE)hFile,(LPVOID)lpBuffer,(DWORD)lBytes, &NumberOfBytesWritten,NULL) == FALSE ) if ( WriteFile(
(HANDLE) hFile,
(LPVOID) lpBuffer,
(DWORD) lBytes,
& NumberOfBytesWritten,
NULL
) == FALSE )
{
return -1; return -1;
else }
return NumberOfBytesWritten; return NumberOfBytesWritten;
} }
/*
//19990828.EA: aliased in DEF
UINT UINT
STDCALL STDCALL
_lwrite( _lwrite(
@ -67,16 +105,16 @@ _lwrite(
{ {
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 )
if ((iReadWrite & OF_SHARE_COMPAT) == OF_SHARE_COMPAT )
dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE; dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE;
else if ((iReadWrite & OF_SHARE_DENY_NONE) == OF_SHARE_DENY_NONE) else if ((iReadWrite & OF_SHARE_DENY_NONE) == OF_SHARE_DENY_NONE)
dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE; dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_READ | FILE_SHARE_DELETE;
else if ((iReadWrite & OF_SHARE_DENY_READ) == OF_SHARE_DENY_READ) else if ((iReadWrite & OF_SHARE_DENY_READ) == OF_SHARE_DENY_READ)
dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_DELETE; dwShareMode = FILE_SHARE_WRITE | FILE_SHARE_DELETE;
else if ((iReadWrite & OF_SHARE_DENY_WRITE) == OF_SHARE_DENY_WRITE ) else if ((iReadWrite & OF_SHARE_DENY_WRITE) == OF_SHARE_DENY_WRITE )
dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE; dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
else if ((iReadWrite & OF_SHARE_EXCLUSIVE) == OF_SHARE_EXCLUSIVE) else if ((iReadWrite & OF_SHARE_EXCLUSIVE) == OF_SHARE_EXCLUSIVE)
dwShareMode = 0; 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
STDCALL
_lclose (
HFILE hFile HFILE hFile
) )
{ {
if ( CloseHandle((HANDLE)hFile) ) if ( CloseHandle((HANDLE)hFile) )
{
return 0; return 0;
else }
return -1; return -1;
} }
LONG _llseek(
LONG
STDCALL
_llseek(
HFILE hFile, HFILE hFile,
LONG lOffset, LONG lOffset,
int iOrigin 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 */

30
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
)
{ {
/* FIXME: it is per thread */
LastError = dwErrorCode; 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 */

202
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,
WINBOOL
STDCALL
GetProcessTimes (
HANDLE hProcess,
LPFILETIME lpCreationTime, LPFILETIME lpCreationTime,
LPFILETIME lpExitTime, LPFILETIME lpExitTime,
LPFILETIME lpKernelTime, LPFILETIME lpKernelTime,
LPFILETIME lpUserTime) 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,
HANDLE
STDCALL
OpenProcess (
DWORD dwDesiredAccess,
WINBOOL bInheritHandle, WINBOOL bInheritHandle,
DWORD dwProcessId) 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,12 +442,22 @@ VOID STDCALL GetStartupInfoA(LPSTARTUPINFO lpStartupInfo)
return; return;
} }
BOOL STDCALL FlushInstructionCache(HANDLE hProcess,
BOOL
STDCALL
FlushInstructionCache (
HANDLE hProcess,
LPCVOID lpBaseAddress, LPCVOID lpBaseAddress,
DWORD dwSize) DWORD dwSize
)
{ {
NTSTATUS errCode; NTSTATUS errCode;
errCode = NtFlushInstructionCache(hProcess,(PVOID)lpBaseAddress,dwSize);
errCode = NtFlushInstructionCache(
hProcess,
(PVOID) lpBaseAddress,
dwSize
);
if (!NT_SUCCESS(errCode)) if (!NT_SUCCESS(errCode))
{ {
SetLastError(RtlNtStatusToDosError(errCode)); SetLastError(RtlNtStatusToDosError(errCode));
@ -369,12 +466,26 @@ BOOL STDCALL FlushInstructionCache(HANDLE hProcess,
return TRUE; 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 */

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

File diff suppressed because it is too large Load diff

54
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
NtCreateKey (
OUT PHANDLE KeyHandle,
IN ACCESS_MASK DesiredAccess, IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes, IN POBJECT_ATTRIBUTES ObjectAttributes,
IN ULONG TitleIndex, IN ULONG TitleIndex,
IN PUNICODE_STRING Class, IN PUNICODE_STRING Class,
IN ULONG CreateOptions, IN ULONG CreateOptions,
OUT PULONG Disposition) 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
NtEnumerateKey (
IN HANDLE KeyHandle,
IN ULONG Index, IN ULONG Index,
IN KEY_INFORMATION_CLASS KeyInformationClass, IN KEY_INFORMATION_CLASS KeyInformationClass,
OUT PVOID KeyInformation, OUT PVOID KeyInformation,
IN ULONG Length, IN ULONG Length,
OUT PULONG ResultLength) 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
NtOpenKey (
OUT PHANDLE KeyHandle,
IN ACCESS_MASK DesiredAccess, IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes) 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 */

37
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
ExInterlockedExchangeUlong (
PULONG Target,
ULONG Value, ULONG Value,
PKSPIN_LOCK Lock) PKSPIN_LOCK Lock
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
} }
ULONG ExInterlockedAddUlong(PULONG Addend,
ULONG
ExInterlockedAddUlong (
PULONG Addend,
ULONG Increment, ULONG Increment,
PKSPIN_LOCK Lock) 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 */

77
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,
@ -104,59 +107,94 @@ NtSetInformationFile (
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(
"NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n",
FileHandle, FileHandle,
IoStatusBlock, IoStatusBlock,
FileInformation, FileInformation,
Length, Length,
FileInformationClass); FileInformationClass
);
/* Get the file object from the file handle */ /* Get the file object from the file handle */
Status = ObReferenceObjectByHandle(FileHandle, Status = ObReferenceObjectByHandle(
FileHandle,
FILE_WRITE_ATTRIBUTES, FILE_WRITE_ATTRIBUTES,
IoFileType, IoFileType,
UserMode, UserMode,
(PVOID *) &FileObject, (PVOID *) & FileObject,
NULL); NULL
);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return Status; return Status;
} }
DPRINT("FileObject %x\n", FileObject); 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.
/* build the IRP to be sent to the driver for the request */ */
Irp = IoBuildSynchronousFsdRequest(IRP_MJ_SET_INFORMATION, KeInitializeEvent(
& Event,
NotificationEvent,
FALSE
);
/*
* Build the IRP to be sent to the driver
* for the request.
*/
Irp = IoBuildSynchronousFsdRequest(
IRP_MJ_SET_INFORMATION,
FileObject->DeviceObject, FileObject->DeviceObject,
FileInformation, FileInformation,
Length, Length,
0, 0,
&Event, & Event,
IoStatusBlock); IoStatusBlock
);
StackPtr = IoGetNextIrpStackLocation(Irp); StackPtr = IoGetNextIrpStackLocation(Irp);
StackPtr->FileObject = FileObject; StackPtr->FileObject = FileObject;
StackPtr->Parameters.SetFile.Length = Length; StackPtr->Parameters.SetFile.Length = Length;
StackPtr->Parameters.SetFile.FileInformationClass = FileInformationClass; StackPtr->Parameters.SetFile.FileInformationClass =
FileInformationClass;
/* Pass the IRP to the FSD (and wait for it if required) */ /*
* Pass the IRP to the FSD (and wait for
* it if required)
*/
DPRINT("FileObject->DeviceObject %x\n", FileObject->DeviceObject); DPRINT("FileObject->DeviceObject %x\n", FileObject->DeviceObject);
Status = IoCallDriver(FileObject->DeviceObject, Irp); Status = IoCallDriver(
if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO)) FileObject->DeviceObject,
Irp
);
if ( (Status == STATUS_PENDING)
&& (FileObject->Flags & FO_SYNCHRONOUS_IO)
)
{ {
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL); KeWaitForSingleObject(
& Event,
Executive,
KernelMode,
FALSE,
NULL
);
Status = Irp->IoStatus.Status; 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 */

200
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,
@ -41,66 +57,85 @@ NtReadFile (
PKEVENT ptrEvent = NULL; PKEVENT ptrEvent = NULL;
KEVENT Event; KEVENT Event;
DPRINT("NtReadFile(FileHandle %x Buffer %x Length %x ByteOffset %x, " DPRINT(
"NtReadFile(FileHandle %x Buffer %x Length %x ByteOffset %x, "
"IoStatusBlock %x)\n", "IoStatusBlock %x)\n",
FileHandle,Buffer,Length,ByteOffset,IoStatusBlock); FileHandle,
Buffer,
Length,
ByteOffset,
IoStatusBlock
);
assert_irql(PASSIVE_LEVEL); assert_irql(PASSIVE_LEVEL);
Status = ObReferenceObjectByHandle(FileHandle, Status = ObReferenceObjectByHandle(
FileHandle,
FILE_READ_DATA, FILE_READ_DATA,
IoFileType, IoFileType,
UserMode, UserMode,
(PVOID *) &FileObject, (PVOID *) & FileObject,
NULL); NULL
);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
DPRINT("NtReadFile() = %x\n",Status); DPRINT("NtReadFile() = %x\n",Status);
return(Status); return Status;
} }
DPRINT("ByteOffset %x FileObject->CurrentByteOffset %d\n", DPRINT(
"ByteOffset %x FileObject->CurrentByteOffset %d\n",
ByteOffset, ByteOffset,
FileObject->CurrentByteOffset.LowPart); FileObject->CurrentByteOffset.LowPart
if (ByteOffset==NULL) );
if (ByteOffset == NULL)
{ {
ByteOffset = &(FileObject->CurrentByteOffset); ByteOffset = & (FileObject->CurrentByteOffset);
} }
if (EventHandle != NULL) if (EventHandle != NULL)
{ {
Status = ObReferenceObjectByHandle(EventHandle, Status = ObReferenceObjectByHandle(
EventHandle,
SYNCHRONIZE, SYNCHRONIZE,
ExEventType, ExEventType,
UserMode, UserMode,
(PVOID *)ptrEvent, (PVOID *) ptrEvent,
NULL); NULL
);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return(Status); return Status;
} }
} }
else else
{ {
KeInitializeEvent(&Event,NotificationEvent,FALSE); KeInitializeEvent(
ptrEvent = &Event; & Event,
NotificationEvent,
FALSE
);
ptrEvent = & Event;
} }
DPRINT("FileObject %x\n",FileObject); DPRINT("FileObject %x\n",FileObject);
Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
Irp = IoBuildSynchronousFsdRequest(
IRP_MJ_READ,
FileObject->DeviceObject, FileObject->DeviceObject,
Buffer, Buffer,
Length, Length,
ByteOffset, ByteOffset,
ptrEvent, ptrEvent,
IoStatusBlock); 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;
} }
@ -109,19 +144,48 @@ NtReadFile (
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
);
if (
(Status == STATUS_PENDING)
&& (FileObject->Flags & FO_SYNCHRONOUS_IO)
)
{ {
KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL); KeWaitForSingleObject(
& Event,
Executive,
KernelMode,
FALSE,
NULL
);
Status = IoStatusBlock->Status; Status = IoStatusBlock->Status;
} }
DPRINT("NtReadFile() = %x\n",Status); DPRINT("NtReadFile() = %x\n",Status);
assert_irql(PASSIVE_LEVEL); assert_irql(PASSIVE_LEVEL);
return(Status);
return Status;
} }
/**********************************************************************
* NAME EXPORTED
* NtWriteFile
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
STDCALL
NtWriteFile ( NtWriteFile (
HANDLE FileHandle, HANDLE FileHandle,
HANDLE EventHandle, HANDLE EventHandle,
@ -140,40 +204,53 @@ NtWriteFile (
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(
FileHandle,
FILE_WRITE_DATA, FILE_WRITE_DATA,
IoFileType, IoFileType,
UserMode, UserMode,
(PVOID *) &FileObject, (PVOID *) & FileObject,
NULL); NULL
);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return(Status); return Status;
} }
if (ByteOffset==NULL) if (ByteOffset == NULL)
{ {
ByteOffset = &(FileObject->CurrentByteOffset); ByteOffset = & (FileObject->CurrentByteOffset);
} }
KeInitializeEvent(&Event,NotificationEvent,FALSE); KeInitializeEvent(
Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE, & Event,
NotificationEvent,
FALSE
);
Irp = IoBuildSynchronousFsdRequest(
IRP_MJ_WRITE,
FileObject->DeviceObject, FileObject->DeviceObject,
Buffer, Buffer,
Length, Length,
ByteOffset, ByteOffset,
&Event, & Event,
IoStatusBlock); 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 = IoGetNextIrpStackLocation(Irp);
StackPtr->FileObject = FileObject; StackPtr->FileObject = FileObject;
if (Key!=NULL) if (Key != NULL)
{ {
StackPtr->Parameters.Write.Key = *Key; StackPtr->Parameters.Write.Key = *Key;
} }
@ -181,16 +258,41 @@ NtWriteFile (
{ {
StackPtr->Parameters.Write.Key = 0; StackPtr->Parameters.Write.Key = 0;
} }
Status = IoCallDriver(FileObject->DeviceObject,Irp); Status = IoCallDriver(
if (Status == STATUS_PENDING && (FileObject->Flags & FO_SYNCHRONOUS_IO)) FileObject->DeviceObject,
Irp
);
if (
(Status == STATUS_PENDING)
&& (FileObject->Flags & FO_SYNCHRONOUS_IO)
)
{ {
KeWaitForSingleObject(&Event,Executive,KernelMode,FALSE,NULL); KeWaitForSingleObject(
& Event,
Executive,
KernelMode,
FALSE,
NULL
);
Status = Irp->IoStatus.Status; Status = Irp->IoStatus.Status;
} }
return(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 */

316
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,64 +20,128 @@
/* 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,
/**********************************************************************
* NAME INTERNAL
* IopCreateSymbolicLink
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURNN VALUE
* Status.
*
* REVISIONS
*/
NTSTATUS
IopCreateSymbolicLink (
PVOID Object,
PVOID Parent, PVOID Parent,
PWSTR RemainingPath, PWSTR RemainingPath,
POBJECT_ATTRIBUTES ObjectAttributes) POBJECT_ATTRIBUTES ObjectAttributes
)
{ {
if (Parent != NULL && RemainingPath != NULL) if ( (Parent != NULL)
&& (RemainingPath != NULL)
)
{ {
ObAddEntryDirectory(Parent, Object, RemainingPath+1); ObAddEntryDirectory(
Parent,
Object,
RemainingPath + 1
);
} }
return(STATUS_SUCCESS); return STATUS_SUCCESS;
} }
PVOID IopParseSymbolicLink(PVOID Object,
PWSTR* RemainingPath) /**********************************************************************
* NAME INTERNAL
* IopParseSymbolicLink
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURNN VALUE
*
* REVISIONS
*/
PVOID
IopParseSymbolicLink (
PVOID Object,
PWSTR * RemainingPath
)
{ {
NTSTATUS Status; NTSTATUS Status;
PSYMLNK_OBJECT SymlinkObject = (PSYMLNK_OBJECT)Object; PSYMLNK_OBJECT SymlinkObject = (PSYMLNK_OBJECT) Object;
PVOID ReturnedObject; PVOID ReturnedObject;
Status = ObReferenceObjectByName(SymlinkObject->Target.ObjectName, Status = ObReferenceObjectByName(
SymlinkObject->Target.ObjectName,
0, 0,
NULL, NULL,
STANDARD_RIGHTS_REQUIRED, STANDARD_RIGHTS_REQUIRED,
NULL, NULL,
UserMode, UserMode,
NULL, NULL,
&ReturnedObject); & ReturnedObject
);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
return(ReturnedObject); return ReturnedObject;
} }
return(NULL); return NULL;
} }
VOID IoInitSymbolicLinkImplementation(VOID)
/**********************************************************************
* NAME INTERNAL
* IoInitSymbolicLinkImplementation
*
* DESCRIPTION
*
* ARGUMENTS
* None.
*
* RETURNN VALUE
* None.
*
* REVISIONS
*/
VOID
IoInitSymbolicLinkImplementation (VOID)
{ {
ANSI_STRING AnsiString; ANSI_STRING AnsiString;
IoSymbolicLinkType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE)); IoSymbolicLinkType = ExAllocatePool(
NonPagedPool,
sizeof (OBJECT_TYPE)
);
IoSymbolicLinkType->TotalObjects = 0; IoSymbolicLinkType->TotalObjects = 0;
IoSymbolicLinkType->TotalHandles = 0; IoSymbolicLinkType->TotalHandles = 0;
IoSymbolicLinkType->MaxObjects = ULONG_MAX; IoSymbolicLinkType->MaxObjects = ULONG_MAX;
IoSymbolicLinkType->MaxHandles = ULONG_MAX; IoSymbolicLinkType->MaxHandles = ULONG_MAX;
IoSymbolicLinkType->PagedPoolCharge = 0; IoSymbolicLinkType->PagedPoolCharge = 0;
IoSymbolicLinkType->NonpagedPoolCharge = sizeof(SYMLNK_OBJECT); IoSymbolicLinkType->NonpagedPoolCharge = sizeof (SYMLNK_OBJECT);
IoSymbolicLinkType->Dump = NULL; IoSymbolicLinkType->Dump = NULL;
IoSymbolicLinkType->Open = NULL; IoSymbolicLinkType->Open = NULL;
IoSymbolicLinkType->Close = NULL; IoSymbolicLinkType->Close = NULL;
@ -87,13 +152,33 @@ VOID IoInitSymbolicLinkImplementation(VOID)
IoSymbolicLinkType->OkayToClose = NULL; IoSymbolicLinkType->OkayToClose = NULL;
IoSymbolicLinkType->Create = IopCreateSymbolicLink; IoSymbolicLinkType->Create = IopCreateSymbolicLink;
RtlInitAnsiString(&AnsiString,"Symbolic Link"); RtlInitAnsiString(
RtlAnsiStringToUnicodeString(&IoSymbolicLinkType->TypeName, & AnsiString,
&AnsiString,TRUE); "Symbolic Link"
);
RtlAnsiStringToUnicodeString(
& IoSymbolicLinkType->TypeName,
& AnsiString,
TRUE
);
} }
/**********************************************************************
* NAME EXPORTED
* NtOpenSymbolicLinkObject
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
STDCALL
NtOpenSymbolicLinkObject ( NtOpenSymbolicLinkObject (
OUT PHANDLE LinkHandle, OUT PHANDLE LinkHandle,
IN ACCESS_MASK DesiredAccess, IN ACCESS_MASK DesiredAccess,
@ -103,34 +188,52 @@ NtOpenSymbolicLinkObject (
NTSTATUS Status; NTSTATUS Status;
PVOID Object; PVOID Object;
Status = ObReferenceObjectByName(ObjectAttributes->ObjectName, Status = ObReferenceObjectByName(
ObjectAttributes->ObjectName,
ObjectAttributes->Attributes, ObjectAttributes->Attributes,
NULL, NULL,
DesiredAccess, DesiredAccess,
NULL, NULL,
UserMode, UserMode,
NULL, NULL,
&Object); & Object
);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return(Status); return Status;
} }
Status = ObCreateHandle(PsGetCurrentProcess(), Status = ObCreateHandle(
PsGetCurrentProcess(),
Object, Object,
DesiredAccess, DesiredAccess,
FALSE, FALSE,
LinkHandle); LinkHandle
);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return(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,
@ -140,34 +243,79 @@ NtQuerySymbolicLinkObject (
PSYMLNK_OBJECT SymlinkObject; PSYMLNK_OBJECT SymlinkObject;
NTSTATUS Status; NTSTATUS Status;
Status = ObReferenceObjectByHandle(LinkHandle, Status = ObReferenceObjectByHandle(
LinkHandle,
SYMBOLIC_LINK_QUERY, SYMBOLIC_LINK_QUERY,
IoSymbolicLinkType, IoSymbolicLinkType,
UserMode, UserMode,
(PVOID*)&SymlinkObject, (PVOID *) & SymlinkObject,
NULL); NULL
);
if (Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS)
{ {
return(Status); return Status;
} }
RtlCopyUnicodeString(LinkTarget,SymlinkObject->Target.ObjectName); RtlCopyUnicodeString(
if (ReturnedLength!=NULL) LinkTarget,
SymlinkObject->Target.ObjectName
);
if (ReturnedLength != NULL)
{ {
*ReturnedLength=SymlinkObject->Target.Length; *ReturnedLength = SymlinkObject->Target.Length;
} }
ObDereferenceObject(SymlinkObject); ObDereferenceObject(SymlinkObject);
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
} }
NTSTATUS IoCreateUnprotectedSymbolicLink(PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName) /**********************************************************************
* NAME EXPORTED
* IoCreateUnprotectedSymbolicLink
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS
STDCALL
IoCreateUnprotectedSymbolicLink (
PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName
)
{ {
return(IoCreateSymbolicLink(SymbolicLinkName,DeviceName)); return IoCreateSymbolicLink(
SymbolicLinkName,
DeviceName
);
} }
NTSTATUS IoCreateSymbolicLink(PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName) /**********************************************************************
* NAME EXPORTED
* IoCreateSymbolicLink
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS
STDCALL
IoCreateSymbolicLink (
PUNICODE_STRING SymbolicLinkName,
PUNICODE_STRING DeviceName
)
{ {
OBJECT_ATTRIBUTES ObjectAttributes; OBJECT_ATTRIBUTES ObjectAttributes;
HANDLE SymbolicLinkHandle; HANDLE SymbolicLinkHandle;
@ -175,41 +323,97 @@ NTSTATUS IoCreateSymbolicLink(PUNICODE_STRING SymbolicLinkName,
assert_irql(PASSIVE_LEVEL); assert_irql(PASSIVE_LEVEL);
DPRINT("IoCreateSymbolicLink(SymbolicLinkName %w, DeviceName %w)\n", DPRINT(
SymbolicLinkName->Buffer,DeviceName->Buffer); "IoCreateSymbolicLink(SymbolicLinkName %w, DeviceName %w)\n",
SymbolicLinkName->Buffer,
DeviceName->Buffer
);
InitializeObjectAttributes(&ObjectAttributes,SymbolicLinkName,0,NULL,NULL); InitializeObjectAttributes(
SymbolicLink = ObCreateObject(&SymbolicLinkHandle, & ObjectAttributes,
SymbolicLinkName,
0,
NULL,
NULL
);
SymbolicLink = ObCreateObject(
& SymbolicLinkHandle,
SYMBOLIC_LINK_ALL_ACCESS, SYMBOLIC_LINK_ALL_ACCESS,
&ObjectAttributes, & ObjectAttributes,
IoSymbolicLinkType); IoSymbolicLinkType
);
if (SymbolicLink == NULL) if (SymbolicLink == NULL)
{ {
return(STATUS_UNSUCCESSFUL); return STATUS_UNSUCCESSFUL;
} }
ZwClose(SymbolicLinkHandle); ZwClose(SymbolicLinkHandle);
SymbolicLink->TargetName.Length = 0; SymbolicLink->TargetName.Length = 0;
SymbolicLink->TargetName.MaximumLength = SymbolicLink->TargetName.MaximumLength =
((wcslen(DeviceName->Buffer) + 1) * sizeof(WCHAR)); ((wcslen(DeviceName->Buffer) + 1) * sizeof(WCHAR));
SymbolicLink->TargetName.Buffer = ExAllocatePool(NonPagedPool, SymbolicLink->TargetName.Buffer =
SymbolicLink->TargetName.MaximumLength); ExAllocatePool(
RtlCopyUnicodeString(&(SymbolicLink->TargetName), DeviceName); NonPagedPool,
SymbolicLink->TargetName.MaximumLength
);
RtlCopyUnicodeString(
& (SymbolicLink->TargetName),
DeviceName
);
DPRINT("DeviceName %w\n", SymbolicLink->TargetName.Buffer); DPRINT("DeviceName %w\n", SymbolicLink->TargetName.Buffer);
InitializeObjectAttributes(&(SymbolicLink->Target),
&(SymbolicLink->TargetName),0,NULL,NULL); InitializeObjectAttributes(
& (SymbolicLink->Target),
& (SymbolicLink->TargetName),
0,
NULL,
NULL
);
DPRINT("%s() = STATUS_SUCCESS\n",__FUNCTION__); DPRINT("%s() = STATUS_SUCCESS\n",__FUNCTION__);
return(STATUS_SUCCESS);
return STATUS_SUCCESS;
} }
/**********************************************************************
* NAME EXPORTED
* IoDeleteSymbolicLink
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*
*/
NTSTATUS NTSTATUS
IoDeleteSymbolicLink(PUNICODE_STRING DeviceName) 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 */

198
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,7 +180,26 @@ 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,
@ -191,27 +211,79 @@ NtOpenSection (
*SectionHandle = 0; *SectionHandle = 0;
Status = ObReferenceObjectByName(ObjectAttributes->ObjectName, Status = ObReferenceObjectByName(
ObjectAttributes->ObjectName,
ObjectAttributes->Attributes, ObjectAttributes->Attributes,
NULL, NULL,
DesiredAccess, DesiredAccess,
MmSectionType, MmSectionType,
UserMode, UserMode,
NULL, NULL,
&Object); & Object
);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return(Status); return Status;
} }
Status = ObCreateHandle(PsGetCurrentProcess(), Status = ObCreateHandle(
PsGetCurrentProcess(),
Object, Object,
DesiredAccess, DesiredAccess,
FALSE, FALSE,
SectionHandle); SectionHandle
return(Status); );
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,34 +298,14 @@ 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(
"NtMapViewOfSection(Section:%08lx, Process:%08lx,\n"
" Base:%08lx, ZeroBits:%08lx, CommitSize:%08lx,\n" " Base:%08lx, ZeroBits:%08lx, CommitSize:%08lx,\n"
" SectionOffs:%08lx, *ViewSize:%08lx, InheritDisp:%08lx,\n" " SectionOffs:%08lx, *ViewSize:%08lx, InheritDisp:%08lx,\n"
" AllocType:%08lx, Protect:%08lx)\n", " AllocType:%08lx, Protect:%08lx)\n",
@ -266,54 +318,67 @@ NtMapViewOfSection (
*ViewSize, *ViewSize,
InheritDisposition, InheritDisposition,
AllocationType, AllocationType,
Protect); Protect
);
DPRINT(" *Base:%08lx\n", *BaseAddress); DPRINT(" *Base:%08lx\n", *BaseAddress);
Status = ObReferenceObjectByHandle(SectionHandle, Status = ObReferenceObjectByHandle(
SectionHandle,
SECTION_MAP_READ, SECTION_MAP_READ,
MmSectionType, MmSectionType,
UserMode, UserMode,
(PVOID*)&Section, (PVOID *) & Section,
NULL); NULL
);
if (Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS)
{ {
DPRINT("ObReference failed rc=%x\n",Status); DPRINT("ObReference failed rc=%x\n",Status);
return(Status);
return Status;
} }
DPRINT("Section %x\n",Section); DPRINT("Section %x\n",Section);
Status = ObReferenceObjectByHandle(ProcessHandle, Status = ObReferenceObjectByHandle(
ProcessHandle,
PROCESS_VM_OPERATION, PROCESS_VM_OPERATION,
PsProcessType, PsProcessType,
UserMode, UserMode,
(PVOID*)&Process, (PVOID *) & Process,
NULL); NULL
);
if (Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS)
{ {
ObDereferenceObject(Section); ObDereferenceObject(Section);
return(Status);
return Status;
} }
DPRINT("ViewSize %x\n",ViewSize); DPRINT("ViewSize %x\n",ViewSize);
if ((*ViewSize) > Section->MaximumSize.u.LowPart) if ((*ViewSize) > Section->MaximumSize.u.LowPart)
{ {
(*ViewSize) = Section->MaximumSize.u.LowPart; (*ViewSize) = Section->MaximumSize.u.LowPart;
} }
Status = MmCreateMemoryArea(UserMode, Status = MmCreateMemoryArea(
UserMode,
Process, Process,
MEMORY_AREA_SECTION_VIEW_COMMIT, MEMORY_AREA_SECTION_VIEW_COMMIT,
BaseAddress, BaseAddress,
*ViewSize, * ViewSize,
Protect, Protect,
&Result); & Result
);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
DPRINT("NtMapViewOfSection() = %x\n",Status); DPRINT("NtMapViewOfSection() = %x\n",Status);
ObDereferenceObject(Process); ObDereferenceObject(Process);
ObDereferenceObject(Section); ObDereferenceObject(Section);
return(Status);
return Status;
} }
Result->Data.SectionData.Section = Section; Result->Data.SectionData.Section = Section;
@ -325,17 +390,37 @@ NtMapViewOfSection (
} }
else else
{ {
Result->Data.SectionData.ViewOffset = SectionOffset->u.LowPart; Result->Data.SectionData.ViewOffset =
SectionOffset->u.LowPart;
} }
DPRINT("*BaseAddress %x\n",*BaseAddress); DPRINT("*BaseAddress %x\n",*BaseAddress);
ObDereferenceObject(Process); ObDereferenceObject(Process);
ObDereferenceObject(Section); ObDereferenceObject(Section);
return(STATUS_SUCCESS);
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
@ -344,19 +429,27 @@ NtUnmapViewOfSection (
PEPROCESS Process; PEPROCESS Process;
NTSTATUS Status; NTSTATUS Status;
Status = ObReferenceObjectByHandle(ProcessHandle, Status = ObReferenceObjectByHandle(
ProcessHandle,
PROCESS_VM_OPERATION, PROCESS_VM_OPERATION,
PsProcessType, PsProcessType,
UserMode, UserMode,
(PVOID*)&Process, (PVOID *) & Process,
NULL); NULL
);
if (Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS)
{ {
return(Status); return Status;
} }
Status = MmFreeMemoryArea(Process,BaseAddress,0,TRUE); Status = MmFreeMemoryArea(
Process,
BaseAddress,
0,
TRUE
);
ObDereferenceObject(Process); ObDereferenceObject(Process);
return(Status);
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

308
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->ObjectName,
ObjectAttributes->Attributes, ObjectAttributes->Attributes,
NULL, NULL,
DesiredAccess, DesiredAccess,
ObDirectoryType, ObDirectoryType,
UserMode, UserMode,
NULL, NULL,
&Object); & Object
);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
return(Status); return Status;
} }
Status = ObCreateHandle(PsGetCurrentProcess(), Status = ObCreateHandle(
PsGetCurrentProcess(),
Object, Object,
DesiredAccess, DesiredAccess,
FALSE, FALSE,
DirectoryHandle); DirectoryHandle
return(STATUS_SUCCESS); );
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,24 +133,6 @@ 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;
@ -102,23 +142,33 @@ NtQueryDirectoryObject (
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
);
DPRINT(
"dir %x namespc_root %x\n",
dir,
HEADER_TO_BODY(&(namespc_root.hdr))
);
// assert_irql(PASSIVE_LEVEL); // assert_irql(PASSIVE_LEVEL);
Status = ObReferenceObjectByHandle(DirObjHandle, Status = ObReferenceObjectByHandle(
DirObjHandle,
DIRECTORY_QUERY, DIRECTORY_QUERY,
ObDirectoryType, ObDirectoryType,
UserMode, UserMode,
(PVOID*)&dir, (PVOID *) & dir,
NULL); NULL
);
if (Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS)
{ {
return(Status); return Status;
} }
EntriesToRead = BufferLength / sizeof(OBJDIR_INFORMATION); EntriesToRead = BufferLength / sizeof (OBJDIR_INFORMATION);
*DataWritten = 0; *DataWritten = 0;
DPRINT("EntriesToRead %d\n",EntriesToRead); DPRINT("EntriesToRead %d\n",EntriesToRead);
@ -133,7 +183,7 @@ NtQueryDirectoryObject (
CHECKPOINT; 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;
} }
@ -144,21 +194,41 @@ NtQueryDirectoryObject (
/* /*
* 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,
OBJECT_HEADER,
Entry
);
DPRINT(
"Scanning %w\n",
current->Name.Buffer
);
DirObjInformation[i].ObjectName.Buffer = DirObjInformation[i].ObjectName.Buffer =
ExAllocatePool(NonPagedPool,(current->Name.Length+1)*2); ExAllocatePool(
DirObjInformation[i].ObjectName.Length = current->Name.Length; NonPagedPool,
DirObjInformation[i].ObjectName.MaximumLength = current->Name.Length; (current->Name.Length + 1) * 2
DPRINT("DirObjInformation[i].ObjectName.Buffer %x\n", );
DirObjInformation[i].ObjectName.Buffer); DirObjInformation[i].ObjectName.Length =
RtlCopyUnicodeString(&DirObjInformation[i].ObjectName, current->Name.Length;
&(current->Name)); 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++; i++;
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
(*DataWritten) = (*DataWritten) + sizeof(OBJDIR_INFORMATION); (*DataWritten) = (*DataWritten) + sizeof (OBJDIR_INFORMATION);
CHECKPOINT; CHECKPOINT;
} }
CHECKPOINT; CHECKPOINT;
@ -168,21 +238,44 @@ NtQueryDirectoryObject (
*/ */
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(
DirectoryHandle,
DesiredAccess, DesiredAccess,
ObjectAttributes, ObjectAttributes,
ObDirectoryType); ObDirectoryType
return(STATUS_SUCCESS); );
return STATUS_SUCCESS;
} }
VOID InitializeObjectAttributes(POBJECT_ATTRIBUTES InitializedAttributes,
/**********************************************************************
* NAME (MACRO in DDK)
* InitializeObjectAttributes
*
* DESCRIPTION
* Sets up a parameter of type OBJECT_ATTRIBUTES for a
* subsequent call to ZwCreateXXX or ZwOpenXXX.
*
* ARGUMENTS
* InitializedAttributes (OUT)
* Caller supplied storage for the object attributes.
*
* ObjectName
* Full path name for object.
*
* Attributes
* Attributes for the object.
*
* RootDirectory
* Where the object should be placed or NULL.
*
* SecurityDescriptor
* Ignored.
*
* NOTE
* Either ObjectName is a fully qualified pathname or a path
* relative to RootDirectory.
*/
VOID
InitializeObjectAttributes (
POBJECT_ATTRIBUTES InitializedAttributes,
PUNICODE_STRING ObjectName, PUNICODE_STRING ObjectName,
ULONG Attributes, ULONG Attributes,
HANDLE RootDirectory, HANDLE RootDirectory,
PSECURITY_DESCRIPTOR SecurityDescriptor) PSECURITY_DESCRIPTOR SecurityDescriptor
/* )
* FUNCTION: Sets up a parameter of type OBJECT_ATTRIBUTES for a
* subsequent call to ZwCreateXXX or ZwOpenXXX
* ARGUMENTS:
* InitializedAttributes (OUT) = Caller supplied storage for the
* object attributes
* ObjectName = Full path name for object
* Attributes = Attributes for the object
* RootDirectory = Where the object should be placed or NULL
* SecurityDescriptor = Ignored
*
* NOTE:
* Either ObjectName is a fully qualified pathname or a path relative
* to RootDirectory
*/
{ {
DPRINT("InitializeObjectAttributes(InitializedAttributes %x " DPRINT(
"InitializeObjectAttributes(InitializedAttributes %x "
"ObjectName %x Attributes %x RootDirectory %x)\n", "ObjectName %x Attributes %x RootDirectory %x)\n",
InitializedAttributes,ObjectName,Attributes,RootDirectory); InitializedAttributes,
InitializedAttributes->Length=sizeof(OBJECT_ATTRIBUTES); ObjectName,
InitializedAttributes->RootDirectory=RootDirectory; Attributes,
InitializedAttributes->ObjectName=ObjectName; RootDirectory
InitializedAttributes->Attributes=Attributes; );
InitializedAttributes->SecurityDescriptor=SecurityDescriptor; InitializedAttributes->Length =
InitializedAttributes->SecurityQualityOfService=NULL; sizeof (OBJECT_ATTRIBUTES);
InitializedAttributes->RootDirectory =
RootDirectory;
InitializedAttributes->ObjectName =
ObjectName;
InitializedAttributes->Attributes =
Attributes;
InitializedAttributes->SecurityDescriptor =
SecurityDescriptor;
InitializedAttributes->SecurityQualityOfService =
NULL;
} }
/* EOF */

74
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,13 +392,24 @@ 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;
@ -394,11 +419,13 @@ NTSTATUS NtClose(HANDLE Handle)
DPRINT("NtClose(Handle %x)\n",Handle); DPRINT("NtClose(Handle %x)\n",Handle);
HandleRep = ObpGetObjectByHandle(PsGetCurrentProcess(), HandleRep = ObpGetObjectByHandle(
Handle); PsGetCurrentProcess(),
Handle
);
if (HandleRep == NULL) if (HandleRep == NULL)
{ {
return(STATUS_INVALID_HANDLE); return STATUS_INVALID_HANDLE;
} }
ObjectBody = HandleRep->ObjectBody; ObjectBody = HandleRep->ObjectBody;
@ -409,15 +436,22 @@ NTSTATUS NtClose(HANDLE Handle)
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 */

36
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,7 +48,10 @@ NtQueryObject (
} }
VOID ObMakeTemporaryObject(PVOID ObjectBody) VOID
ObMakeTemporaryObject (
PVOID ObjectBody
)
{ {
POBJECT_HEADER ObjectHeader; POBJECT_HEADER ObjectHeader;
@ -56,7 +60,20 @@ VOID ObMakeTemporaryObject(PVOID ObjectBody)
} }
/**********************************************************************
* NAME EXPORTED
* NtMakeTemporaryObject
*
* DESCRIPTION
*
* ARGUMENTS
*
* RETURN VALUE
*
* REVISIONS
*/
NTSTATUS NTSTATUS
STDCALL
NtMakeTemporaryObject ( NtMakeTemporaryObject (
HANDLE Handle HANDLE Handle
) )
@ -65,15 +82,17 @@ NtMakeTemporaryObject (
NTSTATUS Status; NTSTATUS Status;
POBJECT_HEADER ObjectHeader; POBJECT_HEADER ObjectHeader;
Status = ObReferenceObjectByHandle(Handle, Status = ObReferenceObjectByHandle(
Handle,
0, 0,
NULL, NULL,
KernelMode, KernelMode,
&Object, & Object,
NULL); NULL
);
if (Status != STATUS_SUCCESS) if (Status != STATUS_SUCCESS)
{ {
return(Status); return Status;
} }
ObjectHeader = BODY_TO_HEADER(Object); ObjectHeader = BODY_TO_HEADER(Object);
@ -81,5 +100,8 @@ NtMakeTemporaryObject (
ObDereferenceObject(Object); ObDereferenceObject(Object);
return(STATUS_SUCCESS); return STATUS_SUCCESS;
} }
/* EOF */

103
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,7 +118,11 @@ 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;
@ -126,20 +131,29 @@ static PETHREAD PsScanThreadList(KPRIORITY Priority)
// DPRINT("PsScanThreadList(Priority %d)\n",Priority); // DPRINT("PsScanThreadList(Priority %d)\n",Priority);
current_entry = PriorityListHead[THREAD_PRIORITY_MAX+Priority].Flink; current_entry =
PriorityListHead[THREAD_PRIORITY_MAX + Priority].Flink;
while (current_entry != &PriorityListHead[THREAD_PRIORITY_MAX+Priority]) while (current_entry != &PriorityListHead[THREAD_PRIORITY_MAX+Priority])
{ {
current = CONTAINING_RECORD(current_entry,ETHREAD,Tcb.Entry); current = CONTAINING_RECORD(
current_entry,
ETHREAD,
Tcb.Entry
);
if (current->Tcb.State == THREAD_STATE_TERMINATED && if ( (current->Tcb.State == THREAD_STATE_TERMINATED)
current != CurrentThread) && (current != CurrentThread)
)
{ {
PsReleaseThread(current); PsReleaseThread(current);
} }
if (current->Tcb.State == THREAD_STATE_RUNNABLE) if (current->Tcb.State == THREAD_STATE_RUNNABLE)
{ {
if (oldest == NULL || oldest_time > current->Tcb.LastTick) if ( (oldest == NULL)
|| (oldest_time > current->Tcb.LastTick)
)
{ {
oldest = current; oldest = current;
oldest_time = current->Tcb.LastTick; oldest_time = current->Tcb.LastTick;
@ -148,10 +162,12 @@ static PETHREAD PsScanThreadList(KPRIORITY Priority)
current_entry = current_entry->Flink; current_entry = current_entry->Flink;
} }
// DPRINT("PsScanThreadList() = %x\n",oldest); // DPRINT("PsScanThreadList() = %x\n",oldest);
return(oldest); return oldest;
} }
VOID PsDispatchThread(VOID)
VOID
PsDispatchThread (VOID)
{ {
KPRIORITY CurrentPriority; KPRIORITY CurrentPriority;
PETHREAD Candidate; PETHREAD Candidate;
@ -163,18 +179,22 @@ VOID PsDispatchThread(VOID)
return; return;
} }
KeAcquireSpinLock(&ThreadListLock, &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); Candidate = PsScanThreadList(CurrentPriority);
if (Candidate == CurrentThread) if (Candidate == CurrentThread)
@ -183,7 +203,10 @@ VOID PsDispatchThread(VOID)
KeQueryTickCount(&TickCount); KeQueryTickCount(&TickCount);
CurrentThread->Tcb.LastTick = TickCount.u.LowPart; CurrentThread->Tcb.LastTick = TickCount.u.LowPart;
CurrentThread->Tcb.State = THREAD_STATE_RUNNING; CurrentThread->Tcb.State = THREAD_STATE_RUNNING;
KeReleaseSpinLock(&ThreadListLock,irql); KeReleaseSpinLock(
& ThreadListLock,
irql
);
return; return;
} }
if (Candidate != NULL) if (Candidate != NULL)
@ -198,7 +221,10 @@ VOID PsDispatchThread(VOID)
CurrentThread = Candidate; CurrentThread = Candidate;
HalTaskSwitch(&CurrentThread->Tcb); HalTaskSwitch(&CurrentThread->Tcb);
KeReleaseSpinLock(&ThreadListLock, irql); KeReleaseSpinLock(
& ThreadListLock,
irql
);
return; return;
} }
} }
@ -206,11 +232,15 @@ VOID PsDispatchThread(VOID)
KeBugCheck(0); KeBugCheck(0);
} }
NTSTATUS PsInitializeThread(HANDLE ProcessHandle,
PETHREAD* ThreadPtr, NTSTATUS
PsInitializeThread (
HANDLE ProcessHandle,
PETHREAD * ThreadPtr,
PHANDLE ThreadHandle, PHANDLE ThreadHandle,
ACCESS_MASK DesiredAccess, ACCESS_MASK DesiredAccess,
POBJECT_ATTRIBUTES ThreadAttributes) 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 */

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

@ -1,7 +1,27 @@
/* $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
* STDCALL : _InterlockedIncrement@4
*/
LONG
FASTCALL
InterlockedIncrement (
PLONG Addend
);
__asm__(
"\n\t.global _InterlockedIncrement@4\n\t"
"_InterlockedIncrement@4:\n\t"
"pushl %ebp\n\t" "pushl %ebp\n\t"
"movl %esp,%ebp\n\t" "movl %esp,%ebp\n\t"
"pushl %ebx\n\t" "pushl %ebx\n\t"
@ -11,21 +31,60 @@ void InterlockedIncrement(void);
"popl %ebx\n\t" "popl %ebx\n\t"
"movl %ebp,%esp\n\t" "movl %ebp,%esp\n\t"
"popl %ebp\n\t" "popl %ebp\n\t"
"ret\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
*/
LONG
FASTCALL
InterlockedDecrement (
PLONG Addend
);
__asm__(
"\n\t.global _InterlockedDecrement@4\n\t"
"_InterlockedDecrement@4:\n\t"
"movl $0xffffffff,%eax\n\t" "movl $0xffffffff,%eax\n\t"
"movl 4(%esp),%ebx\n\t" "movl 4(%esp),%ebx\n\t"
"xaddl %eax,(%ebx)\n\t" "xaddl %eax,(%ebx)\n\t"
"decl %eax\n\t" "decl %eax\n\t"
"ret\n\t"); "ret $4\n\t"
);
void InterlockedExchange(void); /**********************************************************************
__asm__("\n\t.global _InterlockedExchange\n\t" * FASTCALL: @InterlockedExchange@0
"_InterlockedExchange:\n\t" * STDCALL : _InterlockedExchange@8
*/
LONG
FASTCALL
InterlockedExchange (
PLONG Target,
LONG Value
);
__asm__(
"\n\t.global _InterlockedExchange@8\n\t"
"_InterlockedExchange@8:\n\t"
"pushl %ebp\n\t" "pushl %ebp\n\t"
"movl %esp,%ebp\n\t" "movl %esp,%ebp\n\t"
"pushl %eax\n\t" "pushl %eax\n\t"
@ -37,22 +96,115 @@ void InterlockedExchange(void);
"popl %eax\n\t" "popl %eax\n\t"
"movl %ebp,%esp\n\t" "movl %ebp,%esp\n\t"
"popl %ebp\n\t" "popl %ebp\n\t"
"ret\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" * FASTCALL: @InterlockedExchangeAdd@0
* STDCALL : _InterlockedExchangeAdd@8
*/
LONG
FASTCALL
InterlockedExchangeAdd (
PLONG Addend,
LONG Value
);
__asm__(
"\n\t.global _InterlockedExchangeAdd@8\n\t"
"_InterlockedExchangeAdd@8:\n\t"
"movl 8(%esp),%eax\n\t" "movl 8(%esp),%eax\n\t"
"movl 4(%esp),%ebx\n\t" "movl 4(%esp),%ebx\n\t"
"xaddl %eax,(%ebx)\n\t" "xaddl %eax,(%ebx)\n\t"
"ret\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
);
*/
void InterlockedCompareExchange(void);
__asm__("\n\t.global _InterlockedCompareExchange\n\t" /**********************************************************************
"_InterlockedCompareExchange:\n\t" * 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 12(%esp),%eax\n\t"
"movl 8(%esp),%edx\n\t" "movl 8(%esp),%edx\n\t"
"movl 4(%esp),%ebx\n\t" "movl 4(%esp),%ebx\n\t"
"cmpxchg %edx,(%ebx)\n\t" "cmpxchg %edx,(%ebx)\n\t"
"movl %edx,%eax\n\t" "movl %edx,%eax\n\t"
"ret\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 */