SYS_APPS = shell winlogon services
APPS = args hello test cat bench apc shm lpc thread event file gditest \
- pteb consume dump_shared_data vmtest regtest
+ pteb consume dump_shared_data vmtest regtest ptest
# objdir
/*
- * $Id: fat.c,v 1.7 2000/12/07 16:58:42 jean Exp $
+ * $Id: fat.c,v 1.8 2000/12/28 03:38:08 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS ****************************************************************/
-ULONG Fat32GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
+ULONG
+Fat32GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
/*
* FUNCTION: Retrieve the next FAT32 cluster from the FAT table via a physical
* disk read
return(CurrentCluster);
}
-ULONG Fat16GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
+ULONG
+Fat16GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
/*
* FUNCTION: Retrieve the next FAT16 cluster from the FAT table from the
* in-memory FAT
return(CurrentCluster);
}
-ULONG Fat12GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
+ULONG
+Fat12GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
/*
* FUNCTION: Retrieve the next FAT12 cluster from the FAT table from the
* in-memory FAT
unsigned char* CBlock;
ULONG FATOffset;
ULONG Entry;
- CBlock = DeviceExt->FAT;
- FATOffset = (CurrentCluster * 12)/ 8;//first byte containing value
- if ((CurrentCluster % 2) == 0)
+ CBlock = DeviceExt->FAT;
+ FATOffset = (CurrentCluster * 12)/ 8;//first byte containing value
+ if ((CurrentCluster % 2) == 0)
{
- Entry = CBlock[FATOffset];
- Entry |= ((CBlock[FATOffset+1] & 0xf)<<8);
+ Entry = CBlock[FATOffset];
+ Entry |= ((CBlock[FATOffset+1] & 0xf)<<8);
}
- else
+ else
{
- Entry = (CBlock[FATOffset] >> 4);
- Entry |= (CBlock[FATOffset+1] << 4);
+ Entry = (CBlock[FATOffset] >> 4);
+ Entry |= (CBlock[FATOffset+1] << 4);
}
- DPRINT("Entry %x\n",Entry);
- if (Entry >= 0xff8 && Entry <= 0xfff)
+ DPRINT("Entry %x\n",Entry);
+ if (Entry >= 0xff8 && Entry <= 0xfff)
Entry = 0xffffffff;
- DPRINT("Returning %x\n",Entry);
- return(Entry);
+ DPRINT("Returning %x\n",Entry);
+ return(Entry);
}
-ULONG GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
+ULONG
+GetNextCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
/*
* FUNCTION: Retrieve the next cluster depending on the FAT type
*/
ULONG NextCluster;
DPRINT("GetNextCluster(DeviceExt %x, CurrentCluster %x)\n",
- DeviceExt,CurrentCluster);
+ DeviceExt,CurrentCluster);
ExAcquireResourceSharedLite(&DeviceExt->FatResource, TRUE);
if (DeviceExt->FatType == FAT16)
{
- NextCluster = Fat16GetNextCluster(DeviceExt, CurrentCluster);
+ NextCluster = Fat16GetNextCluster(DeviceExt, CurrentCluster);
}
else if (DeviceExt->FatType == FAT32)
{
- NextCluster = Fat32GetNextCluster(DeviceExt, CurrentCluster);
+ NextCluster = Fat32GetNextCluster(DeviceExt, CurrentCluster);
}
else
{
- NextCluster = Fat12GetNextCluster(DeviceExt, CurrentCluster);
+ NextCluster = Fat12GetNextCluster(DeviceExt, CurrentCluster);
}
ExReleaseResourceLite(&DeviceExt->FatResource);
return(NextCluster);
}
-ULONG FAT16FindAvailableCluster(PDEVICE_EXTENSION DeviceExt)
+ULONG
+FAT16FindAvailableCluster(PDEVICE_EXTENSION DeviceExt)
/*
* FUNCTION: Finds the first available cluster in a FAT16 table
*/
return 0;
}
-ULONG FAT12FindAvailableCluster(PDEVICE_EXTENSION DeviceExt)
+ULONG
+FAT12FindAvailableCluster(PDEVICE_EXTENSION DeviceExt)
/*
* FUNCTION: Finds the first available cluster in a FAT12 table
*/
return 0;
}
-ULONG FAT32FindAvailableCluster(PDEVICE_EXTENSION DeviceExt)
+ULONG
+FAT32FindAvailableCluster(PDEVICE_EXTENSION DeviceExt)
/*
* FUNCTION: Finds the first available cluster in a FAT32 table
*/
return 0;
}
-ULONG FAT12CountAvailableClusters(PDEVICE_EXTENSION DeviceExt)
+ULONG
+FAT12CountAvailableClusters(PDEVICE_EXTENSION DeviceExt)
/*
* FUNCTION: Counts free cluster in a FAT12 table
*/
return ulCount;
}
-ULONG FAT16CountAvailableClusters(PDEVICE_EXTENSION DeviceExt)
+ULONG
+FAT16CountAvailableClusters(PDEVICE_EXTENSION DeviceExt)
/*
* FUNCTION: Counts free clusters in a FAT16 table
*/
return ulCount;
}
-ULONG FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt)
+ULONG
+FAT32CountAvailableClusters(PDEVICE_EXTENSION DeviceExt)
/*
* FUNCTION: Counts free clusters in a FAT32 table
*/
return ulCount;
}
-void FAT12WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
- ULONG NewValue)
+VOID
+FAT12WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
+ ULONG NewValue)
/*
* FUNCTION: Writes a cluster to the FAT12 physical and in-memory tables
*/
}
}
-void FAT16WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
- ULONG NewValue)
+VOID
+FAT16WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
+ ULONG NewValue)
/*
* FUNCTION: Writes a cluster to the FAT16 physical and in-memory tables
*/
}
}
-void FAT32WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
- ULONG NewValue)
+VOID
+FAT32WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
+ ULONG NewValue)
/*
* FUNCTION: Writes a cluster to the FAT32 physical tables
*/
ExFreePool(Block);
}
-void WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
- ULONG NewValue)
+VOID
+WriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG ClusterToWrite,
+ ULONG NewValue)
/*
* FUNCTION: Write a changed FAT entry
*/
}
}
-ULONG GetNextWriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
+ULONG
+GetNextWriteCluster(PDEVICE_EXTENSION DeviceExt, ULONG CurrentCluster)
/*
* FUNCTION: Determines the next cluster to be written
*/
}
}
-ULONG ClusterToSector(PDEVICE_EXTENSION DeviceExt,
- unsigned long Cluster)
+ULONG
+ClusterToSector(PDEVICE_EXTENSION DeviceExt,
+ unsigned long Cluster)
/*
* FUNCTION: Converts the cluster number to a sector number for this physical
* device
return DeviceExt->dataStart+((Cluster-2)*DeviceExt->Boot->SectorsPerCluster);
}
-void VFATLoadCluster(PDEVICE_EXTENSION DeviceExt, PVOID Buffer, ULONG Cluster)
+VOID
+VFATLoadCluster(PDEVICE_EXTENSION DeviceExt, PVOID Buffer, ULONG Cluster)
/*
* FUNCTION: Load a cluster from the physical device
*/
DPRINT("Finished VFATReadSectors\n");
}
-void VFATWriteCluster(PDEVICE_EXTENSION DeviceExt, PVOID Buffer, ULONG Cluster)
+VOID
+VFATWriteCluster(PDEVICE_EXTENSION DeviceExt, PVOID Buffer, ULONG Cluster)
/*
* FUNCTION: Write a cluster to the physical device
*/
cp subsys/smss/smss.exe $1/reactos/system32
cp subsys/csrss/csrss.exe $1/reactos/system32
cp subsys/win32k/win32k.sys $1/reactos/system32/drivers
-#cp apps/system/winlogon/winlogon.exe $1/reactos/system32/
+cp apps/system/winlogon/winlogon.exe $1/reactos/system32/
cp apps/apc/apc.exe $1/reactos/bin
cp apps/shm/shmsrv.exe $1/reactos/bin
cp apps/shm/shmclt.exe $1/reactos/bin
cp apps/vmtest/vmtest.exe $1/reactos/bin
cp apps/uitest/uitest.exe $1/reactos/bin/
cp apps/gditest/gditest.exe $1/reactos/bin/
+cp apps/ptest/ptest.exe $1/reactos/bin
+++ /dev/null
-%macro DECLARE_EXTERNAL_SYMBOL 1
-%ifdef coff
-extern _%1
-%elifdef win32
-extern _%1
-%elifdef elf
-extern %1
-_%1:
- call %1
- ret
-%endif
-%endmacro
-
-%macro DECLARE_GLOBAL_SYMBOL 1
-%ifdef coff
-global _%1
-_%1:
-%elifdef win32
-global _%1
-_%1:
-%elifdef elf
-global %1
-%1:
-%endif
-%endmacro
#ifndef __INCLUDE_INTERNAL_CC_H
#define __INCLUDE_INTERNAL_CCS_H
-/* $Id: cc.h,v 1.1 2000/06/29 23:35:36 dwelch Exp $ */
-VOID
-STDCALL
-CcMdlReadCompleteDev (
- IN PMDL MdlChain,
- IN PDEVICE_OBJECT DeviceObject
- );
+/* $Id: cc.h,v 1.2 2000/12/28 03:38:07 dwelch Exp $ */
+VOID STDCALL
+CcMdlReadCompleteDev (IN PMDL MdlChain,
+ IN PDEVICE_OBJECT DeviceObject);
#endif
#include <napi/dbg.h>
#include <internal/port.h>
-NTSTATUS STDCALL LpcSendDebugMessagePort(PEPORT Port,
- PLPC_DBG_MESSAGE Message);
+NTSTATUS STDCALL
+LpcSendDebugMessagePort(PEPORT Port,
+ PLPC_DBG_MESSAGE Message);
#endif /* __INCLUDE_INTERNAL_DBG_H */
* internal executive prototypes
*/
-#ifndef _INCLUDE_INTERNAL_EXECUTIVE_H
-#define _INCLUDE_INTERNAL_EXECUTIVE_H
+#ifndef __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H
+#define __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H
#include <ddk/ntddk.h>
#include <ntos/time.h>
/* INITIALIZATION FUNCTIONS *************************************************/
-VOID ExInit (VOID);
-VOID ExInitTimeZoneInfo (VOID);
-VOID ExInitializeWorkerThreads(VOID);
+VOID
+ExInit (VOID);
+VOID
+ExInitTimeZoneInfo (VOID);
+VOID
+ExInitializeWorkerThreads(VOID);
-#endif /* _INCLUDE_INTERNAL_EXECUTIVE_H */
+#endif /* __NTOSKRNL_INCLUDE_INTERNAL_EXECUTIVE_H */
* FILE: ntoskrnl/include/internal/i386/segment.h
* PURPOSE: Segment selector definitions
* PROGRAMMER: David Welch (welch@cwcom.net)
- * UPDATE HISTORY:
- * Created ??/??/??
*/
/* INCLUDES *****************************************************************/
-#ifndef __INCLUDE_INTERNAL_I386_SEGMENT_H
-#define __INCLUDE_INTERNAL_i386_SEGMENT_H
+#ifndef __NTOSKRNL_INCLUDE_INTERNAL_I386_SEGMENT_H
+#define __NTOSKRNL_INCLUDE_INTERNAL_i386_SEGMENT_H
#define NULL_SELECTOR (0x0)
#define KERNEL_CS (0x8)
#define KERNEL_DS (0x10)
#define USER_CS (0x18 + 0x3)
#define USER_DS (0x20 + 0x3)
-/*
- * FIXME: We actually have one TSS per thread
- */
+/* Task State Segment */
#define TSS_SELECTOR (0x28)
+/* Processor Control Region */
#define PCR_SELECTOR (0x30)
+/* Thread Environment Block */
#define TEB_SELECTOR (0x38 + 0x3)
-#define RESERVED1_SELECTOR (0x40)
+#define RESERVED_SELECTOR (0x40)
+/* Local Descriptor Table */
#define LDT_SELECTOR (0x48)
-#endif /* __INCLUDE_INTERNAL_I386_SEGMENT_H */
+#endif /* __NTOSKRNL_INCLUDE_INTERNAL_I386_SEGMENT_H */
-/* $Id: io.h,v 1.6 2000/10/05 19:12:55 ekohl Exp $
+/*
+ * ReactOS kernel
+ * Copyright (C) 2000 David Welch <welch@cwcom.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+/* $Id: io.h,v 1.7 2000/12/28 03:38:07 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* 28/05/97: Created
*/
-#ifndef __INCLUDE_INTERNAL_IO_H
-#define __INCLUDE_INTERNAL_IO_H
+#ifndef __NTOSKRNL_INCLUDE_INTERNAL_IO_H
+#define __NTOSKRNL_INCLUDE_INTERNAL_IO_H
#include <ddk/ntddk.h>
#include <internal/ob.h>
* entry = pointer to the driver initialization routine
* RETURNS: Success or failure
*/
-NTSTATUS IoInitializeDriver(PDRIVER_INITIALIZE DriverEntry);
-
-
+NTSTATUS
+IoInitializeDriver(PDRIVER_INITIALIZE DriverEntry);
-VOID IoInitCancelHandling(VOID);
-VOID IoInitSymbolicLinkImplementation(VOID);
-VOID IoInitFileSystemImplementation(VOID);
-VOID IoInitVpbImplementation (VOID);
+VOID
+IoInitCancelHandling(VOID);
+VOID
+IoInitSymbolicLinkImplementation(VOID);
+VOID
+IoInitFileSystemImplementation(VOID);
+VOID
+IoInitVpbImplementation (VOID);
NTSTATUS IoTryToMountStorageDevice(PDEVICE_OBJECT DeviceObject);
POBJECT IoOpenSymlink(POBJECT SymbolicLink);
-/* $Id: kd.h,v 1.1 2000/06/29 23:35:36 dwelch Exp $
+/* $Id: kd.h,v 1.2 2000/12/28 03:38:07 dwelch Exp $
*
* kernel debugger prototypes
*/
#ifndef __INCLUDE_INTERNAL_KERNEL_DEBUGGER_H
#define __INCLUDE_INTERNAL_KERNEL_DEBUGGER_H
-
-ULONG KdpPrintString (PANSI_STRING String);
-
+ULONG
+KdpPrintString (PANSI_STRING String);
#endif /* __INCLUDE_INTERNAL_KERNEL_DEBUGGER_H */
/*
- * Various useful prototypes
+ * ReactOS kernel
+ * Copyright (C) 2000 David Welch <welch@cwcom.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-#ifndef __INCLUDE_INTERNAL_KERNEL_H
-#define __INCLUDE_INTERNAL_KERNEL_H
+#ifndef __NTOSKRNL_INCLUDE_INTERNAL_KERNEL_H
+#define __NTOSKRNL_INCLUDE_INTERNAL_KERNEL_H
/* INCLUDES *****************************************************************/
#define SPE_DIRTY (0x8)
#define SPE_IN_PAGEFILE (0x10)
+#define SO_PHYSICAL_MEMORY (0x1)
+
typedef struct
{
ULONG Pages[NR_SECTION_PAGE_ENTRIES];
typedef struct
{
- CSHORT Type;
- CSHORT Size;
- LARGE_INTEGER MaximumSize;
- ULONG SectionPageProtection;
- ULONG AllocateAttributes;
- PFILE_OBJECT FileObject;
- LIST_ENTRY ViewListHead;
- KSPIN_LOCK ViewListLock;
- KMUTEX Lock;
- SECTION_PAGE_DIRECTORY PageDirectory;
+ CSHORT Type;
+ CSHORT Size;
+ LARGE_INTEGER MaximumSize;
+ ULONG SectionPageProtection;
+ ULONG AllocateAttributes;
+ PFILE_OBJECT FileObject;
+ LIST_ENTRY ViewListHead;
+ KSPIN_LOCK ViewListLock;
+ KMUTEX Lock;
+ SECTION_PAGE_DIRECTORY PageDirectory;
+ ULONG Flags;
} SECTION_OBJECT, *PSECTION_OBJECT;
typedef struct
NTSTATUS MmSafeCopyFromUser(PVOID Dest, PVOID Src, ULONG Count);
NTSTATUS MmSafeCopyToUser(PVOID Dest, PVOID Src, ULONG Count);
+NTSTATUS
+MmCreatePhysicalMemorySection(VOID);
#define MM_PHYSICAL_PAGE_MPW_PENDING (0x8)
/* GLOBALS *******************************************************************/
-#define NR_TASKS 128
-
-USHORT KiGdt[(8 + NR_TASKS) * 4] =
+USHORT KiGdt[10 * 4] =
{
0x0, 0x0, 0x0, 0x0, /* Null */
0xffff, 0x0, 0x9a00, 0xcf, /* Kernel CS */
/* FUNCTIONS *****************************************************************/
-VOID KeSetBaseGdtSelector(ULONG Entry,
- PVOID Base)
+VOID
+KeSetBaseGdtSelector(ULONG Entry,
+ PVOID Base)
{
KIRQL oldIrql;
KeReleaseSpinLock(&GdtLock, oldIrql);
}
-VOID KeDumpGdtSelector(ULONG Entry)
+VOID
+KeDumpGdtSelector(ULONG Entry)
{
USHORT a, b, c, d;
ULONG RawLimit;
#endif
#if 0
-ULONG KeAllocateGdtSelector(ULONG Desc[2])
+ULONG
+KeAllocateGdtSelector(ULONG Desc[2])
/*
* FUNCTION: Allocate a gdt selector
* ARGUMENTS:
#define KERNEL_BASE (0xc0000000)
-#define NR_TASKS (128)
-
#define MULTIBOOT_HEADER_MAGIC (0x1BADB002)
#define MULTIBOOT_HEADER_FLAGS (0x00010003)
.long 0x3f8007,0x3f9007,0x3fa007,0x3fb007,0x3fc007,0x3fd007,0x3fe007,0x3ff007
_gdt_descr:
- .word ((8+NR_TASKS)*8)-1
+ .word (10*8)-1
.long _KiGdt
_idt_descr:
-/* $Id: queue.c,v 1.2 2000/10/22 16:36:51 ekohl Exp $
+/* $Id: queue.c,v 1.3 2000/12/28 03:38:07 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include <internal/debug.h>
-VOID
-STDCALL
-EiEnqueueMessagePort (
- IN OUT PEPORT Port,
- IN PQUEUEDMESSAGE Message
- )
+VOID STDCALL
+EiEnqueueMessagePort (IN OUT PEPORT Port,
+ IN PQUEUEDMESSAGE Message)
{
- InsertTailList (
- & Port->QueueListHead,
- & Message->QueueListEntry
- );
- Port->QueueLength++;
+ InsertTailList (&Port->QueueListHead,
+ &Message->QueueListEntry);
+ Port->QueueLength++;
}
-PQUEUEDMESSAGE
-STDCALL
-EiDequeueMessagePort (
- IN OUT PEPORT Port
- )
+PQUEUEDMESSAGE STDCALL
+EiDequeueMessagePort (IN OUT PEPORT Port)
{
- PQUEUEDMESSAGE Message;
- PLIST_ENTRY entry;
+ PQUEUEDMESSAGE Message;
+ PLIST_ENTRY entry;
+
+ if (IsListEmpty(&Port->QueueListHead))
+ {
+ return(NULL);
+ }
+ entry = RemoveHeadList (&Port->QueueListHead);
+ Message = CONTAINING_RECORD (entry, QUEUEDMESSAGE, QueueListEntry);
+ Port->QueueLength--;
- entry = RemoveHeadList (& Port->QueueListHead);
- Message = CONTAINING_RECORD (entry, QUEUEDMESSAGE, QueueListEntry);
- Port->QueueLength--;
-
- return (Message);
+ return (Message);
}
-VOID
-STDCALL
-EiEnqueueConnectMessagePort (
- IN OUT PEPORT Port,
- IN PQUEUEDMESSAGE Message
- )
+VOID STDCALL
+EiEnqueueConnectMessagePort (IN OUT PEPORT Port,
+ IN PQUEUEDMESSAGE Message)
{
- InsertTailList (
- & Port->ConnectQueueListHead,
- & Message->QueueListEntry
- );
- Port->ConnectQueueLength++;
+ InsertTailList (&Port->ConnectQueueListHead,
+ &Message->QueueListEntry);
+ Port->ConnectQueueLength++;
}
-PQUEUEDMESSAGE
-STDCALL
-EiDequeueConnectMessagePort (
- IN OUT PEPORT Port
- )
+PQUEUEDMESSAGE STDCALL
+EiDequeueConnectMessagePort (IN OUT PEPORT Port)
{
- PQUEUEDMESSAGE Message;
- PLIST_ENTRY entry;
-
- entry = RemoveHeadList (& Port->ConnectQueueListHead);
- Message = CONTAINING_RECORD (entry, QUEUEDMESSAGE, QueueListEntry);
- Port->ConnectQueueLength--;
-
- return (Message);
+ PQUEUEDMESSAGE Message;
+ PLIST_ENTRY entry;
+
+ if (IsListEmpty(&Port->ConnectQueueListHead))
+ {
+ return(NULL);
+ }
+ entry = RemoveHeadList (&Port->ConnectQueueListHead);
+ Message = CONTAINING_RECORD (entry, QUEUEDMESSAGE, QueueListEntry);
+ Port->ConnectQueueLength--;
+
+ return (Message);
}
-/* $Id: reply.c,v 1.2 2000/10/22 16:36:51 ekohl Exp $
+/* $Id: reply.c,v 1.3 2000/12/28 03:38:07 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* Created 22/05/98
*/
-/* INCLUDES *****************************************************************/
+/* INCLUDES ******************************************************************/
#include <ddk/ntddk.h>
#include <internal/ob.h>
#define NDEBUG
#include <internal/debug.h>
-
+/* FUNCTIONS *****************************************************************/
/**********************************************************************
* NAME
* REVISIONS
*
*/
-NTSTATUS
-STDCALL
-EiReplyOrRequestPort (
- IN PEPORT Port,
- IN PLPC_MESSAGE LpcReply,
- IN ULONG MessageType,
- IN PEPORT Sender
- )
+NTSTATUS STDCALL
+EiReplyOrRequestPort (IN PEPORT Port,
+ IN PLPC_MESSAGE LpcReply,
+ IN ULONG MessageType,
+ IN PEPORT Sender)
{
KIRQL oldIrql;
PQUEUEDMESSAGE MessageReply;
* REVISIONS
*
*/
-NTSTATUS
-STDCALL
-NtReplyPort (
- IN HANDLE PortHandle,
- IN PLPC_MESSAGE LpcReply
- )
+NTSTATUS STDCALL
+NtReplyPort (IN HANDLE PortHandle,
+ IN PLPC_MESSAGE LpcReply)
{
NTSTATUS Status;
PEPORT Port;
* REVISIONS
*
*/
-NTSTATUS
-STDCALL
-NtReplyWaitReceivePort (
- HANDLE PortHandle,
- PULONG PortId,
- PLPC_MESSAGE LpcReply,
- PLPC_MESSAGE LpcMessage
- )
+NTSTATUS STDCALL
+NtReplyWaitReceivePort (HANDLE PortHandle,
+ PULONG PortId,
+ PLPC_MESSAGE LpcReply,
+ PLPC_MESSAGE LpcMessage)
{
NTSTATUS Status;
PEPORT Port;
/*
* Want for a message to be received
*/
- DPRINT("Entering wait for message\n");
- KeWaitForSingleObject(&Port->Event,
- UserRequest,
- UserMode,
- FALSE,
- NULL);
- DPRINT("Woke from wait for message\n");
+ do
+ {
+ Status = KeWaitForSingleObject(&Port->Event,
+ UserRequest,
+ UserMode,
+ FALSE,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+
+ /*
+ * Dequeue the message
+ */
+ KeAcquireSpinLock(&Port->Lock, &oldIrql);
+ Request = EiDequeueMessagePort(Port);
+
+ /*
+ * There is a race between the event being set and the port being
+ * taken in which another thread may dequeue the same request so
+ * we may need to loop.
+ */
+ if (Request == NULL)
+ {
+ KeReleaseSpinLock(&Port->Lock, oldIrql);
+ }
+ } while(Request == NULL);
- /*
- * Dequeue the message
- */
- KeAcquireSpinLock(&Port->Lock, &oldIrql);
- Request = EiDequeueMessagePort(Port);
memcpy(LpcMessage, &Request->Message, Request->Message.MessageSize);
if (Request->Message.MessageType == LPC_CONNECTION_REQUEST)
{
- EiEnqueueConnectMessagePort(Port, Request);
- KeReleaseSpinLock(&Port->Lock, oldIrql);
+ EiEnqueueConnectMessagePort(Port, Request);
+ KeReleaseSpinLock(&Port->Lock, oldIrql);
}
else
{
- KeReleaseSpinLock(&Port->Lock, oldIrql);
- ExFreePool(Request);
+ KeReleaseSpinLock(&Port->Lock, oldIrql);
+ ExFreePool(Request);
}
/*
- *
+ * Dereference the port
*/
ObDereferenceObject(Port);
return(STATUS_SUCCESS);
* REVISIONS
*
*/
-NTSTATUS
-STDCALL
-NtReplyWaitReplyPort (
- HANDLE PortHandle,
- PLPC_MESSAGE ReplyMessage
- )
+NTSTATUS STDCALL
+NtReplyWaitReplyPort (HANDLE PortHandle,
+ PLPC_MESSAGE ReplyMessage)
{
- UNIMPLEMENTED;
+ UNIMPLEMENTED;
}
-/* $Id: mminit.c,v 1.11 2000/12/20 18:44:20 jean Exp $
+/* $Id: mminit.c,v 1.12 2000/12/28 03:38:07 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top directory
* PROJECT: ReactOS kernel
VOID MmInit3(VOID)
{
MmInitPagerThread();
+ MmCreatePhysicalMemorySection();
+
/* FIXME: Read parameters from memory */
}
-/* $Id: section.c,v 1.39 2000/10/22 16:36:52 ekohl Exp $
+/* $Id: section.c,v 1.40 2000/12/28 03:38:07 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
NULL);
}
-VOID MmUnlockSection(PSECTION_OBJECT Section)
+VOID
+MmUnlockSection(PSECTION_OBJECT Section)
{
KeReleaseMutex(&Section->Lock, FALSE);
}
-VOID MmSetPageEntrySection(PSECTION_OBJECT Section,
- ULONG Offset,
- ULONG Entry)
+VOID
+MmSetPageEntrySection(PSECTION_OBJECT Section,
+ ULONG Offset,
+ ULONG Entry)
{
PSECTION_PAGE_TABLE Table;
ULONG DirectoryOffset;
Table->Pages[TableOffset] = Entry;
}
-ULONG MmGetPageEntrySection(PSECTION_OBJECT Section,
- ULONG Offset)
+ULONG
+MmGetPageEntrySection(PSECTION_OBJECT Section,
+ ULONG Offset)
{
PSECTION_PAGE_TABLE Table;
ULONG Entry;
return(Entry);
}
-NTSTATUS MmUnalignedLoadPageForSection(PMADDRESS_SPACE AddressSpace,
- MEMORY_AREA* MemoryArea,
- PVOID Address)
+NTSTATUS
+MmUnalignedLoadPageForSection(PMADDRESS_SPACE AddressSpace,
+ MEMORY_AREA* MemoryArea,
+ PVOID Address)
{
LARGE_INTEGER Offset;
IO_STATUS_BLOCK IoStatus;
MmLockSection(Section);
+ /*
+ * Don't do an unaligned mapping of physical memory
+ */
+ if (Section->Flags & SO_PHYSICAL_MEMORY)
+ {
+ MmUnlockSection(Section);
+ return(STATUS_UNSUCCESSFUL);
+ }
+
Page = MmAllocPageMaybeSwap(0);
Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
MmBuildMdlFromPages(Mdl, (PULONG)&Page);
}
-NTSTATUS MmWaitForPendingOperationSection(PMADDRESS_SPACE AddressSpace,
- PMEMORY_AREA MemoryArea,
- PVOID Address,
- PSECTION_OBJECT Section,
- LARGE_INTEGER Offset,
- ULONG Entry)
+NTSTATUS
+MmWaitForPendingOperationSection(PMADDRESS_SPACE AddressSpace,
+ PMEMORY_AREA MemoryArea,
+ PVOID Address,
+ PSECTION_OBJECT Section,
+ LARGE_INTEGER Offset,
+ ULONG Entry)
{
PVOID Page;
NTSTATUS Status;
return(STATUS_SUCCESS);
}
-NTSTATUS MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
- MEMORY_AREA* MemoryArea,
- PVOID Address)
+NTSTATUS
+MmNotPresentFaultSectionView(PMADDRESS_SPACE AddressSpace,
+ MEMORY_AREA* MemoryArea,
+ PVOID Address)
{
LARGE_INTEGER Offset;
IO_STATUS_BLOCK IoStatus;
Address));
}
- DPRINT("MemoryArea->BaseAddress %x\n", MemoryArea->BaseAddress);
- DPRINT("MemoryArea->Data.SectionData.ViewOffset %x\n",
- MemoryArea->Data.SectionData.ViewOffset);
- DPRINT("Got offset %x\n", Offset.QuadPart);
-
/*
* Lock the section
*/
Section = MemoryArea->Data.SectionData.Section;
MmLockSection(Section);
+ if (Section->Flags & SO_PHYSICAL_MEMORY)
+ {
+ /*
+ * Just map the desired physical page
+ */
+ Status = MmCreateVirtualMapping(NULL,
+ Address,
+ MemoryArea->Attributes,
+ Offset.QuadPart);
+ MmUnlockSection(Section);
+ return(STATUS_SUCCESS);
+ }
+
/*
* Get the entry corresponding to the offset within the section
*/
}
}
-ULONG MmPageOutSectionView(PMADDRESS_SPACE AddressSpace,
- MEMORY_AREA* MemoryArea,
- PVOID Address,
- PBOOLEAN Ul)
+ULONG
+MmPageOutSectionView(PMADDRESS_SPACE AddressSpace,
+ MEMORY_AREA* MemoryArea,
+ PVOID Address,
+ PBOOLEAN Ul)
{
(*Ul) = FALSE;
return(0);
}
-VOID MmpDeleteSection(PVOID ObjectBody)
+VOID
+MmpDeleteSection(PVOID ObjectBody)
{
DPRINT("MmpDeleteSection(ObjectBody %x)\n", ObjectBody);
}
-VOID MmpCloseSection(PVOID ObjectBody,
- ULONG HandleCount)
+VOID
+MmpCloseSection(PVOID ObjectBody,
+ ULONG HandleCount)
{
DPRINT("MmpCloseSection(OB %x, HC %d) RC %d\n",
ObjectBody, HandleCount, ObGetReferenceCount(ObjectBody));
return(STATUS_SUCCESS);
}
-NTSTATUS MmInitSectionImplementation(VOID)
+NTSTATUS
+MmCreatePhysicalMemorySection(VOID)
{
- MmSectionObjectType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
-
- RtlInitUnicodeString(&MmSectionObjectType->TypeName, L"Section");
-
- MmSectionObjectType->TotalObjects = 0;
- MmSectionObjectType->TotalHandles = 0;
- MmSectionObjectType->MaxObjects = ULONG_MAX;
- MmSectionObjectType->MaxHandles = ULONG_MAX;
- MmSectionObjectType->PagedPoolCharge = 0;
- MmSectionObjectType->NonpagedPoolCharge = sizeof(SECTION_OBJECT);
- MmSectionObjectType->Dump = NULL;
- MmSectionObjectType->Open = NULL;
- MmSectionObjectType->Close = MmpCloseSection;
- MmSectionObjectType->Delete = MmpDeleteSection;
- MmSectionObjectType->Parse = NULL;
- MmSectionObjectType->Security = NULL;
- MmSectionObjectType->QueryName = NULL;
- MmSectionObjectType->OkayToClose = NULL;
- MmSectionObjectType->Create = MmpCreateSection;
-
- return(STATUS_SUCCESS);
+ HANDLE PhysSectionH;
+ PSECTION_OBJECT PhysSection;
+ NTSTATUS Status;
+ OBJECT_ATTRIBUTES Obj;
+ UNICODE_STRING Name;
+ LARGE_INTEGER SectionSize;
+
+ /*
+ * Create the section mapping physical memory
+ */
+ SectionSize.QuadPart = 0xFFFFFFFF;
+ RtlInitUnicodeString(&Name, L"\\Device\\PhysicalMemory");
+ InitializeObjectAttributes(&Obj,
+ &Name,
+ 0,
+ NULL,
+ NULL);
+ Status = NtCreateSection(&PhysSectionH,
+ SECTION_ALL_ACCESS,
+ &Obj,
+ &SectionSize,
+ PAGE_EXECUTE_READWRITE,
+ 0,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ DbgPrint("Failed to create PhysicalMemory section\n");
+ KeBugCheck(0);
+ }
+ Status = ObReferenceObjectByHandle(PhysSectionH,
+ SECTION_ALL_ACCESS,
+ NULL,
+ KernelMode,
+ (PVOID*)&PhysSection,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ DbgPrint("Failed to reference PhysicalMemory section\n");
+ KeBugCheck(0);
+ }
+ PhysSection->Flags = PhysSection->Flags | SO_PHYSICAL_MEMORY;
+ ObDereferenceObject((PVOID)PhysSection);
+
+ return(STATUS_SUCCESS);
+}
+
+NTSTATUS
+MmInitSectionImplementation(VOID)
+{
+ MmSectionObjectType = ExAllocatePool(NonPagedPool,sizeof(OBJECT_TYPE));
+
+ RtlInitUnicodeString(&MmSectionObjectType->TypeName, L"Section");
+
+ MmSectionObjectType->TotalObjects = 0;
+ MmSectionObjectType->TotalHandles = 0;
+ MmSectionObjectType->MaxObjects = ULONG_MAX;
+ MmSectionObjectType->MaxHandles = ULONG_MAX;
+ MmSectionObjectType->PagedPoolCharge = 0;
+ MmSectionObjectType->NonpagedPoolCharge = sizeof(SECTION_OBJECT);
+ MmSectionObjectType->Dump = NULL;
+ MmSectionObjectType->Open = NULL;
+ MmSectionObjectType->Close = MmpCloseSection;
+ MmSectionObjectType->Delete = MmpDeleteSection;
+ MmSectionObjectType->Parse = NULL;
+ MmSectionObjectType->Security = NULL;
+ MmSectionObjectType->QueryName = NULL;
+ MmSectionObjectType->OkayToClose = NULL;
+ MmSectionObjectType->Create = MmpCreateSection;
+
+ return(STATUS_SUCCESS);
}
/* FIXME: NtCS should call MmCS */
-NTSTATUS STDCALL NtCreateSection (OUT PHANDLE SectionHandle,
- IN ACCESS_MASK DesiredAccess,
- IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
- IN PLARGE_INTEGER MaximumSize OPTIONAL,
- IN ULONG SectionPageProtection OPTIONAL,
- IN ULONG AllocationAttributes,
- IN HANDLE FileHandle OPTIONAL)
+NTSTATUS STDCALL
+NtCreateSection (OUT PHANDLE SectionHandle,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN PLARGE_INTEGER MaximumSize OPTIONAL,
+ IN ULONG SectionPageProtection OPTIONAL,
+ IN ULONG AllocationAttributes,
+ IN HANDLE FileHandle OPTIONAL)
/*
* FUNCTION: Creates a section object.
* ARGUMENTS:
KeInitializeSpinLock(&Section->ViewListLock);
KeInitializeMutex(&Section->Lock, 0);
memset(&Section->PageDirectory, 0, sizeof(Section->PageDirectory));
-
- if (FileHandle != (HANDLE)0xffffffff)
+ Section->Flags = 0;
+
+ if (FileHandle != (HANDLE)0)
{
Status = ObReferenceObjectByHandle(FileHandle,
FILE_READ_DATA,
* REVISIONS
*
*/
-NTSTATUS STDCALL NtOpenSection(PHANDLE SectionHandle,
- ACCESS_MASK DesiredAccess,
- POBJECT_ATTRIBUTES ObjectAttributes)
+NTSTATUS STDCALL
+NtOpenSection(PHANDLE SectionHandle,
+ ACCESS_MASK DesiredAccess,
+ POBJECT_ATTRIBUTES ObjectAttributes)
{
PVOID Object;
NTSTATUS Status;
* RETURN VALUE
* Status.
*/
-NTSTATUS STDCALL NtMapViewOfSection(HANDLE SectionHandle,
- HANDLE ProcessHandle,
- PVOID* BaseAddress,
- ULONG ZeroBits,
- ULONG CommitSize,
- PLARGE_INTEGER SectionOffset,
- PULONG ViewSize,
- SECTION_INHERIT InheritDisposition,
- ULONG AllocationType,
- ULONG Protect)
+NTSTATUS STDCALL
+NtMapViewOfSection(HANDLE SectionHandle,
+ HANDLE ProcessHandle,
+ PVOID* BaseAddress,
+ ULONG ZeroBits,
+ ULONG CommitSize,
+ PLARGE_INTEGER SectionOffset,
+ PULONG ViewSize,
+ SECTION_INHERIT InheritDisposition,
+ ULONG AllocationType,
+ ULONG Protect)
{
PSECTION_OBJECT Section;
PEPROCESS Process;
if (!(NT_SUCCESS(Status)))
{
DPRINT("ObReference failed rc=%x\n",Status);
- return Status;
+ return(Status);
}
DPRINT("Section %x\n",Section);
Status);
MmUnlockSection(Section);
ObDereferenceObject(Section);
- return Status;
+ return(Status);
}
AddressSpace = &Process->AddressSpace;
}
if (((*ViewSize)+ViewOffset) > Section->MaximumSize.u.LowPart)
- {
+ {
(*ViewSize) = Section->MaximumSize.u.LowPart - ViewOffset;
- }
+ }
DPRINT("Creating memory area\n");
MmLockAddressSpace(AddressSpace);
MmUnlockSection(Section);
ObDereferenceObject(Section);
- return Status;
+ return(Status);
}
KeAcquireSpinLock(&Section->ViewListLock, &oldIrql);
return(STATUS_SUCCESS);
}
-NTSTATUS STDCALL MmUnmapViewOfSection(PEPROCESS Process,
- PMEMORY_AREA MemoryArea)
+NTSTATUS STDCALL
+MmUnmapViewOfSection(PEPROCESS Process,
+ PMEMORY_AREA MemoryArea)
{
PSECTION_OBJECT Section;
KIRQL oldIrql;
* REVISIONS
*
*/
-NTSTATUS STDCALL NtUnmapViewOfSection (HANDLE ProcessHandle,
- PVOID BaseAddress)
+NTSTATUS STDCALL
+NtUnmapViewOfSection (HANDLE ProcessHandle,
+ PVOID BaseAddress)
{
PEPROCESS Process;
NTSTATUS Status;
MemoryArea);
DPRINT("MmFreeMemoryArea()\n");
- Status = MmFreeMemoryArea(&Process->AddressSpace,
- BaseAddress,
- 0,
- TRUE);
+ if (MemoryArea->Data.SectionData.Section->Flags & SO_PHYSICAL_MEMORY)
+ {
+ Status = MmFreeMemoryArea(&Process->AddressSpace,
+ BaseAddress,
+ 0,
+ FALSE);
+ }
+ else
+ {
+ Status = MmFreeMemoryArea(&Process->AddressSpace,
+ BaseAddress,
+ 0,
+ TRUE);
+ }
MmUnlockAddressSpace(AddressSpace);
ObDereferenceObject(Process);
}
-NTSTATUS STDCALL NtQuerySection (IN HANDLE SectionHandle,
- IN CINT SectionInformationClass,
- OUT PVOID SectionInformation,
- IN ULONG Length,
- OUT PULONG ResultLength)
+NTSTATUS STDCALL
+NtQuerySection (IN HANDLE SectionHandle,
+ IN CINT SectionInformationClass,
+ OUT PVOID SectionInformation,
+ IN ULONG Length,
+ OUT PULONG ResultLength)
/*
* FUNCTION: Queries the information of a section object.
* ARGUMENTS:
}
-NTSTATUS STDCALL NtExtendSection(IN HANDLE SectionHandle,
- IN ULONG NewMaximumSize)
+NTSTATUS STDCALL
+NtExtendSection(IN HANDLE SectionHandle,
+ IN ULONG NewMaximumSize)
{
UNIMPLEMENTED;
}
* REVISIONS
*
*/
-PVOID STDCALL MmAllocateSection (IN ULONG Length)
+PVOID STDCALL
+MmAllocateSection (IN ULONG Length)
{
PVOID Result;
MEMORY_AREA* marea;
* Status.
*
*/
-PVOID
-STDCALL
-MmMapViewOfSection (
- DWORD Unknown0,
- DWORD Unknown1,
- DWORD Unknown2,
- DWORD Unknown3,
- DWORD Unknown4,
- DWORD Unknown5,
- DWORD Unknown6,
- DWORD Unknown7,
- DWORD Unknown8,
- DWORD Unknown9
- )
+PVOID STDCALL
+MmMapViewOfSection (DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3,
+ DWORD Unknown4,
+ DWORD Unknown5,
+ DWORD Unknown6,
+ DWORD Unknown7,
+ DWORD Unknown8,
+ DWORD Unknown9)
{
UNIMPLEMENTED;
return (NULL);
}
-BOOLEAN
-STDCALL
-MmCanFileBeTruncated (
- IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
- IN PLARGE_INTEGER NewFileSize
- )
+BOOLEAN STDCALL
+MmCanFileBeTruncated (IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
+ IN PLARGE_INTEGER NewFileSize)
{
- UNIMPLEMENTED;
- return (FALSE);
+ UNIMPLEMENTED;
+ return (FALSE);
}
-BOOLEAN
-STDCALL
-MmDisableModifiedWriteOfSection (
- DWORD Unknown0
- )
+BOOLEAN STDCALL
+MmDisableModifiedWriteOfSection (DWORD Unknown0)
{
- UNIMPLEMENTED;
- return (FALSE);
+ UNIMPLEMENTED;
+ return (FALSE);
}
-BOOLEAN
-STDCALL
-MmFlushImageSection (
- IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
- IN MMFLUSH_TYPE FlushType
- )
+BOOLEAN STDCALL
+MmFlushImageSection (IN PSECTION_OBJECT_POINTERS SectionObjectPointer,
+ IN MMFLUSH_TYPE FlushType)
{
- UNIMPLEMENTED;
- return (FALSE);
+ UNIMPLEMENTED;
+ return (FALSE);
}
-BOOLEAN
-STDCALL
-MmForceSectionClosed (
- DWORD Unknown0,
- DWORD Unknown1
- )
+BOOLEAN STDCALL
+MmForceSectionClosed (DWORD Unknown0,
+ DWORD Unknown1)
{
- UNIMPLEMENTED;
- return (FALSE);
+ UNIMPLEMENTED;
+ return (FALSE);
}
-NTSTATUS
-STDCALL
-MmMapViewInSystemSpace (
- IN PVOID Section,
- OUT PVOID * MappedBase,
- IN PULONG ViewSize
- )
+NTSTATUS STDCALL
+MmMapViewInSystemSpace (IN PVOID Section,
+ OUT PVOID * MappedBase,
+ IN PULONG ViewSize)
{
- UNIMPLEMENTED;
- return (STATUS_NOT_IMPLEMENTED);
+ UNIMPLEMENTED;
+ return (STATUS_NOT_IMPLEMENTED);
}
-NTSTATUS
-STDCALL
-MmUnmapViewInSystemSpace (
- DWORD Unknown0
- )
+NTSTATUS STDCALL
+MmUnmapViewInSystemSpace (DWORD Unknown0)
{
- UNIMPLEMENTED;
- return (STATUS_NOT_IMPLEMENTED);
+ UNIMPLEMENTED;
+ return (STATUS_NOT_IMPLEMENTED);
}
-NTSTATUS
-STDCALL
-MmSetBankedSection (
- DWORD Unknown0,
- DWORD Unknown1,
- DWORD Unknown2,
- DWORD Unknown3,
- DWORD Unknown4,
- DWORD Unknown5
- )
+NTSTATUS STDCALL
+MmSetBankedSection (DWORD Unknown0,
+ DWORD Unknown1,
+ DWORD Unknown2,
+ DWORD Unknown3,
+ DWORD Unknown4,
+ DWORD Unknown5)
{
- UNIMPLEMENTED;
- return (STATUS_NOT_IMPLEMENTED);
+ UNIMPLEMENTED;
+ return (STATUS_NOT_IMPLEMENTED);
}
* RETURN VALUE
* Status.
*/
-NTSTATUS
-STDCALL
-MmCreateSection (
- OUT PSECTION_OBJECT * SectionObject,
- IN ACCESS_MASK DesiredAccess,
- IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
- IN PLARGE_INTEGER MaximumSize,
- IN ULONG SectionPageProtection,
- IN ULONG AllocationAttributes,
- IN HANDLE FileHandle OPTIONAL,
- IN PFILE_OBJECT File OPTIONAL
- )
+NTSTATUS STDCALL
+MmCreateSection (OUT PSECTION_OBJECT * SectionObject,
+ IN ACCESS_MASK DesiredAccess,
+ IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
+ IN PLARGE_INTEGER MaximumSize,
+ IN ULONG SectionPageProtection,
+ IN ULONG AllocationAttributes,
+ IN HANDLE FileHandle OPTIONAL,
+ IN PFILE_OBJECT File OPTIONAL)
{
- return (STATUS_NOT_IMPLEMENTED);
+ return (STATUS_NOT_IMPLEMENTED);
}
/* EOF */
+
+
+
+
+
+
projects / reactos.git / commitdiff