+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * subsys/smss/init.c (SmPagingFilesQueryRoutine): If possible
+ take the size of the paging file from the registry.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * ntoskrnl/mm/section.c (MmCreateDataFileSection): Extend the
+ section if necessary.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * ntoskrnl/mm/pagefile.c (NtCreatePagingFile): Set the file
+ size using the FileAllocationInformation class.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * ntoskrnl/mm/anonmem.c (MmWritePageVirtualMemory): Implemented
+ function to write anonymous memory pages to the swap file.
+ * ntoskrnl/mm/anonmem.c (MmFreeVirtualMemoryPage): Free any
+ swap page associated with the page.
+ * ntoskrnl/mm/mpw.c (MmWriteDirtyPages): New function to find
+ pages to write to disk.
+ * ntoskrnl/mm/mpw.c (MmMpwThreadMain): Implemented MPW functionality.
+ * ntoskrnl/mm/rmap.c (MmWritePagePhysicalAddress): New function
+ to write a single page back to disk.
+ * ntoskrnl/mm/rmap.c (MmSetCleanAllRmaps, MmSetDirtyAllRmaps,
+ MmIsDirtyPageRmap): New rmap function to support the MPW thread.
+ * ntoskrnl/mm/section.c (MmWritePageSectionView): Implemented
+ function to write back section pages.
+ * ntoskrnl/mm/section.c (MmFreeSectionPage): Free any swap
+ entry associated with the page; mark pages shared with
+ the cache as dirty if necessary.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * ntoskrnl/ldr/loader.c (LdrPEProcessModule): Set name of
+ the module into the module text structure.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * ntoskrnl/io/rw.c (NtReadFile, NtWriteFile): Use the correct
+ test for whether to wait for the completion of i/o.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * ntoskrnl/cm/ntfunc.c (NtFlushKey): Request synchronous i/o
+ from NtOpenFile.
+ * ntoskrnl/cm/regfile (CmiInitPermanentRegistryHive): Request
+ synchronous i/o from NtCreateFile.
+ * ntoskrnl/dbg/kdb_stabs.c (LdrpLoadModuleSymbols): Request
+ synchronous i/o from NtOpenFile.
+ * ntoskrnl/ldr/sysdll.c (LdrpMapSystemDll): Request synchronous i/o
+ from NtOpenFile.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * ntoskrnl/cc/view.c (CcRosSuggestFreeCacheSegment): Maintain the
+ correct reference count.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * ntoskrnl/cc/view.c (CcRosFlushCacheSegment): New function to
+ write back a modified cache segment.
+ * ntoskrnl/cc/view.c (CcRosFlushDirtyPages): New function to
+ flush some dirty pages from the cache.
+ * ntoskrnl/cc/view.c (CcRosMarkDirtyCacheSegment): New function to
+ mark a cache segment modified while mapped into memory as dirty.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * ntoskrnl/cc/pin.c (CcMapData, CcUnpinData, CcSetDirtyPinnedData):
+ Store the dirty status in the BCB; don't write back dirty data
+ immediately.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * include/ntos/mm.h: Added SEC_XXXX defines from 'Windows NT/2000
+ Native API Reference'
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * drivers/fs/vfat/ea.c (VfatSetExtendedAttributes): Empty
+ placeholder for extended attribute functions.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * drivers/fs/vfat/finfo.c (VfatSetAllocationSizeInformation):
+ Added function to set allocation size.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * drivers/fs/vfat/fcb.c (vfatFCBInitializeCache): Renamed
+ to vfatFCBInitializeCacheFromVolume.
+ * drivers/fs/vfat/fcb.c (vfatMakeFCBFromDirEntry): Don't
+ initialise the cache with a file object representing the
+ volume unless the FCB is for a directory.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * drivers/fs/vfat/create.c (VfatPagingFileCreate): Added a
+ new function for handling paging file only code.
+ * drivers/fs/vfat/create.c (VfatSupersedeFile): Added a
+ new function for doing a file supersede.
+ * drivers/fs/vfat/create.c (VfatCreateFile): Reformatted and
+ adjusted control flow. Set allocation size and extended attributes
+ on create.
+ * drivers/fs/vfat/create.c (VfatCreate): Removed goto.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * drivers/fs/vfat/cleanup.c (VfatCleanupFile): Renamed
+ updEntry to VfatUpdateEntry.
+ * drivers/fs/vfat/close.c (VfatCloseFile): Renamed
+ updEntry to VfatUpdateEntry.
+ * drivers/fs/vfat/dirwr.c (updEntry): Renamed to
+ VfatUpdateEntry.
+ * drivers/fs/vfat/dirwr.c (addEntry): Renamed to
+ VfatAddEntry.
+
+2002-08-14 David Welch <welch@computer2.darkstar.org>
+
+ * apps/tests/sectest/sectest.c (main): Fixed formatting.
+
2002-08-10 David Welch <welch@computer2.darkstar.org>
* ntoskrnl/mm/i386/page.c (MmSetPageProtect): Fixed
-/* $Id: sectest.c,v 1.1 2002/05/13 20:15:33 chorns Exp $ */\r
+/* $Id: sectest.c,v 1.2 2002/08/14 20:58:31 dwelch Exp $ */\r
#define UNICODE\r
#define _UNICODE\r
#include <windows.h>\r
int main(int argc, char* argv[])\r
{\r
HANDLE hFile;\r
- HANDLE Section;\r
- PVOID BaseAddress;\r
-\r
- printf("Section Test\n");\r
-\r
- hFile = CreateFile(_T("sectest.txt"),\r
+ HANDLE Section;\r
+ PVOID BaseAddress;\r
+ \r
+ printf("Section Test\n");\r
+ \r
+ hFile = CreateFile(_T("sectest.txt"),\r
GENERIC_READ | GENERIC_WRITE, \r
0, \r
NULL, \r
0);\r
if (hFile == INVALID_HANDLE_VALUE)\r
{\r
- printf("Failed to create file (err=%d)", GetLastError());\r
- return 1;\r
+ printf("Failed to create file (err=%d)", GetLastError());\r
+ return 1;\r
}\r
-\r
- Section = CreateFileMapping(\r
- hFile,\r
- NULL,\r
- PAGE_READWRITE, \r
- 0,\r
- 4096,\r
- NULL);\r
- if (Section == NULL)\r
+ \r
+ Section = CreateFileMapping(hFile,\r
+ NULL,\r
+ PAGE_READWRITE, \r
+ 0,\r
+ 4096,\r
+ NULL);\r
+ if (Section == NULL)\r
{\r
- printf("Failed to create section (err=%d)", GetLastError());\r
- return 1;\r
- }\r
- \r
- printf("Mapping view of section\n");\r
- BaseAddress = MapViewOfFile(Section,\r
- FILE_MAP_ALL_ACCESS,\r
- 0,\r
- 0,\r
- 4096);\r
- printf("BaseAddress %x\n", (UINT) BaseAddress);\r
- if (BaseAddress == NULL)\r
+ printf("Failed to create section (err=%d)", GetLastError());\r
+ return 1;\r
+ }\r
+ \r
+ printf("Mapping view of section\n");\r
+ BaseAddress = MapViewOfFile(Section,\r
+ FILE_MAP_ALL_ACCESS,\r
+ 0,\r
+ 0,\r
+ 4096);\r
+ printf("BaseAddress %x\n", (UINT) BaseAddress);\r
+ if (BaseAddress == NULL)\r
{\r
- printf("Failed to map section (%d)\n", GetLastError());\r
+ printf("Failed to map section (%d)\n", GetLastError());\r
return 1;\r
}\r
- \r
- printf("Clearing section\n");\r
+ \r
+ printf("Clearing section\n");\r
FillMemory(BaseAddress, 4096, ' ');\r
- printf("Copying test data to section\n");\r
- strcpy(BaseAddress, "test data");\r
-\r
+ printf("Copying test data to section\n");\r
+ strcpy(BaseAddress, "test data");\r
+ \r
if (!UnmapViewOfFile(BaseAddress))\r
{ \r
- printf("Failed to unmap view of file (%d)\n", GetLastError());\r
+ printf("Failed to unmap view of file (%d)\n", GetLastError());\r
return 1;\r
}\r
-\r
+ \r
if (!CloseHandle(hFile))\r
{ \r
- printf("Failed to close file (%d)\n", GetLastError());\r
+ printf("Failed to close file (%d)\n", GetLastError());\r
return 1;\r
}\r
-\r
- return 0;\r
+ \r
+ return 0;\r
}\r
\r
-/* $Id: cleanup.c,v 1.6 2002/08/08 17:54:12 dwelch Exp $
+/* $Id: cleanup.c,v 1.7 2002/08/14 20:58:31 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
{
if (pFcb->Flags & FCB_UPDATE_DIRENTRY)
{
- updEntry (DeviceExt, FileObject);
+ VfatUpdateEntry (DeviceExt, FileObject);
pFcb->Flags &= ~FCB_UPDATE_DIRENTRY;
}
}
-/* $Id: close.c,v 1.12 2002/06/10 21:15:58 hbirr Exp $
+/* $Id: close.c,v 1.13 2002/08/14 20:58:31 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
}
if (pFcb->Flags & FCB_UPDATE_DIRENTRY)
{
- updEntry (DeviceExt, FileObject);
+ VfatUpdateEntry (DeviceExt, FileObject);
pFcb->Flags &= ~FCB_UPDATE_DIRENTRY;
}
FileObject->FsContext2 = NULL;
-/* $Id: create.c,v 1.42 2002/06/26 18:36:41 hbirr Exp $
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * 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: create.c,v 1.43 2002/08/14 20:58:31 dwelch Exp $
*
- * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: services/fs/vfat/create.c
* PURPOSE: VFAT Filesystem
return Status;
}
+VOID STATIC
+VfatPagingFileCreate(PDEVICE_EXTENSION DeviceExt, PVFATFCB Fcb)
+{
+ ULONG CurrentCluster, NextCluster, i;
+ NTSTATUS Status;
+
+ Fcb->Flags |= FCB_IS_PAGE_FILE;
+ Fcb->FatChainSize =
+ ((Fcb->entry.FileSize + DeviceExt->FatInfo.BytesPerCluster - 1) /
+ DeviceExt->FatInfo.BytesPerCluster);
+ if (Fcb->FatChainSize)
+ {
+ Fcb->FatChain =
+ ExAllocatePool(NonPagedPool, Fcb->FatChainSize * sizeof(ULONG));
+ }
+
+ if (DeviceExt->FatInfo.FatType == FAT32)
+ {
+ CurrentCluster = Fcb->entry.FirstCluster +
+ Fcb->entry.FirstClusterHigh * 65536;
+ }
+ else
+ {
+ CurrentCluster = Fcb->entry.FirstCluster;
+ }
+
+ i = 0;
+ if (Fcb->FatChainSize)
+ {
+ while (CurrentCluster != 0xffffffff)
+ {
+ Fcb->FatChain[i] = CurrentCluster;
+ Status = GetNextCluster (DeviceExt, CurrentCluster,
+ &NextCluster, FALSE);
+ i++;
+ CurrentCluster = NextCluster;
+ }
+ }
+}
+
+VOID STATIC
+VfatSupersedeFile(PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT FileObject,
+ PVFATFCB Fcb)
+{
+ ULONG Cluster, NextCluster;
+ NTSTATUS Status;
+
+ Fcb->entry.FileSize = 0;
+ if (DeviceExt->FatInfo.FatType == FAT32)
+ {
+ Cluster = Fcb->entry.FirstCluster + Fcb->entry.FirstClusterHigh * 65536;
+ }
+ else
+ {
+ Cluster = Fcb->entry.FirstCluster;
+ }
+ Fcb->entry.FirstCluster = 0;
+ Fcb->entry.FirstClusterHigh = 0;
+ VfatUpdateEntry (DeviceExt, FileObject);
+ if (Fcb->RFCB.FileSize.QuadPart > 0)
+ {
+ Fcb->RFCB.AllocationSize.QuadPart = 0;
+ Fcb->RFCB.FileSize.QuadPart = 0;
+ Fcb->RFCB.ValidDataLength.QuadPart = 0;
+ CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&Fcb->RFCB.AllocationSize);
+ }
+ while (Cluster != 0xffffffff && Cluster > 1)
+ {
+ Status = GetNextCluster (DeviceExt, Cluster, &NextCluster, FALSE);
+ WriteCluster (DeviceExt, Cluster, 0);
+ Cluster = NextCluster;
+ }
+}
+
NTSTATUS
VfatCreateFile (PDEVICE_OBJECT DeviceObject, PIRP Irp)
/*
PVFATCCB pCcb;
PVFATFCB pFcb;
PWCHAR c;
- BOOLEAN PagingFileCreate = FALSE;
-
+ BOOLEAN PagingFileCreate = FALSE;
+
+ /* Unpack the various parameters. */
Stack = IoGetCurrentIrpStackLocation (Irp);
- assert (Stack);
RequestedDisposition = ((Stack->Parameters.Create.Options >> 24) & 0xff);
RequestedOptions =
Stack->Parameters.Create.Options & FILE_VALID_OPTION_FLAGS;
- PagingFileCreate = (Stack->Flags & SL_OPEN_PAGING_FILE) ? TRUE : FALSE;
- if ((RequestedOptions & FILE_DIRECTORY_FILE)
- && RequestedDisposition == FILE_SUPERSEDE)
- return STATUS_INVALID_PARAMETER;
+ PagingFileCreate = (Stack->Flags & SL_OPEN_PAGING_FILE) ? TRUE : FALSE;
FileObject = Stack->FileObject;
DeviceExt = DeviceObject->DeviceExtension;
- assert (DeviceExt);
- if (FileObject->FileName.Length == 0 && FileObject->RelatedFileObject == NULL)
- {
- /* This a open operation for the volume itself */
- if (RequestedDisposition == FILE_CREATE ||
- RequestedDisposition == FILE_OVERWRITE_IF ||
- RequestedDisposition == FILE_SUPERSEDE)
+ /* Check their validity. */
+ if (RequestedOptions & FILE_DIRECTORY_FILE &&
+ RequestedDisposition == FILE_SUPERSEDE)
{
- Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
- return STATUS_ACCESS_DENIED;
+ return(STATUS_INVALID_PARAMETER);
}
- if (RequestedOptions & FILE_DIRECTORY_FILE)
- {
- Irp->IoStatus.Status = STATUS_NOT_A_DIRECTORY;
- return STATUS_NOT_A_DIRECTORY;
+
+ /* This a open operation for the volume itself */
+ if (FileObject->FileName.Length == 0 &&
+ FileObject->RelatedFileObject == NULL)
+ {
+ if (RequestedDisposition == FILE_CREATE ||
+ RequestedDisposition == FILE_OVERWRITE_IF ||
+ RequestedDisposition == FILE_SUPERSEDE)
+ {
+ return(STATUS_ACCESS_DENIED);
+ }
+ if (RequestedOptions & FILE_DIRECTORY_FILE)
+ {
+ return(STATUS_NOT_A_DIRECTORY);
+ }
+ pFcb = DeviceExt->VolumeFcb;
+ pCcb = ExAllocatePoolWithTag (NonPagedPool, sizeof (VFATCCB), TAG_CCB);
+ if (pCcb == NULL)
+ {
+ return (STATUS_INSUFFICIENT_RESOURCES);
+ }
+ memset(pCcb, 0, sizeof(VFATCCB));
+ FileObject->Flags |= FO_FCB_IS_VALID;
+ FileObject->SectionObjectPointers = &pFcb->SectionObjectPointers;
+ FileObject->FsContext = (PVOID) &pFcb->RFCB;
+ FileObject->FsContext2 = pCcb;
+ pCcb->pFcb = pFcb;
+ pCcb->PtrFileObject = FileObject;
+ pFcb->pDevExt = DeviceExt;
+ pFcb->RefCount++;
+
+ Irp->IoStatus.Information = FILE_OPENED;
+ return(STATUS_SUCCESS);
}
- pFcb = DeviceExt->VolumeFcb;
- pCcb = ExAllocatePoolWithTag (NonPagedPool, sizeof (VFATCCB), TAG_CCB);
- if (pCcb == NULL)
- {
- Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
- return STATUS_INSUFFICIENT_RESOURCES;
- }
- memset(pCcb, 0, sizeof(VFATCCB));
- FileObject->Flags |= FO_FCB_IS_VALID;
- FileObject->SectionObjectPointers = &pFcb->SectionObjectPointers;
- FileObject->FsContext = (PVOID) &pFcb->RFCB;
- FileObject->FsContext2 = pCcb;
- pCcb->pFcb = pFcb;
- pCcb->PtrFileObject = FileObject;
- pFcb->pDevExt = DeviceExt;
- pFcb->RefCount++;
-
- Irp->IoStatus.Information = FILE_OPENED;
- Irp->IoStatus.Status = STATUS_SUCCESS;
- return STATUS_SUCCESS;
- }
/*
* Check for illegal characters in the file name
{
if (*c == L'*' || *c == L'?' || (*c == L'\\' && c[1] == L'\\'))
{
- Irp->IoStatus.Information = 0;
- Irp->IoStatus.Status = STATUS_OBJECT_NAME_INVALID;
return(STATUS_OBJECT_NAME_INVALID);
}
c++;
}
+ /* Try opening the file. */
Status = VfatOpenFile (DeviceExt, FileObject, FileObject->FileName.Buffer);
/*
* If the directory containing the file to open doesn't exist then
* fail immediately
*/
- Irp->IoStatus.Information = 0;
- if (Status == STATUS_OBJECT_PATH_NOT_FOUND)
+ if (Status == STATUS_OBJECT_PATH_NOT_FOUND ||
+ Status == STATUS_INVALID_PARAMETER ||
+ Status == STATUS_DELETE_PENDING)
{
- Irp->IoStatus.Status = Status;
- return Status;
+ return(Status);
}
- if (Status == STATUS_INVALID_PARAMETER)
- {
- Irp->IoStatus.Status = Status;
- return Status;
- }
- if (Status == STATUS_DELETE_PENDING)
- {
- Irp->IoStatus.Status = Status;
- return Status;
- }
+
+ /*
+ * If the file open failed then create the required file
+ */
if (!NT_SUCCESS (Status))
- {
- /*
- * If the file open failed then create the required file
- */
+ {
if (RequestedDisposition == FILE_CREATE ||
RequestedDisposition == FILE_OPEN_IF ||
RequestedDisposition == FILE_OVERWRITE_IF ||
RequestedDisposition == FILE_SUPERSEDE)
{
- CHECKPOINT;
- Status =
- addEntry (DeviceExt, FileObject, RequestedOptions,
- (Stack->Parameters.
- Create.FileAttributes & FILE_ATTRIBUTE_VALID_FLAGS));
+ ULONG Attributes;
+ Attributes = Stack->Parameters.Create.FileAttributes;
+ Status = VfatAddEntry (DeviceExt, FileObject, RequestedOptions,
+ Attributes & FILE_ATTRIBUTE_VALID_FLAGS);
if (NT_SUCCESS (Status))
- {
- if (PagingFileCreate)
- {
- DPRINT("Creating a new paging file.\n");
- pCcb = FileObject->FsContext2;
- pFcb = pCcb->pFcb;
- pFcb->Flags |= FCB_IS_PAGE_FILE;
- pFcb->FatChainSize = 0;
- pFcb->FatChain = NULL;
- }
-
- Irp->IoStatus.Information = FILE_CREATED;
- }
- /* FIXME set size if AllocationSize requested */
- /* FIXME set extended attributes? */
- /* FIXME set share access */
- /* IoSetShareAccess(DesiredAccess,ShareAccess,FileObject,
- * ((PVfatCCB)(FileObject->FsContext2))->pFcb->FCBShareAccess);
- */
+ {
+ pCcb = FileObject->FsContext2;
+ pFcb = pCcb->pFcb;
+ Irp->IoStatus.Information = FILE_CREATED;
+ VfatSetAllocationSizeInformation(FileObject,
+ pFcb,
+ DeviceObject,
+ &Irp->Overlay.AllocationSize);
+ VfatSetExtendedAttributes(FileObject,
+ Irp->AssociatedIrp.SystemBuffer,
+ Stack->Parameters.Create.EaLength);
+ IoSetShareAccess(0 /*DesiredAccess*/,
+ Stack->Parameters.Create.ShareAccess,
+ FileObject,
+ &pFcb->FCBShareAccess);
+ }
+ else
+ {
+ return(Status);
+ }
}
- }
- else
- {
- /*
- * Otherwise fail if the caller wanted to create a new file
- */
- if (RequestedDisposition == FILE_CREATE)
+ else
{
- Irp->IoStatus.Information = FILE_EXISTS;
- Status = STATUS_OBJECT_NAME_COLLISION;
+ return(Status);
}
- pCcb = FileObject->FsContext2;
- pFcb = pCcb->pFcb;
- /*
- * If requested then delete the file and create a new one with the
- * same name
- */
- if (RequestedDisposition == FILE_SUPERSEDE)
+ }
+ else
{
- ULONG Cluster, NextCluster;
- /* FIXME set size to 0 and free clusters */
- pFcb->entry.FileSize = 0;
- if (DeviceExt->FatInfo.FatType == FAT32)
- Cluster = pFcb->entry.FirstCluster
- + pFcb->entry.FirstClusterHigh * 65536;
- else
- Cluster = pFcb->entry.FirstCluster;
- pFcb->entry.FirstCluster = 0;
- pFcb->entry.FirstClusterHigh = 0;
- updEntry (DeviceExt, FileObject);
- if ((ULONG)pFcb->RFCB.FileSize.QuadPart > 0)
- {
- pFcb->RFCB.AllocationSize.QuadPart = 0;
- pFcb->RFCB.FileSize.QuadPart = 0;
- pFcb->RFCB.ValidDataLength.QuadPart = 0;
- CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&pFcb->RFCB.AllocationSize);
- }
- while (Cluster != 0xffffffff && Cluster > 1)
- {
- Status = GetNextCluster (DeviceExt, Cluster, &NextCluster, FALSE);
- WriteCluster (DeviceExt, Cluster, 0);
- Cluster = NextCluster;
- }
- }
-
- /*
- * If this create was for a paging file then make sure all the
- * information needed to manipulate it is locked in memory.
- */
- if (PagingFileCreate)
- {
- ULONG CurrentCluster, NextCluster, i;
- DPRINT("Open an existing paging file\n");
- pFcb->Flags |= FCB_IS_PAGE_FILE;
- pFcb->FatChainSize =
- ((pFcb->entry.FileSize + DeviceExt->FatInfo.BytesPerCluster - 1) / DeviceExt->FatInfo.BytesPerCluster);
- if (pFcb->FatChainSize)
+ /* Otherwise fail if the caller wanted to create a new file */
+ if (RequestedDisposition == FILE_CREATE)
{
- pFcb->FatChain = ExAllocatePool(NonPagedPool,
- pFcb->FatChainSize * sizeof(ULONG));
+ Irp->IoStatus.Information = FILE_EXISTS;
+ return(STATUS_OBJECT_NAME_COLLISION);
}
- if (DeviceExt->FatInfo.FatType == FAT32)
- {
- CurrentCluster = pFcb->entry.FirstCluster +
- pFcb->entry.FirstClusterHigh * 65536;
- }
- else
- {
- CurrentCluster = pFcb->entry.FirstCluster;
- }
+ pCcb = FileObject->FsContext2;
+ pFcb = pCcb->pFcb;
- i = 0;
- if (pFcb->FatChainSize)
+ /*
+ * Check the file has the requested attributes
+ */
+ if (RequestedOptions & FILE_NON_DIRECTORY_FILE &&
+ pFcb->entry.Attrib & FILE_ATTRIBUTE_DIRECTORY)
{
- while (CurrentCluster != 0xffffffff)
- {
- pFcb->FatChain[i] = CurrentCluster;
- Status = GetNextCluster (DeviceExt, CurrentCluster, &NextCluster,
- FALSE);
- i++;
- CurrentCluster = NextCluster;
- }
- }
+ VfatCloseFile (DeviceExt, FileObject);
+ return(STATUS_FILE_IS_A_DIRECTORY);
}
-
- /*
- * Check the file has the requested attributes
- */
- if ((RequestedOptions & FILE_NON_DIRECTORY_FILE)
- && (pFcb->entry.Attrib & FILE_ATTRIBUTE_DIRECTORY))
+ if (RequestedOptions & FILE_DIRECTORY_FILE &&
+ !(pFcb->entry.Attrib & FILE_ATTRIBUTE_DIRECTORY))
{
- Status = STATUS_FILE_IS_A_DIRECTORY;
+ VfatCloseFile (DeviceExt, FileObject);
+ return(STATUS_NOT_A_DIRECTORY);
}
- if ((RequestedOptions & FILE_DIRECTORY_FILE)
- && !(pFcb->entry.Attrib & FILE_ATTRIBUTE_DIRECTORY))
+
+ /* Supersede the file */
+ if (RequestedDisposition == FILE_SUPERSEDE)
{
- Status = STATUS_NOT_A_DIRECTORY;
+ VfatSupersedeFile(DeviceExt, FileObject, pFcb);
+ Irp->IoStatus.Information = FILE_SUPERSEDED;
}
- /* FIXME : test share access */
- /* FIXME : test write access if requested */
- if (!NT_SUCCESS (Status))
- VfatCloseFile (DeviceExt, FileObject);
- else
+ else
+ {
Irp->IoStatus.Information = FILE_OPENED;
- /* FIXME : make supersed or overwrite if requested */
- }
+ }
+ }
+
+ /*
+ * If this create was for a paging file then make sure all the
+ * information needed to manipulate it is locked in memory.
+ */
+ if (PagingFileCreate)
+ {
+ VfatPagingFileCreate(DeviceExt, pFcb);
+ }
- Irp->IoStatus.Status = Status;
+ /* FIXME : test share access */
+ /* FIXME : test write access if requested */
- return Status;
+ return(Status);
}
*/
{
NTSTATUS Status;
-
+
assert (IrpContext);
-
-// if (IrpContext->DeviceObject->Size == sizeof (DEVICE_OBJECT))
+
if (IrpContext->DeviceObject == VfatGlobalData->DeviceObject)
- {
- /* DeviceObject represents FileSystem instead of logical volume */
- DPRINT ("FsdCreate called with file system\n");
- IrpContext->Irp->IoStatus.Information = FILE_OPENED;
- Status = STATUS_SUCCESS;
- goto ByeBye;
- }
-
+ {
+ /* DeviceObject represents FileSystem instead of logical volume */
+ DPRINT ("FsdCreate called with file system\n");
+ IrpContext->Irp->IoStatus.Information = FILE_OPENED;
+ IrpContext->Irp->IoStatus.Status = STATUS_SUCCESS;
+ IoCompleteRequest (IrpContext->Irp, IO_DISK_INCREMENT);
+ VfatFreeIrpContext(IrpContext);
+ return(STATUS_SUCCESS);
+ }
+
if (!(IrpContext->Flags & IRPCONTEXT_CANWAIT))
- {
- return VfatQueueRequest (IrpContext);
- }
-
+ {
+ return(VfatQueueRequest (IrpContext));
+ }
+
+ IrpContext->Irp->IoStatus.Information = 0;
ExAcquireResourceExclusiveLite (&IrpContext->DeviceExt->DirResource, TRUE);
Status = VfatCreateFile (IrpContext->DeviceObject, IrpContext->Irp);
ExReleaseResourceLite (&IrpContext->DeviceExt->DirResource);
-ByeBye:
IrpContext->Irp->IoStatus.Status = Status;
- IoCompleteRequest (IrpContext->Irp, NT_SUCCESS(Status) ? IO_DISK_INCREMENT : IO_NO_INCREMENT);
+ IoCompleteRequest (IrpContext->Irp,
+ NT_SUCCESS(Status) ? IO_DISK_INCREMENT : IO_NO_INCREMENT);
VfatFreeIrpContext(IrpContext);
- return Status;
+ return(Status);
}
/* EOF */
-/* $Id: dirwr.c,v 1.26 2002/06/10 21:19:18 hbirr Exp $
+/* $Id: dirwr.c,v 1.27 2002/08/14 20:58:31 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
return FALSE;
}
-NTSTATUS updEntry (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT pFileObject)
+NTSTATUS
+VfatUpdateEntry (PDEVICE_EXTENSION DeviceExt, PFILE_OBJECT pFileObject)
/*
* update an existing FAT entry
*/
}
NTSTATUS
-addEntry (PDEVICE_EXTENSION DeviceExt,
- PFILE_OBJECT pFileObject,
- ULONG RequestedOptions,
- UCHAR ReqAttr)
+VfatAddEntry (PDEVICE_EXTENSION DeviceExt,
+ PFILE_OBJECT pFileObject,
+ ULONG RequestedOptions,
+ UCHAR ReqAttr)
/*
create a new FAT entry
*/
--- /dev/null
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * 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: ea.c,v 1.1 2002/08/14 20:58:31 dwelch Exp $
+ *
+ * PROJECT: ReactOS kernel
+ * FILE: services/fs/vfat/ea.c
+ * PURPOSE: VFAT Filesystem
+ * PROGRAMMER: Jason Filby (jasonfilby@yahoo.com)
+
+ */
+
+/* INCLUDES *****************************************************************/
+
+#include <ddk/ntddk.h>
+#include <wchar.h>
+#include <limits.h>
+
+#define NDEBUG
+#include <debug.h>
+
+#include "vfat.h"
+
+/* FUNCTIONS *****************************************************************/
+
+NTSTATUS
+VfatSetExtendedAttributes(PFILE_OBJECT FileObject,
+ PVOID Ea,
+ ULONG EaLength)
+{
+ return(STATUS_EAS_NOT_SUPPORTED);
+}
-/* $Id: fcb.c,v 1.16 2002/08/08 17:54:12 dwelch Exp $
+/* $Id: fcb.c,v 1.17 2002/08/14 20:58:31 dwelch Exp $
*
*
* FILE: fcb.c
}
NTSTATUS
-vfatFCBInitializeCache (PVCB vcb, PVFATFCB fcb)
+vfatFCBInitializeCacheFromVolume (PVCB vcb, PVFATFCB fcb)
{
NTSTATUS status;
PFILE_OBJECT fileObject;
FCB->RFCB.ValidDataLength.QuadPart = Size;
FCB->RFCB.AllocationSize.QuadPart = Size;
- vfatFCBInitializeCache(pVCB, FCB);
+ vfatFCBInitializeCacheFromVolume(pVCB, FCB);
vfatAddFCBToTable(pVCB, FCB);
vfatGrabFCB(pVCB, FCB);
PVFATFCB directoryFCB,
PWSTR longName,
PFAT_DIR_ENTRY dirEntry,
- ULONG dirIndex,
- PVFATFCB * fileFCB)
+ ULONG dirIndex,
+ PVFATFCB* fileFCB)
{
PVFATFCB rcFCB;
WCHAR pathName [MAX_PATH];
rcFCB->RFCB.FileSize.QuadPart = Size;
rcFCB->RFCB.ValidDataLength.QuadPart = Size;
rcFCB->RFCB.AllocationSize.QuadPart = ROUND_UP(Size, vcb->FatInfo.BytesPerCluster);
-// DPRINT1("%S %d %d\n", longName, Size, (ULONG)rcFCB->RFCB.AllocationSize.QuadPart);
- vfatFCBInitializeCache (vcb, rcFCB);
rcFCB->RefCount++;
+ if (vfatFCBIsDirectory(vcb, rcFCB))
+ {
+ vfatFCBInitializeCacheFromVolume(vcb, rcFCB);
+ }
vfatAddFCBToTable (vcb, rcFCB);
*fileFCB = rcFCB;
-/* $Id: finfo.c,v 1.14 2002/07/20 11:44:37 ekohl Exp $
+/* $Id: finfo.c,v 1.15 2002/08/14 20:58:31 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
return STATUS_SUCCESS;
}
+NTSTATUS
+VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
+ PVFATFCB Fcb,
+ PDEVICE_OBJECT DeviceObject,
+ PLARGE_INTEGER AllocationSize)
+{
+ ULONG OldSize;
+ ULONG Cluster;
+ ULONG Offset;
+ NTSTATUS Status;
+ PDEVICE_EXTENSION DeviceExt =
+ (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
+ ULONG ClusterSize = DeviceExt->FatInfo.BytesPerCluster;
+ ULONG NewSize = AllocationSize->u.LowPart;
+ ULONG NextCluster;
+
+ OldSize = Fcb->entry.FileSize;
+ if (OldSize == AllocationSize->u.LowPart)
+ {
+ return(STATUS_SUCCESS);
+ }
+ Fcb->entry.FileSize = AllocationSize->u.LowPart;
+ Fcb->RFCB.AllocationSize = *AllocationSize;
+ Fcb->RFCB.FileSize = *AllocationSize;
+ Fcb->RFCB.ValidDataLength = *AllocationSize;
+ CcSetFileSizes(FileObject, (PCC_FILE_SIZES)&Fcb->RFCB.AllocationSize);
+
+ if (DeviceExt->FatInfo.FatType == FAT32)
+ {
+ Cluster = Fcb->entry.FirstCluster + Fcb->entry.FirstClusterHigh * 65536;
+ }
+ else
+ {
+ Cluster = Fcb->entry.FirstCluster;
+ }
+
+ if (OldSize > NewSize &&
+ ROUND_UP(OldSize, ClusterSize) > ROUND_DOWN(NewSize, ClusterSize))
+ {
+ /* Seek to the new end of the file. */
+ Offset = 0;
+ while (Cluster != 0xffffffff && Cluster > 1 && Offset <= NewSize)
+ {
+ Status = GetNextCluster (DeviceExt, Cluster, &NextCluster, FALSE);
+ Cluster = NextCluster;
+ Offset += ClusterSize;
+ }
+ /* Free everything beyond this point. */
+ while (Cluster != 0xffffffff && Cluster > 1)
+ {
+ Status = GetNextCluster (DeviceExt, Cluster, &NextCluster, FALSE);
+ WriteCluster (DeviceExt, Cluster, 0xFFFFFFFF);
+ Cluster = NextCluster;
+ }
+ if (NewSize == 0)
+ {
+ Fcb->entry.FirstCluster = 0;
+ Fcb->entry.FirstClusterHigh = 0;
+ }
+ }
+ else if (NewSize > OldSize &&
+ ROUND_UP(NewSize, ClusterSize) > ROUND_DOWN(OldSize, ClusterSize))
+ {
+ /* Seek to the new end of the file. */
+ Offset = 0;
+ if (OldSize == 0)
+ {
+ assert(Cluster == 0);
+ Status = GetNextCluster (DeviceExt, 0, &NextCluster, TRUE);
+ Fcb->entry.FirstCluster = (NextCluster & 0x0000FFFF) >> 0;
+ Fcb->entry.FirstClusterHigh = (NextCluster & 0xFFFF0000) >> 16;
+ Cluster = NextCluster;
+ Offset += ClusterSize;
+ }
+ while (Cluster != 0xffffffff && Cluster > 1 && Offset <= NewSize)
+ {
+ Status = GetNextCluster (DeviceExt, Cluster, &NextCluster, TRUE);
+ Cluster = NextCluster;
+ Offset += ClusterSize;
+ }
+ }
+
+ /* Update the on-disk directory entry */
+ VfatUpdateEntry(DeviceExt, FileObject);
+}
NTSTATUS VfatQueryInformation(PVFAT_IRP_CONTEXT IrpContext)
/*
PVFATFCB FCB = NULL;
NTSTATUS RC = STATUS_SUCCESS;
PVOID SystemBuffer;
-
+ BOOL CanWait = IrpContext->Flags & IRPCONTEXT_CANWAIT;
+
/* PRECONDITION */
assert(IrpContext);
-
+
DPRINT("VfatSetInformation(IrpContext %x)\n", IrpContext);
-
+
/* INITIALIZATION */
- FileInformationClass = IrpContext->Stack->Parameters.SetFile.FileInformationClass;
+ FileInformationClass =
+ IrpContext->Stack->Parameters.SetFile.FileInformationClass;
FCB = ((PVFATCCB) IrpContext->FileObject->FsContext2)->pFcb;
SystemBuffer = IrpContext->Irp->AssociatedIrp.SystemBuffer;
-
+
DPRINT("FileInformationClass %d\n", FileInformationClass);
DPRINT("SystemBuffer %x\n", SystemBuffer);
-
+
if (FCB->Flags & FCB_IS_PAGE_FILE)
- {
- if (!ExAcquireResourceExclusiveLite(&FCB->PagingIoResource, IrpContext->Flags & IRPCONTEXT_CANWAIT))
- {
- return VfatQueueRequest (IrpContext);
- }
- }
+ {
+ if (!ExAcquireResourceExclusiveLite(&FCB->PagingIoResource, CanWait))
+ {
+ return(VfatQueueRequest (IrpContext));
+ }
+ }
else
- {
- if (!ExAcquireResourceExclusiveLite(&FCB->MainResource, IrpContext->Flags & IRPCONTEXT_CANWAIT))
- {
- return VfatQueueRequest (IrpContext);
- }
- }
+ {
+ if (!ExAcquireResourceExclusiveLite(&FCB->MainResource, CanWait))
+ {
+ return(VfatQueueRequest (IrpContext));
+ }
+ }
switch (FileInformationClass)
{
IrpContext->DeviceObject,
SystemBuffer);
break;
- case FileBasicInformation:
- case FileAllocationInformation:
+ case FileAllocationInformation:
case FileEndOfFileInformation:
+ RC = VfatSetAllocationSizeInformation(IrpContext->FileObject,
+ FCB,
+ IrpContext->DeviceObject,
+ (PLARGE_INTEGER)SystemBuffer);
+ break;
+ case FileBasicInformation:
case FileRenameInformation:
RC = STATUS_NOT_IMPLEMENTED;
break;
-/* $Id: iface.c,v 1.63 2002/05/15 18:05:00 ekohl Exp $
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * 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: iface.c,v 1.64 2002/08/14 20:58:31 dwelch Exp $
*
- * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: services/fs/vfat/iface.c
* PURPOSE: VFAT Filesystem
* PROGRAMMER: Jason Filby (jasonfilby@yahoo.com)
- * UPDATE HISTORY:
- * ?? Created
- * 24-10-1998 Fixed bugs in long filename support
- * Fixed a bug that prevented unsuccessful file open requests
- * being reported
- * Now works with long filenames that span over a sector
- * boundary
- * 28-10-1998 Reads entire FAT into memory
- * VFatReadSector modified to read in more than one sector at a
- * time
- * 7-11-1998 Fixed bug that assumed that directory data could be
- * fragmented
- * 8-12-1998 Added FAT32 support
- * Added initial writability functions
- * WARNING: DO NOT ATTEMPT TO TEST WRITABILITY FUNCTIONS!!!
- * 12-12-1998 Added basic support for FILE_STANDARD_INFORMATION request
- *
*/
/* INCLUDES *****************************************************************/
/* GLOBALS *****************************************************************/
-
PVFAT_GLOBAL_DATA VfatGlobalData;
/* FUNCTIONS ****************************************************************/
UNICODE_STRING DeviceName;
NTSTATUS Status;
- DPRINT("VFAT 0.0.6\n");
-
- RtlInitUnicodeString(&DeviceName,
- L"\\Fat");
+ RtlInitUnicodeString(&DeviceName, L"\\Fat");
Status = IoCreateDevice(DriverObject,
sizeof(VFAT_GLOBAL_DATA),
&DeviceName,
DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] = VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] = VfatBuildRequest;
- DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = VfatBuildRequest;
- DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] = VfatBuildRequest;
+ DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] =
+ VfatBuildRequest;
+ DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] =
+ VfatBuildRequest;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = VfatShutdown;
DriverObject->MajorFunction[IRP_MJ_CLEANUP] = VfatBuildRequest;
DriverObject->DriverUnload = NULL;
IoRegisterFileSystem(DeviceObject);
- return STATUS_SUCCESS;
+ return(STATUS_SUCCESS);
}
/* EOF */
-# $Id: makefile,v 1.39 2002/06/26 18:36:41 hbirr Exp $
+# $Id: makefile,v 1.40 2002/08/14 20:58:31 dwelch Exp $
PATH_TO_TOP = ../../..
string.o \
volume.o \
misc.o \
- fsctl.o
+ fsctl.o \
+ ea.o
DEP_OBJECTS = $(TARGET_OBJECTS)
-/* $Id: rw.c,v 1.43 2002/06/26 18:36:41 hbirr Exp $
+/* $Id: rw.c,v 1.44 2002/08/14 20:58:31 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#include "vfat.h"
-/* GLOBALS *******************************************************************/
-
-#define ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))
-#define ROUND_DOWN(N, S) ((N) - ((N) % (S)))
-
/* FUNCTIONS *****************************************************************/
NTSTATUS
if (Extend)
{
Fcb->FatChain = ExAllocatePool(NonPagedPool, sizeof(ULONG));
- if (!Fcb->FatChain)
+ if (Fcb->FatChain == NULL)
{
- return STATUS_NO_MEMORY;
+ return(STATUS_NO_MEMORY);
}
Status = GetNextCluster(DeviceExt, 0, CurrentCluster, TRUE);
if (!NT_SUCCESS(Status))
{
ExFreePool(Fcb->FatChain);
- return Status;
+ return(Status);
}
Fcb->FatChain[0] = *CurrentCluster;
Fcb->FatChainSize = 1;
// update dates/times and length
if (OldAllocationSize != Fcb->RFCB.AllocationSize.u.LowPart)
{
- updEntry (IrpContext->DeviceExt, IrpContext->FileObject);
+ VfatUpdateEntry (IrpContext->DeviceExt, IrpContext->FileObject);
Fcb->Flags &= ~FCB_UPDATE_DIRENTRY;
}
else
-/* $Id: vfat.h,v 1.43 2002/06/26 18:36:41 hbirr Exp $ */
+/* $Id: vfat.h,v 1.44 2002/08/14 20:58:32 dwelch Exp $ */
#include <ddk/ntifs.h>
+#define ROUND_UP(N, S) ((((N) + (S) - 1) / (S)) * (S))
+#define ROUND_DOWN(N, S) ((N) - ((N) % (S)))
+
struct _BootSector
{
unsigned char magic0, res0, magic1;
ULONG NumberOfClusters;
ULONG FatType;
ULONG Sectors;
-}
-FATINFO, *PFATINFO;
+} FATINFO, *PFATINFO;
struct _VFATFCB;
ULONG LastAvailableCluster;
ULONG AvailableClusters;
BOOLEAN AvailableClustersValid;
- ULONG Flags;
+ ULONG Flags;
struct _VFATFCB * VolumeFcb;
-}
-DEVICE_EXTENSION, *PDEVICE_EXTENSION, VCB, *PVCB;
+} DEVICE_EXTENSION, *PDEVICE_EXTENSION, VCB, *PVCB;
typedef struct
{
PDRIVER_OBJECT DriverObject;
PDEVICE_OBJECT DeviceObject;
ULONG Flags;
-}
-VFAT_GLOBAL_DATA, *PVFAT_GLOBAL_DATA;
+} VFAT_GLOBAL_DATA, *PVFAT_GLOBAL_DATA;
extern PVFAT_GLOBAL_DATA VfatGlobalData;
ERESOURCE PagingIoResource;
ERESOURCE MainResource;
ULONG TimerCount;
+ SHARE_ACCESS FCBShareAccess;
/* Structure members used only for paging files. */
ULONG FatChainSize;
PULONG FatChain;
-}
-VFATFCB, *PVFATFCB;
+} VFATFCB, *PVFATFCB;
typedef struct _VFATCCB
{
ULONG LastCluster;
ULONG LastOffset;
-}
-VFATCCB, *PVFATCCB;
+} VFATCCB, *PVFATCCB;
#define TAG(A, B, C, D) (ULONG)(((A)<<0) + ((B)<<8) + ((C)<<16) + ((D)<<24))
UCHAR MajorFunction;
UCHAR MinorFunction;
PFILE_OBJECT FileObject;
-}
-VFAT_IRP_CONTEXT, *PVFAT_IRP_CONTEXT;
+} VFAT_IRP_CONTEXT, *PVFAT_IRP_CONTEXT;
/* ------------------------------------------------------ shutdown.c */
NTSTATUS VfatSetInformation (PVFAT_IRP_CONTEXT IrpContext);
+NTSTATUS
+VfatSetAllocationSizeInformation(PFILE_OBJECT FileObject,
+ PVFATFCB Fcb,
+ PDEVICE_OBJECT DeviceObject,
+ PLARGE_INTEGER AllocationSize);
+
/* --------------------------------------------------------- iface.c */
NTSTATUS STDCALL DriverEntry (PDRIVER_OBJECT DriverObject,
/* --------------------------------------------------------- dirwr.c */
-NTSTATUS addEntry (PDEVICE_EXTENSION DeviceExt,
- PFILE_OBJECT pFileObject,
- ULONG RequestedOptions,UCHAR ReqAttr);
+NTSTATUS VfatAddEntry (PDEVICE_EXTENSION DeviceExt,
+ PFILE_OBJECT pFileObject,
+ ULONG RequestedOptions,UCHAR ReqAttr);
-NTSTATUS updEntry (PDEVICE_EXTENSION DeviceExt,
- PFILE_OBJECT pFileObject);
+NTSTATUS VfatUpdateEntry (PDEVICE_EXTENSION DeviceExt,
+ PFILE_OBJECT pFileObject);
NTSTATUS delEntry(PDEVICE_EXTENSION,
PFILE_OBJECT);
NTSTATUS VfatLockUserBuffer(IN PIRP, IN ULONG,
IN LOCK_OPERATION);
-
+NTSTATUS
+VfatSetExtendedAttributes(PFILE_OBJECT FileObject,
+ PVOID Ea,
+ ULONG EaLength);
/* EOF */
typedef struct _CACHE_SEGMENT* PCACHE_SEGMENT;
-NTSTATUS STDCALL
-CcRosFlushCacheSegment (struct _CACHE_SEGMENT* CacheSeg);
NTSTATUS STDCALL
CcRosReleaseCacheSegment (struct _BCB* Bcb,
struct _CACHE_SEGMENT* CacheSeg,
#ifndef __INCLUDE_MM_H
#define __INCLUDE_MM_H
+#if 0
#define SEC_COMMIT (134217728)
#define SEC_IMAGE (16777216)
#define SEC_NOCACHE (268435456)
#define SEC_RESERVE (67108864)
+#else
+#define SEC_BASED (0x00200000)
+#define SEC_NO_CHANGE (0x00400000)
+#define SEC_IMAGE (0x01000000)
+#define SEC_VLM (0x02000000)
+#define SEC_RESERVE (0x04000000)
+#define SEC_COMMIT (0x08000000)
+#define SEC_NOCACHE (0x10000000)
+#endif
#define PAGE_READONLY (2)
#define PAGE_READWRITE (4)
#define PAGE_WRITECOPY (8)
-/* $Id: pin.c,v 1.3 2002/07/17 21:04:55 dwelch Exp $
+/* $Id: pin.c,v 1.4 2002/08/14 20:58:32 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
{
PUBLIC_BCB PFCB;
PCACHE_SEGMENT CacheSegment;
+ BOOLEAN Dirty;
} INTERNAL_BCB, *PINTERNAL_BCB;
BOOLEAN STDCALL
return FALSE;
}
iBcb->CacheSegment = CacheSeg;
+ iBcb->Dirty = FALSE;
iBcb->PFCB.MappedLength = Length;
iBcb->PFCB.MappedFileOffset.QuadPart = FileOffset->QuadPart;
*pBcb = (PVOID)iBcb;
{
PINTERNAL_BCB iBcb = Bcb;
CcRosReleaseCacheSegment(iBcb->CacheSegment->Bcb, iBcb->CacheSegment, TRUE,
- FALSE, FALSE);
+ iBcb->Dirty, FALSE);
ExFreePool(iBcb);
}
IN PLARGE_INTEGER Lsn)
{
PINTERNAL_BCB iBcb = Bcb;
- /* FIXME: write only the modifyed 4-pages back */
- WriteCacheSegment(iBcb->CacheSegment);
+ iBcb->Dirty = TRUE;
}
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: view.c,v 1.45 2002/08/08 17:54:13 dwelch Exp $
+/* $Id: view.c,v 1.46 2002/08/14 20:58:32 dwelch Exp $
*
- * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/cc/view.c
* PURPOSE: Cache manager
/* FUNCTIONS *****************************************************************/
+NTSTATUS STATIC
+CcRosFlushCacheSegment(PCACHE_SEGMENT CacheSegment)
+{
+ NTSTATUS Status;
+ Status = WriteCacheSegment(CacheSegment);
+ if (NT_SUCCESS(Status))
+ {
+ CacheSegment->Dirty = FALSE;
+ RemoveEntryList(&CacheSegment->DirtySegmentListEntry);
+ }
+ return(Status);
+}
+
+NTSTATUS
+CcRosFlushDirtyPages(ULONG Target, PULONG Count)
+{
+ PLIST_ENTRY current_entry;
+ PCACHE_SEGMENT current;
+ ULONG PagesPerSegment;
+ BOOLEAN Locked;
+ NTSTATUS Status;
+
+ DPRINT("CcRosFlushDirtyPages(Target %d)\n", Target);
+
+ (*Count) = 0;
+
+ ExAcquireFastMutex(&ViewLock);
+ current_entry = DirtySegmentListHead.Flink;
+ while (current_entry != &DirtySegmentListHead && Target > 0)
+ {
+ current = CONTAINING_RECORD(current_entry, CACHE_SEGMENT,
+ DirtySegmentListEntry);
+ current_entry = current_entry->Flink;
+ Locked = ExTryToAcquireFastMutex(¤t->Lock);
+ if (!Locked)
+ {
+ continue;
+ }
+ assert(current->Dirty);
+ if (current->ReferenceCount > 0)
+ {
+ ExReleaseFastMutex(¤t->Lock);
+ continue;
+ }
+ current->ReferenceCount++;
+ ExReleaseFastMutex(&ViewLock);
+ PagesPerSegment = current->Bcb->CacheSegmentSize / PAGESIZE;
+ Status = CcRosFlushCacheSegment(current);
+ current->ReferenceCount--;
+ ExReleaseFastMutex(¤t->Lock);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("CC: Failed to flush cache segment.\n");
+ }
+ (*Count) += PagesPerSegment;
+ Target -= PagesPerSegment;
+
+ ExAcquireFastMutex(&ViewLock);
+ current_entry = DirtySegmentListHead.Flink;
+ }
+ ExReleaseFastMutex(&ViewLock);
+ DPRINT("CcRosTrimCache() finished\n");
+ return(STATUS_SUCCESS);
+}
+
NTSTATUS
CcRosTrimCache(ULONG Target, ULONG Priority, PULONG NrFreed)
/*
return(NULL);
}
+NTSTATUS
+CcRosMarkDirtyCacheSegment(PBCB Bcb, ULONG FileOffset)
+{
+ PCACHE_SEGMENT CacheSeg;
+
+ ExAcquireFastMutex(&ViewLock);
+ CacheSeg = CcRosLookupCacheSegment(Bcb, FileOffset);
+ if (CacheSeg == NULL)
+ {
+ KeBugCheck(0);
+ }
+ ExAcquireFastMutex(&CacheSeg->Lock);
+ if (!CacheSeg->Dirty)
+ {
+ InsertTailList(&DirtySegmentListHead, &CacheSeg->DirtySegmentListEntry);
+ }
+ CacheSeg->Dirty = TRUE;
+ ExReleaseFastMutex(&CacheSeg->Lock);
+ ExReleaseFastMutex(&ViewLock);
+ return(STATUS_SUCCESS);
+}
+
NTSTATUS
CcRosSuggestFreeCacheSegment(PBCB Bcb, ULONG FileOffset, BOOLEAN NowDirty)
{
ExAcquireFastMutex(&CacheSeg->Lock);
CacheSeg->MappedCount--;
CacheSeg->Dirty = CacheSeg->Dirty || NowDirty;
+ CacheSeg->ReferenceCount--;
ExReleaseFastMutex(&CacheSeg->Lock);
return(STATUS_SUCCESS);
}
PCACHE_SEGMENT current;
NTSTATUS Status;
- DPRINT("CcRosReleaseFileCache(FileObject %x, Bcb %x)\n", Bcb->FileObject,
+ DPRINT("CcRosDeleteFileCache(FileObject %x, Bcb %x)\n", Bcb->FileObject,
Bcb);
MmFreeSectionSegments(Bcb->FileObject);
NULL);
Status = NtOpenFile(&FileHandle,
- FILE_ALL_ACCESS,
- &ObjectAttributes,
- NULL,
- 0,
- 0);
+ FILE_ALL_ACCESS,
+ &ObjectAttributes,
+ NULL,
+ 0,
+ FILE_SYNCHRONOUS_IO_NONALERT);
if (!NT_SUCCESS(Status))
{
FILE_ATTRIBUTE_NORMAL,
0,
CreateDisposition,
- FILE_NON_DIRECTORY_FILE,
+ FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
NULL,
0);
&ObjectAttributes,
&IoStatusBlock,
0,
- 0);
+ FILE_SYNCHRONOUS_IO_NONALERT);
if (!NT_SUCCESS(Status))
{
DPRINT("Could not open symbol file: %wZ\n", &SymFileName);
--- /dev/null
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * 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 __NTOSKRNL_INCLUDE_INTERNAL_ARCH_KE_H
+#define __NTOSKRNL_INCLUDE_INTERNAL_ARCH_KE_H
+
+#ifdef i386
+#include <internal/i386/ke.h>
+#else
+#error "Unknown processor"
+#endif
+
+#endif /* __NTOSKRNL_INCLUDE_INTERNAL_ARCH_KE_H */
+
+/* EOF */
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * 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 __NTOSKRNL_INCLUDE_INTERNAL_ARCH_MM_H
#define __NTOSKRNL_INCLUDE_INTERNAL_ARCH_MM_H
--- /dev/null
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * 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 __NTOSKRNL_INCLUDE_INTERNAL_ARCH_PS_H
+#define __NTOSKRNL_INCLUDE_INTERNAL_ARCH_PS_H
+
+#ifdef i386
+#include <internal/i386/ps.h>
+#define KiArchContextSwitch Ki386ContextSwitch
+#define KiArchInitThread Ke386InitThread
+#define KiArchInitThreadWithContext Ke386InitThreadWithContext
+#else
+#error "Unknown processor"
+#endif
+
+#endif /* __NTOSKRNL_INCLUDE_INTERNAL_ARCH_PS_H */
+
+/* EOF */
#ifndef __INCLUDE_INTERNAL_CC_H
#define __INCLUDE_INTERNAL_CC_H
-/* $Id: cc.h,v 1.12 2002/08/08 17:54:14 dwelch Exp $ */
+/* $Id: cc.h,v 1.13 2002/08/14 20:58:34 dwelch Exp $ */
#include <ddk/ntifs.h>
typedef struct _BCB
ULONG Length,
PCACHE_SEGMENT* CacheSeg);
VOID CcInitCacheZeroPage(VOID);
+NTSTATUS
+CcRosMarkDirtyCacheSegment(PBCB Bcb, ULONG FileOffset);
+NTSTATUS
+CcRosFlushDirtyPages(ULONG Target, PULONG Count);
+
#endif
--- /dev/null
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * 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 __NTOSKRNL_INCLUDE_INTERNAL_I386_KE_H
+#define __NTOSKRNL_INCLUDE_INTERNAL_I386_KE_H
+
+#define KTRAP_FRAME_DEBUGEBP (0x0)
+#define KTRAP_FRAME_DEBUGEIP (0x4)
+#define KTRAP_FRAME_DEBUGARGMARK (0x8)
+#define KTRAP_FRAME_DEBUGPOINTER (0xC)
+#define KTRAP_FRAME_TEMPCS (0x10)
+#define KTRAP_FRAME_TEMPEIP (0x14)
+#define KTRAP_FRAME_DR0 (0x18)
+#define KTRAP_FRAME_DR1 (0x1C)
+#define KTRAP_FRAME_DR2 (0x20)
+#define KTRAP_FRAME_DR3 (0x24)
+#define KTRAP_FRAME_DR6 (0x28)
+#define KTRAP_FRAME_DR7 (0x2C)
+#define KTRAP_FRAME_GS (0x30)
+#define KTRAP_FRAME_RESERVED1 (0x32)
+#define KTRAP_FRAME_ES (0x34)
+#define KTRAP_FRAME_RESERVED2 (0x36)
+#define KTRAP_FRAME_DS (0x38)
+#define KTRAP_FRAME_RESERVED3 (0x3A)
+#define KTRAP_FRAME_EDX (0x3C)
+#define KTRAP_FRAME_ECX (0x40)
+#define KTRAP_FRAME_EAX (0x44)
+#define KTRAP_FRAME_PREVIOUS_MODE (0x48)
+#define KTRAP_FRAME_EXCEPTION_LIST (0x4C)
+#define KTRAP_FRAME_FS (0x50)
+#define KTRAP_FRAME_RESERVED4 (0x52)
+#define KTRAP_FRAME_EDI (0x54)
+#define KTRAP_FRAME_ESI (0x58)
+#define KTRAP_FRAME_EBX (0x5C)
+#define KTRAP_FRAME_EBP (0x60)
+#define KTRAP_FRAME_ERROR_CODE (0x64)
+#define KTRAP_FRAME_EIP (0x68)
+#define KTRAP_FRAME_CS (0x6C)
+#define KTRAP_FRAME_EFLAGS (0x70)
+#define KTRAP_FRAME_ESP (0x74)
+#define KTRAP_FRAME_SS (0x78)
+#define KTRAP_FRAME_RESERVED5 (0x7A)
+#define KTRAP_FRAME_V86_ES (0x7C)
+#define KTRAP_FRAME_RESERVED6 (0x7E)
+#define KTRAP_FRAME_V86_DS (0x80)
+#define KTRAP_FRAME_RESERVED7 (0x82)
+#define KTRAP_FRAME_V86_FS (0x84)
+#define KTRAP_FRAME_RESERVED8 (0x86)
+#define KTRAP_FRAME_V86_GS (0x88)
+#define KTRAP_FRAME_RESERVED9 (0x8A)
+#define KTRAP_FRAME_SIZE (0x8C)
+
+#ifndef __ASM__
+
+typedef struct _KTRAP_FRAME
+{
+ PVOID DebugEbp;
+ PVOID DebugEip;
+ PVOID DebugArgMark;
+ PVOID DebugPointer;
+ PVOID TempCs;
+ PVOID TempEip;
+ PVOID Dr0;
+ PVOID Dr1;
+ PVOID Dr2;
+ PVOID Dr3;
+ PVOID Dr6;
+ PVOID Dr7;
+ USHORT Gs;
+ USHORT Reserved1;
+ USHORT Es;
+ USHORT Reserved2;
+ USHORT Ds;
+ USHORT Reserved3;
+ ULONG Edx;
+ ULONG Ecx;
+ ULONG Eax;
+ ULONG PreviousMode;
+ PVOID ExceptionList;
+ USHORT Fs;
+ USHORT Reserved4;
+ ULONG Edi;
+ ULONG Esi;
+ ULONG Ebx;
+ ULONG Ebp;
+ ULONG ErrorCode;
+ ULONG Eip;
+ ULONG Cs;
+ ULONG Eflags;
+ ULONG Esp;
+ USHORT Ss;
+ USHORT Reserved5;
+ USHORT V86_Es;
+ USHORT Reserved6;
+ USHORT V86_Ds;
+ USHORT Reserved7;
+ USHORT V86_Fs;
+ USHORT Reserved8;
+ USHORT V86_Gs;
+ USHORT Reserved9;
+} KTRAP_FRAME, *PKTRAP_FRAME;
+
+struct _KPCR;
+VOID
+KiInitializeGdt(struct _KPCR* Pcr);
+VOID
+Ki386ApplicationProcessorInitializeTSS(VOID);
+VOID
+Ki386BootInitializeTSS(VOID);
+VOID
+KiGdtPrepareForApplicationProcessorInit(ULONG Id);
+VOID
+Ki386InitializeLdt(VOID);
+ULONG KeAllocateGdtSelector(ULONG Desc[2]);
+VOID KeFreeGdtSelector(ULONG Entry);
+VOID
+NtEarlyInitVdm(VOID);
+
+#endif /* __ASM__ */
+
+#endif /* __NTOSKRNL_INCLUDE_INTERNAL_I386_KE_H */
+
+/* EOF */
--- /dev/null
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * 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 __NTOSKRNL_INCLUDE_INTERNAL_I386_PS_H
+#define __NTOSKRNL_INCLUDE_INTERNAL_I386_PS_H
+
+/*
+ * Defines for accessing KPCR and KTHREAD structure members
+ */
+#define KTHREAD_INITIAL_STACK 0x18
+#define KTHREAD_STACK_LIMIT 0x1C
+#define KTHREAD_TEB 0x20
+#define KTHREAD_KERNEL_STACK 0x28
+#define KTHREAD_PREVIOUS_MODE 0x137
+#define KTHREAD_TRAP_FRAME 0x128
+#define KTHREAD_CALLBACK_STACK 0x120
+
+#define ETHREAD_THREADS_PROCESS 0x234
+
+#define KPROCESS_DIRECTORY_TABLE_BASE 0x18
+
+#define KPCR_BASE 0xFF000000
+
+#define KPCR_EXCEPTION_LIST 0x0
+#define KPCR_SELF 0x18
+#define KPCR_TSS 0x28
+#define KPCR_CURRENT_THREAD 0x124
+
+#ifndef __ASM__
+
+/*
+ * Processor Control Region
+ */
+typedef struct _KPCR
+{
+ PVOID ExceptionList; /* 00 */
+ PVOID StackBase; /* 04 */
+ PVOID StackLimit; /* 08 */
+ PVOID SubSystemTib; /* 0C */
+ PVOID Reserved1; /* 10 */
+ PVOID ArbitraryUserPointer; /* 14 */
+ struct _KPCR* Self; /* 18 */
+ UCHAR ProcessorNumber; /* 1C */
+ KIRQL Irql; /* 1D */
+ UCHAR Reserved2[0x2]; /* 1E */
+ PUSHORT IDT; /* 20 */
+ PUSHORT GDT; /* 24 */
+ KTSS* TSS; /* 28 */
+ UCHAR Reserved3[0xF8]; /* 2C */
+ struct _KTHREAD* CurrentThread; /* 124 */
+} __attribute__((packed)) KPCR, *PKPCR;
+
+static inline PKPCR KeGetCurrentKPCR(VOID)
+{
+ ULONG value;
+
+ __asm__ __volatile__ ("movl %%fs:0x18, %0\n\t"
+ : "=r" (value)
+ : /* no inputs */
+ );
+ return((PKPCR)value);
+}
+
+VOID
+Ki386ContextSwitch(struct _KTHREAD* NewThread,
+ struct _KTHREAD* OldThread);
+NTSTATUS
+Ke386InitThread(struct _KTHREAD* Thread, PKSTART_ROUTINE fn,
+ PVOID StartContext);
+NTSTATUS
+Ke386InitThreadWithContext(struct _KTHREAD* Thread, PCONTEXT Context);
+NTSTATUS
+Ki386ValidateUserContext(PCONTEXT Context);
+
+#endif /* __ASM__ */
+
+#endif /* __NTOSKRNL_INCLUDE_INTERNAL_I386_PS_H */
+
+/* EOF */
#define PCR_SELECTOR (0x30)
/* Thread Environment Block */
#define TEB_SELECTOR (0x38 + 0x3)
-#define RESERVED_SELECTOR (0x40)
+#define RESERVED_SELECTOR (0x40)
/* Local Descriptor Table */
#define LDT_SELECTOR (0x48)
#define TRAP_TSS_SELECTOR (0x50)
#endif /* __NTOSKRNL_INCLUDE_INTERNAL_I386_SEGMENT_H */
-
+/* EOF */
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-#ifndef __NTOSKRNL_INCLUDE_INTERNAL_KERNEL_H
-#define __NTOSKRNL_INCLUDE_INTERNAL_KERNEL_H
+#ifndef __NTOSKRNL_INCLUDE_INTERNAL_KE_H
+#define __NTOSKRNL_INCLUDE_INTERNAL_KE_H
/* INCLUDES *****************************************************************/
#include <stdarg.h>
#endif /* not __ASM__ */
+#include <internal/arch/ke.h>
+
/* INTERNAL KERNEL FUNCTIONS ************************************************/
#ifndef __ASM__
struct _KTHREAD;
-#endif /* not __ASM__ */
-
-#define KTRAP_FRAME_DEBUGEBP (0x0)
-#define KTRAP_FRAME_DEBUGEIP (0x4)
-#define KTRAP_FRAME_DEBUGARGMARK (0x8)
-#define KTRAP_FRAME_DEBUGPOINTER (0xC)
-#define KTRAP_FRAME_TEMPCS (0x10)
-#define KTRAP_FRAME_TEMPEIP (0x14)
-#define KTRAP_FRAME_DR0 (0x18)
-#define KTRAP_FRAME_DR1 (0x1C)
-#define KTRAP_FRAME_DR2 (0x20)
-#define KTRAP_FRAME_DR3 (0x24)
-#define KTRAP_FRAME_DR6 (0x28)
-#define KTRAP_FRAME_DR7 (0x2C)
-#define KTRAP_FRAME_GS (0x30)
-#define KTRAP_FRAME_RESERVED1 (0x32)
-#define KTRAP_FRAME_ES (0x34)
-#define KTRAP_FRAME_RESERVED2 (0x36)
-#define KTRAP_FRAME_DS (0x38)
-#define KTRAP_FRAME_RESERVED3 (0x3A)
-#define KTRAP_FRAME_EDX (0x3C)
-#define KTRAP_FRAME_ECX (0x40)
-#define KTRAP_FRAME_EAX (0x44)
-#define KTRAP_FRAME_PREVIOUS_MODE (0x48)
-#define KTRAP_FRAME_EXCEPTION_LIST (0x4C)
-#define KTRAP_FRAME_FS (0x50)
-#define KTRAP_FRAME_RESERVED4 (0x52)
-#define KTRAP_FRAME_EDI (0x54)
-#define KTRAP_FRAME_ESI (0x58)
-#define KTRAP_FRAME_EBX (0x5C)
-#define KTRAP_FRAME_EBP (0x60)
-#define KTRAP_FRAME_ERROR_CODE (0x64)
-#define KTRAP_FRAME_EIP (0x68)
-#define KTRAP_FRAME_CS (0x6C)
-#define KTRAP_FRAME_EFLAGS (0x70)
-#define KTRAP_FRAME_ESP (0x74)
-#define KTRAP_FRAME_SS (0x78)
-#define KTRAP_FRAME_RESERVED5 (0x7A)
-#define KTRAP_FRAME_V86_ES (0x7C)
-#define KTRAP_FRAME_RESERVED6 (0x7E)
-#define KTRAP_FRAME_V86_DS (0x80)
-#define KTRAP_FRAME_RESERVED7 (0x82)
-#define KTRAP_FRAME_V86_FS (0x84)
-#define KTRAP_FRAME_RESERVED8 (0x86)
-#define KTRAP_FRAME_V86_GS (0x88)
-#define KTRAP_FRAME_RESERVED9 (0x8A)
-#define KTRAP_FRAME_SIZE (0x8C)
-
-#ifndef __ASM__
-
-typedef struct _KTRAP_FRAME
-{
- PVOID DebugEbp;
- PVOID DebugEip;
- PVOID DebugArgMark;
- PVOID DebugPointer;
- PVOID TempCs;
- PVOID TempEip;
- PVOID Dr0;
- PVOID Dr1;
- PVOID Dr2;
- PVOID Dr3;
- PVOID Dr6;
- PVOID Dr7;
- USHORT Gs;
- USHORT Reserved1;
- USHORT Es;
- USHORT Reserved2;
- USHORT Ds;
- USHORT Reserved3;
- ULONG Edx;
- ULONG Ecx;
- ULONG Eax;
- ULONG PreviousMode;
- PVOID ExceptionList;
- USHORT Fs;
- USHORT Reserved4;
- ULONG Edi;
- ULONG Esi;
- ULONG Ebx;
- ULONG Ebp;
- ULONG ErrorCode;
- ULONG Eip;
- ULONG Cs;
- ULONG Eflags;
- ULONG Esp;
- USHORT Ss;
- USHORT Reserved5;
- USHORT V86_Es;
- USHORT Reserved6;
- USHORT V86_Ds;
- USHORT Reserved7;
- USHORT V86_Fs;
- USHORT Reserved8;
- USHORT V86_Gs;
- USHORT Reserved9;
-} KTRAP_FRAME, *PKTRAP_FRAME;
-
VOID KiUpdateSystemTime (KIRQL oldIrql, ULONG Eip);
VOID KeAcquireDispatcherDatabaseLock(BOOLEAN Wait);
VOID KeReleaseDispatcherDatabaseLock(BOOLEAN Wait);
BOOLEAN KeDispatcherObjectWake(DISPATCHER_HEADER* hdr);
-
-#if 0
-VOID KiInterruptDispatch(ULONG irq);
-#endif
VOID STDCALL KeExpireTimers(PKDPC Apc,
PVOID Arg1,
- PVOID Arg2,
- PVOID Arg3);
+ PVOID Arg2,
+ PVOID Arg3);
VOID KeInitializeDispatcherHeader(DISPATCHER_HEADER* Header, ULONG Type,
ULONG Size, ULONG SignalState);
-
VOID KeDumpStackFrames(PULONG Frame);
-ULONG KeAllocateGdtSelector(ULONG Desc[2]);
-VOID KeFreeGdtSelector(ULONG Entry);
BOOLEAN KiTestAlert(VOID);
VOID KeRemoveAllWaitsThread(struct _ETHREAD* Thread, NTSTATUS WaitStatus);
PULONG KeGetStackTopThread(struct _ETHREAD* Thread);
BOOLEAN KiDeliverUserApc(PKTRAP_FRAME TrapFrame);
VOID
-NtEarlyInitVdm(VOID);
-VOID
-KiAddProfileEvent(KPROFILE_SOURCE Source, ULONG Eip);
+KiAddProfileEvent(KPROFILE_SOURCE Source, ULONG Pc);
VOID
KiDispatchException(PEXCEPTION_RECORD ExceptionRecord,
PCONTEXT Context,
BOOLEAN SearchFrames);
VOID KeTrapFrameToContext(PKTRAP_FRAME TrapFrame,
PCONTEXT Context);
-struct _KPCR;
-VOID
-KiInitializeGdt(struct _KPCR* Pcr);
VOID
KeApplicationProcessorInit();
VOID
-Ki386ApplicationProcessorInitializeTSS(VOID);
-VOID
-Ki386BootInitializeTSS(VOID);
-VOID
-KiGdtPrepareForApplicationProcessorInit(ULONG Id);
-VOID
KePrepareForApplicationProcessorInit(ULONG id);
-VOID
-Ki386InitializeLdt(VOID);
ULONG
KiUserTrapHandler(PKTRAP_FRAME Tf, ULONG ExceptionNr, PVOID Cr2);
VOID STDCALL
#define MAXIMUM_PROCESSORS 32
-#endif
+#endif /* __NTOSKRNL_INCLUDE_INTERNAL_KE_H */
PSECTION_PAGE_TABLE PageTables[NR_SECTION_PAGE_TABLES];
} SECTION_PAGE_DIRECTORY, *PSECTION_PAGE_DIRECTORY;
-#define MM_PAGEFILE_SECTION (0x1)
-#define MM_IMAGE_SECTION (0x2)
-/*
- * Flags for section objects
- */
-#define SO_PHYSICAL_MEMORY (0x4)
+#define SEC_PHYSICALMEMORY (0x80000000)
+
+#define MM_PAGEFILE_SEGMENT (0x1)
+#define MM_DATAFILE_SEGMENT (0x2)
#define MM_SECTION_SEGMENT_BSS (0x1)
CSHORT Size;
LARGE_INTEGER MaximumSize;
ULONG SectionPageProtection;
- ULONG AllocateAttributes;
+ ULONG AllocationAttributes;
PFILE_OBJECT FileObject;
LIST_ENTRY ViewListHead;
KSPIN_LOCK ViewListLock;
KMUTEX Lock;
- ULONG Flags;
ULONG NrSegments;
PMM_SECTION_SEGMENT Segments;
PVOID ImageBase;
NTSTATUS MmWaitForPage(PVOID Page);
VOID MmClearWaitPage(PVOID Page);
VOID MmSetWaitPage(PVOID Page);
-BOOLEAN MmIsPageDirty(struct _EPROCESS* Process, PVOID Address);
+BOOLEAN MmIsDirtyPage(struct _EPROCESS* Process, PVOID Address);
BOOLEAN MmIsPageTablePresent(PVOID PAddress);
NTSTATUS
MmPageOutVirtualMemory(PMADDRESS_SPACE AddressSpace,
extern MM_STATS MmStats;
-NTSTATUS
-MmWritePageSectionView(PMADDRESS_SPACE AddressSpace,
- PMEMORY_AREA MArea,
- PVOID Address);
-NTSTATUS
-MmWritePageVirtualMemory(PMADDRESS_SPACE AddressSpace,
- PMEMORY_AREA MArea,
- PVOID Address);
PVOID
MmGetDirtyPagesFromWorkingSet(struct _EPROCESS* Process);
NTSTATUS
ULONG Length,
ULONG Protect,
PULONG OldProtect);
+NTSTATUS
+MmWritePageSectionView(PMADDRESS_SPACE AddressSpace,
+ PMEMORY_AREA MArea,
+ PVOID Address,
+ PMM_PAGEOP PageOp);
+NTSTATUS
+MmWritePageVirtualMemory(PMADDRESS_SPACE AddressSpace,
+ PMEMORY_AREA MArea,
+ PVOID Address,
+ PMM_PAGEOP PageOp);
+VOID
+MmSetCleanAllRmaps(PHYSICAL_ADDRESS PhysicalAddress);
+VOID
+MmSetDirtyAllRmaps(PHYSICAL_ADDRESS PhysicalAddress);
+NTSTATUS
+MmWritePagePhysicalAddress(PHYSICAL_ADDRESS PhysicalAddress);
+BOOL
+MmIsDirtyPageRmap(PHYSICAL_ADDRESS PhysicalAddress);
+NTSTATUS MmInitMpwThread(VOID);
+BOOLEAN
+MmIsAvailableSwapPage(VOID);
+
#endif
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: ps.h,v 1.38 2002/08/09 17:23:56 dwelch Exp $
+/* $Id: ps.h,v 1.39 2002/08/14 20:58:34 dwelch Exp $
*
* FILE: ntoskrnl/ke/kthread.c
* PURPOSE: Process manager definitions
#ifndef __INCLUDE_INTERNAL_PS_H
#define __INCLUDE_INTERNAL_PS_H
-/*
- * Defines for accessing KPCR and KTHREAD structure members
- */
-#define KTHREAD_INITIAL_STACK 0x18
-#define KTHREAD_STACK_LIMIT 0x1C
-#define KTHREAD_TEB 0x20
-#define KTHREAD_KERNEL_STACK 0x28
-#define KTHREAD_PREVIOUS_MODE 0x137
-#define KTHREAD_TRAP_FRAME 0x128
-#define KTHREAD_CALLBACK_STACK 0x120
-
-#define ETHREAD_THREADS_PROCESS 0x234
+#ifndef __ASM__
-#define KPROCESS_DIRECTORY_TABLE_BASE 0x18
+/* Forward declarations. */
+struct _KTHREAD;
+struct _KTRAPFRAME;
-#define KPCR_BASE 0xFF000000
+#endif /* __ASM__ */
-#define KPCR_EXCEPTION_LIST 0x0
-#define KPCR_SELF 0x18
-#define KPCR_TSS 0x28
-#define KPCR_CURRENT_THREAD 0x124
+#include <internal/arch/ps.h>
#ifndef __ASM__
#include <internal/mm.h>
#include <napi/teb.h>
-struct _KTHREAD;
-struct _KTRAPFRAME;
-
-/* FIXME: This does not work if we have more than 24 IRQs (ie. more than one I/O APIC) */
-#define VECTOR2IRQ(vector) (((vector) - 0x31) / 8)
-#define VECTOR2IRQL(vector) (4 + VECTOR2IRQ(vector))
-
-/*
- * Processor Control Region
- */
-typedef struct _KPCR
-{
- PVOID ExceptionList; /* 00 */
- PVOID StackBase; /* 04 */
- PVOID StackLimit; /* 08 */
- PVOID SubSystemTib; /* 0C */
- PVOID Reserved1; /* 10 */
- PVOID ArbitraryUserPointer; /* 14 */
- struct _KPCR* Self; /* 18 */
- UCHAR ProcessorNumber; /* 1C */
- KIRQL Irql; /* 1D */
- UCHAR Reserved2[0x2]; /* 1E */
- PUSHORT IDT; /* 20 */
- PUSHORT GDT; /* 24 */
- KTSS* TSS; /* 28 */
- UCHAR Reserved3[0xF8]; /* 2C */
- struct _KTHREAD* CurrentThread; /* 124 */
-} __attribute__((packed)) KPCR, *PKPCR;
-
-static inline PKPCR KeGetCurrentKPCR(VOID)
-{
- ULONG value;
-
- __asm__ __volatile__ ("movl %%fs:0x18, %0\n\t"
- : "=r" (value)
- : /* no inputs */
- );
- return((PKPCR)value);
-}
-
#define KeGetCurrentProcessorNumber() (KeGetCurrentKPCR()->ProcessorNumber)
extern HANDLE SystemProcessHandle;
extern LCID PsDefaultThreadLocaleId;
extern LCID PsDefaultSystemLocaleId;
-
typedef struct _KAPC_STATE
{
LIST_ENTRY ApcListHead[2];
LIST_ENTRY ProcessThreadListEntry; /* 1B0 */
} __attribute__((packed)) KTHREAD, *PKTHREAD;
-// According to documentation the stack should have a commited [ 1 page ] and
-// a reserved part [ 1 M ] but can be specified otherwise in the image file.
-
-
-
-
-
-
-
-// TopLevelIrp can be one of the following values:
-// FIXME I belong somewhere else
-
+/* Top level irp definitions. */
#define FSRTL_FSP_TOP_LEVEL_IRP (0x01)
#define FSRTL_CACHE_TOP_LEVEL_IRP (0x02)
#define FSRTL_MOD_WRITE_TOP_LEVEL_IRP (0x03)
SECURITY_IMPERSONATION_LEVEL Level; // 0x8
} PS_IMPERSONATION_INFO, *PPS_IMPERSONATION_INFO;
-
typedef struct _ETHREAD
{
KTHREAD Tcb; /* 000 */
struct _EPORT* ExceptionPort;
PVOID ObjectTable;
PVOID Token;
- // FAST_MUTEX WorkingSetLock;
+ /* FAST_MUTEX WorkingSetLock; */
KMUTEX WorkingSetLock;
PVOID WorkingSetPage;
UCHAR ProcessOutswapEnabled;
VOID PsBeginThreadWithContextInternal(VOID);
VOID PiKillMostProcesses(VOID);
NTSTATUS STDCALL PiTerminateProcess(PEPROCESS Process, NTSTATUS ExitStatus);
-ULONG PsUnfreezeThread(PETHREAD Thread, PNTSTATUS WaitStatus);
-ULONG PsFreezeThread(PETHREAD Thread, PNTSTATUS WaitStatus,
- UCHAR Alertable, ULONG WaitMode);
VOID PiInitApcManagement(VOID);
VOID STDCALL PiDeleteThread(PVOID ObjectBody);
VOID STDCALL PiCloseThread(PVOID ObjectBody, ULONG HandleCount);
/*
* Internal thread priorities, added by Phillip Susi
- * TODO: rebalence these to make use of all priorities... the ones above 16 can not all be used right now
+ * TODO: rebalence these to make use of all priorities... the ones above 16
+ * can not all be used right now
*/
-
#define PROCESS_PRIO_IDLE 3
#define PROCESS_PRIO_NORMAL 8
#define PROCESS_PRIO_HIGH 13
VOID
KeInitializeThread(PKPROCESS Process, PKTHREAD Thread, BOOLEAN First);
NTSTATUS KeReleaseThread(PETHREAD Thread);
-NTSTATUS
-Ke386InitThread(PKTHREAD Thread, PKSTART_ROUTINE fn, PVOID StartContext);
-NTSTATUS
-Ke386InitThreadWithContext(PKTHREAD Thread, PCONTEXT Context);
VOID STDCALL PiDeleteProcess(PVOID ObjectBody);
VOID PsReapThreads(VOID);
VOID PsUnfreezeOtherThread(PETHREAD Thread);
VOID PsUnfreezeProcessThreads(PEPROCESS Process);
PEPROCESS PsGetNextProcess(PEPROCESS OldProcess);
VOID
-Ki386ContextSwitch(PKTHREAD NewThread, PKTHREAD OldThread);
-VOID
PsBlockThread(PNTSTATUS Status, UCHAR Alertable, ULONG WaitMode,
BOOLEAN DispatcherLock, KIRQL WaitIrql);
VOID
PiSuspendThreadNormalRoutine(PVOID NormalContext,
PVOID SystemArgument1,
PVOID SystemArgument2);
-
-VOID STDCALL
-PiTimeoutThread(struct _KDPC *dpc,
- PVOID Context,
- PVOID arg1,
- PVOID arg2);
-
VOID STDCALL
PsDispatchThread(ULONG NewThreadStatus);
VOID
-/* $Id: file.c,v 1.18 2002/07/20 01:00:34 ekohl Exp $
+/* $Id: file.c,v 1.19 2002/08/14 20:58:34 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
assert(IoStatusBlock != NULL);
assert(FileInformation != NULL);
- DPRINT("NtQueryInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n",
- FileHandle,
- IoStatusBlock,
- FileInformation,
- Length,
- FileInformationClass);
+ DPRINT("NtQueryInformationFile(Handle %x StatBlk %x FileInfo %x Length %d "
+ "Class %d)\n", FileHandle, IoStatusBlock, FileInformation,
+ Length, FileInformationClass);
Status = ObReferenceObjectByHandle(FileHandle,
FILE_READ_ATTRIBUTES,
IoStatusBlock->Information);
}
- ExFreePool(SystemBuffer);
-
+ ExFreePool(SystemBuffer);
return(Status);
}
assert(IoStatusBlock != NULL)
assert(FileInformation != NULL)
- DPRINT("NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d Class %d)\n",
- FileHandle,
- IoStatusBlock,
- FileInformation,
- Length,
- FileInformationClass);
+ DPRINT("NtSetInformationFile(Handle %x StatBlk %x FileInfo %x Length %d "
+ "Class %d)\n", FileHandle, IoStatusBlock, FileInformation,
+ Length, FileInformationClass);
/* Get the file object from the file handle */
Status = ObReferenceObjectByHandle(FileHandle,
-/* $Id: iomgr.c,v 1.22 2002/06/10 08:47:21 ekohl Exp $
+/* $Id: iomgr.c,v 1.23 2002/08/14 20:58:34 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
HANDLE Handle;
IopInitDriverImplementation();
+
+ /*
+ * Register iomgr types: DeviceObjectType
+ */
+ IoDeviceObjectType = ExAllocatePool (NonPagedPool,
+ sizeof (OBJECT_TYPE));
+
+ IoDeviceObjectType->Tag = TAG_DEVICE_TYPE;
+ IoDeviceObjectType->TotalObjects = 0;
+ IoDeviceObjectType->TotalHandles = 0;
+ IoDeviceObjectType->MaxObjects = ULONG_MAX;
+ IoDeviceObjectType->MaxHandles = ULONG_MAX;
+ IoDeviceObjectType->PagedPoolCharge = 0;
+ IoDeviceObjectType->NonpagedPoolCharge = sizeof (DEVICE_OBJECT);
+ IoDeviceObjectType->Mapping = &IopFileMapping;
+ IoDeviceObjectType->Dump = NULL;
+ IoDeviceObjectType->Open = NULL;
+ IoDeviceObjectType->Close = NULL;
+ IoDeviceObjectType->Delete = NULL;
+ IoDeviceObjectType->Parse = NULL;
+ IoDeviceObjectType->Security = NULL;
+ IoDeviceObjectType->QueryName = NULL;
+ IoDeviceObjectType->OkayToClose = NULL;
+ IoDeviceObjectType->Create = IopCreateDevice;
+ IoDeviceObjectType->DuplicationNotify = NULL;
+
+ RtlInitUnicodeString (&IoDeviceObjectType->TypeName, L"Device");
- /*
- * Register iomgr types: DeviceObjectType
- */
- IoDeviceObjectType = ExAllocatePool (NonPagedPool,
- sizeof (OBJECT_TYPE));
-
- IoDeviceObjectType->Tag = TAG_DEVICE_TYPE;
- IoDeviceObjectType->TotalObjects = 0;
- IoDeviceObjectType->TotalHandles = 0;
- IoDeviceObjectType->MaxObjects = ULONG_MAX;
- IoDeviceObjectType->MaxHandles = ULONG_MAX;
- IoDeviceObjectType->PagedPoolCharge = 0;
- IoDeviceObjectType->NonpagedPoolCharge = sizeof (DEVICE_OBJECT);
- IoDeviceObjectType->Mapping = &IopFileMapping;
- IoDeviceObjectType->Dump = NULL;
- IoDeviceObjectType->Open = NULL;
- IoDeviceObjectType->Close = NULL;
- IoDeviceObjectType->Delete = NULL;
- IoDeviceObjectType->Parse = NULL;
- IoDeviceObjectType->Security = NULL;
- IoDeviceObjectType->QueryName = NULL;
- IoDeviceObjectType->OkayToClose = NULL;
- IoDeviceObjectType->Create = IopCreateDevice;
- IoDeviceObjectType->DuplicationNotify = NULL;
-
- RtlInitUnicodeString (
- & IoDeviceObjectType->TypeName,
- L"Device"
- );
-
- /*
- * Register iomgr types: FileObjectType
- * (alias DriverObjectType)
- */
- IoFileObjectType = ExAllocatePool (
- NonPagedPool,
- sizeof (OBJECT_TYPE)
- );
-
- IoFileObjectType->Tag = TAG_FILE_TYPE;
- IoFileObjectType->TotalObjects = 0;
- IoFileObjectType->TotalHandles = 0;
- IoFileObjectType->MaxObjects = ULONG_MAX;
- IoFileObjectType->MaxHandles = ULONG_MAX;
- IoFileObjectType->PagedPoolCharge = 0;
- IoFileObjectType->NonpagedPoolCharge = sizeof(FILE_OBJECT);
- IoFileObjectType->Mapping = &IopFileMapping;
- IoFileObjectType->Dump = NULL;
- IoFileObjectType->Open = NULL;
- IoFileObjectType->Close = IopCloseFile;
- IoFileObjectType->Delete = IopDeleteFile;
- IoFileObjectType->Parse = NULL;
- IoFileObjectType->Security = NULL;
- IoFileObjectType->QueryName = NULL;
- IoFileObjectType->OkayToClose = NULL;
- IoFileObjectType->Create = IopCreateFile;
- IoFileObjectType->DuplicationNotify = NULL;
-
- RtlInitUnicodeString (
- & IoFileObjectType->TypeName,
- L"File"
- );
+ /*
+ * Register iomgr types: FileObjectType
+ * (alias DriverObjectType)
+ */
+ IoFileObjectType = ExAllocatePool (NonPagedPool, sizeof (OBJECT_TYPE));
+
+ IoFileObjectType->Tag = TAG_FILE_TYPE;
+ IoFileObjectType->TotalObjects = 0;
+ IoFileObjectType->TotalHandles = 0;
+ IoFileObjectType->MaxObjects = ULONG_MAX;
+ IoFileObjectType->MaxHandles = ULONG_MAX;
+ IoFileObjectType->PagedPoolCharge = 0;
+ IoFileObjectType->NonpagedPoolCharge = sizeof(FILE_OBJECT);
+ IoFileObjectType->Mapping = &IopFileMapping;
+ IoFileObjectType->Dump = NULL;
+ IoFileObjectType->Open = NULL;
+ IoFileObjectType->Close = IopCloseFile;
+ IoFileObjectType->Delete = IopDeleteFile;
+ IoFileObjectType->Parse = NULL;
+ IoFileObjectType->Security = NULL;
+ IoFileObjectType->QueryName = NULL;
+ IoFileObjectType->OkayToClose = NULL;
+ IoFileObjectType->Create = IopCreateFile;
+ IoFileObjectType->DuplicationNotify = NULL;
+
+ RtlInitUnicodeString (&IoFileObjectType->TypeName, L"File");
/*
* Create the '\Driver' object directory
*/
- RtlInitUnicodeString(&DirName,
- L"\\Driver");
+ RtlInitUnicodeString(&DirName, L"\\Driver");
InitializeObjectAttributes(&ObjectAttributes,
&DirName,
0,
-/* $Id: rw.c,v 1.37 2002/04/27 19:22:09 hbirr Exp $
+/* $Id: rw.c,v 1.38 2002/08/14 20:58:35 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#define NDEBUG
#include <internal/debug.h>
-/* DATA ********************************************************************/
-
-
-
/* FUNCTIONS ***************************************************************/
HANDLE EventHandle,
PIO_APC_ROUTINE ApcRoutine,
PVOID ApcContext,
- PIO_STATUS_BLOCK IoStatusBlock,
+ PIO_STATUS_BLOCK UserIoStatusBlock,
PVOID Buffer,
ULONG Length,
PLARGE_INTEGER ByteOffset,
PULONG Key)
{
- NTSTATUS Status;
- PFILE_OBJECT FileObject;
- PIRP Irp;
- PIO_STACK_LOCATION StackPtr;
- PKEVENT ptrEvent = NULL;
- IO_STATUS_BLOCK IoSB;
-
- DPRINT("NtReadFile(FileHandle %x Buffer %x Length %x ByteOffset %x, "
- "IoStatusBlock %x)\n", FileHandle, Buffer, Length, ByteOffset,
- IoStatusBlock);
-
- Status = ObReferenceObjectByHandle(FileHandle,
- FILE_READ_DATA,
- IoFileObjectType,
+ NTSTATUS Status;
+ PFILE_OBJECT FileObject;
+ PIRP Irp;
+ PIO_STACK_LOCATION StackPtr;
+ PKEVENT Event = NULL;
+ IO_STATUS_BLOCK Iosb;
+ PIO_STATUS_BLOCK IoStatusBlock;
+
+ DPRINT("NtReadFile(FileHandle %x Buffer %x Length %x ByteOffset %x, "
+ "IoStatusBlock %x)\n", FileHandle, Buffer, Length, ByteOffset,
+ IoStatusBlock);
+
+ Status = ObReferenceObjectByHandle(FileHandle,
+ FILE_READ_DATA,
+ IoFileObjectType,
+ UserMode,
+ (PVOID*)&FileObject,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+
+ if (ByteOffset == NULL)
+ {
+ ByteOffset = &FileObject->CurrentByteOffset;
+ }
+
+ if (EventHandle != NULL)
+ {
+ Status = ObReferenceObjectByHandle(EventHandle,
+ SYNCHRONIZE,
+ ExEventObjectType,
+ UserMode,
+ (PVOID*)&Event,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(FileObject);
+ return(Status);
+ }
+ }
+ else
+ {
+ Event = &FileObject->Event;
+ KeResetEvent(Event);
+ }
+
+ if (FileObject->Flags & FO_SYNCHRONOUS_IO)
+ {
+ IoStatusBlock = &Iosb;
+ }
+ else
+ {
+ IoStatusBlock = UserIoStatusBlock;
+ }
+
+ Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
+ FileObject->DeviceObject,
+ Buffer,
+ Length,
+ ByteOffset,
+ Event,
+ IoStatusBlock);
+
+ Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
+ Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
+
+ StackPtr = IoGetNextIrpStackLocation(Irp);
+ StackPtr->FileObject = FileObject;
+ if (Key != NULL)
+ {
+ StackPtr->Parameters.Read.Key = *Key;
+ }
+ else
+ {
+ StackPtr->Parameters.Read.Key = 0;
+ }
+
+ Status = IoCallDriver(FileObject->DeviceObject, Irp);
+ if (Status == STATUS_PENDING && FileObject->Flags & FO_SYNCHRONOUS_IO)
+ {
+ BOOLEAN Alertable;
+
+ if (FileObject->Flags & FO_ALERTABLE_IO)
+ {
+ Alertable = TRUE;
+ }
+ else
+ {
+ Alertable = FALSE;
+ }
+
+ Status = KeWaitForSingleObject(Event,
+ Executive,
UserMode,
- (PVOID*)&FileObject,
+ Alertable,
NULL);
- if( !NT_SUCCESS( Status ) )
- return Status;
-
- if (ByteOffset == NULL)
- {
- ByteOffset = &FileObject->CurrentByteOffset;
- }
-
- if (EventHandle != NULL)
- {
- Status = ObReferenceObjectByHandle(EventHandle,
- SYNCHRONIZE,
- ExEventObjectType,
- UserMode,
- (PVOID*)&ptrEvent,
- NULL);
- if (!NT_SUCCESS(Status))
- {
- ObDereferenceObject(FileObject);
- return Status;
- }
- }
- else
- {
- ptrEvent = &FileObject->Event;
- KeResetEvent( ptrEvent );
- }
-
- Irp = IoBuildSynchronousFsdRequest(IRP_MJ_READ,
- FileObject->DeviceObject,
- Buffer,
- Length,
- ByteOffset,
- ptrEvent,
- EventHandle ? IoStatusBlock : &IoSB);
-
- Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
- Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
-
- StackPtr = IoGetNextIrpStackLocation(Irp);
- StackPtr->FileObject = FileObject;
- if (Key != NULL)
- {
- StackPtr->Parameters.Read.Key = *Key;
- }
- else
- {
- StackPtr->Parameters.Read.Key = 0;
- }
-
- Status = IoCallDriver(FileObject->DeviceObject,
- Irp);
- if (EventHandle == NULL && Status == STATUS_PENDING &&
- !(FileObject->Flags & FO_SYNCHRONOUS_IO))
- {
- BOOLEAN Alertable;
-
- if (FileObject->Flags & FO_ALERTABLE_IO)
- {
- Alertable = TRUE;
- }
- else
- {
- Alertable = FALSE;
- }
-
- Status = KeWaitForSingleObject(ptrEvent,
- Executive,
- KernelMode,
- Alertable,
- NULL);
- if( !NT_SUCCESS( Status ) )
- {
- DPRINT1( "WaitForSingleObject failed: %x\n", Status );
- }
- else Status = IoSB.Status;
- }
- if (IoStatusBlock && EventHandle == NULL)
- {
- *IoStatusBlock = IoSB;
+ if (Status != STATUS_WAIT_0)
+ {
+ /* Wait failed. */
+ return(Status);
+ }
+ Status = Iosb.Status;
+ return(Status);
}
- return (Status);
+ if (FileObject->Flags & FO_SYNCHRONOUS_IO)
+ {
+ *UserIoStatusBlock = Iosb;
+ }
+ return(Status);
}
HANDLE EventHandle,
PIO_APC_ROUTINE ApcRoutine,
PVOID ApcContext,
- PIO_STATUS_BLOCK IoStatusBlock,
+ PIO_STATUS_BLOCK UserIoStatusBlock,
PVOID Buffer,
ULONG Length,
PLARGE_INTEGER ByteOffset,
PULONG Key)
{
- NTSTATUS Status;
- PFILE_OBJECT FileObject;
- PIRP Irp;
- PIO_STACK_LOCATION StackPtr;
- PKEVENT ptrEvent;
- IO_STATUS_BLOCK IoSB;
-
- DPRINT("NtWriteFile(FileHandle %x, Buffer %x, Length %d)\n",
- FileHandle, Buffer, Length);
-
- Status = ObReferenceObjectByHandle(FileHandle,
- FILE_WRITE_DATA,
- IoFileObjectType,
+ NTSTATUS Status;
+ PFILE_OBJECT FileObject;
+ PIRP Irp;
+ PIO_STACK_LOCATION StackPtr;
+ PKEVENT Event = NULL;
+ IO_STATUS_BLOCK Iosb;
+ PIO_STATUS_BLOCK IoStatusBlock;
+
+ DPRINT("NtReadFile(FileHandle %x Buffer %x Length %x ByteOffset %x, "
+ "IoStatusBlock %x)\n", FileHandle, Buffer, Length, ByteOffset,
+ IoStatusBlock);
+
+ Status = ObReferenceObjectByHandle(FileHandle,
+ FILE_READ_DATA,
+ IoFileObjectType,
+ UserMode,
+ (PVOID*)&FileObject,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ return(Status);
+ }
+
+ if (ByteOffset == NULL)
+ {
+ ByteOffset = &FileObject->CurrentByteOffset;
+ }
+
+ if (EventHandle != NULL)
+ {
+ Status = ObReferenceObjectByHandle(EventHandle,
+ SYNCHRONIZE,
+ ExEventObjectType,
+ UserMode,
+ (PVOID*)&Event,
+ NULL);
+ if (!NT_SUCCESS(Status))
+ {
+ ObDereferenceObject(FileObject);
+ return(Status);
+ }
+ }
+ else
+ {
+ Event = &FileObject->Event;
+ KeResetEvent(Event);
+ }
+
+ if (FileObject->Flags & FO_SYNCHRONOUS_IO)
+ {
+ IoStatusBlock = &Iosb;
+ }
+ else
+ {
+ IoStatusBlock = UserIoStatusBlock;
+ }
+
+ Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE,
+ FileObject->DeviceObject,
+ Buffer,
+ Length,
+ ByteOffset,
+ Event,
+ IoStatusBlock);
+
+ Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
+ Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
+
+ StackPtr = IoGetNextIrpStackLocation(Irp);
+ StackPtr->FileObject = FileObject;
+ if (Key != NULL)
+ {
+ StackPtr->Parameters.Write.Key = *Key;
+ }
+ else
+ {
+ StackPtr->Parameters.Write.Key = 0;
+ }
+
+ Status = IoCallDriver(FileObject->DeviceObject, Irp);
+ if (Status == STATUS_PENDING && FileObject->Flags & FO_SYNCHRONOUS_IO)
+ {
+ BOOLEAN Alertable;
+
+ if (FileObject->Flags & FO_ALERTABLE_IO)
+ {
+ Alertable = TRUE;
+ }
+ else
+ {
+ Alertable = FALSE;
+ }
+
+ Status = KeWaitForSingleObject(Event,
+ Executive,
UserMode,
- (PVOID*)&FileObject,
+ Alertable,
NULL);
- if (!NT_SUCCESS(Status))
- {
+ if (Status != STATUS_WAIT_0)
+ {
+ /* Wait failed. */
+ return(Status);
+ }
+ Status = Iosb.Status;
return(Status);
}
-
- if (ByteOffset == NULL)
- {
- ByteOffset = &FileObject->CurrentByteOffset;
- }
-
- if (EventHandle != NULL)
- {
- Status = ObReferenceObjectByHandle(EventHandle,
- SYNCHRONIZE,
- ExEventObjectType,
- UserMode,
- (PVOID*)&ptrEvent,
- NULL);
- if (!NT_SUCCESS(Status))
- {
- ObDereferenceObject(FileObject);
- return(Status);
- }
- }
- else
- {
- ptrEvent = &FileObject->Event;
- KeResetEvent( ptrEvent );
- }
-
- Irp = IoBuildSynchronousFsdRequest(IRP_MJ_WRITE,
- FileObject->DeviceObject,
- Buffer,
- Length,
- ByteOffset,
- ptrEvent,
- EventHandle ? IoStatusBlock : &IoSB);
-
- Irp->Overlay.AsynchronousParameters.UserApcRoutine = ApcRoutine;
- Irp->Overlay.AsynchronousParameters.UserApcContext = ApcContext;
-
- DPRINT("FileObject->DeviceObject %x\n",FileObject->DeviceObject);
-
- StackPtr = IoGetNextIrpStackLocation(Irp);
- StackPtr->FileObject = FileObject;
- if (Key != NULL)
- {
- StackPtr->Parameters.Write.Key = *Key;
- }
- else
- {
- StackPtr->Parameters.Write.Key = 0;
- }
- Status = IoCallDriver(FileObject->DeviceObject, Irp);
- if (EventHandle == NULL && Status == STATUS_PENDING &&
- !(FileObject->Flags & FO_SYNCHRONOUS_IO))
- {
- KeWaitForSingleObject(ptrEvent,
- Executive,
- KernelMode,
- FileObject->Flags & FO_ALERTABLE_IO ? TRUE : FALSE,
- NULL);
- Status = IoSB.Status;
- }
- if (IoStatusBlock && EventHandle == NULL)
- {
- *IoStatusBlock = IoSB;
- }
- return(Status);
+ if (FileObject->Flags & FO_SYNCHRONOUS_IO)
+ {
+ *UserIoStatusBlock = Iosb;
+ }
+ return(Status);
}
VOID
KiDumpTrapFrame(PKTRAP_FRAME Tf, ULONG Parameter1, ULONG Parameter2)
{
- unsigned int cr3;
- unsigned int i;
+ ULONG cr3;
+ ULONG i;
ULONG StackLimit;
PULONG Frame;
ULONG Esp0;
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: irq.c,v 1.21 2002/07/10 15:12:33 ekohl Exp $
+/* $Id: irq.c,v 1.22 2002/08/14 20:58:35 dwelch Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/i386/irq.c
#ifdef MP
+/*
+ * FIXME: This does not work if we have more than 24 IRQs (ie. more than one
+ * I/O APIC)
+ */
+#define VECTOR2IRQ(vector) (((vector) - 0x31) / 8)
+#define VECTOR2IRQL(vector) (4 + VECTOR2IRQ(vector))
+
#define IRQ_BASE FIRST_DEVICE_VECTOR
#define NR_IRQS 0x100 - 0x30
#define NDEBUG
#include <internal/debug.h>
-/* FUNCTIONS **************************************************************/
+/* GLOBALS *******************************************************************/
#define FLAG_NT (1<<14)
#define FLAG_VM (1<<17)
#define FLAG_IF (1<<9)
#define FLAG_IOPL ((1<<12)+(1<<13))
+/* FUNCTIONS *****************************************************************/
+
NTSTATUS
-KeValidateUserContext(PCONTEXT Context)
+Ki386ValidateUserContext(PCONTEXT Context)
/*
* FUNCTION: Validates a processor context
* ARGUMENTS:
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: kthread.c,v 1.31 2002/08/09 17:23:57 dwelch Exp $
+/* $Id: kthread.c,v 1.32 2002/08/14 20:58:35 dwelch Exp $
*
* FILE: ntoskrnl/ke/kthread.c
* PURPOSE: Microkernel thread support
#define NDEBUG
#include <internal/debug.h>
-/* EXTERN ********************************************************************/
-
-//extern VOID
-//PiTimeoutThread(struct _KDPC Dpc, PVOID Context, PVOID Arg1, PVOID Arg2);
-
/* FUNCTIONS *****************************************************************/
VOID
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: main.c,v 1.133 2002/08/10 16:41:18 dwelch Exp $
+/* $Id: main.c,v 1.134 2002/08/14 20:58:35 dwelch Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/ke/main.c
KeLoaderBlock.ModsAddr = (ULONG)&KeLoaderModules;
/*
- * Convert a path specification in the grub to one understood by the
+ * Convert a path specification in the grub format to one understood by the
* rest of the kernel.
*/
if (((PUCHAR)_LoaderBlock->CommandLine)[0] == '(')
-/* $Id: timer.c,v 1.50 2002/05/14 21:19:18 dwelch Exp $
+/* $Id: timer.c,v 1.51 2002/08/14 20:58:35 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
NTSTATUS STDCALL
NtGetTickCount (PULONG UpTime)
{
- LARGE_INTEGER TickCount;
- if ( UpTime == NULL )
- return(STATUS_INVALID_PARAMETER);
- KeQueryTickCount(&TickCount);
- *UpTime = TickCount.u.LowPart;
- return (STATUS_SUCCESS);
+ LARGE_INTEGER TickCount;
+ if (UpTime == NULL)
+ return(STATUS_INVALID_PARAMETER);
+ KeQueryTickCount(&TickCount);
+ *UpTime = TickCount.u.LowPart;
+ return (STATUS_SUCCESS);
}
InsertTailList(&TimerListHead,&Timer->TimerListEntry);
KeReleaseSpinLock(&TimerListLock, oldlvl);
- return FALSE;
+ return(FALSE);
}
BOOLEAN STDCALL
* NOTE: This function initializes a notification timer
*/
{
- KeInitializeTimerEx(Timer,NotificationTimer);
+ KeInitializeTimerEx(Timer, NotificationTimer);
}
VOID STDCALL
-/* $Id: loader.c,v 1.119 2002/08/10 16:41:18 dwelch Exp $
+/* $Id: loader.c,v 1.120 2002/08/14 20:58:36 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
&ObjectAttributes,
&IoStatusBlock,
0,
- 0);
+ FILE_SYNCHRONOUS_IO_NONALERT);
CHECKPOINT;
if (!NT_SUCCESS(Status))
{
RtlZeroMemory(CreatedModuleObject, sizeof(MODULE_OBJECT));
/* Initialize ModuleObject data */
- CreatedModuleObject->Base = DriverBase;
- CreatedModuleObject->Flags = MODULE_FLAG_PE;
-
- RtlCreateUnicodeString(&CreatedModuleObject->FullName,
- FileName->Buffer);
- LdrpBuildModuleBaseName(&CreatedModuleObject->BaseName,
- &CreatedModuleObject->FullName);
-
- CreatedModuleObject->EntryPoint = (PVOID)((DWORD)DriverBase +
- PEOptionalHeader->AddressOfEntryPoint);
+ CreatedModuleObject->Base = DriverBase;
+ CreatedModuleObject->Flags = MODULE_FLAG_PE;
+
+ RtlCreateUnicodeString(&CreatedModuleObject->FullName,
+ FileName->Buffer);
+ LdrpBuildModuleBaseName(&CreatedModuleObject->BaseName,
+ &CreatedModuleObject->FullName);
+
+ CreatedModuleObject->EntryPoint =
+ (PVOID)((DWORD)DriverBase +
+ PEOptionalHeader->AddressOfEntryPoint);
CreatedModuleObject->Length = DriverSize;
DPRINT("EntryPoint at %x\n", CreatedModuleObject->EntryPoint);
-
+
CreatedModuleObject->Image.PE.FileHeader =
(PIMAGE_FILE_HEADER) ((unsigned int) DriverBase + PEDosHeader->e_lfanew + sizeof(ULONG));
RtlZeroMemory(ModuleTextSection, sizeof(MODULE_TEXT_SECTION));
ModuleTextSection->Base = (ULONG)DriverBase;
ModuleTextSection->Length = DriverSize;
- ModuleTextSection->Name =
- ExAllocatePool(NonPagedPool,
- (wcslen(NameBuffer) + 1) * sizeof(WCHAR));
- wcscpy(ModuleTextSection->Name, NameBuffer);
+ ModuleTextSection->Name = ExAllocatePool(NonPagedPool,
+ (wcslen(CreatedModuleObject->BaseName.Buffer) + 1) * sizeof(WCHAR));
+ wcscpy(ModuleTextSection->Name, CreatedModuleObject->BaseName.Buffer);
ModuleTextSection->OptionalHeader =
CreatedModuleObject->Image.PE.OptionalHeader;
InsertTailList(&ModuleTextListHead, &ModuleTextSection->ListEntry);
PEPROCESS Process;
ANSI_STRING ProcedureName;
ULONG ViewSize;
+ IO_STATUS_BLOCK Iosb;
/*
* Locate and open NTDLL to determine ImageBase
&FileObjectAttributes,
NULL,
FILE_SHARE_READ,
- 0);
+ FILE_SYNCHRONOUS_IO_NONALERT);
if (!NT_SUCCESS(Status))
{
DbgPrint("NTDLL open failed (Status %x)\n", Status);
0,
0,
0,
- 0,
+ &Iosb,
BlockBuffer,
sizeof(BlockBuffer),
0,
0);
- if (!NT_SUCCESS(Status))
+ if (!NT_SUCCESS(Status) || Iosb.Information != sizeof(BlockBuffer))
{
DbgPrint("NTDLL header read failed (Status %x)\n", Status);
ZwClose(FileHandle);
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: anonmem.c,v 1.1 2002/08/10 16:41:19 dwelch Exp $
+/* $Id: anonmem.c,v 1.2 2002/08/14 20:58:36 dwelch Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/anonmem.c
NTSTATUS
MmWritePageVirtualMemory(PMADDRESS_SPACE AddressSpace,
- PMEMORY_AREA MArea,
- PVOID Address)
+ PMEMORY_AREA MemoryArea,
+ PVOID Address,
+ PMM_PAGEOP PageOp)
{
- return(STATUS_UNSUCCESSFUL);
-}
+ SWAPENTRY SwapEntry;
+ LARGE_INTEGER PhysicalAddress;
+ PMDL Mdl;
+ NTSTATUS Status;
+
+ /*
+ * Check for paging out from a deleted virtual memory area.
+ */
+ if (MemoryArea->DeleteInProgress)
+ {
+ PageOp->Status = STATUS_UNSUCCESSFUL;
+ KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
+ MmReleasePageOp(PageOp);
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ PhysicalAddress =
+ MmGetPhysicalAddressForProcess(AddressSpace->Process, Address);
+
+ /*
+ * Get that the page actually is dirty.
+ */
+ if (!MmIsDirtyPage(MemoryArea->Process, Address))
+ {
+ PageOp->Status = STATUS_SUCCESS;
+ KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
+ MmReleasePageOp(PageOp);
+ return(STATUS_SUCCESS);
+ }
+ /*
+ * Speculatively set the mapping to clean.
+ */
+ MmSetCleanPage(MemoryArea->Process, Address);
+
+ /*
+ * If necessary, allocate an entry in the paging file for this page
+ */
+ SwapEntry = MmGetSavedSwapEntryPage(PhysicalAddress);
+ if (SwapEntry == 0)
+ {
+ SwapEntry = MmAllocSwapPage();
+ if (SwapEntry == 0)
+ {
+ MmSetDirtyPage(MemoryArea->Process, Address);
+ PageOp->Status = STATUS_PAGEFILE_QUOTA_EXCEEDED;
+ KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
+ MmReleasePageOp(PageOp);
+ return(STATUS_PAGEFILE_QUOTA_EXCEEDED);
+ }
+ }
+
+ /*
+ * Write the page to the pagefile
+ */
+ Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
+ MmBuildMdlFromPages(Mdl, (PULONG)&PhysicalAddress);
+ Status = MmWriteToSwapPage(SwapEntry, Mdl);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n",
+ Status);
+ MmSetDirtyPage(MemoryArea->Process, Address);
+ PageOp->Status = STATUS_UNSUCCESSFUL;
+ KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
+ MmReleasePageOp(PageOp);
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ /*
+ * Otherwise we have succeeded.
+ */
+ MmSetSavedSwapEntryPage(PhysicalAddress, SwapEntry);
+ PageOp->Status = STATUS_SUCCESS;
+ KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
+ MmReleasePageOp(PageOp);
+ return(STATUS_SUCCESS);
+}
NTSTATUS
MmPageOutVirtualMemory(PMADDRESS_SPACE AddressSpace,
*/
if (MemoryArea->DeleteInProgress)
{
- return(STATUS_UNSUCCESSFUL);
- }
-
- /*
- * Paging out code or readonly data is easy.
- */
- if ((MemoryArea->Attributes & PAGE_READONLY) ||
- (MemoryArea->Attributes & PAGE_EXECUTE_READ))
- {
- MmDeleteVirtualMapping(MemoryArea->Process, Address, FALSE,
- NULL, &PhysicalAddress);
- MmDeleteAllRmaps(PhysicalAddress, NULL, NULL);
- if (MmGetSavedSwapEntryPage(PhysicalAddress) != 0)
- {
- DPRINT1("Read-only page was swapped out.\n");
- KeBugCheck(0);
- }
- MmReleasePageMemoryConsumer(MC_USER, PhysicalAddress);
-
- PageOp->Status = STATUS_SUCCESS;
+ PageOp->Status = STATUS_UNSUCCESSFUL;
KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
MmReleasePageOp(PageOp);
- return(STATUS_SUCCESS);
+ return(STATUS_UNSUCCESSFUL);
}
/*
- * Otherwise this is read-write data
+ * Disable the virtual mapping.
*/
MmDisableVirtualMapping(MemoryArea->Process, Address,
&WasDirty, (PULONG)&PhysicalAddress);
{
KeBugCheck(0);
}
+
+ /*
+ * Paging out non-dirty data is easy.
+ */
if (!WasDirty)
{
MmDeleteVirtualMapping(MemoryArea->Process, Address, FALSE, NULL, NULL);
FALSE, NULL, NULL);
if (PhysicalAddr.QuadPart != 0)
{
+ SWAPENTRY SavedSwapEntry;
+ SavedSwapEntry = MmGetSavedSwapEntryPage(PhysicalAddr);
+ if (SavedSwapEntry != 0)
+ {
+ MmFreeSwapPage(SavedSwapEntry);
+ MmSetSavedSwapEntryPage(PhysicalAddr, 0);
+ }
MmDeleteRmap(PhysicalAddr, AddressSpace->Process,
BaseAddress + (i * PAGESIZE));
MmReleasePageMemoryConsumer(MC_USER, PhysicalAddr);
* a combination of PAGE_READONLY, PAGE_READWRITE,
* PAGE_EXECUTE_READ, PAGE_EXECUTE_READWRITE, PAGE_GUARD,
* PAGE_NOACCESS
- * REMARKS:
- * This function maps to the win32 VirtualAllocEx. Virtual memory is
- * process based so the protocol starts with a ProcessHandle. I
- * splitted the functionality of obtaining the actual address and
- * specifying the start address in two parameters ( BaseAddress and
- * StartAddress ) The NumberOfBytesAllocated specify the range and the
- * AllocationType and ProctectionType map to the other two parameters.
* RETURNS: Status
*/
{
PBaseAddress = *UBaseAddress;
PRegionSize = *URegionSize;
-
BaseAddress = (PVOID)PAGE_ROUND_DOWN(PBaseAddress);
RegionSize = PAGE_ROUND_UP(PBaseAddress + PRegionSize) -
PAGE_ROUND_DOWN(PBaseAddress);
if (PhysicalAddr.QuadPart != 0)
{
+ SWAPENTRY SavedSwapEntry;
+ SavedSwapEntry = MmGetSavedSwapEntryPage(PhysicalAddr);
+ if (SavedSwapEntry != 0)
+ {
+ MmFreeSwapPage(SavedSwapEntry);
+ MmSetSavedSwapEntryPage(PhysicalAddr, 0);
+ }
MmDeleteRmap(PhysicalAddr, Process, Address);
MmReleasePageMemoryConsumer(MC_USER, PhysicalAddr);
}
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: balance.c,v 1.10 2002/06/10 21:34:37 hbirr Exp $
+/* $Id: balance.c,v 1.11 2002/08/14 20:58:36 dwelch Exp $
*
- * COPYRIGHT: See COPYING in the top directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/balance.c
* PURPOSE: kernel memory managment functions
VOID MmPrintMemoryStatistic(VOID)
{
DbgPrint("MC_CACHE %d, MC_USER %d, MC_PPOOL %d, MC_NPPOOL %d\n",
- MiMemoryConsumers[MC_CACHE].PagesUsed, MiMemoryConsumers[MC_USER].PagesUsed,
- MiMemoryConsumers[MC_PPOOL].PagesUsed, MiMemoryConsumers[MC_NPPOOL].PagesUsed);
+ MiMemoryConsumers[MC_CACHE].PagesUsed,
+ MiMemoryConsumers[MC_USER].PagesUsed,
+ MiMemoryConsumers[MC_PPOOL].PagesUsed,
+ MiMemoryConsumers[MC_NPPOOL].PagesUsed);
}
VOID
/* Set up targets. */
MiMinimumAvailablePages = 64;
MiMemoryConsumers[MC_CACHE].PagesTarget = NrAvailablePages / 2;
- MiMemoryConsumers[MC_USER].PagesTarget = NrAvailablePages - MiMinimumAvailablePages;
+ MiMemoryConsumers[MC_USER].PagesTarget =
+ NrAvailablePages - MiMinimumAvailablePages;
MiMemoryConsumers[MC_PPOOL].PagesTarget = NrAvailablePages / 2;
MiMemoryConsumers[MC_NPPOOL].PagesTarget = 0xFFFFFFFF;
}
KeAcquireSpinLock(&AllocationListLock, &oldIrql);
if (MmGetReferenceCountPage(Page) == 1)
- {
- InterlockedDecrement(&MiMemoryConsumers[Consumer].PagesUsed);
- InterlockedIncrement(&MiNrAvailablePages);
- InterlockedDecrement(&MiPagesRequired);
- if (IsListEmpty(&AllocationListHead))
{
- KeReleaseSpinLock(&AllocationListLock, oldIrql);
- MmDereferencePage(Page);
+ InterlockedDecrement(&MiMemoryConsumers[Consumer].PagesUsed);
+ InterlockedIncrement(&MiNrAvailablePages);
+ InterlockedDecrement(&MiPagesRequired);
+ if (IsListEmpty(&AllocationListHead))
+ {
+ KeReleaseSpinLock(&AllocationListLock, oldIrql);
+ MmDereferencePage(Page);
+ }
+ else
+ {
+ Entry = RemoveHeadList(&AllocationListHead);
+ Request = CONTAINING_RECORD(Entry, MM_ALLOCATION_REQUEST, ListEntry);
+ KeReleaseSpinLock(&AllocationListLock, oldIrql);
+ Request->Page = Page;
+ KeSetEvent(&Request->Event, IO_NO_INCREMENT, FALSE);
+ }
}
- else
+ else
{
- Entry = RemoveHeadList(&AllocationListHead);
- Request = CONTAINING_RECORD(Entry, MM_ALLOCATION_REQUEST, ListEntry);
KeReleaseSpinLock(&AllocationListLock, oldIrql);
- Request->Page = Page;
- KeSetEvent(&Request->Event, IO_NO_INCREMENT, FALSE);
+ MmDereferencePage(Page);
}
- }
- else
- {
- KeReleaseSpinLock(&AllocationListLock, oldIrql);
- MmDereferencePage(Page);
- }
return(STATUS_SUCCESS);
}
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: page.c,v 1.39 2002/08/10 16:41:20 dwelch Exp $
+/* $Id: page.c,v 1.40 2002/08/14 20:58:37 dwelch Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/i386/page.c
return(page_tlb);
}
-BOOLEAN MmIsPageDirty(PEPROCESS Process, PVOID Address)
+BOOLEAN MmIsDirtyPage(PEPROCESS Process, PVOID Address)
{
return((MmGetPageEntryForProcess(Process, Address)) & PA_DIRTY);
}
-/* $Id: mminit.c,v 1.36 2002/07/17 21:04:56 dwelch Exp $
+/* $Id: mminit.c,v 1.37 2002/08/14 20:58:36 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top directory
* PROJECT: ReactOS kernel
MmCreatePhysicalMemorySection();
MmInitializeRmapList();
+ /*
+ * Initialise the modified page writer.
+ */
+ MmInitMpwThread();
+
/* FIXME: Read parameters from memory */
}
-/* $Id: mpw.c,v 1.7 2001/12/31 01:53:45 dwelch Exp $
+/*
+ * ReactOS kernel
+ * Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
+ *
+ * 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: mpw.c,v 1.8 2002/08/14 20:58:36 dwelch Exp $
*
- * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/mpw.c
* PURPOSE: Writes data that has been modified in memory but not on
#include <ddk/ntddk.h>
#include <internal/ps.h>
#include <internal/mm.h>
+#include <internal/cc.h>
#define NDEBUG
#include <internal/debug.h>
/* FUNCTIONS *****************************************************************/
+NTSTATUS STDCALL
+MmWriteDirtyPages(ULONG Target, PULONG Actual)
+{
+ PHYSICAL_ADDRESS Page;
+ PHYSICAL_ADDRESS NextPage;
+ NTSTATUS Status;
+
+ Page = MmGetLRUFirstUserPage();
+ while (Page.QuadPart != 0LL && Target > 0)
+ {
+ NextPage = MmGetLRUNextUserPage(Page);
+ if (MmIsDirtyPageRmap(Page))
+ {
+ Status = MmWritePagePhysicalAddress(Page);
+ if (NT_SUCCESS(Status))
+ {
+ Target--;
+ }
+ }
+ Page = NextPage;
+ }
+ *Actual = Target;
+ return(STATUS_SUCCESS);
+}
+
NTSTATUS STDCALL
MmMpwThreadMain(PVOID Ignored)
{
NTSTATUS Status;
-
+ ULONG PagesWritten;
+ LARGE_INTEGER Timeout;
+
+ Timeout.QuadPart = -50000000;
+
for(;;)
{
- Status = KeWaitForSingleObject(&MpwThreadEvent,
- 0,
- KernelMode,
- FALSE,
- NULL);
- if (!NT_SUCCESS(Status))
- {
- DbgPrint("MpwThread: Wait failed\n");
- KeBugCheck(0);
- return(STATUS_UNSUCCESSFUL);
- }
- if (MpwThreadShouldTerminate)
- {
- DbgPrint("MpwThread: Terminating\n");
- return(STATUS_SUCCESS);
- }
+ Status = KeWaitForSingleObject(&MpwThreadEvent,
+ 0,
+ KernelMode,
+ FALSE,
+ &Timeout);
+ if (!NT_SUCCESS(Status))
+ {
+ DbgPrint("MpwThread: Wait failed\n");
+ KeBugCheck(0);
+ return(STATUS_UNSUCCESSFUL);
+ }
+ if (MpwThreadShouldTerminate)
+ {
+ DbgPrint("MpwThread: Terminating\n");
+ return(STATUS_SUCCESS);
+ }
+
+ PagesWritten = 0;
+ MmWriteDirtyPages(128, &PagesWritten);
+ CcRosFlushDirtyPages(128, &PagesWritten);
}
}
NTSTATUS Status;
MpwThreadShouldTerminate = FALSE;
- KeInitializeEvent(&MpwThreadEvent,
- SynchronizationEvent,
- FALSE);
-
+ KeInitializeEvent(&MpwThreadEvent, SynchronizationEvent, FALSE);
+
Status = PsCreateSystemThread(&MpwThreadHandle,
THREAD_ALL_ACCESS,
NULL,
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: pagefile.c,v 1.21 2002/07/17 21:04:56 dwelch Exp $
+/* $Id: pagefile.c,v 1.22 2002/08/14 20:58:36 dwelch Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/pagefile.c
static ULONG MmCoreDumpSize;
static PULONG MmCoreDumpBlockMap = NULL;
static MM_DUMP_POINTERS MmCoreDumpDeviceFuncs;
-DWORD MmCoreDumpType;
+ULONG MmCoreDumpType;
/*
* Translate between a swap entry and a file and offset pair.
KeAcquireSpinLock(&PagingFileListLock, &oldIrql);
MiAvailSwapPages =
(MiFreeSwapPages * MM_PAGEFILE_COMMIT_RATIO) + MM_PAGEFILE_COMMIT_GRACE;
+ MiReservedSwapPages = MiReservedSwapPages + Nr;
if (MM_PAGEFILE_COMMIT_RATIO != 0 && MiAvailSwapPages < MiReservedSwapPages)
{
KeReleaseSpinLock(&PagingFileListLock, oldIrql);
return(FALSE);
- }
- MiReservedSwapPages = MiReservedSwapPages + Nr;
+ }
KeReleaseSpinLock(&PagingFileListLock, oldIrql);
-
return(TRUE);
}
KeReleaseSpinLock(&PagingFileListLock, oldIrql);
}
+BOOLEAN
+MmIsAvailableSwapPage(VOID)
+{
+ return(MiFreeSwapPages > 0);
+}
+
SWAPENTRY
MmAllocSwapPage(VOID)
{
KIRQL oldIrql;
ULONG AllocMapSize;
ULONG i;
- PVOID Buffer;
DPRINT("NtCreatePagingFile(FileName %wZ, InitialSize %I64d)\n",
FileName, InitialSize->QuadPart);
return(Status);
}
- Buffer = ExAllocatePool(NonPagedPool, 4096);
- memset(Buffer, 0, 4096);
- Status = NtWriteFile(FileHandle,
- NULL,
- NULL,
- NULL,
- &IoStatus,
- Buffer,
- 4096,
- InitialSize,
- NULL);
+ Status = NtSetInformationFile(FileHandle,
+ &IoStatus,
+ InitialSize,
+ sizeof(LARGE_INTEGER),
+ FileAllocationInformation);
if (!NT_SUCCESS(Status))
{
- NtClose(FileHandle);
+ ZwClose(FileHandle);
return(Status);
}
- ExFreePool(Buffer);
Status = ObReferenceObjectByHandle(FileHandle,
FILE_ALL_ACCESS,
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: rmap.c,v 1.7 2002/08/10 16:41:19 dwelch Exp $
+/* $Id: rmap.c,v 1.8 2002/08/14 20:58:36 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top directory
* PROJECT: ReactOS kernel
}
NTSTATUS
-MmPageOutPhysicalAddress(PHYSICAL_ADDRESS PhysicalAddress)
+MmWritePagePhysicalAddress(PHYSICAL_ADDRESS PhysicalAddress)
{
PMM_RMAP_ENTRY entry;
PMEMORY_AREA MemoryArea;
KeBugCheck(0);
}
+ ExReleaseFastMutex(&RmapListLock);
MmLockAddressSpace(&Process->AddressSpace);
MemoryArea = MmOpenMemoryAreaByAddress(&Process->AddressSpace, Address);
Type = MemoryArea->Type;
{
MmReleasePageOp(PageOp);
MmUnlockAddressSpace(&Process->AddressSpace);
- ExReleaseFastMutex(&RmapListLock);
return(STATUS_UNSUCCESSFUL);
}
+ /*
+ * Release locks now we have a page op.
+ */
+ MmUnlockAddressSpace(&Process->AddressSpace);
+
+ /*
+ * Do the actual page out work.
+ */
+ Status = MmWritePageSectionView(&Process->AddressSpace, MemoryArea,
+ Address, PageOp);
+ }
+ else if (Type == MEMORY_AREA_VIRTUAL_MEMORY)
+ {
+ PageOp = MmGetPageOp(MemoryArea, Process->UniqueProcessId,
+ Address, NULL, 0, MM_PAGEOP_PAGEOUT);
+ if (PageOp->Thread != PsGetCurrentThread())
+ {
+ MmReleasePageOp(PageOp);
+ MmUnlockAddressSpace(&Process->AddressSpace);
+ return(STATUS_UNSUCCESSFUL);
+ }
+
/*
* Release locks now we have a page op.
*/
MmUnlockAddressSpace(&Process->AddressSpace);
+
+ /*
+ * Do the actual page out work.
+ */
+ Status = MmWritePageVirtualMemory(&Process->AddressSpace, MemoryArea,
+ Address, PageOp);
+ }
+ else
+ {
+ KeBugCheck(0);
+ }
+ return(Status);
+}
+
+NTSTATUS
+MmPageOutPhysicalAddress(PHYSICAL_ADDRESS PhysicalAddress)
+{
+ PMM_RMAP_ENTRY entry;
+ PMEMORY_AREA MemoryArea;
+ ULONG Type;
+ PVOID Address;
+ PEPROCESS Process;
+ PMM_PAGEOP PageOp;
+ LARGE_INTEGER Offset;
+ NTSTATUS Status;
+
+ ExAcquireFastMutex(&RmapListLock);
+ entry = MmGetRmapListHeadPage(PhysicalAddress);
+ if (entry == NULL)
+ {
ExReleaseFastMutex(&RmapListLock);
+ return(STATUS_UNSUCCESSFUL);
+ }
+ Process = entry->Process;
+ Address = entry->Address;
+ if ((((ULONG)Address) & 0xFFF) != 0)
+ {
+ KeBugCheck(0);
+ }
+
+ ExReleaseFastMutex(&RmapListLock);
+ MmLockAddressSpace(&Process->AddressSpace);
+ MemoryArea = MmOpenMemoryAreaByAddress(&Process->AddressSpace, Address);
+ Type = MemoryArea->Type;
+ if (Type == MEMORY_AREA_SECTION_VIEW)
+ {
+ Offset.QuadPart = (ULONG)((Address - (ULONG)MemoryArea->BaseAddress) +
+ MemoryArea->Data.SectionData.ViewOffset);
+
+ /*
+ * Get or create a pageop
+ */
+ PageOp = MmGetPageOp(MemoryArea, 0, 0,
+ MemoryArea->Data.SectionData.Segment,
+ Offset.u.LowPart, MM_PAGEOP_PAGEOUT);
+ if (PageOp == NULL)
+ {
+ DPRINT1("MmGetPageOp failed\n");
+ KeBugCheck(0);
+ }
+
+ if (PageOp->Thread != PsGetCurrentThread())
+ {
+ MmReleasePageOp(PageOp);
+ MmUnlockAddressSpace(&Process->AddressSpace);
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ /*
+ * Release locks now we have a page op.
+ */
+ MmUnlockAddressSpace(&Process->AddressSpace);
/*
* Do the actual page out work.
{
MmReleasePageOp(PageOp);
MmUnlockAddressSpace(&Process->AddressSpace);
- ExReleaseFastMutex(&RmapListLock);
return(STATUS_UNSUCCESSFUL);
}
* Release locks now we have a page op.
*/
MmUnlockAddressSpace(&Process->AddressSpace);
- ExReleaseFastMutex(&RmapListLock);
/*
* Do the actual page out work.
return(Status);
}
+VOID
+MmSetCleanAllRmaps(PHYSICAL_ADDRESS PhysicalAddress)
+{
+ PMM_RMAP_ENTRY current_entry;
+
+ ExAcquireFastMutex(&RmapListLock);
+ current_entry = MmGetRmapListHeadPage(PhysicalAddress);
+ if (current_entry == NULL)
+ {
+ DPRINT1("MmIsDirtyRmap: No rmaps.\n");
+ KeBugCheck(0);
+ }
+ while (current_entry != NULL)
+ {
+ MmSetCleanPage(current_entry->Process, current_entry->Address);
+ current_entry = current_entry->Next;
+ }
+ ExReleaseFastMutex(&RmapListLock);
+}
+
+VOID
+MmSetDirtyAllRmaps(PHYSICAL_ADDRESS PhysicalAddress)
+{
+ PMM_RMAP_ENTRY current_entry;
+
+ ExAcquireFastMutex(&RmapListLock);
+ current_entry = MmGetRmapListHeadPage(PhysicalAddress);
+ if (current_entry == NULL)
+ {
+ DPRINT1("MmIsDirtyRmap: No rmaps.\n");
+ KeBugCheck(0);
+ }
+ while (current_entry != NULL)
+ {
+ MmSetDirtyPage(current_entry->Process, current_entry->Address);
+ current_entry = current_entry->Next;
+ }
+ ExReleaseFastMutex(&RmapListLock);
+}
+
+BOOL
+MmIsDirtyPageRmap(PHYSICAL_ADDRESS PhysicalAddress)
+{
+ PMM_RMAP_ENTRY current_entry;
+
+ ExAcquireFastMutex(&RmapListLock);
+ current_entry = MmGetRmapListHeadPage(PhysicalAddress);
+ if (current_entry == NULL)
+ {
+ ExReleaseFastMutex(&RmapListLock);
+ return(FALSE);
+ }
+ while (current_entry != NULL)
+ {
+ if (MmIsDirtyPage(current_entry->Process, current_entry->Address))
+ {
+ ExReleaseFastMutex(&RmapListLock);
+ return(TRUE);
+ }
+ current_entry = current_entry->Next;
+ }
+ ExReleaseFastMutex(&RmapListLock);
+ return(FALSE);
+}
+
VOID
MmInsertRmap(PHYSICAL_ADDRESS PhysicalAddress, PEPROCESS Process,
PVOID Address)
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: section.c,v 1.88 2002/08/10 16:41:19 dwelch Exp $
+/* $Id: section.c,v 1.89 2002/08/14 20:58:37 dwelch Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/section.c
}
}
-NTSTATUS
-MmWritePageSectionView(PMADDRESS_SPACE AddressSpace,
- PMEMORY_AREA MArea,
- PVOID Address)
-{
- return(STATUS_UNSUCCESSFUL);
-}
-
VOID
MmLockSection(PSECTION_OBJECT Section)
{
{
PFILE_OBJECT FileObject;
PREACTOS_COMMON_FCB_HEADER Fcb;
+ SWAPENTRY SavedSwapEntry;
+ PHYSICAL_ADDRESS Page;
MmSetPageEntrySectionSegment(Segment, Offset, 0);
FileObject = Section->FileObject;
}
}
}
+
+ Page = (PHYSICAL_ADDRESS)(LONGLONG)PAGE_FROM_SSE(Entry);
+ SavedSwapEntry = MmGetSavedSwapEntryPage(Page);
+ if (SavedSwapEntry != 0)
+ {
+ MmFreeSwapPage(SavedSwapEntry);
+ MmSetSavedSwapEntryPage(Page, 0);
+ }
}
else
{
/*
* Satisfying a page fault on a map of /Device/PhysicalMemory is easy
*/
- if (Section->Flags & SO_PHYSICAL_MEMORY)
+ if (Section->AllocationAttributes & SEC_PHYSICALMEMORY)
{
/*
* Just map the desired physical page
MmUnlockSection(Section);
MmUnlockAddressSpace(AddressSpace);
- if (Segment->Flags & MM_PAGEFILE_SECTION)
+ if (Segment->Flags & MM_PAGEFILE_SEGMENT)
{
Status = MmRequestPageMemoryConsumer(MC_USER, TRUE, &Page);
}
* This should never happen since mappings of physical memory are never
* placed in the rmap lists.
*/
- if (Section->Flags & SO_PHYSICAL_MEMORY)
+ if (Section->AllocationAttributes & SEC_PHYSICALMEMORY)
{
DPRINT1("Trying to page out from physical memory section address 0x%X "
"process %d\n", Address, AddressSpace->Process->UniqueProcessId);
return(STATUS_SUCCESS);
}
+NTSTATUS
+MmWritePageSectionView(PMADDRESS_SPACE AddressSpace,
+ PMEMORY_AREA MemoryArea,
+ PVOID Address,
+ PMM_PAGEOP PageOp)
+{
+ LARGE_INTEGER Offset;
+ PSECTION_OBJECT Section;
+ PMM_SECTION_SEGMENT Segment;
+ PHYSICAL_ADDRESS PhysicalAddress;
+ SWAPENTRY SwapEntry;
+ PMDL Mdl;
+ ULONG Entry;
+ BOOLEAN Private;
+ NTSTATUS Status;
+ PFILE_OBJECT FileObject;
+ PREACTOS_COMMON_FCB_HEADER Fcb;
+ BOOLEAN DirectMapped;
+
+ Address = (PVOID)PAGE_ROUND_DOWN(Address);
+
+ Offset.QuadPart = (ULONG)(Address - (ULONG)MemoryArea->BaseAddress) +
+ MemoryArea->Data.SectionData.ViewOffset;
+
+ FileObject = MemoryArea->Data.SectionData.Section->FileObject;
+ DirectMapped = FALSE;
+ if (FileObject != NULL)
+ {
+ Fcb = (PREACTOS_COMMON_FCB_HEADER)FileObject->FsContext;
+
+ /*
+ * If the file system is letting us go directly to the cache and the
+ * memory area was mapped at an offset in the file which is page aligned
+ * then note this is a direct mapped page.
+ */
+ if (FileObject->Flags & FO_DIRECT_CACHE_PAGING_READ &&
+ (Offset.QuadPart % PAGESIZE) == 0)
+ {
+ DirectMapped = TRUE;
+ }
+ }
+
+ /*
+ * Get the segment and section.
+ */
+ Segment = MemoryArea->Data.SectionData.Segment;
+ Section = MemoryArea->Data.SectionData.Section;
+
+ /*
+ * This should never happen since mappings of physical memory are never
+ * placed in the rmap lists.
+ */
+ if (Section->AllocationAttributes & SEC_PHYSICALMEMORY)
+ {
+ DPRINT1("Trying to write back page from physical memory mapped at %X "
+ "process %d\n", Address, AddressSpace->Process->UniqueProcessId);
+ KeBugCheck(0);
+ }
+
+ /*
+ * Get the section segment entry and the physical address.
+ */
+ Entry = MmGetPageEntrySectionSegment(Segment, Offset.QuadPart);
+ if (!MmIsPagePresent(AddressSpace->Process, Address))
+ {
+ DPRINT1("Trying to page out not-present page at (%d,0x%.8X).\n",
+ AddressSpace->Process->UniqueProcessId, Address);
+ KeBugCheck(0);
+ }
+ PhysicalAddress =
+ MmGetPhysicalAddressForProcess(AddressSpace->Process, Address);
+ SwapEntry = MmGetSavedSwapEntryPage(PhysicalAddress);
+
+ /*
+ * Check for a private (COWed) page.
+ */
+ if (Segment->Characteristics & IMAGE_SECTION_CHAR_BSS ||
+ IS_SWAP_FROM_SSE(Entry) ||
+ (LONGLONG)PAGE_FROM_SSE(Entry) != PhysicalAddress.QuadPart)
+ {
+ Private = TRUE;
+ }
+ else
+ {
+ Private = FALSE;
+ }
+
+ /*
+ * Speculatively set all mappings of the page to clean.
+ */
+ MmSetCleanAllRmaps(PhysicalAddress);
+
+ /*
+ * If this page was direct mapped from the cache then the cache manager
+ * will take care of writing it back to disk.
+ */
+ if (DirectMapped && !Private)
+ {
+ assert(SwapEntry == 0);
+ CcRosMarkDirtyCacheSegment(Fcb->Bcb, Offset.u.LowPart);
+ PageOp->Status = STATUS_SUCCESS;
+ KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
+ MmReleasePageOp(PageOp);
+ return(STATUS_SUCCESS);
+ }
+
+ /*
+ * If necessary, allocate an entry in the paging file for this page
+ */
+ SwapEntry = MmGetSavedSwapEntryPage(PhysicalAddress);
+ if (SwapEntry == 0)
+ {
+ SwapEntry = MmAllocSwapPage();
+ if (SwapEntry == 0)
+ {
+ MmSetDirtyAllRmaps(PhysicalAddress);
+ PageOp->Status = STATUS_UNSUCCESSFUL;
+ KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
+ MmReleasePageOp(PageOp);
+ return(STATUS_UNSUCCESSFUL);
+ }
+ }
+
+ /*
+ * Write the page to the pagefile
+ */
+ Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
+ MmBuildMdlFromPages(Mdl, (PULONG)&PhysicalAddress);
+ Status = MmWriteToSwapPage(SwapEntry, Mdl);
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("MM: Failed to write to swap page (Status was 0x%.8X)\n",
+ Status);
+ MmSetDirtyAllRmaps(PhysicalAddress);
+ PageOp->Status = STATUS_UNSUCCESSFUL;
+ KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
+ MmReleasePageOp(PageOp);
+ return(STATUS_UNSUCCESSFUL);
+ }
+
+ /*
+ * Otherwise we have succeeded.
+ */
+ DPRINT("MM: Wrote section page 0x%.8X to swap!\n", PhysicalAddress);
+ MmSetSavedSwapEntryPage(PhysicalAddress, SwapEntry);
+ PageOp->Status = STATUS_SUCCESS;
+ KeSetEvent(&PageOp->CompletionEvent, IO_NO_INCREMENT, FALSE);
+ MmReleasePageOp(PageOp);
+ return(STATUS_SUCCESS);
+}
+
VOID STATIC
MmAlterViewAttributes(PMADDRESS_SPACE AddressSpace,
PVOID BaseAddress,
Info->RegionSize = MemoryArea->Length;
Info->State = MEM_COMMIT;
Info->Protect = Region->Protect;
- if (MemoryArea->Data.SectionData.Section->Flags & MM_IMAGE_SECTION)
+ if (MemoryArea->Data.SectionData.Section->AllocationAttributes & SEC_IMAGE)
{
Info->Type = MEM_IMAGE;
}
PSECTION_OBJECT Section = (PSECTION_OBJECT)ObjectBody;
DPRINT("MmpDeleteSection(ObjectBody %x)\n", ObjectBody);
- if (Section->Flags & MM_IMAGE_SECTION)
- {
- ULONG i;
-
- for (i = 0; i < Section->NrSegments; i++)
- {
- InterlockedDecrement(&Section->Segments[i].ReferenceCount);
- }
- }
- else
- {
- InterlockedDecrement(&Section->Segments->ReferenceCount);
- }
+ if (Section->AllocationAttributes & SEC_IMAGE)
+ {
+ ULONG i;
+
+ for (i = 0; i < Section->NrSegments; i++)
+ {
+ InterlockedDecrement(&Section->Segments[i].ReferenceCount);
+ }
+ }
+ else
+ {
+ InterlockedDecrement(&Section->Segments->ReferenceCount);
+ }
if (Section->FileObject != NULL)
{
ObDereferenceObject(Section->FileObject);
DbgPrint("Failed to reference PhysicalMemory section\n");
KeBugCheck(0);
}
- PhysSection->Flags = PhysSection->Flags | SO_PHYSICAL_MEMORY;
+ PhysSection->AllocationAttributes |= SEC_PHYSICALMEMORY;
ObDereferenceObject((PVOID)PhysSection);
return(STATUS_SUCCESS);
* Initialize it
*/
Section->SectionPageProtection = SectionPageProtection;
- Section->AllocateAttributes = AllocationAttributes;
+ Section->AllocationAttributes = AllocationAttributes;
InitializeListHead(&Section->ViewListHead);
KeInitializeSpinLock(&Section->ViewListLock);
KeInitializeMutex(&Section->Lock, 0);
- Section->Flags = 0;
Section->FileObject = NULL;
Section->MaximumSize = MaximumSize;
Segment = ExAllocatePoolWithTag(NonPagedPool, sizeof(MM_SECTION_SEGMENT),
Segment->Protection = SectionPageProtection;
Segment->Attributes = AllocationAttributes;
Segment->Length = MaximumSize.u.LowPart;
- Segment->Flags = MM_PAGEFILE_SECTION;
+ Segment->Flags = MM_PAGEFILE_SEGMENT;
Segment->WriteCopy = FALSE;
return(STATUS_SUCCESS);
}
* Initialize it
*/
Section->SectionPageProtection = SectionPageProtection;
- Section->AllocateAttributes = AllocationAttributes;
+ Section->AllocationAttributes = AllocationAttributes;
InitializeListHead(&Section->ViewListHead);
KeInitializeSpinLock(&Section->ViewListLock);
KeInitializeMutex(&Section->Lock, 0);
- Section->Flags = 0;
Section->NrSegments = 1;
Section->ImageBase = NULL;
Section->EntryPoint = NULL;
((PREACTOS_COMMON_FCB_HEADER)FileObject->FsContext)->FileSize;
}
+ if (MaximumSize.QuadPart >
+ ((PREACTOS_COMMON_FCB_HEADER)FileObject->FsContext)->FileSize.QuadPart)
+ {
+ IO_STATUS_BLOCK Iosb;
+ Status = NtSetInformationFile(FileHandle,
+ &Iosb,
+ &MaximumSize,
+ sizeof(LARGE_INTEGER),
+ FileAllocationInformation);
+ if (!NT_SUCCESS(Status))
+ {
+ ZwClose(*SectionHandle);
+ ObDereferenceObject(Section);
+ ObDereferenceObject(FileObject);
+ return(STATUS_SECTION_NOT_EXTENDED);
+ }
+ }
+
/*
* Lock the file
*/
Segment->FileOffset = 0;
Segment->Protection = 0;
Segment->Attributes = 0;
- Segment->Flags = 0;
+ Segment->Flags = MM_DATAFILE_SEGMENT;
Segment->Characteristics = 0;
Segment->WriteCopy = FALSE;
if (AllocationAttributes & SEC_RESERVE)
DataSectionObject;
Section->Segments = Segment;
InterlockedIncrement((PLONG)&Segment->ReferenceCount);
- Status = KeWaitForSingleObject((PVOID)&Section->Lock,
+ Status = KeWaitForSingleObject((PVOID)&Segment->Lock,
0,
KernelMode,
FALSE,
}
KeSetEvent((PVOID)&FileObject->Lock, IO_NO_INCREMENT, FALSE);
Section->FileObject = FileObject;
+ Section->MaximumSize = MaximumSize;
KeReleaseMutex(&Segment->Lock, FALSE);
ObDereferenceObject(Section);
* Initialize it
*/
Section->SectionPageProtection = SectionPageProtection;
- Section->AllocateAttributes = AllocationAttributes;
+ Section->AllocationAttributes = AllocationAttributes;
InitializeListHead(&Section->ViewListHead);
KeInitializeSpinLock(&Section->ViewListLock);
KeInitializeMutex(&Section->Lock, 0);
- Section->Flags = MM_IMAGE_SECTION;
Section->NrSegments = PEHeader.FileHeader.NumberOfSections + 1;
Section->ImageBase = (PVOID)PEHeader.OptionalHeader.ImageBase;
Section->EntryPoint = (PVOID)PEHeader.OptionalHeader.AddressOfEntryPoint;
{
PMEMORY_AREA MArea;
ULONG Entry;
+ PFILE_OBJECT FileObject;
+ PREACTOS_COMMON_FCB_HEADER Fcb;
+ ULONG Offset;
+ SWAPENTRY SavedSwapEntry;
+ PMM_PAGEOP PageOp;
MArea = (PMEMORY_AREA)Context;
+ Offset = ((ULONG)PAGE_ROUND_DOWN(Address) - (ULONG)MArea->BaseAddress) +
+ MArea->Data.SectionData.ViewOffset;
+ Entry = MmGetPageEntrySectionSegment(MArea->Data.SectionData.Segment,
+ Offset);
+
+ PageOp = MmCheckForPageOp(MArea, 0, NULL, MArea->Data.SectionData.Segment,
+ Offset);
+ assert(PageOp == NULL);
+
+ /*
+ * For a dirty, datafile, non-private page mark it as dirty in the
+ * cache manager.
+ */
+ if (MArea->Data.SectionData.Segment->Flags & MM_DATAFILE_SEGMENT)
+ {
+ if (PhysAddr.QuadPart == PAGE_FROM_SSE(Entry) && Dirty)
+ {
+ FileObject = MemoryArea->Data.SectionData.Section->FileObject;
+ Fcb = (PREACTOS_COMMON_FCB_HEADER)FileObject->FsContext;
+ CcRosMarkDirtyCacheSegment(Fcb->Bcb, Offset);
+ assert(SwapEntry == 0);
+ }
+ }
+
if (SwapEntry != 0)
{
MmFreeSwapPage(SwapEntry);
}
else if (PhysAddr.QuadPart != 0)
- {
- ULONG Offset;
-
- Offset =
- ((ULONG)PAGE_ROUND_DOWN(Address) - (ULONG)MArea->BaseAddress) +
- MArea->Data.SectionData.ViewOffset;
-
- Entry = MmGetPageEntrySectionSegment(MArea->Data.SectionData.Segment,
- Offset);
- if (IS_SWAP_FROM_SSE(Entry))
- {
- KeBugCheck(0);
- }
- else if (PhysAddr.QuadPart != (PAGE_FROM_SSE(Entry)))
+ {
+ if (IS_SWAP_FROM_SSE(Entry) ||
+ PhysAddr.QuadPart != (PAGE_FROM_SSE(Entry)))
{
/*
* Just dereference private pages
*/
+ SavedSwapEntry = MmGetSavedSwapEntryPage(PhysAddr);
+ if (SavedSwapEntry != 0)
+ {
+ MmFreeSwapPage(SavedSwapEntry);
+ MmSetSavedSwapEntryPage(PhysAddr, 0);
+ }
MmDeleteRmap(PhysAddr, MArea->Process, Address);
MmReleasePageMemoryConsumer(MC_USER, PhysAddr);
}
AddressSpace = &Process->AddressSpace;
DPRINT("Opening memory area Process %x BaseAddress %x\n",
- Process, BaseAddress);
+ Process, BaseAddress);
MemoryArea = MmOpenMemoryAreaByAddress(AddressSpace,
BaseAddress);
if (MemoryArea == NULL)
MmUnlockAddressSpace(AddressSpace);
return(STATUS_UNSUCCESSFUL);
}
+
+ MemoryArea->DeleteInProgress = TRUE;
MmLockSection(MemoryArea->Data.SectionData.Section);
MmLockSectionSegment(MemoryArea->Data.SectionData.Segment);
ExFreePool(CurrentRegion);
}
- if (MemoryArea->Data.SectionData.Section->Flags & SO_PHYSICAL_MEMORY)
+ if (MemoryArea->Data.SectionData.Section->AllocationAttributes &
+ SEC_PHYSICALMEMORY)
{
Status = MmFreeMemoryArea(&Process->AddressSpace,
BaseAddress,
MmLockAddressSpace(AddressSpace);
MmLockSection(SectionObject);
- if (Section->Flags & MM_IMAGE_SECTION)
+ if (Section->AllocationAttributes & SEC_IMAGE)
{
ULONG i;
return(STATUS_MAPPED_ALIGNMENT);
}
- if (((*ViewSize)+ViewOffset) > Section->MaximumSize.u.LowPart)
+ if ((*ViewSize) == 0)
+ {
+ (*ViewSize) = Section->MaximumSize.u.LowPart - ViewOffset;
+ }
+ else if (((*ViewSize)+ViewOffset) > Section->MaximumSize.u.LowPart)
{
(*ViewSize) = Section->MaximumSize.u.LowPart - ViewOffset;
}
-/* $Id: ntobj.c,v 1.8 2001/03/06 23:34:39 cnettel Exp $
+/* $Id: ntobj.c,v 1.9 2002/08/14 20:58:38 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
If we don't do it this way, we should anyway add switches and separate functions to handle
the different object types*/
{
- POBJECT_NAME_INFORMATION nameinfo;
- POBJECT_TYPE_INFORMATION typeinfo;
- PFILE_NAME_INFORMATION filenameinfo;
- PVOID Object;
- NTSTATUS Status;
- POBJECT_HEADER ObjectHeader;
- PFILE_OBJECT fileob;
-
- Status = ObReferenceObjectByHandle(
- ObjectHandle,
- 0,
- NULL,
- KernelMode,
- & Object,
- NULL
- );
- if (Status != STATUS_SUCCESS)
+ POBJECT_NAME_INFORMATION nameinfo;
+ POBJECT_TYPE_INFORMATION typeinfo;
+ PFILE_NAME_INFORMATION filenameinfo;
+ PVOID Object;
+ NTSTATUS Status;
+ POBJECT_HEADER ObjectHeader;
+ PFILE_OBJECT fileob;
+
+ Status = ObReferenceObjectByHandle(ObjectHandle,
+ 0,
+ NULL,
+ KernelMode,
+ &Object,
+ NULL);
+ if (Status != STATUS_SUCCESS)
+ {
+ return Status;
+ }
+
+ ObjectHeader = BODY_TO_HEADER(Object);
+
+ switch (ObjectInformationClass)
+ {
+ case ObjectNameInformation:
+ if (Length!=sizeof(OBJECT_NAME_INFORMATION)) return STATUS_INVALID_BUFFER_SIZE;
+ nameinfo = (POBJECT_NAME_INFORMATION)ObjectInformation;
+ (*ResultLength)=Length;
+
+ if (ObjectHeader->Type==InternalFileType) // FIXME: Temporary QueryName implementation, or at least separate functions
{
- return Status;
+ fileob = (PFILE_OBJECT) Object;
+ Status = internalNameBuilder(BODY_TO_HEADER(fileob->DeviceObject->Vpb->RealDevice), &nameinfo->Name);
+
+ if (Status != STATUS_SUCCESS)
+ {
+ ObDereferenceObject(Object);
+ return Status;
+ }
+ filenameinfo = ExAllocatePool(NonPagedPool,MAX_PATH*sizeof(WCHAR)+sizeof(ULONG));
+ IoQueryFileInformation(fileob,FileNameInformation,MAX_PATH*sizeof(WCHAR)+sizeof(ULONG), filenameinfo,NULL);
+
+ Status = RtlAppendUnicodeToString(&(nameinfo->Name), filenameinfo->FileName);
+
+ ExFreePool( filenameinfo);
+ ObDereferenceObject(Object);
+ return Status;
}
-
- ObjectHeader = BODY_TO_HEADER(Object);
-
-
- switch (ObjectInformationClass)
+ else
+ if (ObjectHeader->Name.Buffer) // If it's got a name there, we can probably just make the full path through Name and Parent
+ {
+ Status = internalNameBuilder(ObjectHeader, &nameinfo->Name);
+ ObDereferenceObject(Object);
+ return Status;
+ }
+ ObDereferenceObject(Object);
+ return STATUS_NOT_IMPLEMENTED;
+ case ObjectTypeInformation:
+ typeinfo = (POBJECT_TYPE_INFORMATION)ObjectInformation;
+ if (Length!=sizeof(OBJECT_TYPE_INFORMATION)) return STATUS_INVALID_BUFFER_SIZE;
+
+ // FIXME: Is this supposed to only be the header's Name field?
+ // Can somebody check/verify this?
+ RtlCopyUnicodeString(&typeinfo->Name,&ObjectHeader->Name);
+
+ if (Status != STATUS_SUCCESS)
{
- case ObjectNameInformation:
- if (Length!=sizeof(OBJECT_NAME_INFORMATION)) return STATUS_INVALID_BUFFER_SIZE;
- nameinfo = (POBJECT_NAME_INFORMATION)ObjectInformation;
- (*ResultLength)=Length;
-
- if (ObjectHeader->Type==InternalFileType) // FIXME: Temporary QueryName implementation, or at least separate functions
- {
- fileob = (PFILE_OBJECT) Object;
- Status = internalNameBuilder(BODY_TO_HEADER(fileob->DeviceObject->Vpb->RealDevice), &nameinfo->Name);
-
- if (Status != STATUS_SUCCESS)
- {
- ObDereferenceObject(Object);
- return Status;
- }
- filenameinfo = ExAllocatePool(NonPagedPool,MAX_PATH*sizeof(WCHAR)+sizeof(ULONG));
- IoQueryFileInformation(fileob,FileNameInformation,MAX_PATH*sizeof(WCHAR)+sizeof(ULONG), filenameinfo,NULL);
-
- Status = RtlAppendUnicodeToString(&(nameinfo->Name), filenameinfo->FileName);
-
- ExFreePool( filenameinfo);
- ObDereferenceObject(Object);
- return Status;
- }
- else
- if (ObjectHeader->Name.Buffer) // If it's got a name there, we can probably just make the full path through Name and Parent
- {
- Status = internalNameBuilder(ObjectHeader, &nameinfo->Name);
- ObDereferenceObject(Object);
- return Status;
- }
- ObDereferenceObject(Object);
- return STATUS_NOT_IMPLEMENTED;
- case ObjectTypeInformation:
- typeinfo = (POBJECT_TYPE_INFORMATION)ObjectInformation;
- if (Length!=sizeof(OBJECT_TYPE_INFORMATION)) return STATUS_INVALID_BUFFER_SIZE;
-
- // FIXME: Is this supposed to only be the header's Name field?
- // Can somebody check/verify this?
- RtlCopyUnicodeString(&typeinfo->Name,&ObjectHeader->Name);
-
- if (Status != STATUS_SUCCESS)
- {
- ObDereferenceObject(Object);
- return Status;
- }
-
- RtlCopyUnicodeString(&typeinfo->Type,&ObjectHeader->ObjectType->TypeName);
-//This should be info from the object header, not the object type, right?
- typeinfo->TotalHandles = ObjectHeader-> HandleCount;
- typeinfo->ReferenceCount = ObjectHeader -> RefCount;
-
- ObDereferenceObject(Object);
- return Status;
- default:
- ObDereferenceObject(Object);
- return STATUS_NOT_IMPLEMENTED;
+ ObDereferenceObject(Object);
+ return Status;
}
+
+ RtlCopyUnicodeString(&typeinfo->Type,&ObjectHeader->ObjectType->TypeName);
+ //This should be info from the object header, not the object type, right?
+ typeinfo->TotalHandles = ObjectHeader-> HandleCount;
+ typeinfo->ReferenceCount = ObjectHeader -> RefCount;
+
+ ObDereferenceObject(Object);
+ return Status;
+ default:
+ ObDereferenceObject(Object);
+ return STATUS_NOT_IMPLEMENTED;
+ }
}
-
-VOID
-STDCALL
-ObMakeTemporaryObject (
- PVOID ObjectBody
- )
+VOID STDCALL
+ObMakeTemporaryObject (PVOID ObjectBody)
{
- POBJECT_HEADER ObjectHeader;
-
- ObjectHeader = BODY_TO_HEADER(ObjectBody);
- ObjectHeader->Permanent = FALSE;
+ POBJECT_HEADER ObjectHeader;
+
+ ObjectHeader = BODY_TO_HEADER(ObjectBody);
+ ObjectHeader->Permanent = FALSE;
}
-/* $Id: object.c,v 1.52 2002/07/17 21:04:56 dwelch Exp $
+/* $Id: object.c,v 1.53 2002/08/14 20:58:38 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
DPRINT("ObCreateObject(Handle %x, ObjectAttributes %x, Type %x)\n",
Handle, ObjectAttributes, Type);
- if (ObjectAttributes != NULL &&
- ObjectAttributes->ObjectName != NULL)
- {
- DPRINT("ObjectAttributes->ObjectName->Buffer %S\n",
- ObjectAttributes->ObjectName->Buffer);
- }
if (ObjectAttributes != NULL &&
- ObjectAttributes->ObjectName != NULL)
+ ObjectAttributes->ObjectName != NULL &&
+ ObjectAttributes->ObjectName->Buffer != NULL)
{
Status = ObFindObject(ObjectAttributes,
&Parent,
-/* $Id: create.c,v 1.49 2002/08/09 17:23:57 dwelch Exp $
+/* $Id: create.c,v 1.50 2002/08/14 20:58:38 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
return(Thread->ImpersonationInfo->Token);
}
-VOID STDCALL
-PiTimeoutThread(struct _KDPC *dpc,
- PVOID Context,
- PVOID arg1,
- PVOID arg2)
-{
- /* Wake up the thread, and tell it it timed out */
- NTSTATUS Status = STATUS_TIMEOUT;
-
- DPRINT("PiTimeoutThread()\n");
-
- KeRemoveAllWaitsThread((PETHREAD)Context, Status);
-}
-
VOID
PiBeforeBeginThread(CONTEXT c)
{
return(Status);
}
- Status = Ke386InitThreadWithContext(&Thread->Tcb,
- ThreadContext);
+ Status = KiArchInitThreadWithContext(&Thread->Tcb, ThreadContext);
if (!NT_SUCCESS(Status))
{
return(Status);
}
Thread->StartAddress = StartRoutine;
- Status = Ke386InitThread(&Thread->Tcb,
- StartRoutine,
- StartContext);
+ Status = KiArchInitThread(&Thread->Tcb, StartRoutine, StartContext);
if (!NT_SUCCESS(Status))
{
return(Status);
-/* $Id: thread.c,v 1.100 2002/08/08 17:54:16 dwelch Exp $
+/* $Id: thread.c,v 1.101 2002/08/14 20:58:38 dwelch Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
static PETHREAD PsScanThreadList (KPRIORITY Priority, ULONG Affinity)
{
-#if 0
- PLIST_ENTRY current_entry;
- PETHREAD current;
-
- current_entry = RemoveHeadList(&PriorityListHead[Priority]);
- if (current_entry != &PriorityListHead[Priority])
- {
- current = CONTAINING_RECORD(current_entry, ETHREAD,
- Tcb.QueueListEntry);
- }
- else
- {
- current = NULL;
- }
-
- return(current);
-#else
PLIST_ENTRY current_entry;
PETHREAD current;
current_entry = current_entry->Flink;
}
return(NULL);
-#endif
}
-
VOID PsDispatchThreadNoLock (ULONG NewThreadStatus)
{
KPRIORITY CurrentPriority;
CurrentThread = Candidate;
KeReleaseSpinLockFromDpcLevel(&PiThreadListLock);
- Ki386ContextSwitch(&CurrentThread->Tcb, &OldThread->Tcb);
+ KiArchContextSwitch(&CurrentThread->Tcb, &OldThread->Tcb);
PsReapThreads();
return;
}
DoneInitYet = TRUE;
}
-
+LONG STDCALL
+KeSetBasePriorityThread (PKTHREAD Thread,
+ LONG Increment)
/*
* Sets thread's base priority relative to the process' base priority
* Should only be passed in THREAD_PRIORITY_ constants in pstypes.h
*/
-LONG STDCALL
-KeSetBasePriorityThread (PKTHREAD Thread,
- LONG Increment)
{
Thread->BasePriority =
((PETHREAD)Thread)->ThreadsProcess->Pcb.BasePriority + Increment;
-/* $Id: init.c,v 1.39 2002/06/14 07:46:47 ekohl Exp $
+/* $Id: init.c,v 1.40 2002/08/14 20:58:39 dwelch Exp $
*
* init.c - Session Manager initialization
*
LARGE_INTEGER InitialSize;
LARGE_INTEGER MaximumSize;
NTSTATUS Status;
+ LPWSTR p;
#ifndef NDEBUG
PrintString("ValueName '%S' Type %lu Length %lu\n", ValueName, ValueType, ValueLength);
}
/*
- * FIXME:
- * read initial and maximum size from the registry or use default values
- *
* Format: "<path>[ <initial_size>[ <maximum_size>]]"
*/
+ if ((p = wcschr(ValueData, ' ')) != NULL)
+ {
+ *p = L'\0';
+ InitialSize.QuadPart = wcstoul(p + 1, &p, 0);
+ if (*p == ' ')
+ {
+ MaximumSize.QuadPart = wcstoul(p + 1, NULL, 0);
+ }
+ }
+ else
+ {
+ InitialSize.QuadPart = 50 * 4096;
+ MaximumSize.QuadPart = 80 * 4096;
+ }
if (!RtlDosPathNameToNtPathName_U ((LPWSTR)ValueData,
- &FileName,
- NULL,
- NULL))
- {
- return (STATUS_SUCCESS);
- }
-
- InitialSize.QuadPart = 50 * 4096;
- MaximumSize.QuadPart = 80 * 4096;
+ &FileName,
+ NULL,
+ NULL))
+ {
+ return (STATUS_SUCCESS);
+ }
+ DbgPrint("SMSS: Created paging file %wZ with size %dKB\n",
+ &FileName, InitialSize.QuadPart / 1024);
Status = NtCreatePagingFile(&FileName,
&InitialSize,
&MaximumSize,
-/* $Id: shell.c,v 1.9 2002/05/02 09:10:00 jfilby Exp $
+/* $Id: shell.c,v 1.10 2002/08/14 20:58:39 dwelch Exp $
*
* PROJECT : ReactOS Operating System
* DESCRIPTION: ReactOS' Native Shell
HANDLE FileHandle;
char c;
DWORD Result;
+ BOOL Success;
FileHandle = CreateFile(cmdline,
FILE_GENERIC_READ,
debug_printf("Unknown file\n");
return;
}
- while (ReadFile(FileHandle,
- &c,
- 1,
- &Result,
- NULL))
+ do
{
- debug_printf("%c",c);
- c = 0;
- }
+ Success = ReadFile(FileHandle,
+ &c,
+ 1,
+ &Result,
+ NULL);
+ if (Success)
+ {
+ debug_printf("%c",c);
+ c = 0;
+ }
+ } while (Success && Result > 0);
CloseHandle(FileHandle);
}