* drivers/dd/floppy/floppy.c: Changed PAGESIZE to PAGE_SIZE.
* drivers/fs/cdfs/fcb.c: Ditto.
* drivers/fs/cdfs/fsctl.c: Ditto.
* drivers/fs/cdfs/rw.c: Ditto.
* drivers/fs/ext2/dir.c: Ditto.
* drivers/fs/ext2/inode.c: Ditto.
* drivers/fs/ext2/rw.c: Ditto.
* drivers/fs/ext2/super.c: Ditto.
* drivers/fs/minix/blockdev.c: Ditto.
* drivers/fs/minix/cache.c: Ditto.
* drivers/fs/minix/inode.c: Ditto.
* drivers/fs/minix/rw.c: Ditto.
* drivers/fs/ntfs/fcb.c: Ditto.
* drivers/fs/ntfs/ntfs.h: Ditto.
* drivers/fs/vfat/create.c: Ditto.
* drivers/fs/vfat/direntry.c: Ditto.
* drivers/fs/vfat/dirwr.c: Ditto.
* drivers/fs/vfat/fat.c: Ditto.
* drivers/fs/vfat/fcb.c: Ditto.
* drivers/fs/vfat/fsctl.c: Ditto.
* drivers/fs/vfat/rw.c: Ditto.
* drivers/storage/class2/class2.c: Ditto.
* drivers/storage/scsiport/scsiport.c: Ditto.
* hal/halx86/adapter.c: Ditto.
* hal/halx86/mp.c: Ditto.
* include/ddk/mmfuncs.h: Ditto.
* include/ddk/mmtypes.h: Ditto.
* include/ddk/i386/pagesize.h: Ditto.
* include/ntdll/pagesize.h: Ditto.
* lib/kernel32/process/create.c: Ditto.
* lib/kernel32/thread/thread.c: Ditto.
* lib/ntdll/ldr/utils.c: Ditto.
* lib/ntdll/rtl/env.c: Ditto.
* lib/ntdll/rtl/heap.c: Ditto.
* lib/ntdll/rtl/ppb.c: Ditto.
* lib/ntdll/rtl/process.c: Ditto.
* lib/ntdll/rtl/thread.c: Ditto.
* ntoskrnl/cc/copy.c: Ditto.
* ntoskrnl/cc/view.c: Ditto.
* ntoskrnl/ex/sysinfo.c: Ditto.
* ntoskrnl/include/internal/i386/mm.h: Ditto.
* ntoskrnl/io/mdl.c: Ditto.
* ntoskrnl/ke/kthread.c: Ditto.
* ntoskrnl/ke/i386/kernel.c: Ditto.
* ntoskrnl/ldr/init.c: Ditto.
* ntoskrnl/ldr/loader.c: Ditto.
* ntoskrnl/mm/anonmem.c: Ditto.
* ntoskrnl/mm/cont.c: Ditto.
* ntoskrnl/mm/freelist.c: Ditto.
* ntoskrnl/mm/iospace.c: Ditto.
* ntoskrnl/mm/kmap.c: Ditto.
* ntoskrnl/mm/marea.c: Ditto.
* ntoskrnl/mm/mdl.c: Ditto.
* ntoskrnl/mm/mminit.c: Ditto.
* ntoskrnl/mm/ncache.c: Ditto.
* ntoskrnl/mm/npool.c: Ditto.
* ntoskrnl/mm/pagefile.c: Ditto.
* ntoskrnl/mm/pageop.c: Ditto.
* ntoskrnl/mm/section.c: Ditto.
* ntoskrnl/mm/slab.c: Ditto.
* ntoskrnl/mm/i386/page.c: Ditto.
* ntoskrnl/ob/handle.c: Ditto.
* ntoskrnl/ps/create.c: Ditto.
* ntoskrnl/ps/process.c: Ditto.
* ntoskrnl/ps/w32call.c: Ditto.
* subsys/win32k/include/object.h: Ditto.
svn path=/trunk/; revision=3594
+2002-10-01 Casper S. Hornstrup <chorns@users.sourceforge.net>
+
+ * drivers/dd/floppy/floppy.c: Changed PAGESIZE to PAGE_SIZE.
+ * drivers/fs/cdfs/fcb.c: Ditto.
+ * drivers/fs/cdfs/fsctl.c: Ditto.
+ * drivers/fs/cdfs/rw.c: Ditto.
+ * drivers/fs/ext2/dir.c: Ditto.
+ * drivers/fs/ext2/inode.c: Ditto.
+ * drivers/fs/ext2/rw.c: Ditto.
+ * drivers/fs/ext2/super.c: Ditto.
+ * drivers/fs/minix/blockdev.c: Ditto.
+ * drivers/fs/minix/cache.c: Ditto.
+ * drivers/fs/minix/inode.c: Ditto.
+ * drivers/fs/minix/rw.c: Ditto.
+ * drivers/fs/ntfs/fcb.c: Ditto.
+ * drivers/fs/ntfs/ntfs.h: Ditto.
+ * drivers/fs/vfat/create.c: Ditto.
+ * drivers/fs/vfat/direntry.c: Ditto.
+ * drivers/fs/vfat/dirwr.c: Ditto.
+ * drivers/fs/vfat/fat.c: Ditto.
+ * drivers/fs/vfat/fcb.c: Ditto.
+ * drivers/fs/vfat/fsctl.c: Ditto.
+ * drivers/fs/vfat/rw.c: Ditto.
+ * drivers/storage/class2/class2.c: Ditto.
+ * drivers/storage/scsiport/scsiport.c: Ditto.
+ * hal/halx86/adapter.c: Ditto.
+ * hal/halx86/mp.c: Ditto.
+ * include/ddk/mmfuncs.h: Ditto.
+ * include/ddk/mmtypes.h: Ditto.
+ * include/ddk/i386/pagesize.h: Ditto.
+ * include/ntdll/pagesize.h: Ditto.
+ * lib/kernel32/process/create.c: Ditto.
+ * lib/kernel32/thread/thread.c: Ditto.
+ * lib/ntdll/ldr/utils.c: Ditto.
+ * lib/ntdll/rtl/env.c: Ditto.
+ * lib/ntdll/rtl/heap.c: Ditto.
+ * lib/ntdll/rtl/ppb.c: Ditto.
+ * lib/ntdll/rtl/process.c: Ditto.
+ * lib/ntdll/rtl/thread.c: Ditto.
+ * ntoskrnl/cc/copy.c: Ditto.
+ * ntoskrnl/cc/view.c: Ditto.
+ * ntoskrnl/ex/sysinfo.c: Ditto.
+ * ntoskrnl/include/internal/i386/mm.h: Ditto.
+ * ntoskrnl/io/mdl.c: Ditto.
+ * ntoskrnl/ke/kthread.c: Ditto.
+ * ntoskrnl/ke/i386/kernel.c: Ditto.
+ * ntoskrnl/ldr/init.c: Ditto.
+ * ntoskrnl/ldr/loader.c: Ditto.
+ * ntoskrnl/mm/anonmem.c: Ditto.
+ * ntoskrnl/mm/cont.c: Ditto.
+ * ntoskrnl/mm/freelist.c: Ditto.
+ * ntoskrnl/mm/iospace.c: Ditto.
+ * ntoskrnl/mm/kmap.c: Ditto.
+ * ntoskrnl/mm/marea.c: Ditto.
+ * ntoskrnl/mm/mdl.c: Ditto.
+ * ntoskrnl/mm/mminit.c: Ditto.
+ * ntoskrnl/mm/ncache.c: Ditto.
+ * ntoskrnl/mm/npool.c: Ditto.
+ * ntoskrnl/mm/pagefile.c: Ditto.
+ * ntoskrnl/mm/pageop.c: Ditto.
+ * ntoskrnl/mm/section.c: Ditto.
+ * ntoskrnl/mm/slab.c: Ditto.
+ * ntoskrnl/mm/i386/page.c: Ditto.
+ * ntoskrnl/ob/handle.c: Ditto.
+ * ntoskrnl/ps/create.c: Ditto.
+ * ntoskrnl/ps/process.c: Ditto.
+ * ntoskrnl/ps/w32call.c: Ditto.
+ * subsys/win32k/include/object.h: Ditto.
+
2002-10-01 Casper S. Hornstrup <chorns@users.sourceforge.net>
* lib/ntdll/string/ctype.c: Undefine __MSVCRT__ to not have mingw
CHECKPOINT;
Status = IoAllocateAdapterChannel( ControllerExtension->AdapterObject,
DeviceObject,
- 0x3000/PAGESIZE, // max track size is 12k
+ 0x3000/PAGE_SIZE, // max track size is 12k
FloppyAdapterControl,
ControllerExtension );
if( !NT_SUCCESS( Status ) )
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: fcb.c,v 1.10 2002/09/09 17:26:24 hbirr Exp $
+/* $Id: fcb.c,v 1.11 2002/10/01 19:27:16 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
Status = CcRosInitializeFileCache(FileObject,
&Fcb->RFCB.Bcb,
- PAGESIZE);
+ PAGE_SIZE);
if (!NT_SUCCESS(Status))
{
DbgPrint("CcRosInitializeFileCache failed\n");
{
Status = CcRosInitializeFileCache(FileObject,
&Fcb->RFCB.Bcb,
- PAGESIZE);
+ PAGE_SIZE);
if (!NT_SUCCESS(Status))
{
DbgPrint("CcRosInitializeFileCache failed\n");
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: fsctl.c,v 1.11 2002/09/17 20:42:59 hbirr Exp $
+/* $Id: fsctl.c,v 1.12 2002/10/01 19:27:16 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
Status = CcRosInitializeFileCache(DeviceExt->StreamFileObject,
&Fcb->RFCB.Bcb,
- PAGESIZE);
+ PAGE_SIZE);
if (!NT_SUCCESS (Status))
{
DbgPrint("CcRosInitializeFileCache failed\n");
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: rw.c,v 1.6 2002/09/15 22:26:52 hbirr Exp $
+/* $Id: rw.c,v 1.7 2002/10/01 19:27:16 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
if (FileObject->PrivateCacheMap == NULL)
{
- CcRosInitializeFileCache(FileObject, &Fcb->RFCB.Bcb, PAGESIZE);
+ CcRosInitializeFileCache(FileObject, &Fcb->RFCB.Bcb, PAGE_SIZE);
}
FileOffset.QuadPart = (LONGLONG)ReadOffset;
DPRINT("Found file\n");
Fcb->inode = current_inode;
- CcRosInitializeFileCache(FileObject, &Fcb->Bcb, PAGESIZE*3);
+ CcRosInitializeFileCache(FileObject, &Fcb->Bcb, PAGE_SIZE*3);
FileObject->FsContext = Fcb;
return(STATUS_SUCCESS);
}
-#define INODES_PER_PAGE (PAGESIZE / sizeof(struct ext2_inode))
+#define INODES_PER_PAGE (PAGE_SIZE / sizeof(struct ext2_inode))
#define INODES_PER_BLOCK (BLOCKSIZE / sizeof(struct ext2_inode))
VOID Ext2LoadInode(PDEVICE_EXTENSION DeviceExt,
Ext2ReleaseInode(DeviceExt,
&Fcb->i);
- if ((Offset % PAGESIZE) != 0)
+ if ((Offset % PAGE_SIZE) != 0)
{
- Delta = min(PAGESIZE - (Offset % PAGESIZE),Length);
+ Delta = min(PAGE_SIZE - (Offset % PAGE_SIZE),Length);
CcRequestCachePage(Fcb->Bcb,
Offset,
&BaseAddress,
BaseAddress,
Offset / BLOCKSIZE);
}
- memcpy(Buffer, BaseAddress + (Offset % PAGESIZE), Delta);
+ memcpy(Buffer, BaseAddress + (Offset % PAGE_SIZE), Delta);
CcReleaseCachePage(Fcb->Bcb,
CacheSeg,
TRUE);
Buffer = Buffer + Delta;
}
CHECKPOINT;
- for (i=0; i<(Length/PAGESIZE); i++)
+ for (i=0; i<(Length/PAGE_SIZE); i++)
{
CcRequestCachePage(Fcb->Bcb,
Offset,
BaseAddress,
(Offset / BLOCKSIZE));
}
- memcpy(Buffer, BaseAddress, PAGESIZE);
+ memcpy(Buffer, BaseAddress, PAGE_SIZE);
CcReleaseCachePage(Fcb->Bcb,
CacheSeg,
TRUE);
- Length = Length - PAGESIZE;
- Offset = Offset + PAGESIZE;
- Buffer = Buffer + PAGESIZE;
+ Length = Length - PAGE_SIZE;
+ Offset = Offset + PAGE_SIZE;
+ Buffer = Buffer + PAGE_SIZE;
}
CHECKPOINT;
- if ((Length % PAGESIZE) != 0)
+ if ((Length % PAGE_SIZE) != 0)
{
CcRequestCachePage(Fcb->Bcb,
Offset,
DeviceExt->superblock = superblock;
CcRosInitializeFileCache(DeviceExt->FileObject,
&DeviceExt->Bcb,
- PAGESIZE * 3);
+ PAGE_SIZE * 3);
DPRINT("Ext2Mount() = STATUS_SUCCESS\n");
for (i=0; i<4; i++)
{
Result = MinixReadSector(DeviceObject,
- (Offset + (i * PAGESIZE)) / BLOCKSIZE,
- (Buffer + (i * PAGESIZE)));
+ (Offset + (i * PAGE_SIZE)) / BLOCKSIZE,
+ (Buffer + (i * PAGE_SIZE)));
if (!Result)
{
return(Result);
PAGE_ROUND_DOWN(FileOffset),
BaseAddress);
}
- BaseAddress = BaseAddress + (FileOffset % PAGESIZE);
+ BaseAddress = BaseAddress + (FileOffset % PAGE_SIZE);
return(STATUS_SUCCESS);
}
DPRINT("Reading block %x offset %x\n",block,block*BLOCKSIZE);
DPRINT("Index %x\n",(ino-1)%MINIX_INODES_PER_BLOCK);
- BaseAddress = ExAllocatePool(NonPagedPool, PAGESIZE);
+ BaseAddress = ExAllocatePool(NonPagedPool, PAGE_SIZE);
MinixReadPage(DeviceObject,
block,
Length = FsContext->inode.i_size - Offset;
}
- if ((Offset%PAGESIZE)!=0)
+ if ((Offset%PAGE_SIZE)!=0)
{
- CurrentOffset = Offset - (Offset%PAGESIZE);
+ CurrentOffset = Offset - (Offset%PAGE_SIZE);
MinixReadFilePage(DeviceObject,
DeviceExt,
&DiskBuffer);
memcpy(Buffer,
- DiskBuffer+(Offset%PAGESIZE),
- min(PAGESIZE - (Offset%PAGESIZE),Length));
+ DiskBuffer+(Offset%PAGE_SIZE),
+ min(PAGE_SIZE - (Offset%PAGE_SIZE),Length));
ExFreePool(DiskBuffer);
DPRINT("(BLOCKSIZE - (Offset%BLOCKSIZE)) %d\n",
(BLOCKSIZE - (Offset%BLOCKSIZE)));
DPRINT("Length %d\n",Length);
- CurrentOffset = CurrentOffset + PAGESIZE;
- Buffer = Buffer + PAGESIZE - (Offset%PAGESIZE);
- Length = Length - min(PAGESIZE - (Offset%PAGESIZE),Length);
+ CurrentOffset = CurrentOffset + PAGE_SIZE;
+ Buffer = Buffer + PAGE_SIZE - (Offset%PAGE_SIZE);
+ Length = Length - min(PAGE_SIZE - (Offset%PAGE_SIZE),Length);
DPRINT("CurrentOffset %d Buffer %x Length %d\n",CurrentOffset,Buffer,
Length);
}
- for (i=0;i<(Length/PAGESIZE);i++)
+ for (i=0;i<(Length/PAGE_SIZE);i++)
{
CHECKPOINT;
FsContext,
CurrentOffset,
&DiskBuffer);
- memcpy(Buffer, DiskBuffer, PAGESIZE);
+ memcpy(Buffer, DiskBuffer, PAGE_SIZE);
ExFreePool(DiskBuffer);
- CurrentOffset = CurrentOffset + PAGESIZE;
- Buffer = Buffer + PAGESIZE;
+ CurrentOffset = CurrentOffset + PAGE_SIZE;
+ Buffer = Buffer + PAGE_SIZE;
}
- if ((Length%PAGESIZE) > 0)
+ if ((Length%PAGE_SIZE) > 0)
{
CHECKPOINT;
- DPRINT("Length %x Buffer %x\n",(Length%PAGESIZE),Buffer);
+ DPRINT("Length %x Buffer %x\n",(Length%PAGE_SIZE),Buffer);
MinixReadFilePage(DeviceObject,
DeviceExt,
CurrentOffset,
&DiskBuffer);
- memcpy(Buffer, DiskBuffer, (Length%PAGESIZE));
+ memcpy(Buffer, DiskBuffer, (Length%PAGE_SIZE));
ExFreePool(DiskBuffer);
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: fcb.c,v 1.3 2002/09/08 10:22:11 chorns Exp $
+/* $Id: fcb.c,v 1.4 2002/10/01 19:27:17 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
// Fcb->Entry.FileFlags = 0x02; // FILE_ATTRIBUTE_DIRECTORY;
Fcb->RefCount = 1;
Fcb->DirIndex = 0;
- Fcb->RFCB.FileSize.QuadPart = PAGESIZE;//Vcb->CdInfo.RootSize;
- Fcb->RFCB.ValidDataLength.QuadPart = PAGESIZE;//Vcb->CdInfo.RootSize;
- Fcb->RFCB.AllocationSize.QuadPart = PAGESIZE;//Vcb->CdInfo.RootSize;
+ Fcb->RFCB.FileSize.QuadPart = PAGE_SIZE;//Vcb->CdInfo.RootSize;
+ Fcb->RFCB.ValidDataLength.QuadPart = PAGE_SIZE;//Vcb->CdInfo.RootSize;
+ Fcb->RFCB.AllocationSize.QuadPart = PAGE_SIZE;//Vcb->CdInfo.RootSize;
NtfsFCBInitializeCache(Vcb, Fcb);
NtfsAddFCBToTable(Vcb, Fcb);
#define CACHEPAGESIZE(pDeviceExt) \
- ((pDeviceExt)->NtfsInfo.BytesPerCluster > PAGESIZE ? \
- (pDeviceExt)->NtfsInfo.BytesPerCluster : PAGESIZE)
+ ((pDeviceExt)->NtfsInfo.BytesPerCluster > PAGE_SIZE ? \
+ (pDeviceExt)->NtfsInfo.BytesPerCluster : PAGE_SIZE)
#define TAG(A, B, C, D) (ULONG)(((A)<<0) + ((B)<<8) + ((C)<<16) + ((D)<<24))
* 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.46 2002/09/08 10:22:12 chorns Exp $
+/* $Id: create.c,v 1.47 2002/10/01 19:27:17 chorns Exp $
*
* PROJECT: ReactOS kernel
* FILE: services/fs/vfat/create.c
/* GLOBALS *******************************************************************/
-#define ENTRIES_PER_PAGE (PAGESIZE / sizeof (FATDirEntry))
+#define ENTRIES_PER_PAGE (PAGE_SIZE / sizeof (FATDirEntry))
/* FUNCTIONS *****************************************************************/
Offset = 0;
CcUnpinData(*pContext);
FileOffset.QuadPart = *pIndex * sizeof(FATDirEntry);
- if(!CcMapData(FileObject, &FileOffset, PAGESIZE, TRUE, pContext, Block))
+ if(!CcMapData(FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, Block))
{
*pContext = NULL;
return STATUS_NO_MORE_ENTRIES;
Offset = 0;
CcUnpinData(*pContext);
FileOffset.QuadPart = *pIndex * sizeof(FATDirEntry);
- if(!CcMapData(FileObject, &FileOffset, PAGESIZE, TRUE, pContext, Block))
+ if(!CcMapData(FileObject, &FileOffset, PAGE_SIZE, TRUE, pContext, Block))
{
*pContext = NULL;
return STATUS_NO_MORE_ENTRIES;
}
FileOffset.u.HighPart = 0;
FileOffset.u.LowPart = (DirIndex - Offset) * sizeof(FATDirEntry);
- if (!CcMapData(pFcb->FileObject, &FileOffset, PAGESIZE, TRUE, &Context, (PVOID*)&Entry))
+ if (!CcMapData(pFcb->FileObject, &FileOffset, PAGE_SIZE, TRUE, &Context, (PVOID*)&Entry))
{
Context = NULL;
break;
CcUnpinData(Context);
}
FileOffset.QuadPart = (DirIndex - Offset) * sizeof(FATDirEntry);
- if (!CcMapData(Parent->FileObject, &FileOffset, PAGESIZE, TRUE,
+ if (!CcMapData(Parent->FileObject, &FileOffset, PAGE_SIZE, TRUE,
&Context, (PVOID*)&block))
{
Context = NULL;
-/* $Id: direntry.c,v 1.8 2002/09/08 10:22:12 chorns Exp $
+/* $Id: direntry.c,v 1.9 2002/10/01 19:27:17 chorns Exp $
*
*
* FILE: DirEntry.c
#include "vfat.h"
-#define CACHEPAGESIZE(pDeviceExt) ((pDeviceExt)->FatInfo.BytesPerCluster > PAGESIZE ? \
- (pDeviceExt)->FatInfo.BytesPerCluster : PAGESIZE)
+#define CACHEPAGESIZE(pDeviceExt) ((pDeviceExt)->FatInfo.BytesPerCluster > PAGE_SIZE ? \
+ (pDeviceExt)->FatInfo.BytesPerCluster : PAGE_SIZE)
#define ENTRIES_PER_CACHEPAGE(pDeviceExt) (ENTRIES_PER_SECTOR * \
(CACHEPAGESIZE(pDeviceExt) / ((pDeviceExt)->FatInfo.BytesPerSector)))
-/* $Id: dirwr.c,v 1.30 2002/09/08 10:22:12 chorns Exp $
+/* $Id: dirwr.c,v 1.31 2002/10/01 19:27:18 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
Offset.u.HighPart = 0;
for (i = startEntry; i <= Entry; i++)
{
- if (Context == NULL || ((i * sizeof(FATDirEntry)) % PAGESIZE) == 0)
+ if (Context == NULL || ((i * sizeof(FATDirEntry)) % PAGE_SIZE) == 0)
{
if (Context)
{
CcSetDirtyPinnedData(Context, NULL);
CcUnpinData(Context);
}
- Offset.u.LowPart = (i * sizeof(FATDirEntry) / PAGESIZE) * PAGESIZE;
- CcMapData (pDirFcb->FileObject, &Offset, PAGESIZE, TRUE,
+ Offset.u.LowPart = (i * sizeof(FATDirEntry) / PAGE_SIZE) * PAGE_SIZE;
+ CcMapData (pDirFcb->FileObject, &Offset, PAGE_SIZE, TRUE,
&Context, (PVOID*)&pDirEntry);
}
- pDirEntry[i % (PAGESIZE / sizeof(FATDirEntry))].Filename[0] = 0xe5;
+ pDirEntry[i % (PAGE_SIZE / sizeof(FATDirEntry))].Filename[0] = 0xe5;
if (i == Entry)
{
CurrentCluster =
vfatDirEntryGetFirstCluster (DeviceExt,
- &pDirEntry[i % (PAGESIZE / sizeof(FATDirEntry))]);
+ &pDirEntry[i % (PAGE_SIZE / sizeof(FATDirEntry))]);
}
}
if (Context)
/*
- * $Id: fat.c,v 1.39 2002/09/08 10:22:12 chorns Exp $
+ * $Id: fat.c,v 1.40 2002/10/01 19:27:18 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
#define ROUND_DOWN(N, S) ((N) - ((N) % (S)))
-#define CACHEPAGESIZE(pDeviceExt) ((pDeviceExt)->FatInfo.BytesPerCluster > PAGESIZE ? \
- (pDeviceExt)->FatInfo.BytesPerCluster : PAGESIZE)
+#define CACHEPAGESIZE(pDeviceExt) ((pDeviceExt)->FatInfo.BytesPerCluster > PAGE_SIZE ? \
+ (pDeviceExt)->FatInfo.BytesPerCluster : PAGE_SIZE)
/* FUNCTIONS ****************************************************************/
-/* $Id: fcb.c,v 1.20 2002/09/08 10:22:12 chorns Exp $
+/* $Id: fcb.c,v 1.21 2002/10/01 19:27:18 chorns Exp $
*
*
* FILE: fcb.c
fcb->pDevExt = vcb;
- fileCacheQuantum = (vcb->FatInfo.BytesPerCluster >= PAGESIZE) ?
- vcb->FatInfo.BytesPerCluster : PAGESIZE;
+ fileCacheQuantum = (vcb->FatInfo.BytesPerCluster >= PAGE_SIZE) ?
+ vcb->FatInfo.BytesPerCluster : PAGE_SIZE;
status = CcRosInitializeFileCache (fileObject,
&fcb->RFCB.Bcb,
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: fsctl.c,v 1.10 2002/09/08 10:22:12 chorns Exp $
+/* $Id: fsctl.c,v 1.11 2002/10/01 19:27:18 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS ****************************************************************/
-#define CACHEPAGESIZE(pDeviceExt) ((pDeviceExt)->FatInfo.BytesPerCluster > PAGESIZE ? \
- (pDeviceExt)->FatInfo.BytesPerCluster : PAGESIZE)
+#define CACHEPAGESIZE(pDeviceExt) ((pDeviceExt)->FatInfo.BytesPerCluster > PAGE_SIZE ? \
+ (pDeviceExt)->FatInfo.BytesPerCluster : PAGE_SIZE)
static NTSTATUS
return(Status);
}
- if (DeviceExt->FatInfo.BytesPerCluster >= PAGESIZE &&
- (DeviceExt->FatInfo.BytesPerCluster % PAGESIZE) != 0)
+ if (DeviceExt->FatInfo.BytesPerCluster >= PAGE_SIZE &&
+ (DeviceExt->FatInfo.BytesPerCluster % PAGE_SIZE) != 0)
{
DbgPrint("(%s:%d) Invalid cluster size\n", __FILE__, __LINE__);
KeBugCheck(0);
}
- else if (DeviceExt->FatInfo.BytesPerCluster < PAGESIZE &&
- (PAGESIZE % DeviceExt->FatInfo.BytesPerCluster) != 0)
+ else if (DeviceExt->FatInfo.BytesPerCluster < PAGE_SIZE &&
+ (PAGE_SIZE % DeviceExt->FatInfo.BytesPerCluster) != 0)
{
DbgPrint("(%s:%d) Invalid cluster size2\n", __FILE__, __LINE__);
KeBugCheck(0);
}
else
{
- Status = CcRosInitializeFileCache(DeviceExt->FATFileObject, &Fcb->RFCB.Bcb, 2 * PAGESIZE);
+ Status = CcRosInitializeFileCache(DeviceExt->FATFileObject, &Fcb->RFCB.Bcb, 2 * PAGE_SIZE);
}
if (!NT_SUCCESS (Status))
{
-/* $Id: rw.c,v 1.48 2002/09/08 10:22:12 chorns Exp $
+/* $Id: rw.c,v 1.49 2002/10/01 19:27:18 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
{
ULONG CacheSize;
CacheSize = IrpContext->DeviceExt->FatInfo.BytesPerCluster;
- if (CacheSize < PAGESIZE)
+ if (CacheSize < PAGE_SIZE)
{
- CacheSize = PAGESIZE;
+ CacheSize = PAGE_SIZE;
}
CcRosInitializeFileCache(IrpContext->FileObject, &Fcb->RFCB.Bcb, CacheSize);
}
{
ULONG CacheSize;
CacheSize = IrpContext->DeviceExt->FatInfo.BytesPerCluster;
- if (CacheSize < PAGESIZE)
+ if (CacheSize < PAGE_SIZE)
{
- CacheSize = PAGESIZE;
+ CacheSize = PAGE_SIZE;
}
CcRosInitializeFileCache(IrpContext->FileObject, &Fcb->RFCB.Bcb, CacheSize);
}
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: class2.c,v 1.25 2002/09/19 16:18:00 ekohl Exp $
+/* $Id: class2.c,v 1.26 2002/10/01 19:27:18 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* Adjust the maximum transfer length */
CurrentTransferPages = DeviceExtension->PortCapabilities->MaximumPhysicalPages;
- if (MaximumTransferLength > CurrentTransferPages * PAGESIZE)
- MaximumTransferLength = CurrentTransferPages * PAGESIZE;
+ if (MaximumTransferLength > CurrentTransferPages * PAGE_SIZE)
+ MaximumTransferLength = CurrentTransferPages * PAGE_SIZE;
if (MaximumTransferLength == 0)
- MaximumTransferLength = PAGESIZE;
+ MaximumTransferLength = PAGE_SIZE;
IoMarkIrpPending(Irp);
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: scsiport.c,v 1.22 2002/09/20 05:40:28 ei Exp $
+/* $Id: scsiport.c,v 1.23 2002/10/01 19:27:18 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PortCapabilities->MaximumTransferLength =
PortDeviceExtension->PortConfig.MaximumTransferLength;
PortCapabilities->MaximumPhysicalPages =
- PortCapabilities->MaximumTransferLength / PAGESIZE;
+ PortCapabilities->MaximumTransferLength / PAGE_SIZE;
PortCapabilities->SupportedAsynchronousEvents = 0; /* FIXME */
PortCapabilities->AlignmentMask =
PortDeviceExtension->PortConfig.AlignmentMask;
-/* $Id: adapter.c,v 1.3 2002/09/08 10:22:24 chorns Exp $
+/* $Id: adapter.c,v 1.4 2002/10/01 19:27:18 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
LARGE_INTEGER MaxAddress;
MaxAddress.QuadPart = 0x1000000;
- Buffer = MmAllocateContiguousAlignedMemory( NumberOfMapRegisters * PAGESIZE,
+ Buffer = MmAllocateContiguousAlignedMemory( NumberOfMapRegisters * PAGE_SIZE,
MaxAddress,
0x10000 );
if( !Buffer )
-/* $Id: mp.c,v 1.3 2002/09/08 10:22:24 chorns Exp $
+/* $Id: mp.c,v 1.4 2002/10/01 19:27:19 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
CommonBase = (PULONG)COMMON_AREA;
/* Copy bootstrap code to common area */
- memcpy((PVOID)((ULONG)CommonBase + PAGESIZE),
+ memcpy((PVOID)((ULONG)CommonBase + PAGE_SIZE),
&APstart,
(ULONG)&APend - (ULONG)&APstart + 1);
/* Set warm reset vector */
ps = (PUSHORT)((ULONG)BIOSBase + 0x467);
- *ps = (COMMON_AREA + PAGESIZE) & 0xF;
+ *ps = (COMMON_AREA + PAGE_SIZE) & 0xF;
ps = (PUSHORT)((ULONG)BIOSBase + 0x469);
- *ps = (COMMON_AREA + PAGESIZE) >> 4;
+ *ps = (COMMON_AREA + PAGE_SIZE) >> 4;
/* Calibrate APIC timer */
APICCalibrateTimer(0);
APICSendIPI(CPUMap[CPU].APICId,
0,
- APIC_DM_STARTUP | ((COMMON_AREA + PAGESIZE) >> 12),
+ APIC_DM_STARTUP | ((COMMON_AREA + PAGE_SIZE) >> 12),
APIC_ICR0_LEVEL_DEASSERT);
/* Wait up to 10ms for IPI to be delivered */
#ifndef __INCLUDE_DDK_I386_PAGESIZE_H
#define __INCLUDE_DDK_I386_PAGESIZE_H
-#define PAGESIZE (4096)
+#define PAGE_SIZE (4096)
#endif /* __INCLUDE_DDK_I386_PAGESIZE_H */
#ifndef _INCLUDE_DDK_MMFUNCS_H
#define _INCLUDE_DDK_MMFUNCS_H
-/* $Id: mmfuncs.h,v 1.13 2002/09/08 10:47:44 chorns Exp $ */
+/* $Id: mmfuncs.h,v 1.14 2002/10/01 19:27:19 chorns Exp $ */
/* MEMORY MANAGMENT ******************************************************/
HighestAddr = PAGE_ROUND_UP(Size + ((ULONG)Va));
LowestAddr = PAGE_ROUND_DOWN((ULONG)Va);
- return((HighestAddr - LowestAddr) / PAGESIZE);
+ return((HighestAddr - LowestAddr) / PAGE_SIZE);
}
#endif
#define ADDRESS_AND_SIZE_TO_SPAN_PAGES(Va, Size) \
(ULONG)((PAGE_ROUND_UP((Size) + ((ULONG)(Va))) - \
- PAGE_ROUND_DOWN((ULONG)(Va))) / PAGESIZE)
+ PAGE_ROUND_DOWN((ULONG)(Va))) / PAGE_SIZE)
/*
* FUNCTION: Returns FALSE is the pointer is NULL, TRUE otherwise
/*
* FUNCTION: Returns the byte offset of the address within its page
*/
-#define BYTE_OFFSET(va) (((ULONG)va)%PAGESIZE)
+#define BYTE_OFFSET(va) (((ULONG)va)%PAGE_SIZE)
/*
* FUNCTION: Takes a count in bytes and returns the number of pages
-/* $Id: mmtypes.h,v 1.13 2002/09/08 10:47:44 chorns Exp $ */
+/* $Id: mmtypes.h,v 1.14 2002/10/01 19:27:19 chorns Exp $ */
#ifndef _INCLUDE_DDK_MMTYPES_H
#define _INCLUDE_DDK_MMTYPES_H
#include <ntos/mm.h>
-#define PAGE_ROUND_UP(x) ( (((ULONG)x)%PAGESIZE) ? ((((ULONG)x)&(~0xfff))+0x1000) : ((ULONG)x) )
+#define PAGE_ROUND_UP(x) ( (((ULONG)x)%PAGE_SIZE) ? ((((ULONG)x)&(~0xfff))+0x1000) : ((ULONG)x) )
#define PAGE_ROUND_DOWN(x) (((ULONG)x)&(~0xfff))
*/
#ifdef i386
-#define PAGESIZE (4096)
+#define PAGE_SIZE (4096)
#endif
-/* $Id: create.c,v 1.53 2002/09/13 18:55:31 hbirr Exp $
+/* $Id: create.c,v 1.54 2002/10/01 19:27:19 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
InitialTeb.StackReserve = (StackReserve < 0x100000) ? 0x100000 : StackReserve;
/* FIXME: use correct commit size */
#if 0
- InitialTeb.StackCommit = (StackCommit < PAGESIZE) ? PAGESIZE : StackCommit;
+ InitialTeb.StackCommit = (StackCommit < PAGE_SIZE) ? PAGE_SIZE : StackCommit;
#endif
- InitialTeb.StackCommit = InitialTeb.StackReserve - PAGESIZE;
+ InitialTeb.StackCommit = InitialTeb.StackReserve - PAGE_SIZE;
/* size of guard page */
- InitialTeb.StackCommit += PAGESIZE;
+ InitialTeb.StackCommit += PAGE_SIZE;
/* Reserve stack */
InitialTeb.StackAllocate = NULL;
/* Protect guard page */
Status = NtProtectVirtualMemory(ProcessHandle,
InitialTeb.StackLimit,
- PAGESIZE,
+ PAGE_SIZE,
PAGE_GUARD | PAGE_READWRITE,
&OldPageProtection);
if (!NT_SUCCESS(Status))
-/* $Id: thread.c,v 1.29 2002/09/08 10:22:46 chorns Exp $
+/* $Id: thread.c,v 1.30 2002/10/01 19:27:20 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
InitialTeb.StackReserve = 0x100000; /* 1MByte */
/* FIXME: use correct commit size */
#if 0
- InitialTeb.StackCommit = (dwStackSize == 0) ? PAGESIZE : dwStackSize;
+ InitialTeb.StackCommit = (dwStackSize == 0) ? PAGE_SIZE : dwStackSize;
#endif
- InitialTeb.StackCommit = InitialTeb.StackReserve - PAGESIZE;
+ InitialTeb.StackCommit = InitialTeb.StackReserve - PAGE_SIZE;
/* size of guard page */
- InitialTeb.StackCommit += PAGESIZE;
+ InitialTeb.StackCommit += PAGE_SIZE;
/* Reserve stack */
InitialTeb.StackAllocate = NULL;
/* Protect guard page */
Status = NtProtectVirtualMemory(hProcess,
InitialTeb.StackLimit,
- PAGESIZE,
+ PAGE_SIZE,
PAGE_GUARD | PAGE_READWRITE,
&OldPageProtection);
if (!NT_SUCCESS(Status))
-/* $Id: utils.c,v 1.56 2002/09/08 10:23:04 chorns Exp $
+/* $Id: utils.c,v 1.57 2002/10/01 19:27:20 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
Status = NtProtectVirtualMemory(NtCurrentProcess(),
ImageBase +
RelocationDir->VirtualAddress,
- PAGESIZE,
+ PAGE_SIZE,
PAGE_READWRITE,
&OldProtect);
if (!NT_SUCCESS(Status))
Status = NtProtectVirtualMemory(NtCurrentProcess(),
ImageBase +
RelocationDir->VirtualAddress,
- PAGESIZE,
+ PAGE_SIZE,
OldProtect,
&OldProtect);
if (!NT_SUCCESS(Status))
-/* $Id: env.c,v 1.17 2002/09/08 10:23:05 chorns Exp $
+/* $Id: env.c,v 1.18 2002/10/01 19:27:20 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
MEMORY_BASIC_INFORMATION MemInfo;
PVOID EnvPtr = NULL;
NTSTATUS Status = STATUS_SUCCESS;
- ULONG RegionSize = PAGESIZE;
+ ULONG RegionSize = PAGE_SIZE;
if (Inherit == TRUE)
{
/* enlarge environment size */
/* check the size of available memory */
new_size += (env_len - hole_len) * sizeof(WCHAR);
- new_size = ROUNDUP(new_size, PAGESIZE);
+ new_size = ROUNDUP(new_size, PAGE_SIZE);
mbi.RegionSize = 0;
DPRINT("new_size %lu\n", new_size);
Peb = NtCurrentPeb();
Peb->NumberOfHeaps = 0;
- Peb->MaximumNumberOfHeaps = (PAGESIZE - sizeof(PEB)) / sizeof(HANDLE);
+ Peb->MaximumNumberOfHeaps = (PAGE_SIZE - sizeof(PEB)) / sizeof(HANDLE);
Peb->ProcessHeaps = (PVOID)Peb + sizeof(PEB);
RtlInitializeCriticalSection(&RtlpProcessHeapsListLock);
-/* $Id: ppb.c,v 1.14 2002/09/08 10:23:06 chorns Exp $
+/* $Id: ppb.c,v 1.15 2002/10/01 19:27:20 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
Length += ALIGN(RuntimeInfo->MaximumLength, sizeof(ULONG));
/* Calculate the required block size */
- RegionSize = ROUNDUP(Length, PAGESIZE);
+ RegionSize = ROUNDUP(Length, PAGE_SIZE);
Status = NtAllocateVirtualMemory(NtCurrentProcess(),
(PVOID*)&Param,
-/* $Id: process.c,v 1.30 2002/09/08 10:23:06 chorns Exp $
+/* $Id: process.c,v 1.31 2002/10/01 19:27:20 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries
/* FIXME */
#if 0
- if (StackCommit > PAGESIZE)
+ if (StackCommit > PAGE_SIZE)
InitialTeb.StackCommit = StackCommit;
else
- InitialTeb.StackCommit = PAGESIZE;
+ InitialTeb.StackCommit = PAGE_SIZE;
#endif
- InitialTeb.StackCommit = InitialTeb.StackReserve - PAGESIZE;
+ InitialTeb.StackCommit = InitialTeb.StackReserve - PAGE_SIZE;
/* add guard page size */
- InitialTeb.StackCommit += PAGESIZE;
+ InitialTeb.StackCommit += PAGE_SIZE;
/* Reserve stack */
InitialTeb.StackAllocate = NULL;
/* Protect guard page */
Status = NtProtectVirtualMemory(ProcessHandle,
InitialTeb.StackLimit,
- PAGESIZE,
+ PAGE_SIZE,
PAGE_GUARD | PAGE_READWRITE,
&OldPageProtection);
if (!NT_SUCCESS(Status))
/* FIXME: use correct commit size */
#if 0
- if ((StackCommit != NULL) && (*StackCommit > PAGESIZE))
+ if ((StackCommit != NULL) && (*StackCommit > PAGE_SIZE))
InitialTeb.StackCommit = *StackCommit;
else
- InitialTeb.StackCommit = PAGESIZE;
+ InitialTeb.StackCommit = PAGE_SIZE;
#endif
- InitialTeb.StackCommit = InitialTeb.StackReserve - PAGESIZE;
+ InitialTeb.StackCommit = InitialTeb.StackReserve - PAGE_SIZE;
/* add size of guard page */
- InitialTeb.StackCommit += PAGESIZE;
+ InitialTeb.StackCommit += PAGE_SIZE;
/* Reserve stack */
InitialTeb.StackAllocate = NULL;
/* Protect guard page */
Status = NtProtectVirtualMemory(ProcessHandle,
InitialTeb.StackLimit,
- PAGESIZE,
+ PAGE_SIZE,
PAGE_GUARD | PAGE_READWRITE,
&OldPageProtection);
if (!NT_SUCCESS(Status))
-/* $Id: copy.c,v 1.12 2002/09/08 10:23:16 chorns Exp $
+/* $Id: copy.c,v 1.13 2002/10/01 19:27:20 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
offset = 0;
while (current2 != NULL && !current2->Valid)
{
- for (i = 0; i < (Bcb->CacheSegmentSize / PAGESIZE); i++)
+ for (i = 0; i < (Bcb->CacheSegmentSize / PAGE_SIZE); i++)
{
PVOID address;
PHYSICAL_ADDRESS page;
- address = current2->BaseAddress + (i * PAGESIZE);
+ address = current2->BaseAddress + (i * PAGE_SIZE);
page = MmGetPhysicalAddressForProcess(NULL, address);
((PULONG)(Mdl + 1))[offset] = page.u.LowPart;
offset++;
while (Length > 0)
{
- if (Length + WriteOffset.u.LowPart % PAGESIZE > 262144)
+ if (Length + WriteOffset.u.LowPart % PAGE_SIZE > 262144)
{
Mdl = MmCreateMdl(NULL, (PVOID)WriteOffset.u.LowPart,
- 262144 - WriteOffset.u.LowPart % PAGESIZE);
+ 262144 - WriteOffset.u.LowPart % PAGE_SIZE);
WriteOffset.QuadPart +=
- (262144 - WriteOffset.u.LowPart % PAGESIZE);
- Length -= (262144 - WriteOffset.u.LowPart % PAGESIZE);
+ (262144 - WriteOffset.u.LowPart % PAGE_SIZE);
+ Length -= (262144 - WriteOffset.u.LowPart % PAGE_SIZE);
}
else
{
Mdl =
MmCreateMdl(NULL, (PVOID)WriteOffset.u.LowPart,
- Length - WriteOffset.u.LowPart % PAGESIZE);
+ Length - WriteOffset.u.LowPart % PAGE_SIZE);
WriteOffset.QuadPart +=
- (Length - WriteOffset.u.LowPart % PAGESIZE);
+ (Length - WriteOffset.u.LowPart % PAGE_SIZE);
Length = 0;
}
if (Mdl == NULL)
Length -= TempLength;
size = ((Mdl->Size - sizeof(MDL)) / sizeof(ULONG));
- for (i = 0; i < (Bcb->CacheSegmentSize / PAGESIZE) &&
+ for (i = 0; i < (Bcb->CacheSegmentSize / PAGE_SIZE) &&
count < size; i++)
{
PVOID Address;
- Address = current->BaseAddress + (i * PAGESIZE);
+ Address = current->BaseAddress + (i * PAGE_SIZE);
page =
MmGetPhysicalAddressForProcess(NULL, Address);
((PULONG)(Mdl + 1))[count++] = page.u.LowPart;
* 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.51 2002/09/30 20:55:33 chorns Exp $
+/* $Id: view.c,v 1.52 2002/10/01 19:27:20 chorns Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/cc/view.c
}
current->ReferenceCount++;
ExReleaseFastMutex(&ViewLock);
- PagesPerSegment = current->Bcb->CacheSegmentSize / PAGESIZE;
+ PagesPerSegment = current->Bcb->CacheSegmentSize / PAGE_SIZE;
Status = CcRosFlushCacheSegment(current);
current->ReferenceCount--;
ExReleaseFastMutex(¤t->Lock);
ExReleaseFastMutex(¤t->Lock);
DPRINT("current->Bcb->CacheSegmentSize %d\n",
current->Bcb->CacheSegmentSize);
- PagesPerSegment = current->Bcb->CacheSegmentSize / PAGESIZE;
+ PagesPerSegment = current->Bcb->CacheSegmentSize / PAGE_SIZE;
CcRosInternalFreeCacheSegment(current->Bcb, current);
DPRINT("CcRosTrimCache(): Freed %d\n", PagesPerSegment);
PagesFreed = min(PagesPerSegment, Target);
ExAcquireFastMutex(¤t->Lock);
}
ExReleaseFastMutex(&ViewLock);
- for (i = 0; i < (Bcb->CacheSegmentSize / PAGESIZE); i++)
+ for (i = 0; i < (Bcb->CacheSegmentSize / PAGE_SIZE); i++)
{
PHYSICAL_ADDRESS Page;
}
Status = MmCreateVirtualMapping(NULL,
- current->BaseAddress + (i * PAGESIZE),
+ current->BaseAddress + (i * PAGE_SIZE),
PAGE_READWRITE,
Page,
TRUE);
-/* $Id: sysinfo.c,v 1.17 2002/09/08 10:23:19 chorns Exp $
+/* $Id: sysinfo.c,v 1.18 2002/10/01 19:27:21 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
Sbi->Reserved = 0;
Sbi->TimerResolution = 0; /* FIXME */
- Sbi->PageSize = PAGESIZE; /* FIXME: it should be PAGE_SIZE */
+ Sbi->PageSize = PAGE_SIZE; /* FIXME: it should be PAGE_SIZE */
Sbi->NumberOfPhysicalPages = 0; /* FIXME */
Sbi->LowestPhysicalPageNumber = 0; /* FIXME */
Sbi->HighestPhysicalPageNumber = 0; /* FIXME */
#define PA_SYSTEM (0)
#endif
-#define PAGESIZE (4096)
+#define PAGE_SIZE (4096)
PULONG MmGetPageEntry(PVOID Address);
-/* $Id: mdl.c,v 1.10 2002/09/08 10:23:25 chorns Exp $
+/* $Id: mdl.c,v 1.11 2002/10/01 19:27:21 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PULONG SourcePages = (PULONG)(SourceMdl + 1);
ULONG Va;
ULONG Delta = (PAGE_ROUND_DOWN(VirtualAddress) - (ULONG)SourceMdl->StartVa)/
- PAGESIZE;
+ PAGE_SIZE;
- for (Va = 0; Va < (PAGE_ROUND_UP(Length)/PAGESIZE); Va++)
+ for (Va = 0; Va < (PAGE_ROUND_UP(Length)/PAGE_SIZE); Va++)
{
TargetPages[Va] = SourcePages[Va+Delta];
}
* Create a PCR for this processor
*/
Offset = InterlockedIncrement(&PcrsAllocated) - 1;
- KPCR = (PKPCR)(KPCR_BASE + (Offset * PAGESIZE));
+ KPCR = (PKPCR)(KPCR_BASE + (Offset * PAGE_SIZE));
MmCreateVirtualMappingForKernel((PVOID)KPCR,
PAGE_READWRITE,
PcrPages[Offset]);
- memset(KPCR, 0, PAGESIZE);
+ memset(KPCR, 0, PAGE_SIZE);
KPCR->ProcessorNumber = Offset;
KPCR->Self = KPCR;
KPCR->Irql = HIGH_LEVEL;
* called, so we use a predefined page in low memory
*/
KPCR = (PKPCR)KPCR_BASE;
- memset(KPCR, 0, PAGESIZE);
+ memset(KPCR, 0, PAGE_SIZE);
KPCR->Self = (PKPCR)KPCR_BASE;
KPCR->Irql = HIGH_LEVEL;
KPCR->GDT = (PUSHORT)&KiBootGdt;
* 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.34 2002/09/08 10:23:28 chorns Exp $
+/* $Id: kthread.c,v 1.35 2002/10/01 19:27:21 chorns Exp $
*
* FILE: ntoskrnl/ke/kthread.c
* PURPOSE: Microkernel thread support
DPRINT1("Failed to create thread stack\n");
KeBugCheck(0);
}
- for (i = 0; i < (MM_STACK_SIZE / PAGESIZE); i++)
+ for (i = 0; i < (MM_STACK_SIZE / PAGE_SIZE); i++)
{
PHYSICAL_ADDRESS Page;
Status = MmRequestPageMemoryConsumer(MC_NPPOOL, TRUE, &Page);
KeBugCheck(0);
}
Status = MmCreateVirtualMapping(NULL,
- KernelStack + (i * PAGESIZE),
+ KernelStack + (i * PAGE_SIZE),
PAGE_EXECUTE_READWRITE,
Page,
TRUE);
DPRINT("NTHeaders %x\n", NTHeaders);
InitialTeb.StackReserve = NTHeaders->OptionalHeader.SizeOfStackReserve;
/* FIXME: use correct commit size */
- InitialTeb.StackCommit = NTHeaders->OptionalHeader.SizeOfStackReserve - PAGESIZE;
+ InitialTeb.StackCommit = NTHeaders->OptionalHeader.SizeOfStackReserve - PAGE_SIZE;
// InitialTeb.StackCommit = NTHeaders->OptionalHeader.SizeOfStackCommit;
/* add guard page size */
- InitialTeb.StackCommit += PAGESIZE;
+ InitialTeb.StackCommit += PAGE_SIZE;
DPRINT("StackReserve 0x%lX StackCommit 0x%lX\n",
InitialTeb.StackReserve, InitialTeb.StackCommit);
KeDetachProcess();
/* Protect guard page */
Status = NtProtectVirtualMemory(ProcessHandle,
InitialTeb.StackLimit,
- PAGESIZE,
+ PAGE_SIZE,
PAGE_GUARD | PAGE_READWRITE,
&OldPageProtection);
if (!NT_SUCCESS(Status))
-/* $Id: loader.c,v 1.122 2002/09/08 10:23:31 chorns Exp $
+/* $Id: loader.c,v 1.123 2002/10/01 19:27:22 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
{
for (i = 0; i < PAGE_ROUND_DOWN(Length); i++)
{
- MmSetPageProtect(NULL, BaseAddress + (i * PAGESIZE),
+ MmSetPageProtect(NULL, BaseAddress + (i * PAGE_SIZE),
PAGE_READONLY);
}
}
* 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.6 2002/09/08 10:23:32 chorns Exp $
+/* $Id: anonmem.c,v 1.7 2002/10/01 19:27:22 chorns Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/anonmem.c
/*
* Write the page to the pagefile
*/
- Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
+ Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
MmBuildMdlFromPages(Mdl, (PULONG)&PhysicalAddress);
Status = MmWriteToSwapPage(SwapEntry, Mdl);
if (!NT_SUCCESS(Status))
/*
* Write the page to the pagefile
*/
- Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
+ Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
MmBuildMdlFromPages(Mdl, (PULONG)&PhysicalAddress);
Status = MmWriteToSwapPage(SwapEntry, Mdl);
if (!NT_SUCCESS(Status))
PMDL Mdl;
MmDeletePageFileMapping(NULL, Address, &SwapEntry);
- Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
+ Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
MmBuildMdlFromPages(Mdl, (PULONG)&Page);
Status = MmReadFromSwapPage(SwapEntry, Mdl);
if (!NT_SUCCESS(Status))
{
ULONG i;
- for (i=0; i <= (RegionSize/PAGESIZE); i++)
+ for (i=0; i <= (RegionSize/PAGE_SIZE); i++)
{
LARGE_INTEGER PhysicalAddr;
if (MmIsPageSwapEntry(AddressSpace->Process,
- BaseAddress + (i * PAGESIZE)))
+ BaseAddress + (i * PAGE_SIZE)))
{
SWAPENTRY SwapEntry;
MmDeletePageFileMapping(AddressSpace->Process,
- BaseAddress + (i * PAGESIZE),
+ BaseAddress + (i * PAGE_SIZE),
&SwapEntry);
MmFreeSwapPage(SwapEntry);
}
else
{
- PhysicalAddr = MmGetPhysicalAddress(BaseAddress + (i*PAGESIZE));
+ PhysicalAddr = MmGetPhysicalAddress(BaseAddress + (i*PAGE_SIZE));
MmDeleteVirtualMapping(AddressSpace->Process,
- BaseAddress + (i*PAGESIZE),
+ BaseAddress + (i*PAGE_SIZE),
FALSE, NULL, NULL);
if (PhysicalAddr.QuadPart != 0)
{
MmSetSavedSwapEntryPage(PhysicalAddr, 0);
}
MmDeleteRmap(PhysicalAddr, AddressSpace->Process,
- BaseAddress + (i * PAGESIZE));
+ BaseAddress + (i * PAGE_SIZE));
MmReleasePageMemoryConsumer(MC_USER, PhysicalAddr);
}
}
{
ULONG i;
- for (i=0; i <= (RegionSize/PAGESIZE); i++)
+ for (i=0; i <= (RegionSize/PAGE_SIZE); i++)
{
if (MmIsPagePresent(AddressSpace->Process,
- BaseAddress + (i*PAGESIZE)))
+ BaseAddress + (i*PAGE_SIZE)))
{
MmSetPageProtect(AddressSpace->Process,
- BaseAddress + (i*PAGESIZE),
+ BaseAddress + (i*PAGE_SIZE),
NewProtect);
}
}
*/
if (MemoryArea->PageOpCount > 0)
{
- for (i = 0; i < (PAGE_ROUND_UP(MemoryArea->Length) / PAGESIZE); i++)
+ for (i = 0; i < (PAGE_ROUND_UP(MemoryArea->Length) / PAGE_SIZE); i++)
{
PMM_PAGEOP PageOp;
}
PageOp = MmCheckForPageOp(MemoryArea, Process->UniqueProcessId,
- MemoryArea->BaseAddress + (i * PAGESIZE),
+ MemoryArea->BaseAddress + (i * PAGE_SIZE),
NULL, 0);
if (PageOp != NULL)
{
-/* $Id: cont.c,v 1.23 2002/09/08 10:23:32 chorns Exp $
+/* $Id: cont.c,v 1.24 2002/10/01 19:27:22 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
{
return(MmAllocateContiguousAlignedMemory(NumberOfBytes,
HighestAcceptableAddress,
- PAGESIZE));
+ PAGE_SIZE));
}
VOID
MmTransferOwnershipPage(PHYSICAL_ADDRESS PhysicalAddress, ULONG NewConsumer)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
KeAcquireSpinLock(&PageListLock, &oldIrql);
}
PageDescriptor = CONTAINING_RECORD(NextListEntry, PHYSICAL_PAGE, ListEntry);
Next.QuadPart = (ULONG)((ULONG)PageDescriptor - (ULONG)MmPageArray);
- Next.QuadPart = (Next.QuadPart / sizeof(PHYSICAL_PAGE)) * PAGESIZE;
+ Next.QuadPart = (Next.QuadPart / sizeof(PHYSICAL_PAGE)) * PAGE_SIZE;
KeReleaseSpinLock(&PageListLock, oldIrql);
return(Next);
}
PHYSICAL_ADDRESS
MmGetLRUNextUserPage(PHYSICAL_ADDRESS PreviousPhysicalAddress)
{
- ULONG Start = PreviousPhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PreviousPhysicalAddress.u.LowPart / PAGE_SIZE;
PLIST_ENTRY NextListEntry;
PHYSICAL_ADDRESS Next;
PHYSICAL_PAGE* PageDescriptor;
}
PageDescriptor = CONTAINING_RECORD(NextListEntry, PHYSICAL_PAGE, ListEntry);
Next.QuadPart = (ULONG)((ULONG)PageDescriptor - (ULONG)MmPageArray);
- Next.QuadPart = (Next.QuadPart / sizeof(PHYSICAL_PAGE)) * PAGESIZE;
+ Next.QuadPart = (Next.QuadPart / sizeof(PHYSICAL_PAGE)) * PAGE_SIZE;
KeReleaseSpinLock(&PageListLock, oldIrql);
return(Next);
}
ULONG length;
KIRQL oldIrql;
- NrPages = PAGE_ROUND_UP(NumberOfBytes) / PAGESIZE;
+ NrPages = PAGE_ROUND_UP(NumberOfBytes) / PAGE_SIZE;
KeAcquireSpinLock(&PageListLock, &oldIrql);
start = -1;
length = 0;
- for (i = 0; i < (HighestAcceptableAddress.QuadPart / PAGESIZE); )
+ for (i = 0; i < (HighestAcceptableAddress.QuadPart / PAGE_SIZE); )
{
if (MM_PTYPE(MmPageArray[i].Flags) == MM_PHYSICAL_PAGE_FREE)
{
/*
* Fast forward to the base of the next aligned region
*/
- i = ROUND_UP((i + 1), (Alignment / PAGESIZE));
+ i = ROUND_UP((i + 1), (Alignment / PAGE_SIZE));
}
}
if (start == -1 || length != NrPages)
Range->LengthLow,
Range->Type);
- first = (Range->BaseAddrLow + PAGESIZE - 1) / PAGESIZE;
- last = first + ((Range->LengthLow + PAGESIZE - 1) / PAGESIZE);
+ first = (Range->BaseAddrLow + PAGE_SIZE - 1) / PAGE_SIZE;
+ last = first + ((Range->LengthLow + PAGE_SIZE - 1) / PAGE_SIZE);
for (i = first; i < last; i++)
{
if (MmPageArray[i].Flags == 0)
Range->LengthLow,
Range->Type);
- first = (Range->BaseAddrLow + PAGESIZE - 1) / PAGESIZE;
- last = first + ((Range->LengthLow + PAGESIZE - 1) / PAGESIZE);
+ first = (Range->BaseAddrLow + PAGE_SIZE - 1) / PAGE_SIZE;
+ last = first + ((Range->LengthLow + PAGE_SIZE - 1) / PAGE_SIZE);
for (i = first; i < last; i++)
{
/* Remove the page from the free list if it is there */
p = BIOSMemoryMap;
for (i = 0; i < AddressRangeCount; i++)
{
- if (((p->BaseAddrLow + PAGESIZE - 1) / PAGESIZE) < MemorySizeInPages)
+ if (((p->BaseAddrLow + PAGE_SIZE - 1) / PAGE_SIZE) < MemorySizeInPages)
{
if (p->Type == 1)
{
LastKernelAddress = PAGE_ROUND_UP(LastKernelAddress);
Reserved =
- PAGE_ROUND_UP((MemorySizeInPages * sizeof(PHYSICAL_PAGE))) / PAGESIZE;
+ PAGE_ROUND_UP((MemorySizeInPages * sizeof(PHYSICAL_PAGE))) / PAGE_SIZE;
MmPageArray = (PHYSICAL_PAGE *)LastKernelAddress;
DPRINT("Reserved %d\n", Reserved);
LastKernelAddress = PAGE_ROUND_UP(LastKernelAddress);
- LastKernelAddress = ((ULONG)LastKernelAddress + (Reserved * PAGESIZE));
+ LastKernelAddress = ((ULONG)LastKernelAddress + (Reserved * PAGE_SIZE));
LastPhysKernelAddress = (PVOID)PAGE_ROUND_UP(LastPhysKernelAddress);
- LastPhysKernelAddress = LastPhysKernelAddress + (Reserved * PAGESIZE);
+ LastPhysKernelAddress = LastPhysKernelAddress + (Reserved * PAGE_SIZE);
MmStats.NrTotalPages = 0;
MmStats.NrSystemPages = 0;
for (i = 0; i < Reserved; i++)
{
- PVOID Address = (PVOID)(ULONG)MmPageArray + (i * PAGESIZE);
+ PVOID Address = (PVOID)(ULONG)MmPageArray + (i * PAGE_SIZE);
if (!MmIsPagePresent(NULL, Address))
{
ULONG PhysicalAddress;
PhysicalAddress = (ULONG)LastPhysKernelAddress -
- (Reserved * PAGESIZE) + (i * PAGESIZE);
+ (Reserved * PAGE_SIZE) + (i * PAGE_SIZE);
Status =
MmCreateVirtualMappingUnsafe(NULL,
Address,
KeBugCheck(0);
}
}
- memset((PVOID)MmPageArray + (i * PAGESIZE), 0, PAGESIZE);
+ memset((PVOID)MmPageArray + (i * PAGE_SIZE), 0, PAGE_SIZE);
}
/*
i = 2;
if ((ULONG)FirstPhysKernelAddress < 0xa0000)
{
- MmStats.NrFreePages += (((ULONG)FirstPhysKernelAddress/PAGESIZE) - 1);
- for (; i<((ULONG)FirstPhysKernelAddress/PAGESIZE); i++)
+ MmStats.NrFreePages += (((ULONG)FirstPhysKernelAddress/PAGE_SIZE) - 1);
+ for (; i<((ULONG)FirstPhysKernelAddress/PAGE_SIZE); i++)
{
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE;
MmPageArray[i].ReferenceCount = 0;
&MmPageArray[i].ListEntry);
}
MmStats.NrSystemPages +=
- ((((ULONG)LastPhysKernelAddress) / PAGESIZE) - i);
- for (; i<((ULONG)LastPhysKernelAddress / PAGESIZE); i++)
+ ((((ULONG)LastPhysKernelAddress) / PAGE_SIZE) - i);
+ for (; i<((ULONG)LastPhysKernelAddress / PAGE_SIZE); i++)
{
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_USED;
MmPageArray[i].ReferenceCount = 1;
InsertTailList(&UsedPageListHeads[MC_NPPOOL],
&MmPageArray[i].ListEntry);
}
- MmStats.NrFreePages += ((0xa0000/PAGESIZE) - i);
- for (; i<(0xa0000/PAGESIZE); i++)
+ MmStats.NrFreePages += ((0xa0000/PAGE_SIZE) - i);
+ for (; i<(0xa0000/PAGE_SIZE); i++)
{
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE;
MmPageArray[i].ReferenceCount = 0;
InsertTailList(&FreeUnzeroedPageListHead,
&MmPageArray[i].ListEntry);
}
- MmStats.NrReservedPages += ((0x100000/PAGESIZE) - i);
- for (; i<(0x100000 / PAGESIZE); i++)
+ MmStats.NrReservedPages += ((0x100000/PAGE_SIZE) - i);
+ for (; i<(0x100000 / PAGE_SIZE); i++)
{
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_BIOS;
MmPageArray[i].ReferenceCount = 1;
}
else
{
- MmStats.NrFreePages += ((0xa0000 / PAGESIZE) - 1);
- for (; i<(0xa0000 / PAGESIZE); i++)
+ MmStats.NrFreePages += ((0xa0000 / PAGE_SIZE) - 1);
+ for (; i<(0xa0000 / PAGE_SIZE); i++)
{
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE;
MmPageArray[i].ReferenceCount = 0;
InsertTailList(&FreeUnzeroedPageListHead,
&MmPageArray[i].ListEntry);
}
- MmStats.NrReservedPages += (0x60000 / PAGESIZE);
- for (; i<(0x100000 / PAGESIZE); i++)
+ MmStats.NrReservedPages += (0x60000 / PAGE_SIZE);
+ for (; i<(0x100000 / PAGE_SIZE); i++)
{
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_BIOS;
MmPageArray[i].ReferenceCount = 1;
InsertTailList(&BiosPageListHead,
&MmPageArray[i].ListEntry);
}
- MmStats.NrFreePages += (((ULONG)FirstPhysKernelAddress/PAGESIZE) - i);
- for (; i<((ULONG)FirstPhysKernelAddress/PAGESIZE); i++)
+ MmStats.NrFreePages += (((ULONG)FirstPhysKernelAddress/PAGE_SIZE) - i);
+ for (; i<((ULONG)FirstPhysKernelAddress/PAGE_SIZE); i++)
{
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_FREE;
MmPageArray[i].ReferenceCount = 0;
&MmPageArray[i].ListEntry);
}
MmStats.NrSystemPages +=
- (((ULONG)LastPhysKernelAddress/PAGESIZE) - i);
- for (; i<((ULONG)LastPhysKernelAddress/PAGESIZE); i++)
+ (((ULONG)LastPhysKernelAddress/PAGE_SIZE) - i);
+ for (; i<((ULONG)LastPhysKernelAddress/PAGE_SIZE); i++)
{
MmPageArray[i].Flags = MM_PHYSICAL_PAGE_USED;
MmPageArray[i].ReferenceCount = 1;
VOID
MmSetFlagsPage(PHYSICAL_ADDRESS PhysicalAddress, ULONG Flags)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
KeAcquireSpinLock(&PageListLock, &oldIrql);
MmSetRmapListHeadPage(PHYSICAL_ADDRESS PhysicalAddress,
struct _MM_RMAP_ENTRY* ListHead)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
MmPageArray[Start].RmapListHead = ListHead;
}
struct _MM_RMAP_ENTRY*
MmGetRmapListHeadPage(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
return(MmPageArray[Start].RmapListHead);
}
VOID
MmMarkPageMapped(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
KeAcquireSpinLock(&PageListLock, &oldIrql);
VOID
MmMarkPageUnmapped(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
KeAcquireSpinLock(&PageListLock, &oldIrql);
ULONG
MmGetFlagsPage(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
ULONG Flags;
MmSetSavedSwapEntryPage(PHYSICAL_ADDRESS PhysicalAddress,
SWAPENTRY SavedSwapEntry)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
KeAcquireSpinLock(&PageListLock, &oldIrql);
SWAPENTRY
MmGetSavedSwapEntryPage(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
SWAPENTRY SavedSwapEntry;
KIRQL oldIrql;
VOID
MmReferencePage(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
DPRINT("MmReferencePage(PhysicalAddress %x)\n", PhysicalAddress);
ULONG
MmGetReferenceCountPage(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
ULONG RCount;
BOOLEAN
MmIsUsablePage(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
DPRINT("MmGetReferenceCountPage(PhysicalAddress %x)\n", PhysicalAddress);
VOID
MmDereferencePage(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
DPRINT("MmDereferencePage(PhysicalAddress %I64x)\n", PhysicalAddress);
ULONG
MmGetLockCountPage(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
ULONG LockCount;
VOID
MmLockPage(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
DPRINT("MmLockPage(PhysicalAddress %x)\n", PhysicalAddress);
VOID
MmUnlockPage(PHYSICAL_ADDRESS PhysicalAddress)
{
- ULONG Start = PhysicalAddress.u.LowPart / PAGESIZE;
+ ULONG Start = PhysicalAddress.u.LowPart / PAGE_SIZE;
KIRQL oldIrql;
DPRINT("MmUnlockPage(PhysicalAddress %llx)\n", PhysicalAddress);
PageOffset.QuadPart = (ULONG)((ULONG)PageDescriptor - (ULONG)MmPageArray);
PageOffset.QuadPart =
- (PageOffset.QuadPart / sizeof(PHYSICAL_PAGE)) * PAGESIZE;
+ (PageOffset.QuadPart / sizeof(PHYSICAL_PAGE)) * PAGE_SIZE;
if (NeedClear)
{
MiZeroPage(PageOffset);
* 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.44 2002/09/15 10:45:04 guido Exp $
+/* $Id: page.c,v 1.45 2002/10/01 19:27:25 chorns Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/i386/page.c
KProcess->DirectoryTableBase = PhysPageDirectory;
CurrentPageDirectory = (PULONG)PAGEDIRECTORY_MAP;
- memset(PageDirectory,0,PAGESIZE);
+ memset(PageDirectory,0,PAGE_SIZE);
for (i=768; i<896; i++)
{
PageDirectory[i] = CurrentPageDirectory[i];
MmGlobalKernelPageDirectory[ADDR_TO_PDE_OFFSET(Address)] =
*Pde;
}
- memset((PVOID)PAGE_ROUND_DOWN(ADDR_TO_PTE(Address)), 0, PAGESIZE);
+ memset((PVOID)PAGE_ROUND_DOWN(ADDR_TO_PTE(Address)), 0, PAGE_SIZE);
FLUSH_TLB;
}
}
return(Status);
}
(*page_dir) = npage.QuadPart | 0x7;
- memset((PVOID)PAGE_ROUND_DOWN(ADDR_TO_PTE(Address)), 0, PAGESIZE);
+ memset((PVOID)PAGE_ROUND_DOWN(ADDR_TO_PTE(Address)), 0, PAGE_SIZE);
FLUSH_TLB;
}
return(STATUS_SUCCESS);
KeBugCheck(0);
}
(*page_dir) = npage.QuadPart | 0x7;
- memset((PVOID)PAGE_ROUND_DOWN(ADDR_TO_PTE(Address)), 0, PAGESIZE);
+ memset((PVOID)PAGE_ROUND_DOWN(ADDR_TO_PTE(Address)), 0, PAGE_SIZE);
FLUSH_TLB;
}
page_tlb = ADDR_TO_PTE(Address);
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: iospace.c,v 1.15 2002/09/08 10:23:33 chorns Exp $
+/* $Id: iospace.c,v 1.16 2002/10/01 19:27:22 chorns Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/iospace.c
{
Attributes |= (PAGE_NOCACHE | PAGE_WRITETHROUGH);
}
- for (i = 0; (i < ((NumberOfBytes + PAGESIZE - 1) / PAGESIZE)); i++)
+ for (i = 0; (i < ((NumberOfBytes + PAGE_SIZE - 1) / PAGE_SIZE)); i++)
{
Status =
- MmCreateVirtualMappingForKernel(Result + (i * PAGESIZE),
+ MmCreateVirtualMappingForKernel(Result + (i * PAGE_SIZE),
Attributes,
(PHYSICAL_ADDRESS)
(PhysicalAddress.QuadPart +
- (i * PAGESIZE)));
+ (i * PAGE_SIZE)));
if (!NT_SUCCESS(Status))
{
DbgPrint("Unable to create virtual mapping\n");
KeBugCheck(0);
}
}
- return ((PVOID)(Result + PhysicalAddress.QuadPart % PAGESIZE));
+ return ((PVOID)(Result + PhysicalAddress.QuadPart % PAGE_SIZE));
}
IN ULONG NumberOfBytes)
{
(VOID)MmFreeMemoryArea(&PsGetCurrentProcess()->AddressSpace,
- (PVOID)(((ULONG)BaseAddress / PAGESIZE) * PAGESIZE),
+ (PVOID)(((ULONG)BaseAddress / PAGE_SIZE) * PAGE_SIZE),
NumberOfBytes,
NULL,
NULL);
-/* $Id: kmap.c,v 1.20 2002/09/08 10:23:33 chorns Exp $
+/* $Id: kmap.c,v 1.21 2002/10/01 19:27:22 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* GLOBALS *****************************************************************/
-#define ALLOC_MAP_SIZE (NONPAGED_POOL_SIZE / PAGESIZE)
+#define ALLOC_MAP_SIZE (NONPAGED_POOL_SIZE / PAGE_SIZE)
/*
* One bit for each page in the kmalloc region
ExUnmapPage(PVOID Addr)
{
KIRQL oldIrql;
- ULONG i = (Addr - NonPagedPoolBase) / PAGESIZE;
+ ULONG i = (Addr - NonPagedPoolBase) / PAGE_SIZE;
DPRINT("ExUnmapPage(Addr %x)\n",Addr);
DPRINT("i %x\n",i);
{
return(STATUS_NO_MEMORY);
}
- memset(TempAddress, 0, PAGESIZE);
+ memset(TempAddress, 0, PAGE_SIZE);
ExUnmapPage(TempAddress);
return(STATUS_SUCCESS);
}
{
return(STATUS_NO_MEMORY);
}
- memcpy(TempAddress, SourceAddress, PAGESIZE);
+ memcpy(TempAddress, SourceAddress, PAGE_SIZE);
ExUnmapPage(TempAddress);
return(STATUS_SUCCESS);
}
DPRINT("i %x\n",i);
AllocMap[i / 32] |= (1 << (i % 32));
AllocMapHint = i + 1;
- addr = (ULONG)(NonPagedPoolBase + (i*PAGESIZE));
+ addr = (ULONG)(NonPagedPoolBase + (i*PAGE_SIZE));
Status = MmCreateVirtualMapping(NULL,
(PVOID)addr,
PAGE_READWRITE | PAGE_SYSTEM,
MiFreeNonPagedPoolRegion(PVOID Addr, ULONG Count, BOOLEAN Free)
{
ULONG i;
- ULONG Base = (Addr - NonPagedPoolBase) / PAGESIZE;
+ ULONG Base = (Addr - NonPagedPoolBase) / PAGE_SIZE;
ULONG Offset;
KIRQL oldlvl;
Offset = Base + i;
AllocMap[Offset / 32] &= (~(1 << (Offset % 32)));
MmDeleteVirtualMapping(NULL,
- Addr + (i * PAGESIZE),
+ Addr + (i * PAGE_SIZE),
Free,
NULL,
NULL);
{
AllocMap[j / 32] |= (1 << (j % 32));
}
- DPRINT("returning %x\n",((start*PAGESIZE)+NonPagedPoolBase));
+ DPRINT("returning %x\n",((start*PAGE_SIZE)+NonPagedPoolBase));
KeReleaseSpinLock(&AllocMapLock, oldlvl);
- return(((start*PAGESIZE)+NonPagedPoolBase));
+ return(((start*PAGE_SIZE)+NonPagedPoolBase));
}
}
else
KeBugCheck(0);
return(STATUS_UNSUCCESSFUL);
}
- for (i=0; i<(PAGE_ROUND_UP(MemoryArea->Length)/PAGESIZE); i++)
+ for (i=0; i<(PAGE_ROUND_UP(MemoryArea->Length)/PAGE_SIZE); i++)
{
PHYSICAL_ADDRESS PhysAddr = (PHYSICAL_ADDRESS)0LL;
BOOL Dirty;
SWAPENTRY SwapEntry = 0;
if (MmIsPageSwapEntry(AddressSpace->Process,
- MemoryArea->BaseAddress + (i * PAGESIZE)))
+ MemoryArea->BaseAddress + (i * PAGE_SIZE)))
{
MmDeletePageFileMapping(AddressSpace->Process,
- MemoryArea->BaseAddress + (i * PAGESIZE),
+ MemoryArea->BaseAddress + (i * PAGE_SIZE),
&SwapEntry);
}
else
{
MmDeleteVirtualMapping(AddressSpace->Process,
- MemoryArea->BaseAddress + (i*PAGESIZE),
+ MemoryArea->BaseAddress + (i*PAGE_SIZE),
FALSE, &Dirty, &PhysAddr);
}
if (FreePage != NULL)
{
FreePage(FreePageContext, MemoryArea,
- MemoryArea->BaseAddress + (i * PAGESIZE), PhysAddr,
+ MemoryArea->BaseAddress + (i * PAGE_SIZE), PhysAddr,
SwapEntry, Dirty);
}
}
if ((*BaseAddress)==0 && !FixedAddress)
{
*BaseAddress = MmFindGap(AddressSpace,
- PAGE_ROUND_UP(Length) +(PAGESIZE*2));
+ PAGE_ROUND_UP(Length) +(PAGE_SIZE*2));
if ((*BaseAddress)==0)
{
DPRINT("No suitable gap\n");
return(STATUS_NO_MEMORY);
}
- (*BaseAddress)=(*BaseAddress)+PAGESIZE;
+ (*BaseAddress)=(*BaseAddress)+PAGE_SIZE;
}
else
{
-/* $Id: mdl.c,v 1.44 2002/09/08 10:23:34 chorns Exp $
+/* $Id: mdl.c,v 1.45 2002/10/01 19:27:22 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
MiMdlMappingRegionAllocMap =
ExAllocatePool(NonPagedPool,
- MI_MDL_MAPPING_REGION_SIZE / (PAGESIZE * 32));
+ MI_MDL_MAPPING_REGION_SIZE / (PAGE_SIZE * 32));
MiMdlMappingRegionHighWaterMark = 0;
KeInitializeSpinLock(&MiMdlMappingRegionLock);
}
MdlPages = (PULONG)(Mdl + 1);
- return((PVOID)MdlPages[((ULONG)Offset) / PAGESIZE]);
+ return((PVOID)MdlPages[((ULONG)Offset) / PAGE_SIZE]);
}
VOID STDCALL
}
MdlPages = (PULONG)(Mdl + 1);
- for (i=0; i<(PAGE_ROUND_UP(Mdl->ByteCount+Mdl->ByteOffset)/PAGESIZE); i++)
+ for (i=0; i<(PAGE_ROUND_UP(Mdl->ByteCount+Mdl->ByteOffset)/PAGE_SIZE); i++)
{
MmUnlockPage((LARGE_INTEGER)(LONGLONG)MdlPages[i]);
MmDereferencePage((LARGE_INTEGER)(LONGLONG)MdlPages[i]);
}
/* Calculate the number of pages required. */
- RegionSize = PAGE_ROUND_UP(Mdl->ByteCount + Mdl->ByteOffset) / PAGESIZE;
+ RegionSize = PAGE_ROUND_UP(Mdl->ByteCount + Mdl->ByteOffset) / PAGE_SIZE;
/* Allocate that number of pages from the mdl mapping region. */
KeAcquireSpinLock(&MiMdlMappingRegionLock, &oldIrql);
- Base = MiMdlMappingRegionBase + MiMdlMappingRegionHighWaterMark * PAGESIZE;
+ Base = MiMdlMappingRegionBase + MiMdlMappingRegionHighWaterMark * PAGE_SIZE;
for (i = 0; i < RegionSize; i++)
{
ULONG Offset = MiMdlMappingRegionHighWaterMark + i;
{
NTSTATUS Status;
Status = MmCreateVirtualMapping(NULL,
- (PVOID)((ULONG)Base+(i*PAGESIZE)),
+ (PVOID)((ULONG)Base+(i*PAGE_SIZE)),
PAGE_READWRITE,
(LARGE_INTEGER)(LONGLONG)MdlPages[i],
FALSE);
}
/* Calculate the number of pages we mapped. */
- RegionSize = PAGE_ROUND_UP(Mdl->ByteCount + Mdl->ByteOffset) / PAGESIZE;
+ RegionSize = PAGE_ROUND_UP(Mdl->ByteCount + Mdl->ByteOffset) / PAGE_SIZE;
/* Unmap all the pages. */
for (i = 0; i < RegionSize; i++)
{
MmDeleteVirtualMapping(NULL,
- BaseAddress + (i * PAGESIZE),
+ BaseAddress + (i * PAGE_SIZE),
FALSE,
NULL,
NULL);
KeAcquireSpinLock(&MiMdlMappingRegionLock, &oldIrql);
/* Deallocate all the pages used. */
Base = (ULONG)(BaseAddress - MiMdlMappingRegionBase - Mdl->ByteOffset);
- Base = Base / PAGESIZE;
+ Base = Base / PAGE_SIZE;
for (i = 0; i < RegionSize; i++)
{
ULONG Offset = Base + i;
MdlPages = (PULONG)(Mdl + 1);
- for (i=0;i<(PAGE_ROUND_UP(Mdl->ByteOffset+Mdl->ByteCount)/PAGESIZE);i++)
+ for (i=0;i<(PAGE_ROUND_UP(Mdl->ByteOffset+Mdl->ByteCount)/PAGE_SIZE);i++)
{
MdlPages[i] = Pages[i];
}
MmLockAddressSpace(&Mdl->Process->AddressSpace);
MdlPages = (ULONG *)(Mdl + 1);
- NrPages = PAGE_ROUND_UP(Mdl->ByteOffset + Mdl->ByteCount) / PAGESIZE;
+ NrPages = PAGE_ROUND_UP(Mdl->ByteOffset + Mdl->ByteCount) / PAGE_SIZE;
for (i = 0; i < NrPages; i++)
{
PVOID Address;
- Address = Mdl->StartVa + (i*PAGESIZE);
+ Address = Mdl->StartVa + (i*PAGE_SIZE);
if (!MmIsPagePresent(NULL, Address))
{
for (va=0; va < ((Mdl->Size - sizeof(MDL)) / sizeof(ULONG)); va++)
{
((PULONG)(Mdl + 1))[va] =
- (MmGetPhysicalAddress(Mdl->StartVa + (va * PAGESIZE))).u.LowPart;
+ (MmGetPhysicalAddress(Mdl->StartVa + (va * PAGE_SIZE))).u.LowPart;
}
Mdl->MappedSystemVa = Mdl->StartVa + Mdl->ByteOffset;
}
-/* $Id: mminit.c,v 1.40 2002/09/08 10:23:35 chorns Exp $
+/* $Id: mminit.c,v 1.41 2002/10/01 19:27:22 chorns Exp $
*
* COPYRIGHT: See COPYING in the top directory
* PROJECT: ReactOS kernel
LastKernelAddress = PAGE_ROUND_UP(LastKernelAddress);
MmInitMemoryAreas();
- ExInitNonPagedPool(LastKernelAddress + PAGESIZE);
+ ExInitNonPagedPool(LastKernelAddress + PAGE_SIZE);
/*
* Setup the system area descriptor list
&kernel_param_desc,
FALSE);
- BaseAddress = (PVOID)(LastKernelAddress + PAGESIZE);
+ BaseAddress = (PVOID)(LastKernelAddress + PAGE_SIZE);
Length = NONPAGED_POOL_SIZE;
MmCreateMemoryArea(NULL,
MmGetKernelAddressSpace(),
FALSE);
MmPagedPoolSize = MM_PAGED_POOL_SIZE;
- BaseAddress = (PVOID)(LastKernelAddress + PAGESIZE + NONPAGED_POOL_SIZE +
- PAGESIZE);
+ BaseAddress = (PVOID)(LastKernelAddress + PAGE_SIZE + NONPAGED_POOL_SIZE +
+ PAGE_SIZE);
MmPagedPoolBase = BaseAddress;
Length = MM_PAGED_POOL_SIZE;
MmCreateMemoryArea(NULL,
* Create the kernel mapping of the user/kernel shared memory.
*/
BaseAddress = (PVOID)KI_USER_SHARED_DATA;
- Length = PAGESIZE;
+ Length = PAGE_SIZE;
MmCreateMemoryArea(NULL,
MmGetKernelAddressSpace(),
MEMORY_AREA_SYSTEM,
for (i = 0; i < AddressRangeCount; i++)
{
if (BIOSMemoryMap[i].Type == 1
- && (BIOSMemoryMap[i].BaseAddrLow + BIOSMemoryMap[i].LengthLow + PAGESIZE -1) / PAGESIZE > last)
+ && (BIOSMemoryMap[i].BaseAddrLow + BIOSMemoryMap[i].LengthLow + PAGE_SIZE -1) / PAGE_SIZE > last)
{
- last = (BIOSMemoryMap[i].BaseAddrLow + BIOSMemoryMap[i].LengthLow + PAGESIZE -1) / PAGESIZE;
+ last = (BIOSMemoryMap[i].BaseAddrLow + BIOSMemoryMap[i].LengthLow + PAGE_SIZE -1) / PAGE_SIZE;
}
}
if ((last - 256) * 4 > KeLoaderBlock.MemHigher)
#ifdef BIOS_MEM_FIX
MmStats.NrTotalPages += 16;
#endif
- DbgPrint("Used memory %dKb\n", (MmStats.NrTotalPages * PAGESIZE) / 1024);
+ DbgPrint("Used memory %dKb\n", (MmStats.NrTotalPages * PAGE_SIZE) / 1024);
LastKernelAddress = (ULONG)MmInitializePageList(
(PVOID)FirstKrnlPhysAddr,
CHECKPOINT;
DPRINT("_text_start__ %x _text_end__ %x\n",(int)&_text_start__,(int)&_text_end__);
for (i=PAGE_ROUND_UP(((int)&_text_start__));
- i<PAGE_ROUND_DOWN(((int)&_text_end__));i=i+PAGESIZE)
+ i<PAGE_ROUND_DOWN(((int)&_text_end__));i=i+PAGE_SIZE)
{
MmSetPageProtect(NULL,
(PVOID)i,
KERNEL_BASE + 2 * PAGE_TABLE_SIZE);
for (i=(LastKernelAddress);
i<(KERNEL_BASE + 2 * PAGE_TABLE_SIZE);
- i=i+PAGESIZE)
+ i=i+PAGE_SIZE)
{
MmDeleteVirtualMapping(NULL, (PVOID)(i), FALSE, NULL, NULL);
}
-/* $Id: ncache.c,v 1.21 2002/09/08 10:23:35 chorns Exp $
+/* $Id: ncache.c,v 1.22 2002/10/01 19:27:23 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
}
Attributes = PAGE_READWRITE | PAGE_SYSTEM | PAGE_NOCACHE |
PAGE_WRITETHROUGH;
- for (i = 0; i <= (NumberOfBytes / PAGESIZE); i++)
+ for (i = 0; i <= (NumberOfBytes / PAGE_SIZE); i++)
{
PHYSICAL_ADDRESS NPage;
Status = MmRequestPageMemoryConsumer(MC_NPPOOL, TRUE, &NPage);
MmCreateVirtualMapping (NULL,
- Result + (i * PAGESIZE),
+ Result + (i * PAGE_SIZE),
Attributes,
NPage,
TRUE);
-/* $Id: npool.c,v 1.61 2002/09/08 10:23:35 chorns Exp $
+/* $Id: npool.c,v 1.62 2002/10/01 19:27:23 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
*/
{
unsigned int total_size = size + sizeof(BLOCK_HDR);
- unsigned int nr_pages = PAGE_ROUND_UP(total_size) / PAGESIZE;
+ unsigned int nr_pages = PAGE_ROUND_UP(total_size) / PAGE_SIZE;
unsigned int start;
BLOCK_HDR* used_blk=NULL;
BLOCK_HDR* free_blk=NULL;
return(NULL);
}
Status = MmCreateVirtualMapping(NULL,
- (PVOID)(start + (i*PAGESIZE)),
+ (PVOID)(start + (i*PAGE_SIZE)),
PAGE_READWRITE,
Page,
FALSE);
}
KeAcquireSpinLock(&MmNpoolLock, &oldIrql);
- if ((PAGESIZE-(total_size%PAGESIZE))>(2*sizeof(BLOCK_HDR)))
+ if ((PAGE_SIZE-(total_size%PAGE_SIZE))>(2*sizeof(BLOCK_HDR)))
{
used_blk = (struct _BLOCK_HDR *)start;
DPRINT("Creating block at %x\n",start);
free_blk = (BLOCK_HDR *)(start + sizeof(BLOCK_HDR) + size);
DPRINT("Creating block at %x\n",free_blk);
free_blk->Magic = BLOCK_HDR_FREE_MAGIC;
- free_blk->Size = (nr_pages * PAGESIZE) -((sizeof(BLOCK_HDR)*2) + size);
+ free_blk->Size = (nr_pages * PAGE_SIZE) -((sizeof(BLOCK_HDR)*2) + size);
add_to_free_list(free_blk);
EiFreeNonPagedPool = EiFreeNonPagedPool + free_blk->Size;
{
used_blk = (struct _BLOCK_HDR *)start;
used_blk->Magic = BLOCK_HDR_USED_MAGIC;
- used_blk->Size = (nr_pages * PAGESIZE) - sizeof(BLOCK_HDR);
+ used_blk->Size = (nr_pages * PAGE_SIZE) - sizeof(BLOCK_HDR);
add_to_used_list(used_blk);
EiUsedNonPagedPool = EiUsedNonPagedPool + used_blk->Size;
ULONG NrPages;
Size = sizeof(ULONG) + UserSize;
- NrPages = ROUND_UP(Size, PAGESIZE) / PAGESIZE;
+ NrPages = ROUND_UP(Size, PAGE_SIZE) / PAGE_SIZE;
Address = MiAllocNonPagedPoolRegion(NrPages + 1);
KeBugCheck(0);
}
MmCreateVirtualMapping(NULL,
- Address + (i * PAGESIZE),
+ Address + (i * PAGE_SIZE),
PAGE_READWRITE | PAGE_SYSTEM,
Page,
TRUE);
}
- *((PULONG)((ULONG)Address + (NrPages * PAGESIZE) - Size)) = NrPages;
- return((PVOID)((ULONG)Address + (NrPages * PAGESIZE) - UserSize));
+ *((PULONG)((ULONG)Address + (NrPages * PAGE_SIZE) - Size)) = NrPages;
+ return((PVOID)((ULONG)Address + (NrPages * PAGE_SIZE) - UserSize));
}
VOID STDCALL
* 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.26 2002/09/08 10:23:35 chorns Exp $
+/* $Id: pagefile.c,v 1.27 2002/10/01 19:27:23 chorns Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/pagefile.c
/*
* Initialize the crash dump support.
*/
- MmCoreDumpPageFrame = MmAllocateSection(PAGESIZE);
+ MmCoreDumpPageFrame = MmAllocateSection(PAGE_SIZE);
if (MmCoreDumpType == MM_CORE_DUMP_TYPE_FULL)
{
MmCoreDumpSize = MmStats.NrTotalPages * 4096 + 1024 * 1024;
Headers->FaultingStackBase = (PVOID)Thread->Tcb.StackLimit;
Headers->FaultingStackSize = StackSize =
(ULONG)(Thread->Tcb.StackBase - Thread->Tcb.StackLimit);
- Headers->PhysicalMemorySize = MmStats.NrTotalPages * PAGESIZE;
+ Headers->PhysicalMemorySize = MmStats.NrTotalPages * PAGE_SIZE;
/* Initialize the dump device. */
Context = MmCoreDumpDeviceFuncs.Context;
Mdl->Process = NULL;
Mdl->MappedSystemVa = MmCoreDumpPageFrame;
Mdl->StartVa = NULL;
- Mdl->ByteCount = PAGESIZE;
+ Mdl->ByteCount = PAGE_SIZE;
Mdl->ByteOffset = 0;
MdlMap = (PULONG)(Mdl + 1);
DbgPrint(".");
/* Write out the kernel mode stack of the faulting thread. */
- for (i = 0; i < (StackSize / PAGESIZE); i++)
+ for (i = 0; i < (StackSize / PAGE_SIZE); i++)
{
- Mdl->MappedSystemVa = (PVOID)(Thread->Tcb.StackLimit + (i * PAGESIZE));
+ Mdl->MappedSystemVa = (PVOID)(Thread->Tcb.StackLimit + (i * PAGE_SIZE));
MdlMap[0] = MmGetPhysicalAddress(Mdl->MappedSystemVa).u.LowPart;
Status =
MmCoreDumpDeviceFuncs.DeviceWrite(Context,
for (i = 0; i < MmStats.NrTotalPages; i++)
{
LARGE_INTEGER PhysicalAddress;
- PhysicalAddress.QuadPart = i * PAGESIZE;
- MdlMap[0] = i * PAGESIZE;
+ PhysicalAddress.QuadPart = i * PAGE_SIZE;
+ MdlMap[0] = i * PAGE_SIZE;
MmCreateVirtualMappingForKernel(MmCoreDumpPageFrame,
PAGE_READWRITE,
PhysicalAddress);
PagingFile->FileObject = FileObject;
PagingFile->MaximumSize.QuadPart = MaximumSize->QuadPart;
PagingFile->CurrentSize.QuadPart = InitialSize->QuadPart;
- PagingFile->FreePages = InitialSize->QuadPart / PAGESIZE;
+ PagingFile->FreePages = InitialSize->QuadPart / PAGE_SIZE;
PagingFile->UsedPages = 0;
KeInitializeSpinLock(&PagingFile->AllocMapLock);
{
MmCoreDumpBlockMap =
ExAllocatePool(NonPagedPool,
- (MmCoreDumpSize / PAGESIZE) * sizeof(ULONG));
+ (MmCoreDumpSize / PAGE_SIZE) * sizeof(ULONG));
if (MmCoreDumpBlockMap == NULL)
{
DPRINT1("Failed to allocate block map.\n");
&MmCoreDumpSize,
sizeof(ULONG),
MmCoreDumpBlockMap,
- (MmCoreDumpSize / PAGESIZE) * sizeof(ULONG));
+ (MmCoreDumpSize / PAGE_SIZE) * sizeof(ULONG));
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to get dump block map (Status %X)\n", Status);
-/* $Id: pageop.c,v 1.13 2002/09/08 10:23:36 chorns Exp $
+/* $Id: pageop.c,v 1.14 2002/10/01 19:27:24 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
*/
if (MArea->Type == MEMORY_AREA_SECTION_VIEW)
{
- Hash = (((ULONG)Segment) | (((ULONG)Offset) / PAGESIZE));
+ Hash = (((ULONG)Segment) | (((ULONG)Offset) / PAGE_SIZE));
}
else
{
- Hash = (((ULONG)Pid) | (((ULONG)Address) / PAGESIZE));
+ Hash = (((ULONG)Pid) | (((ULONG)Address) / PAGE_SIZE));
}
Hash = Hash % PAGEOP_HASH_TABLE_SIZE;
*/
if (MArea->Type == MEMORY_AREA_SECTION_VIEW)
{
- Hash = (((ULONG)Segment) | (((ULONG)Offset) / PAGESIZE));
+ Hash = (((ULONG)Segment) | (((ULONG)Offset) / PAGE_SIZE));
}
else
{
- Hash = (((ULONG)Pid) | (((ULONG)Address) / PAGESIZE));
+ Hash = (((ULONG)Pid) | (((ULONG)Address) / PAGE_SIZE));
}
Hash = Hash % PAGEOP_HASH_TABLE_SIZE;
* 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.98 2002/09/15 10:45:03 guido Exp $
+/* $Id: section.c,v 1.99 2002/10/01 19:27:24 chorns Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/section.c
Fcb = (PREACTOS_COMMON_FCB_HEADER)FileObject->FsContext;
if (FileObject->Flags & FO_DIRECT_CACHE_PAGING_READ &&
- (Offset % PAGESIZE) == 0)
+ (Offset % PAGE_SIZE) == 0)
{
NTSTATUS Status;
Status = CcRosUnmapCacheSegment(Fcb->Bcb, Offset, Dirty);
* then get the related cache segment.
*/
if (FileObject->Flags & FO_DIRECT_CACHE_PAGING_READ &&
- (Offset->QuadPart % PAGESIZE) == 0)
+ (Offset->QuadPart % PAGE_SIZE) == 0)
{
ULONG BaseOffset;
PVOID BaseAddress;
/*
* Create an mdl to hold the page we are going to read data into.
*/
- Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
+ Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
MmBuildMdlFromPages(Mdl, &Page->u.LowPart);
/*
* Call the FSD to read the page
KeBugCheck(0);
}
- Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
+ Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
MmBuildMdlFromPages(Mdl, (PULONG)&Page);
Status = MmReadFromSwapPage(SwapEntry, Mdl);
if (!NT_SUCCESS(Status))
KeBugCheck(0);
}
- Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
+ Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
MmBuildMdlFromPages(Mdl, (PULONG)&Page);
Status = MmReadFromSwapPage(SwapEntry, Mdl);
if (!NT_SUCCESS(Status))
OldPage = MmGetPhysicalAddressForProcess(NULL, Address);
NewAddress = ExAllocatePageWithPhysPage(NewPage);
- memcpy(NewAddress, (PVOID)PAGE_ROUND_DOWN(Address), PAGESIZE);
+ memcpy(NewAddress, (PVOID)PAGE_ROUND_DOWN(Address), PAGE_SIZE);
ExUnmapPage(NewAddress);
/*
* then note this is a direct mapped page.
*/
if (FileObject->Flags & FO_DIRECT_CACHE_PAGING_READ &&
- (Offset.QuadPart % PAGESIZE) == 0)
+ (Offset.QuadPart % PAGE_SIZE) == 0)
{
DirectMapped = TRUE;
}
/*
* Write the page to the pagefile
*/
- Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
+ Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
MmBuildMdlFromPages(Mdl, (PULONG)&PhysicalAddress);
Status = MmWriteToSwapPage(SwapEntry, Mdl);
if (!NT_SUCCESS(Status))
* then note this is a direct mapped page.
*/
if (FileObject->Flags & FO_DIRECT_CACHE_PAGING_READ &&
- (Offset.QuadPart % PAGESIZE) == 0)
+ (Offset.QuadPart % PAGE_SIZE) == 0)
{
DirectMapped = TRUE;
}
/*
* Write the page to the pagefile
*/
- Mdl = MmCreateMdl(NULL, NULL, PAGESIZE);
+ Mdl = MmCreateMdl(NULL, NULL, PAGE_SIZE);
MmBuildMdlFromPages(Mdl, (PULONG)&PhysicalAddress);
Status = MmWriteToSwapPage(SwapEntry, Mdl);
if (!NT_SUCCESS(Status))
if (OldProtect != NewProtect)
{
- for (i = 0; i < (RegionSize / PAGESIZE); i++)
+ for (i = 0; i < (RegionSize / PAGE_SIZE); i++)
{
- PVOID Address = BaseAddress + (i * PAGESIZE);
+ PVOID Address = BaseAddress + (i * PAGE_SIZE);
ULONG Protect = NewProtect;
/*
SectionSegments[0].FileOffset = 0;
SectionSegments[0].Characteristics = IMAGE_SECTION_CHAR_DATA;
SectionSegments[0].Protection = PAGE_READWRITE;
- SectionSegments[0].RawLength = PAGESIZE;
- SectionSegments[0].Length = PAGESIZE;
+ SectionSegments[0].RawLength = PAGE_SIZE;
+ SectionSegments[0].Length = PAGE_SIZE;
SectionSegments[0].Flags = 0;
SectionSegments[0].ReferenceCount = 1;
SectionSegments[0].VirtualAddress = 0;
}
MmUnlockAddressSpace(AddressSpace);
DPRINT("Result %p\n",Result);
- for (i = 0; (i <= (Length / PAGESIZE)); i++)
+ for (i = 0; (i <= (Length / PAGE_SIZE)); i++)
{
PHYSICAL_ADDRESS Page;
KeBugCheck(0);
}
Status = MmCreateVirtualMapping (NULL,
- (Result + (i * PAGESIZE)),
+ (Result + (i * PAGE_SIZE)),
PAGE_READWRITE,
Page,
TRUE);
ViewOffset = SectionOffset->u.LowPart;
}
- if ((ViewOffset % PAGESIZE) != 0)
+ if ((ViewOffset % PAGE_SIZE) != 0)
{
MmUnlockSection(Section);
MmUnlockAddressSpace(AddressSpace);
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: slab.c,v 1.7 2002/09/08 10:23:36 chorns Exp $
+/* $Id: slab.c,v 1.8 2002/10/01 19:27:24 chorns Exp $
*
* COPYRIGHT: See COPYING in the top directory
* PROJECT: ReactOS kernel
AlignSize = Align - (ObjectSize % Align);
Slab->ObjectSize = ObjectSize + AlignSize;
Slab->ObjectsPerPage =
- (PAGESIZE - sizeof(SLAB_CACHE_PAGE)) / Slab->ObjectSize;
+ (PAGE_SIZE - sizeof(SLAB_CACHE_PAGE)) / Slab->ObjectSize;
InitializeListHead(&Slab->PageListHead);
KeInitializeSpinLock(&Slab->SlabLock);
return(NULL);
}
- SlabPage = (PSLAB_CACHE_PAGE)(Page + PAGESIZE - sizeof(SLAB_CACHE_PAGE));
+ SlabPage = (PSLAB_CACHE_PAGE)(Page + PAGE_SIZE - sizeof(SLAB_CACHE_PAGE));
SlabPage->ReferenceCount = 0;
SlabPage->FirstFreeBuffer = (PSLAB_CACHE_BUFCTL)Page;
for (i = 0; i < Slab->ObjectsPerPage; i++)
current = CONTAINING_RECORD(current_entry,
SLAB_CACHE_PAGE,
PageListEntry);
- Base = (PVOID)current + sizeof(SLAB_CACHE_PAGE) - PAGESIZE;
+ Base = (PVOID)current + sizeof(SLAB_CACHE_PAGE) - PAGE_SIZE;
if (Base >= Object &&
- (Base + PAGESIZE - sizeof(SLAB_CACHE_PAGE)) >=
+ (Base + PAGE_SIZE - sizeof(SLAB_CACHE_PAGE)) >=
(Object + Slab->ObjectSize))
{
ExFreeFromPageSlabCache(Slab, current, Object);
current = CONTAINING_RECORD(current_entry,
SLAB_CACHE_PAGE,
PageListEntry);
- Base = (PVOID)current + sizeof(SLAB_CACHE_PAGE) - PAGESIZE;
+ Base = (PVOID)current + sizeof(SLAB_CACHE_PAGE) - PAGE_SIZE;
if (Slab->Destructor != NULL)
{
for (i = 0; i < Slab->ObjectsPerPage; i++)
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
-/* $Id: handle.c,v 1.40 2002/09/08 10:23:39 chorns Exp $
+/* $Id: handle.c,v 1.41 2002/10/01 19:27:25 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
BOOLEAN Inherit;
} HANDLE_REP, *PHANDLE_REP;
-#define HANDLE_BLOCK_ENTRIES ((PAGESIZE-sizeof(LIST_ENTRY))/sizeof(HANDLE_REP))
+#define HANDLE_BLOCK_ENTRIES ((PAGE_SIZE-sizeof(LIST_ENTRY))/sizeof(HANDLE_REP))
/*
-/* $Id: create.c,v 1.54 2002/09/30 20:56:17 hbirr Exp $
+/* $Id: create.c,v 1.55 2002/10/01 19:27:25 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
ULONG ResultLength;
TebBase = (PVOID)0x7FFDE000;
- TebSize = PAGESIZE;
+ TebSize = PAGE_SIZE;
while (TRUE)
{
-/* $Id: process.c,v 1.92 2002/09/08 10:23:40 chorns Exp $
+/* $Id: process.c,v 1.93 2002/10/01 19:27:25 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
&Process->AddressSpace,
MEMORY_AREA_SHARED_DATA,
&BaseAddress,
- PAGESIZE,
+ PAGE_SIZE,
PAGE_READONLY,
&MemoryArea,
FALSE);
-/* $Id: w32call.c,v 1.4 2002/09/08 10:23:41 chorns Exp $
+/* $Id: w32call.c,v 1.5 2002/10/01 19:27:25 chorns Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
DPRINT("Failed to create thread stack\n");
return(NULL);
}
- for (i = 0; i < (StackSize / PAGESIZE); i++)
+ for (i = 0; i < (StackSize / PAGE_SIZE); i++)
{
PHYSICAL_ADDRESS Page;
Status = MmRequestPageMemoryConsumer(MC_NPPOOL, TRUE, &Page);
return(NULL);
}
Status = MmCreateVirtualMapping(NULL,
- KernelStack + (i * PAGESIZE),
+ KernelStack + (i * PAGE_SIZE),
PAGE_EXECUTE_READWRITE,
Page,
TRUE);
PVOID ObjectBody;
} USER_HANDLE, *PUSER_HANDLE;
-#define HANDLE_BLOCK_ENTRIES ((PAGESIZE-sizeof(LIST_ENTRY))/sizeof(USER_HANDLE))
+#define HANDLE_BLOCK_ENTRIES ((PAGE_SIZE-sizeof(LIST_ENTRY))/sizeof(USER_HANDLE))
typedef struct _USER_HANDLE_BLOCK
{