DPRINT("Found file\n");
Fcb->inode = current_inode;
- CcInitializeFileCache(FileObject, &Fcb->Bcb);
+ CcRosInitializeFileCache(FileObject, &Fcb->Bcb);
FileObject->FsContext = Fcb;
return(STATUS_SUCCESS);
{
if (Fcb->Bcb != NULL)
{
- CcReleaseFileCache(FileObject, Fcb->Bcb);
+ CcRosReleaseFileCache(FileObject, Fcb->Bcb);
}
ExFreePool(Fcb);
FileObject->FsContext = NULL;
DPRINT("DeviceExt->StorageDevice %x\n", DeviceExt->StorageDevice);
DeviceExt->FileObject = IoCreateStreamFileObject(NULL, DeviceObject);
DeviceExt->superblock = superblock;
- CcInitializeFileCache(DeviceExt->FileObject,
+ CcRosInitializeFileCache(DeviceExt->FileObject,
&DeviceExt->Bcb);
DPRINT("Ext2Mount() = STATUS_SUCCESS\n");
{
BOOLEAN UptoDate;
- CcRequestCacheSegment(Bcb,
+ CcRosRequestCacheSegment(Bcb,
FileOffset,
BaseAddress,
&UptoDate,
-/* $Id: close.c,v 1.5 2001/03/09 14:40:28 dwelch Exp $
+/* $Id: close.c,v 1.6 2001/05/04 01:21:45 rex Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
pFcb = pCcb->pFcb;
pFcb->RefCount--;
+ CHECKPOINT;
if (pFcb->RefCount <= 0)
{
- CcReleaseFileCache(FileObject, pFcb->RFCB.Bcb);
+ CcRosReleaseFileCache(FileObject, pFcb->RFCB.Bcb);
KeAcquireSpinLock (&DeviceExt->FcbListLock, &oldIrql);
+ CHECKPOINT;
RemoveEntryList (&pFcb->FcbListEntry);
KeReleaseSpinLock (&DeviceExt->FcbListLock, oldIrql);
ExFreePool (pFcb);
+ CHECKPOINT;
}
ExFreePool (pCcb);
return STATUS_SUCCESS;
-/* $Id: create.c,v 1.24 2001/05/02 03:18:03 rex Exp $
+/* $Id: create.c,v 1.25 2001/05/04 01:21:45 rex Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
PVFATCCB newCCB;
NTSTATUS Status;
PWSTR AbsFileName = NULL;
- ULONG BytesPerCluster;
+ ULONG BytesPerCluster, FileCacheQuantum;
DPRINT ("VfatOpenFile(%08lx, %08lx, %S)\n", DeviceExt, FileObject, FileName);
newCCB->pFcb = ParentFcb;
newCCB->PtrFileObject = FileObject;
ParentFcb->RefCount++;
+ ParentFcb->pDevExt = DeviceExt;
/* FIXME : initialize all fields in FCB and CCB */
- vfatAddFCBToTable (DeviceExt, ParentFcb);
-
-/* vfat_wcsncpy (ParentFcb->PathName, FileName, MAX_PATH);
- ParentFcb->ObjectName = ParentFcb->PathName + (current - FileName); */
- ParentFcb->pDevExt = DeviceExt;
BytesPerCluster = DeviceExt->Boot->SectorsPerCluster * BLOCKSIZE;
- if (BytesPerCluster >= PAGESIZE)
- {
- Status = CcInitializeFileCache(FileObject, &ParentFcb->RFCB.Bcb,
- BytesPerCluster);
- }
- else
- {
- Status = CcInitializeFileCache(FileObject, &ParentFcb->RFCB.Bcb,
- PAGESIZE);
- }
+ FileCacheQuantum = (BytesPerCluster >= PAGESIZE) ? BytesPerCluster : PAGESIZE;
+ Status = CcRosInitializeFileCache(FileObject,
+ &ParentFcb->RFCB.Bcb,
+ FileCacheQuantum);
if (!NT_SUCCESS(Status))
{
- DbgPrint("CcInitializeFileCache failed\n");
+ DbgPrint("CcRosInitializeFileCache failed\n");
KeBugCheck(0);
}
DPRINT ("file open, fcb=%x\n", ParentFcb);
DPRINT ("FileSize %d\n", ParentFcb->entry.FileSize);
+
+ vfatAddFCBToTable (DeviceExt, ParentFcb);
+
if (Fcb)
ExFreePool (Fcb);
if (AbsFileName)
-/* $Id: dirwr.c,v 1.18 2001/05/02 03:18:03 rex Exp $
+/* $Id: dirwr.c,v 1.19 2001/05/04 01:21:45 rex Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
BytesPerCluster = DeviceExt->Boot->SectorsPerCluster * BLOCKSIZE;
if (BytesPerCluster >= PAGESIZE)
{
- Status = CcInitializeFileCache(pFileObject, &newFCB->RFCB.Bcb,
+ Status = CcRosInitializeFileCache(pFileObject, &newFCB->RFCB.Bcb,
BytesPerCluster);
}
else
{
- Status = CcInitializeFileCache(pFileObject, &newFCB->RFCB.Bcb,
+ Status = CcRosInitializeFileCache(pFileObject, &newFCB->RFCB.Bcb,
PAGESIZE);
}
/*
- * $Id: fat.c,v 1.24 2001/04/29 21:08:14 cnettel Exp $
+ * $Id: fat.c,v 1.25 2001/05/04 01:21:45 rex Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
FATOffset = (DeviceExt->FATStart * BLOCKSIZE) +
(CurrentCluster * sizeof(ULONG));
- Status = CcRequestCacheSegment(DeviceExt->StorageBcb,
+ Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
PAGE_ROUND_DOWN(FATOffset),
&BaseAddress,
&Valid,
BaseAddress);
if (!NT_SUCCESS(Status))
{
- CcReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
return(Status);
}
}
CurrentCluster = *(PULONG)(BaseAddress + (FATOffset % PAGESIZE));
if (CurrentCluster >= 0xffffff8 && CurrentCluster <= 0xfffffff)
CurrentCluster = 0xffffffff;
- CcReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
*NextCluster = CurrentCluster;
return (STATUS_SUCCESS);
}
FATOffset = (DeviceExt->FATStart * BLOCKSIZE) + (CurrentCluster * 2);
- Status = CcRequestCacheSegment(DeviceExt->StorageBcb,
+ Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
PAGE_ROUND_DOWN(FATOffset),
&BaseAddress,
&Valid,
BaseAddress);
if (!NT_SUCCESS(Status))
{
- CcReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
return(Status);
}
}
CurrentCluster = *((PUSHORT)(BaseAddress + (FATOffset % PAGESIZE)));
if (CurrentCluster >= 0xfff8 && CurrentCluster <= 0xffff)
CurrentCluster = 0xffffffff;
- CcReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
*NextCluster = CurrentCluster;
return (STATUS_SUCCESS);
}
*NextCluster = 0;
- Status = CcRequestCacheSegment(DeviceExt->Fat12StorageBcb,
+ Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
0,
&BaseAddress,
&Valid,
BaseAddress);
if (!NT_SUCCESS(Status))
{
- CcReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
return(Status);
}
}
Entry = 0xffffffff;
// DPRINT("Returning %x\n",Entry);
*NextCluster = Entry;
- CcReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
return Entry == 0xffffffff ? STATUS_END_OF_FILE : STATUS_SUCCESS;
}
{
if (CacheSeg != NULL)
{
- CcReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
}
- Status = CcRequestCacheSegment(DeviceExt->StorageBcb,
+ Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
PAGE_ROUND_DOWN(FatStart + i),
&BaseAddress,
&Valid,
BaseAddress);
if (!NT_SUCCESS(Status))
{
- CcReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg,
+ CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg,
FALSE);
return(Status);
}
{
DPRINT("Found available cluster 0x%x\n", i);
*Cluster = i / 2;
- CcReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
return(STATUS_SUCCESS);
}
}
- CcReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
return(STATUS_DISK_FULL);
}
*Cluster = 0;
- Status = CcRequestCacheSegment(DeviceExt->Fat12StorageBcb,
+ Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
0,
&BaseAddress,
&Valid,
BaseAddress);
if (!NT_SUCCESS(Status))
{
- CcReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
return(Status);
}
}
{
DPRINT("Found available cluster 0x%x\n", i);
*Cluster = i;
- CcReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
return(STATUS_SUCCESS);
}
}
- CcReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
return (STATUS_DISK_FULL);
}
ULONG numberofclusters;
ExAcquireResourceSharedLite (&DeviceExt->FatResource, TRUE);
- Status = CcRequestCacheSegment(DeviceExt->Fat12StorageBcb,
+ Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
0,
&BaseAddress,
&Valid,
BaseAddress);
if (!NT_SUCCESS(Status))
{
- CcReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
ExReleaseResourceLite (&DeviceExt->FatResource);
return 0; // Will the caller understand NTSTATUS values?
}
ulCount++;
}
- CcReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
ExReleaseResourceLite (&DeviceExt->FatResource);
return ulCount;
BOOLEAN Valid;
PCACHE_SEGMENT CacheSeg;
- Status = CcRequestCacheSegment(DeviceExt->Fat12StorageBcb,
+ Status = CcRosRequestCacheSegment(DeviceExt->Fat12StorageBcb,
0,
&BaseAddress,
&Valid,
BaseAddress);
if (!NT_SUCCESS(Status))
{
- CcReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, FALSE);
return(Status);
}
}
1, CBlock + FATsector * 512);
}
}
- CcReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(DeviceExt->Fat12StorageBcb, CacheSeg, TRUE);
return(STATUS_SUCCESS);
}
for (i = 0; i < DeviceExt->Boot->FATCount; i++)
{
- Status = CcRequestCacheSegment(DeviceExt->StorageBcb,
+ Status = CcRosRequestCacheSegment(DeviceExt->StorageBcb,
PAGE_ROUND_DOWN(FATOffset),
&BaseAddress,
&Valid,
BaseAddress);
if (!NT_SUCCESS(Status))
{
- CcReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, FALSE);
return(Status);
}
}
PAGE_ROUND_DOWN(FATOffset) / BLOCKSIZE,
PAGESIZE / BLOCKSIZE,
BaseAddress);
- CcReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(DeviceExt->StorageBcb, CacheSeg, TRUE);
DPRINT("DeviceExt->Boot->FATSectors %d\n",
DeviceExt->Boot->FATSectors);
-/* $Id: iface.c,v 1.51 2001/03/07 13:44:40 ekohl Exp $
+/* $Id: iface.c,v 1.52 2001/05/04 01:21:45 rex Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
DeviceToMount);
DeviceExt->StreamStorageDevice = IoCreateStreamFileObject(NULL,
DeviceExt->StorageDevice);
- Status = CcInitializeFileCache(DeviceExt->StreamStorageDevice,
+ Status = CcRosInitializeFileCache(DeviceExt->StreamStorageDevice,
&DeviceExt->StorageBcb,
PAGESIZE);
if (!NT_SUCCESS(Status))
{
DeviceExt->Fat12StorageDevice =
IoCreateStreamFileObject(NULL, DeviceExt->StorageDevice);
- Status = CcInitializeFileCache(DeviceExt->Fat12StorageDevice,
+ Status = CcRosInitializeFileCache(DeviceExt->Fat12StorageDevice,
&DeviceExt->Fat12StorageBcb,
PAGESIZE * 3);
if (!NT_SUCCESS(Status))
-/* $Id: rw.c,v 1.23 2001/04/26 01:28:54 phreak Exp $
+/* $Id: rw.c,v 1.24 2001/05/04 01:21:45 rex Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
if (!NoCache)
{
- Status = CcRequestCacheSegment(Fcb->RFCB.Bcb,
+ Status = CcRosRequestCacheSegment(Fcb->RFCB.Bcb,
StartOffset,
&BaseAddress,
&Valid,
{
if (!NoCache)
{
- CcReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, FALSE);
}
else if (InternalOffset != 0)
{
}
if (!NoCache)
{
- CcReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, TRUE);
}
else if (InternalOffset != 0)
{
*/
if (!NoCache)
{
- Status = CcRequestCacheSegment(Fcb->RFCB.Bcb,
+ Status = CcRosRequestCacheSegment(Fcb->RFCB.Bcb,
StartOffset,
&BaseAddress,
&Valid,
{
if (!NoCache)
{
- CcReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, FALSE);
}
else if (InternalOffset != 0)
{
}
if (!NoCache)
{
- CcReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, TRUE);
}
else if (InternalOffset != 0)
{
*/
if (!NoCache)
{
- Status = CcRequestCacheSegment(Fcb->RFCB.Bcb,
+ Status = CcRosRequestCacheSegment(Fcb->RFCB.Bcb,
StartOffset,
&BaseAddress,
&Valid,
{
if (!NoCache)
{
- CcReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, FALSE);
}
else if (InternalOffset != 0)
{
*CurrentCluster);
if (!NoCache)
{
- CcReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, TRUE);
}
else if (InternalOffset != 0)
{
if (!NoCache)
{
- Status = CcRequestCacheSegment(Fcb->RFCB.Bcb,
+ Status = CcRosRequestCacheSegment(Fcb->RFCB.Bcb,
StartOffset,
&BaseAddress,
&Valid,
{
if (!NoCache)
{
- CcReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, FALSE);
}
else if (InternalOffset != 0)
{
{
if (!NoCache)
{
- CcReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, FALSE);
}
else if (InternalOffset != 0)
{
if (!NoCache)
{
- CcReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(Fcb->RFCB.Bcb, CacheSeg, TRUE);
}
else if (InternalOffset != 0)
{
typedef struct _CACHE_SEGMENT* PCACHE_SEGMENT;
NTSTATUS STDCALL
-CcFlushCacheSegment (struct _CACHE_SEGMENT* CacheSeg);
+CcRosFlushCacheSegment (struct _CACHE_SEGMENT* CacheSeg);
NTSTATUS STDCALL
-CcReleaseCacheSegment (struct _BCB* Bcb,
+CcRosReleaseCacheSegment (struct _BCB* Bcb,
struct _CACHE_SEGMENT* CacheSeg,
BOOLEAN Valid);
NTSTATUS STDCALL
-CcRequestCacheSegment (struct _BCB* Bcb,
+CcRosRequestCacheSegment (struct _BCB* Bcb,
ULONG FileOffset,
PVOID* BaseAddress,
PBOOLEAN UptoDate,
struct _CACHE_SEGMENT** CacheSeg);
NTSTATUS STDCALL
-CcInitializeFileCache (PFILE_OBJECT FileObject,
+CcRosInitializeFileCache (PFILE_OBJECT FileObject,
struct _BCB** Bcb,
ULONG CacheSegmentSize);
NTSTATUS STDCALL
-CcReleaseFileCache (PFILE_OBJECT FileObject,
+CcRosReleaseFileCache (PFILE_OBJECT FileObject,
struct _BCB* Bcb);
#include <ddk/cctypes.h>
* 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.25 2001/05/01 23:08:18 chorns Exp $
+/* $Id: view.c,v 1.26 2001/05/04 01:21:43 rex Exp $
*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS kernel
/* FUNCTIONS *****************************************************************/
NTSTATUS STDCALL
-CcFlushCacheSegment(PCACHE_SEGMENT CacheSeg)
+CcRosFlushCacheSegment(PCACHE_SEGMENT CacheSeg)
/*
* FUNCTION: Asks the FSD to flush the contents of the page back to disk
*/
}
NTSTATUS STDCALL
-CcReleaseCacheSegment(PBCB Bcb,
+CcRosReleaseCacheSegment(PBCB Bcb,
PCACHE_SEGMENT CacheSeg,
BOOLEAN Valid)
{
}
NTSTATUS
-CcGetCacheSegment(PBCB Bcb,
+CcRosGetCacheSegment(PBCB Bcb,
ULONG FileOffset,
PULONG BaseOffset,
PVOID* BaseAddress,
}
NTSTATUS STDCALL
-CcRequestCacheSegment(PBCB Bcb,
+CcRosRequestCacheSegment(PBCB Bcb,
ULONG FileOffset,
PVOID* BaseAddress,
PBOOLEAN UptoDate,
KeBugCheck(0);
}
- return(CcGetCacheSegment(Bcb,
+ return(CcRosGetCacheSegment(Bcb,
FileOffset,
&BaseOffset,
BaseAddress,
}
NTSTATUS STDCALL
-CcFreeCacheSegment(PBCB Bcb, PCACHE_SEGMENT CacheSeg)
+CcRosFreeCacheSegment(PBCB Bcb, PCACHE_SEGMENT CacheSeg)
/*
* FUNCTION: Releases a cache segment associated with a BCB
*/
}
NTSTATUS STDCALL
-CcReleaseFileCache(PFILE_OBJECT FileObject, PBCB Bcb)
+CcRosReleaseFileCache(PFILE_OBJECT FileObject, PBCB Bcb)
/*
* FUNCTION: Releases the BCB associated with a file object
*/
PLIST_ENTRY current_entry;
PCACHE_SEGMENT current;
- DPRINT("CcReleaseFileCache(FileObject %x, Bcb %x)\n", FileObject, Bcb);
+ DPRINT("CcRosReleaseFileCache(FileObject %x, Bcb %x)\n", Bcb->FileObject, Bcb);
- MmFreeSectionSegments(FileObject);
+ MmFreeSectionSegments(Bcb->FileObject);
current_entry = Bcb->CacheSegmentListHead.Flink;
while (current_entry != &Bcb->CacheSegmentListHead)
current =
CONTAINING_RECORD(current_entry, CACHE_SEGMENT, BcbListEntry);
current_entry = current_entry->Flink;
- CcFreeCacheSegment(Bcb, current);
+ CcRosFreeCacheSegment(Bcb, current);
}
-
+
+ ObDereferenceObject (Bcb->FileObject);
ExFreePool(Bcb);
- DPRINT("CcReleaseFileCache() finished\n");
+ DPRINT("CcRosReleaseFileCache() finished\n");
return(STATUS_SUCCESS);
}
NTSTATUS STDCALL
-CcInitializeFileCache(PFILE_OBJECT FileObject,
+CcRosInitializeFileCache(PFILE_OBJECT FileObject,
PBCB* Bcb,
ULONG CacheSegmentSize)
/*
* FUNCTION: Initializes a BCB for a file object
*/
{
- DPRINT("CcInitializeFileCache(FileObject %x)\n",FileObject);
+ DPRINT("CcRosInitializeFileCache(FileObject %x)\n",FileObject);
(*Bcb) = ExAllocatePoolWithTag(NonPagedPool, sizeof(BCB), TAG_BCB);
if ((*Bcb) == NULL)
KeInitializeSpinLock(&(*Bcb)->BcbLock);
(*Bcb)->CacheSegmentSize = CacheSegmentSize;
- DPRINT("Finished CcInitializeFileCache() = %x\n", *Bcb);
+ DPRINT("Finished CcRosInitializeFileCache() = %x\n", *Bcb);
return(STATUS_SUCCESS);
}
#ifndef __INCLUDE_INTERNAL_CC_H
#define __INCLUDE_INTERNAL_CC_H
-/* $Id: cc.h,v 1.4 2001/04/09 02:45:03 dwelch Exp $ */
+/* $Id: cc.h,v 1.5 2001/05/04 01:21:44 rex Exp $ */
#include <ddk/ntifs.h>
typedef struct _BCB
CcMdlReadCompleteDev (IN PMDL MdlChain,
IN PDEVICE_OBJECT DeviceObject);
NTSTATUS
-CcGetCacheSegment(PBCB Bcb,
+CcRosGetCacheSegment(PBCB Bcb,
ULONG FileOffset,
PULONG BaseOffset,
PVOID* BaseAddress,
* 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.56 2001/04/04 22:21:31 dwelch Exp $
+/* $Id: section.c,v 1.57 2001/05/04 01:21:44 rex Exp $
*
* PROJECT: ReactOS kernel
* FILE: ntoskrnl/mm/section.c
LARGE_INTEGER SegOffset;
PHYSICAL_ADDRESS Addr;
- Status = CcGetCacheSegment(Fcb->Bcb,
+ Status = CcRosGetCacheSegment(Fcb->Bcb,
(ULONG)Offset->QuadPart,
&BaseOffset,
&BaseAddress,
TRUE);
if (!NT_SUCCESS(Status))
{
- CcReleaseCacheSegment(Fcb->Bcb, CacheSeg, FALSE);
+ CcRosReleaseCacheSegment(Fcb->Bcb, CacheSeg, FALSE);
return(Status);
}
}
(*Page) = (PVOID)(ULONG)Addr.QuadPart;
MmReferencePage((*Page));
- CcReleaseCacheSegment(Fcb->Bcb, CacheSeg, TRUE);
+ CcRosReleaseCacheSegment(Fcb->Bcb, CacheSeg, TRUE);
return(STATUS_SUCCESS);
}
else
-; $Id: ntoskrnl.def,v 1.105 2001/05/01 23:08:17 chorns Exp $
+; $Id: ntoskrnl.def,v 1.106 2001/05/04 01:21:42 rex Exp $
;
; reactos/ntoskrnl/ntoskrnl.def
;
; ReactOS Operating System
;
EXPORTS
-CcInitializeFileCache@12
+CcRosInitializeFileCache@12
CcMdlReadComplete@8
-CcRequestCacheSegment@20
-CcReleaseCacheSegment@12
-CcReleaseFileCache@8
+CcRosRequestCacheSegment@20
+CcRosReleaseCacheSegment@12
+CcRosReleaseFileCache@8
DbgBreakPoint@0
DbgBreakPointWithStatus@4
;DbgLoadImageSymbols@12
-; $Id: ntoskrnl.edf,v 1.92 2001/05/01 23:08:18 chorns Exp $
+; $Id: ntoskrnl.edf,v 1.93 2001/05/04 01:21:43 rex Exp $
;
; reactos/ntoskrnl/ntoskrnl.def
;
; ReactOS Operating System
;
EXPORTS
-CcInitializeFileCache=CcInitializeFileCache@12
+CcRosInitializeFileCache=CcRosInitializeFileCache@12
CcMdlReadComplete=CcMdlReadComplete@8
-CcRequestCacheSegment=CcRequestCacheSegment@20
-CcReleaseCacheSegment=CcReleaseCacheSegment@12
-CcReleaseFileCache=CcReleaseFileCache@8
+CcRosRequestCacheSegment=CcRosRequestCacheSegment@20
+CcRosReleaseCacheSegment=CcRosReleaseCacheSegment@12
+CcRosReleaseFileCache=CcRosReleaseFileCache@8
DbgBreakPoint=DbgBreakPoint@0
DbgBreakPointWithStatus=DbgBreakPointWithStatus@4
;DbgLoadImageSymbols=DbgLoadImageSymbols@12
WRITE_PORT_UCHAR=WRITE_PORT_UCHAR@8
WRITE_PORT_ULONG=WRITE_PORT_ULONG@8
WRITE_PORT_USHORT=WRITE_PORT_USHORT@8
-KdSystemDebugControl = KdSystemDebugControl@4
\ No newline at end of file
+KdSystemDebugControl = KdSystemDebugControl@4