logrcsup.c File Reference

#include "lfsprocs.h"

Go to the source code of this file.

Defines
#define	Dbg   (DEBUG_TRACE_LOG_RECORD_SUP)
Functions
VOID	LfsPrepareLfcbForLogRecord (IN OUT PLFCB Lfcb, IN ULONG RemainingLogBytes)
VOID	LfsTransferLogBytes (IN PLBCB Lbcb, IN OUT PLFS_WRITE_ENTRY *ThisWriteEntry, IN OUT PCHAR *CurrentBuffer, IN OUT PULONG CurrentByteCount, IN OUT PULONG PadBytes, IN OUT PULONG RemainingPageBytes, IN OUT PULONG RemainingLogBytes)
BOOLEAN	LfsWriteLogRecordIntoLogPage (IN PLFCB Lfcb, IN PLCH Lch, IN ULONG NumberOfWriteEntries, IN PLFS_WRITE_ENTRY WriteEntries, IN LFS_RECORD_TYPE RecordType, IN TRANSACTION_ID *TransactionId OPTIONAL, IN LSN ClientUndoNextLsn OPTIONAL, IN LSN ClientPreviousLsn OPTIONAL, IN LONG UndoRequirement, IN BOOLEAN ForceToDisk, OUT PLSN Lsn)

---

Define Documentation

#define Dbg   (DEBUG_TRACE_LOG_RECORD_SUP)

Definition at line 28 of file logrcsup.c.

---

Function Documentation

VOID LfsPrepareLfcbForLogRecord (  IN OUT PLFCB  Lfcb, IN ULONG  RemainingLogBytes )

Definition at line 431 of file logrcsup.c. References _LBCB::ActiveLinks, _LBCB::BufferOffset, ClearFlag, Dbg, DebugTrace, FlagOn, LBCB_ON_ACTIVE_QUEUE, _LBCB::LbcbFlags, LFCB_PACK_LOG, LfsGetLbcb(), PAGED_CODE, and TRUE. Referenced by LfsWriteLogRecordIntoLogPage(). : This routine is called to insure that the Lfcb has a Lbcb in the active queue to perform the next log record transfer. This condition is met when there is a least one buffer block and the log record data will fit entirely on this page or this buffer block contains no other data in the unpacked case. For the packed case we just need to make sure that there are sufficient Lbcb's. Arguments: Lfcb - File control block for this log file. RemainingLogBytes - The number of bytes remaining for this log record. Return Value: None --*/ { PLBCB ThisLbcb; ULONG RemainingPageBytes; PLIST_ENTRY LbcbLinks; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsPrepareLfcbForLogRecord: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "RemainingLogBytes -> %08lx\n", RemainingLogBytes ); // // If there is no Lbcb in the active queue, we don't check it for size. // if (!IsListEmpty( &Lfcb->LbcbActive )) { // // If the log record won't fit in the remaining bytes of this page, // we queue this log buffer. // ThisLbcb = CONTAINING_RECORD( Lfcb->LbcbActive.Flink, LBCB, ActiveLinks ); RemainingPageBytes = (ULONG)Lfcb->LogPageSize - (ULONG)ThisLbcb->BufferOffset; // // This log page won't do if the remaining bytes won't hold the data // unless this is the first log record in the page or we are packing // the log file. // if (RemainingLogBytes > RemainingPageBytes && !FlagOn( Lfcb->Flags, LFCB_PACK_LOG ) && (ULONG)ThisLbcb->BufferOffset != (ULONG)Lfcb->LogPageDataOffset) { RemoveHeadList( &Lfcb->LbcbActive ); ClearFlag( ThisLbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE ); } } // // We now make sure we can allocate enough Lbcb's for all of the log pages // we will need. We now include the bytes for the log record reader. // LbcbLinks = Lfcb->LbcbActive.Flink; while (TRUE) { // // If the Lbcb link we have is the head of the list, we will need another // Lbcb. // if (LbcbLinks == &Lfcb->LbcbActive) { ThisLbcb = LfsGetLbcb( Lfcb ); } else { ThisLbcb = CONTAINING_RECORD( LbcbLinks, LBCB, ActiveLinks ); } // // Remember the bytes remaining on this page. This will always be quad // aligned. // RemainingPageBytes = (ULONG)Lfcb->LogPageSize - (ULONG)ThisLbcb->BufferOffset; if (RemainingPageBytes >= RemainingLogBytes) { break; } // // Move to the next log record. // RemainingLogBytes -= RemainingPageBytes; LbcbLinks = ThisLbcb->ActiveLinks.Flink; } DebugTrace( -1, Dbg, "LfsPrepareLfcbForLogRecord: Exit\n", 0 ); return; }

VOID LfsTransferLogBytes (  IN PLBCB  Lbcb, IN OUT PLFS_WRITE_ENTRY *  ThisWriteEntry, IN OUT PCHAR *  CurrentBuffer, IN OUT PULONG  CurrentByteCount, IN OUT PULONG  PadBytes, IN OUT PULONG  RemainingPageBytes, IN OUT PULONG  RemainingLogBytes )

Definition at line 556 of file logrcsup.c. References Add2Ptr, Dbg, DebugTrace, NULL, and PAGED_CODE. Referenced by LfsWriteLogRecordIntoLogPage(). 00568 : 00569 00570 This routine is called to transfer the next block of bytes into 00571 a log page. It is given a pointer to the current position in the 00572 current Lfs write entry and the number of bytes remaining on that 00573 log page. It will transfer as many of the client's bytes from the 00574 current buffer that will fit and update various pointers. 00575 00576 Arguments: 00577 00578 Lbcb - This is the buffer block for this log page. 00579 00580 ThisWriteEntry - This is a pointer to a pointer to the current Lfs 00581 write entry. 00582 00583 CurrentBuffer - This is a pointer to a pointer to the current position 00584 in the current write entry buffer. If this points to a NULL 00585 value it means to put zero bytes into the log. 00586 00587 CurrentByteCount - This is a pointer to the number of bytes remaining 00588 in the current buffer. 00589 00590 PadBytes - This is a pointer to the number of padding byes for 00591 this write entry. 00592 00593 RemainingPageBytes - This is pointer to the number of bytes remaining 00594 in this page. 00595 00596 RemainingLogBytes - This is the number of bytes remaining to transfer 00597 for this log record. 00598 00599 Return Value: 00600 00601 None 00602 00603 --*/ 00604 00605 { 00606 PCHAR CurrentLogPagePosition; 00607 PCHAR CurrentClientPosition; 00608 00609 ULONG TransferBytes; 00610 ULONG ThisPadBytes; 00611 00612 PAGED_CODE(); 00613 00614 DebugTrace( +1, Dbg, "LfsTransferLogBytes: Entered\n", 0 ); 00615 DebugTrace( 0, Dbg, "Lbcb -> %08lx\n", Lbcb ); 00616 DebugTrace( 0, Dbg, "ThisWriteEntry -> %08lx\n", *ThisWriteEntry ); 00617 DebugTrace( 0, Dbg, "CurrentBuffer -> %08lx\n", *CurrentBuffer ); 00618 DebugTrace( 0, Dbg, "CurrentByteCount -> %08lx\n", *CurrentByteCount ); 00619 DebugTrace( 0, Dbg, "RemainingPageBytes -> %08lx\n", *RemainingPageBytes ); 00620 DebugTrace( 0, Dbg, "RemainingLogBytes -> %08lx\n", *RemainingLogBytes ); 00621 00622 // 00623 // Remember the current client buffer position and current position 00624 // in log page. 00625 // 00626 00627 CurrentLogPagePosition = Add2Ptr( Lbcb->PageHeader, (ULONG)Lbcb->BufferOffset, PCHAR ); 00628 CurrentClientPosition = *CurrentBuffer; 00629 00630 // 00631 // The limiting factor is either the number of bytes remaining in a 00632 // write entry or the number remaining in the log page. 00633 // 00634 00635 if (*CurrentByteCount <= *RemainingPageBytes) { 00636 00637 TransferBytes = *CurrentByteCount; 00638 00639 ThisPadBytes = *PadBytes; 00640 00641 if (*RemainingLogBytes != (*CurrentByteCount + *PadBytes) ) { 00642 00643 (*ThisWriteEntry)++; 00644 00645 *CurrentBuffer = (*ThisWriteEntry)->Buffer; 00646 *CurrentByteCount = (*ThisWriteEntry)->ByteLength; 00647 00648 *PadBytes = (8 - (*CurrentByteCount & ~(0xfffffff8))) & ~(0xfffffff8); 00649 } 00650 00651 } else { 00652 00653 TransferBytes = *RemainingPageBytes; 00654 00655 ThisPadBytes = 0; 00656 00657 *CurrentByteCount -= TransferBytes; 00658 00659 if (*CurrentBuffer != NULL) { 00660 00661 *CurrentBuffer += TransferBytes; 00662 } 00663 } 00664 00665 // 00666 // Transfer the requested bytes. 00667 // 00668 00669 if (CurrentClientPosition != NULL) { 00670 00671 RtlCopyMemory( CurrentLogPagePosition, CurrentClientPosition, TransferBytes ); 00672 00673 } else { 00674 00675 RtlZeroMemory( CurrentLogPagePosition, TransferBytes ); 00676 } 00677 00678 // 00679 // Reduce the remaining page and log bytes by the transfer amount and 00680 // move forward in the log page. 00681 // 00682 00683 *RemainingLogBytes -= (TransferBytes + ThisPadBytes); 00684 *RemainingPageBytes -= (TransferBytes + ThisPadBytes); 00685 00686 (ULONG)Lbcb->BufferOffset += (TransferBytes + ThisPadBytes); 00687 00688 DebugTrace( -1, Dbg, "LfsTransferLogBytes: Exit\n", 0 ); 00689 00690 return; 00691 } }

BOOLEAN LfsWriteLogRecordIntoLogPage (  IN PLFCB  Lfcb, IN PLCH  Lch, IN ULONG  NumberOfWriteEntries, IN PLFS_WRITE_ENTRY  WriteEntries, IN LFS_RECORD_TYPE  RecordType, IN TRANSACTION_ID *TransactionId  OPTIONAL, IN LSN ClientUndoNextLsn  OPTIONAL, IN LSN ClientPreviousLsn  OPTIONAL, IN LONG  UndoRequirement, IN BOOLEAN  ForceToDisk, OUT PLSN  Lsn )

Definition at line 55 of file logrcsup.c. References Add2Ptr, _LFS_WRITE_ENTRY::Buffer, _LBCB::BufferOffset, _LFS_WRITE_ENTRY::ByteLength, ClearFlag, _LFS_RECORD_HEADER::ClientDataLength, _LFS_RECORD_HEADER::ClientId, _LFS_RECORD_HEADER::ClientPreviousLsn, _LFS_RECORD_HEADER::ClientUndoNextLsn, _LFS_RECORD_PAGE_HEADER::Copy, Dbg, DebugTrace, Executive, FALSE, FlagOn, _LFS_RECORD_PAGE_HEADER::Flags, _LBCB::Flags, _LFS_RECORD_HEADER::Flags, _LFS_RECORD_PAGE_HEADER::Header, KernelMode, KeWaitForSingleObject(), _LBCB::LastEndLsn, _LBCB::LastLsn, LBCB_NOT_EMPTY, LBCB_ON_ACTIVE_QUEUE, _LBCB::LbcbFlags, LFCB_NO_LAST_LSN, LFCB_PACK_LOG, LfsAcquireLfcb, LfsComputeLsnFromLbcb, LfsPrepareLfcbForLogRecord(), LfsReleaseLfcb, LfsTransferLogBytes(), LfsVerifyLogSpaceAvail(), LOG_PAGE_LOG_RECORD_END, LOG_RECORD_MULTI_PAGE, _LBCB::LogPageBcb, LSN, NULL, PAGED_CODE, _LBCB::PageHeader, QuadAlign, _LFS_RECORD_HEADER::RecordType, SetFlag, _LFS_RECORD_HEADER::ThisLsn, _LFS_RECORD_HEADER::TransactionId, TRUE, USHORT, and _LBCB::WorkqueLinks. Referenced by LfsForceWrite(), LfsWrite(), and LfsWriteRestartArea(). : This routine is called to write a log record into the log file using the cache manager. If there is room in the current log page it is added to that. Otherwise we allocate a new log page and write the log record header for this log page. We then write the log record into the remaining bytes of this page and into any subsequent pages if needed. Arguments: Lfcb - File control block for this log file. Lch - This is the client handle, we may update the undo space for this client. NumberOfWriteEntries - Number of components of the log record. WriteEntries - Pointer to an array of write entries. UndoRequirement - Signed value indicating the requirement to write an abort log record for this log record. A negative value indicates that this is the abort record. RecordType - The Lfs-defined type of this log record. TransactionId - Pointer to the transaction structure containing the Id for transaction containing this operation. ClientUndoNextLsn - This is the Lsn provided by the client for use in his restart. Will be the zero Lsn for a restart log record. ClientPreviousLsn - This is the Lsn provided by the client for use in his restart. Will the the zero Lsn for a restart log record. UndoRequirement - This is the data size for the undo record for this log record. ForceToDisk - Indicates if this log record will be flushed immediately to disk. Lsn - A pointer to store the Lsn for this log record. Return Value: BOOLEAN - Advisory, TRUE indicates that less than 1/4 of the log file is available. --*/ { PLFS_WRITE_ENTRY ThisWriteEntry; ULONG RemainingLogBytes; ULONG OriginalLogBytes; ULONG RemainingPageBytes; ULONG HeaderAdjust; PLBCB ThisLbcb; LSN NextLsn; PLFS_RECORD_HEADER RecordHeader; PCHAR CurrentBuffer; ULONG CurrentByteCount; ULONG PadBytes; BOOLEAN LogFileFull = FALSE; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsWriteLogRecordIntoLogPage: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "Lch -> %08lx\n", Lch ); DebugTrace( 0, Dbg, "Number of Write Entries -> %08lx\n", NumberOfWriteEntries ); DebugTrace( 0, Dbg, "Write Entries -> %08lx\n", WriteEntries ); DebugTrace( 0, Dbg, "Record Type -> %08lx\n", RecordType ); DebugTrace( 0, Dbg, "Transaction Id -> %08lx\n", TransactionId ); DebugTrace( 0, Dbg, "ClientUndoNextLsn (Low) -> %08lx\n", ClientUndoNextLsn.LowPart ); DebugTrace( 0, Dbg, "ClientUndoNextLsn (High) -> %08lx\n", ClientUndoNextLsn.HighPart ); DebugTrace( 0, Dbg, "ClientPreviousLsn (Low) -> %08lx\n", ClientPreviousLsn.LowPart ); DebugTrace( 0, Dbg, "ClientPreviousLsn (High) -> %08lx\n", ClientPreviousLsn.HighPart ); DebugTrace( 0, Dbg, "UndoRequirement -> %08lx\n", UndoRequirement ); DebugTrace( 0, Dbg, "ForceToDisk -> %04x\n", ForceToDisk ); // // We compute the size of this log record. // ThisWriteEntry = WriteEntries; RemainingLogBytes = 0; while (NumberOfWriteEntries--) { RemainingLogBytes += QuadAlign( ThisWriteEntry->ByteLength ); ThisWriteEntry++; } OriginalLogBytes = RemainingLogBytes; ThisWriteEntry = WriteEntries; // // Loop until we have the Lbcb and we know it is not part of // a partial page transfer. We need to make sure we have // a Bcb for this page. // while (TRUE) { LogFileFull = LfsVerifyLogSpaceAvail( Lfcb, Lch, RemainingLogBytes, UndoRequirement, ForceToDisk ); // // We update the Lfcb so that we can start putting the log record into // the top of the Lbcb active list. // LfsPrepareLfcbForLogRecord( Lfcb, RemainingLogBytes + Lfcb->RecordHeaderLength ); ThisLbcb = CONTAINING_RECORD( Lfcb->LbcbActive.Flink, LBCB, ActiveLinks ); // // If there is a Bcb then we are golden. // if (ThisLbcb->LogPageBcb != NULL) { break; } // // Otherwise we want to drop the Lfcb and wait for the IO to complete. // Lfcb->Waiters += 1; LfsReleaseLfcb( Lfcb ); KeWaitForSingleObject( &Lfcb->Sync->Event, Executive, KernelMode, FALSE, NULL ); LfsAcquireLfcb( Lfcb ); Lfcb->Waiters -= 1; } RemainingPageBytes = (ULONG)Lfcb->LogPageSize - (ULONG)ThisLbcb->BufferOffset; // // Compute the Lsn starting in the next log buffer. // NextLsn.QuadPart = LfsComputeLsnFromLbcb( Lfcb, ThisLbcb ); // // We get a pointer to the log record header and the start of the // log record in the pinned buffer. // RecordHeader = Add2Ptr( ThisLbcb->PageHeader, (ULONG)ThisLbcb->BufferOffset, PLFS_RECORD_HEADER ); // // We update the record header. // // // Zero out the structure initially. // RtlZeroMemory( RecordHeader, Lfcb->RecordHeaderLength ); // // Update all the fields. // RecordHeader->ThisLsn = NextLsn; RecordHeader->ClientPreviousLsn = ClientPreviousLsn; RecordHeader->ClientUndoNextLsn = ClientUndoNextLsn; if (TransactionId != NULL) { RecordHeader->TransactionId = *TransactionId; } RecordHeader->ClientDataLength = RemainingLogBytes; RecordHeader->ClientId = Lch->ClientId; RecordHeader->RecordType = RecordType; // // Check if this is a multi-page record. // if (RemainingLogBytes + Lfcb->RecordHeaderLength > RemainingPageBytes) { SetFlag( RecordHeader->Flags, LOG_RECORD_MULTI_PAGE ); } RemainingPageBytes -= Lfcb->RecordHeaderLength; // // Update the buffer position in the Lbcb // (ULONG)ThisLbcb->BufferOffset += Lfcb->RecordHeaderLength; HeaderAdjust = Lfcb->RecordHeaderLength; // // Remember the values in the current write entry. // CurrentBuffer = ThisWriteEntry->Buffer; CurrentByteCount = ThisWriteEntry->ByteLength; PadBytes = (8 - (CurrentByteCount & ~(0xfffffff8))) & ~(0xfffffff8); // // Continue to transfer bytes until all the client's data has // been transferred. // while (RemainingLogBytes != 0) { PLFS_RECORD_PAGE_HEADER PageHeader; PageHeader = (PLFS_RECORD_PAGE_HEADER) ThisLbcb->PageHeader; // // If the Lbcb is empty and we are about to store data into it we // subtract the data size of the page from the available space. // Update all the information we want to put in the header. // if (!FlagOn( ThisLbcb->LbcbFlags, LBCB_NOT_EMPTY )) { // // We subtract this page from the available pages only if // we are at the beginning of the page. Otherwise this // could be a reuse page. In that case it has already // been subtracted. // if ((ULONG)ThisLbcb->BufferOffset - HeaderAdjust == (ULONG)Lfcb->LogPageDataOffset) { Lfcb->CurrentAvailable = Lfcb->CurrentAvailable - Lfcb->ReservedLogPageSize; //**** xxSub( Lfcb->CurrentAvailable, Lfcb->ReservedLogPageSize ); } InsertTailList( &Lfcb->LbcbWorkque, &ThisLbcb->WorkqueLinks ); SetFlag( ThisLbcb->LbcbFlags, LBCB_NOT_EMPTY ); } HeaderAdjust = 0; // // Compute the number of transfer bytes. Update the remaining // page bytes, remaining log bytes and position in the write // buffer array. This routine also copies the bytes into the buffer. // LfsTransferLogBytes( ThisLbcb, &ThisWriteEntry, &CurrentBuffer, &CurrentByteCount, &PadBytes, &RemainingPageBytes, &RemainingLogBytes ); // // This log record ends on this page. Update the fields for the // ending Lsn. // if (RemainingLogBytes == 0) { SetFlag( ThisLbcb->Flags, LOG_PAGE_LOG_RECORD_END ); ThisLbcb->LastEndLsn = NextLsn; if (FlagOn( Lfcb->Flags, LFCB_PACK_LOG )) { PageHeader->Header.Packed.LastEndLsn = NextLsn; PageHeader->Header.Packed.NextRecordOffset = (USHORT)ThisLbcb->BufferOffset; } } // // We are done with this page, update the fields in the page header. // if (RemainingPageBytes == 0 || RemainingLogBytes == 0) { // // We are done with this page. Update the Lbcb and page header. // ThisLbcb->LastLsn = NextLsn; PageHeader->Copy.LastLsn = NextLsn; PageHeader->Flags = ThisLbcb->Flags; // // We can't put any more log records on this page. Remove // it from the active queue. // if (RemainingPageBytes < Lfcb->RecordHeaderLength) { RemoveHeadList( &Lfcb->LbcbActive ); ClearFlag( ThisLbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE ); // // If there are more log bytes then get the next Lbcb. // if (RemainingLogBytes != 0) { ThisLbcb = CONTAINING_RECORD( Lfcb->LbcbActive.Flink, LBCB, ActiveLinks ); RemainingPageBytes = (ULONG)Lfcb->LogPageSize - (ULONG)ThisLbcb->BufferOffset; } } } } *Lsn = NextLsn; Lfcb->RestartArea->CurrentLsn = NextLsn; Lfcb->RestartArea->LastLsnDataLength = OriginalLogBytes; ClearFlag( Lfcb->Flags, LFCB_NO_LAST_LSN ); DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn->LowPart ); DebugTrace( 0, Dbg, "Lsn (High) -> %08lx\n", Lsn->HighPart ); DebugTrace( -1, Dbg, "LfsWriteLogRecordIntoLogPage: Exit\n", 0 ); return LogFileFull; }

---