able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/lfs/strucsup.c

675 lines
13 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1990 Microsoft Corporation
Module Name:
StrucSup.c
Abstract:
This module provides support routines for creation and deletion
of Lfs structures.
Author:
Brian Andrew [BrianAn] 20-June-1991
Revision History:
--*/
#include "lfsprocs.h"
//
// The debug trace level
//
#define Dbg (DEBUG_TRACE_STRUC_SUP)
#undef MODULE_POOL_TAG
#define MODULE_POOL_TAG ('SsfL')
#ifdef ALLOC_PRAGMA
#pragma alloc_text(PAGE, LfsAllocateLbcb)
#pragma alloc_text(PAGE, LfsAllocateLfcb)
#pragma alloc_text(PAGE, LfsDeallocateLbcb)
#pragma alloc_text(PAGE, LfsDeallocateLfcb)
#pragma alloc_text(PAGE, LfsAllocateLeb)
#pragma alloc_text(PAGE, LfsDeallocateLeb)
#pragma alloc_text(PAGE, LfsReadPage)
#endif
PLFCB
LfsAllocateLfcb (
IN ULONG LogPageSize,
IN LONGLONG FileSize
)
/*++
Routine Description:
This routine allocates and initializes a log file control block.
Arguments:
LogPageSize - lfs log file page size
FileSize - Initial file size
Return Value:
PLFCB - A pointer to the log file control block just
allocated and initialized.
--*/
{
PLFCB Lfcb = NULL;
ULONG Count;
PLBCB NextLbcb;
PLEB NextLeb;
PAGED_CODE();
DebugTrace( +1, Dbg, "LfsAllocateLfcb: Entered\n", 0 );
//
// Use a try-finally to facilitate cleanup.
//
try {
//
// Allocate and zero the structure for the Lfcb.
//
ASSERT( LogPageSize <= PAGE_SIZE );
Lfcb = LfsAllocatePool( PagedPool, sizeof( LFCB ) + sizeof( PLBCB ) * (PAGE_SIZE / LogPageSize) );
//
// Zero out the structure initially.
//
RtlZeroMemory( Lfcb, sizeof( LFCB ) + sizeof( PLBCB ) * (PAGE_SIZE / LogPageSize));
//
// Initialize the log file control block.
//
Lfcb->NodeTypeCode = LFS_NTC_LFCB;
Lfcb->NodeByteSize = sizeof( LFCB );
//
// Initialize the client links.
//
InitializeListHead( &Lfcb->LchLinks );
//
// Initialize the Lbcb links.
//
InitializeListHead( &Lfcb->LbcbWorkque );
InitializeListHead( &Lfcb->LbcbActive );
//
// Initialize and allocate the spare Lbcb queue.
//
InitializeListHead( &Lfcb->SpareLbcbList );
for (Count = 0; Count < LFCB_RESERVE_LBCB_COUNT; Count++) {
NextLbcb = ExAllocatePoolWithTag( PagedPool, sizeof( LBCB ), ' sfL' );
if (NextLbcb != NULL) {
InsertHeadList( &Lfcb->SpareLbcbList, (PLIST_ENTRY) NextLbcb );
Lfcb->SpareLbcbCount += 1;
}
}
//
// Initialize and allocate the spare Leb queue.
//
InitializeListHead( &Lfcb->SpareLebList );
for (Count = 0; Count < LFCB_RESERVE_LEB_COUNT; Count++) {
NextLeb = ExAllocatePoolWithTag( PagedPool, sizeof( LEB ), ' sfL' );
if (NextLeb != NULL) {
InsertHeadList( &Lfcb->SpareLebList, (PLIST_ENTRY) NextLeb );
Lfcb->SpareLebCount += 1;
}
}
//
// Allocate the Lfcb synchronization event.
//
Lfcb->Sync = LfsAllocatePool( NonPagedPool, sizeof( LFCB_SYNC ));
ExInitializeResourceLite( &Lfcb->Sync->Resource );
//
// Initialize the pseudo Lsn for the restart Lbcb's
//
Lfcb->NextRestartLsn = LfsLi1;
//
// Initialize the event to the signalled state.
//
KeInitializeEvent( &Lfcb->Sync->Event, NotificationEvent, TRUE );
Lfcb->Sync->UserCount = 0;
//
// Initialize the spare list mutex
//
ExInitializeFastMutex( &(Lfcb->Sync->SpareListMutex) );
Lfcb->FileSize = FileSize;
} finally {
DebugUnwind( LfsAllocateFileControlBlock );
if (AbnormalTermination() && (Lfcb != NULL)) {
LfsDeallocateLfcb( Lfcb, TRUE );
Lfcb = NULL;
}
DebugTrace( -1, Dbg, "LfsAllocateLfcb: Exit -> %08lx\n", Lfcb );
}
return Lfcb;
}
VOID
LfsDeallocateLfcb (
IN PLFCB Lfcb,
IN BOOLEAN CompleteTeardown
)
/*++
Routine Description:
This routine releases the resources associated with a log file control
block.
Arguments:
Lfcb - Supplies a pointer to the log file control block.
CompleteTeardown - Indicates if we are to completely remove this Lfcb.
Return Value:
None
--*/
{
PLBCB NextLbcb;
PLEB NextLeb;
PAGED_CODE();
DebugTrace( +1, Dbg, "LfsDeallocateLfcb: Entered\n", 0 );
DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb );
//
// Check that there are no buffer blocks.
//
ASSERT( IsListEmpty( &Lfcb->LbcbActive ));
ASSERT( IsListEmpty( &Lfcb->LbcbWorkque ));
//
// Check that we have no clients.
//
ASSERT( IsListEmpty( &Lfcb->LchLinks ));
//
// If there is a restart area we deallocate it.
//
if (Lfcb->RestartArea != NULL) {
LfsDeallocateRestartArea( Lfcb->RestartArea );
}
//
// If there are any of the tail Lbcb's, deallocate them now.
//
if (Lfcb->ActiveTail != NULL) {
LfsDeallocateLbcb( Lfcb, Lfcb->ActiveTail );
Lfcb->ActiveTail = NULL;
}
if (Lfcb->PrevTail != NULL) {
LfsDeallocateLbcb( Lfcb, Lfcb->PrevTail );
Lfcb->PrevTail = NULL;
}
//
// Only do the following if we are to remove the Lfcb completely.
//
if (CompleteTeardown) {
//
// If there is a resource structure we deallocate it.
//
if (Lfcb->Sync != NULL) {
#ifdef BENL_DBG
KdPrint(( "LFS: lfcb teardown: 0x%x 0x%x\n", Lfcb, Lfcb->Sync ));
#endif
ExDeleteResourceLite( &Lfcb->Sync->Resource );
ExFreePool( Lfcb->Sync );
}
}
//
// Deallocate all of the spare Lbcb's.
//
while (!IsListEmpty( &Lfcb->SpareLbcbList )) {
NextLbcb = (PLBCB) Lfcb->SpareLbcbList.Flink;
RemoveHeadList( &Lfcb->SpareLbcbList );
ExFreePool( NextLbcb );
}
//
// Deallocate all of the spare Leb's.
//
while (!IsListEmpty( &Lfcb->SpareLebList )) {
NextLeb = (PLEB) Lfcb->SpareLebList.Flink;
RemoveHeadList( &Lfcb->SpareLebList );
ExFreePool( NextLeb );
}
//
// Cleanup the log head mdls and buffer
//
if (Lfcb->LogHeadBuffer) {
LfsFreePool( Lfcb->LogHeadBuffer );
}
if (Lfcb->LogHeadPartialMdl) {
IoFreeMdl( Lfcb->LogHeadPartialMdl );
}
if (Lfcb->LogHeadMdl) {
IoFreeMdl( Lfcb->LogHeadMdl );
}
if (Lfcb->ErrorLogPacket) {
IoFreeErrorLogEntry( Lfcb->ErrorLogPacket );
Lfcb->ErrorLogPacket = NULL;
}
//
// Discard the Lfcb structure.
//
ExFreePool( Lfcb );
DebugTrace( -1, Dbg, "LfsDeallocateLfcb: Exit\n", 0 );
return;
}
VOID
LfsAllocateLbcb (
IN PLFCB Lfcb,
OUT PLBCB *Lbcb
)
/*++
Routine Description:
This routine will allocate the next Lbcb. If the pool allocation fails
we will look at the private queue of Lbcb's.
Arguments:
Lfcb - Supplies a pointer to the log file control block.
Lbcb - Address to store the allocated Lbcb.
Return Value:
None
--*/
{
PLBCB NewLbcb = NULL;
PAGED_CODE();
//
// If there are enough entries on the look-aside list then get one from
// there.
//
if (Lfcb->SpareLbcbCount > LFCB_RESERVE_LBCB_COUNT) {
NewLbcb = (PLBCB) Lfcb->SpareLbcbList.Flink;
Lfcb->SpareLbcbCount -= 1;
RemoveHeadList( &Lfcb->SpareLbcbList );
//
// Otherwise try to allocate from pool.
//
} else {
NewLbcb = ExAllocatePoolWithTag( PagedPool, sizeof( LBCB ), ' sfL' );
}
//
// If we didn't get one then look at the look-aside list.
//
if (NewLbcb == NULL) {
if (Lfcb->SpareLbcbCount != 0) {
NewLbcb = (PLBCB) Lfcb->SpareLbcbList.Flink;
Lfcb->SpareLbcbCount -= 1;
RemoveHeadList( &Lfcb->SpareLbcbList );
} else {
ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
}
}
//
// Initialize the structure.
//
RtlZeroMemory( NewLbcb, sizeof( LBCB ));
NewLbcb->NodeTypeCode = LFS_NTC_LBCB;
NewLbcb->NodeByteSize = sizeof( LBCB );
//
// Return it to the user.
//
*Lbcb = NewLbcb;
return;
}
VOID
LfsDeallocateLbcb (
IN PLFCB Lfcb,
IN PLBCB Lbcb
)
/*++
Routine Description:
This routine will deallocate the Lbcb. If we need one for the look-aside
list we will put it there.
Arguments:
Lfcb - Supplies a pointer to the log file control block.
Lbcb - This is the Lbcb to deallocate.
Return Value:
None
--*/
{
PAGED_CODE();
//
// Deallocate any restart area attached to this Lbcb.
//
if (FlagOn( Lbcb->LbcbFlags, LBCB_RESTART_LBCB ) &&
(Lbcb->PageHeader != NULL)) {
LfsDeallocateRestartArea( Lbcb->PageHeader );
}
//
// Put this in the Lbcb queue if it is short.
//
if (Lfcb->SpareLbcbCount < LFCB_MAX_LBCB_COUNT) {
InsertHeadList( &Lfcb->SpareLbcbList, (PLIST_ENTRY) Lbcb );
Lfcb->SpareLbcbCount += 1;
//
// Otherwise just free the pool block.
//
} else {
ExFreePool( Lbcb );
}
return;
}
VOID
LfsAllocateLeb (
IN PLFCB Lfcb,
OUT PLEB *NewLeb
)
/*++
Routine Description:
This routine will allocate an Leb. If the pool fails we will fall back
on our spare list. A failure then will result in an exception
Arguments:
Lfcb - Supplies a pointer to the log file control block.
Leb - This will contain the new Leb
Return Value:
None
--*/
{
ExAcquireFastMutex( &(Lfcb->Sync->SpareListMutex) );
try {
*NewLeb = NULL;
if (Lfcb->SpareLebCount < LFCB_RESERVE_LEB_COUNT) {
(*NewLeb) = ExAllocatePoolWithTag( PagedPool, sizeof( LEB ), ' sfL' );
}
if ((*NewLeb) == NULL) {
if (Lfcb->SpareLebCount > 0) {
*NewLeb = (PLEB) Lfcb->SpareLebList.Flink;
Lfcb->SpareLebCount -= 1;
RemoveHeadList( &Lfcb->SpareLebList );
} else {
ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
}
}
RtlZeroMemory( (*NewLeb), sizeof( LEB ) );
(*NewLeb)->NodeTypeCode = LFS_NTC_LEB;
(*NewLeb)->NodeByteSize = sizeof( LEB );
} finally {
ExReleaseFastMutex( &(Lfcb->Sync->SpareListMutex) );
}
}
VOID
LfsDeallocateLeb (
IN PLFCB Lfcb,
IN PLEB Leb
)
/*++
Routine Description:
This routine will deallocate an Leb. We'll cache the old Leb if there
aren't too many already on the spare list
Arguments:
Lfcb - Supplies a pointer to the log file control block.
Leb - This will contain the Leb to release
Return Value:
None
--*/
{
if (Leb->RecordHeaderBcb != NULL) {
CcUnpinData( Leb->RecordHeaderBcb );
}
if ((Leb->CurrentLogRecord != NULL) && Leb->AuxilaryBuffer) {
LfsFreeSpanningBuffer( Leb->CurrentLogRecord );
}
ExAcquireFastMutex( &(Lfcb->Sync->SpareListMutex) );
try {
if (Lfcb->SpareLebCount < LFCB_MAX_LEB_COUNT) {
InsertHeadList( &Lfcb->SpareLebList, (PLIST_ENTRY) Leb );
Lfcb->SpareLebCount += 1;
} else {
ExFreePool( Leb );
}
} finally {
ExReleaseFastMutex( &(Lfcb->Sync->SpareListMutex) );
}
}
VOID
LfsReadPage (
IN PLFCB Lfcb,
IN PLARGE_INTEGER Offset,
OUT PMDL *Mdl,
OUT PVOID *Buffer
)
/*++
Routine Description:
Directly pages in a page off the disk - the cache manager interfaces (LfsPinOrMapPage)
may come from the cache. This wil raise if memory can't be allocated and used for
verification purposes
Arguments:
Lfcb - Supplies a pointer to the log file control block.
Offset - offset of page to pagein from the logfile
Mdl - On success the mdl that describes the mdl - it must be deallocated via
IoFreeMdl
Buffer - On output an allocated buffer that holds the data from the page - it
must be freed using ExFreePool
Return Value:
None
--*/
{
IO_STATUS_BLOCK Iosb;
KEVENT Event;
NTSTATUS Status;
PAGED_CODE();
KeInitializeEvent( &Event, NotificationEvent, FALSE );
//
// Allocate buffer / mdl and page in the restart page from disk
//
*Buffer = LfsAllocatePool( NonPagedPool, (ULONG)Lfcb->LogPageSize );
*Mdl = IoAllocateMdl( *Buffer,
(ULONG)Lfcb->LogPageSize,
FALSE,
FALSE,
NULL );
if (*Mdl == NULL) {
ExRaiseStatus( STATUS_INSUFFICIENT_RESOURCES );
}
MmBuildMdlForNonPagedPool( *Mdl );
//
// We own the LFCB sync exclusively and there is only a main resource for the logfile
// so we don't need to preacquire any resources before doing the page read
//
Status = IoPageRead( Lfcb->FileObject, *Mdl, Offset, &Event, &Iosb );
if (Status == STATUS_PENDING) {
KeWaitForSingleObject( &Event,
WrPageIn,
KernelMode,
FALSE,
(PLARGE_INTEGER)NULL);
}
}
Reference in a new issue Copy permalink