lbcbsup.c File Reference

#include "lfsprocs.h"

Go to the source code of this file.

Defines
#define	Dbg   (DEBUG_TRACE_LBCB_SUP)
Functions
VOID	LfsFlushLbcb (IN PLFCB Lfcb, IN PLBCB Lbcb)
VOID	LfsFlushToLsnPriv (IN PLFCB Lfcb, IN LSN Lsn)
PLBCB	LfsGetLbcb (IN PLFCB Lfcb)

---

Define Documentation

#define Dbg   (DEBUG_TRACE_LBCB_SUP)

Definition at line 27 of file lbcbsup.c.

---

Function Documentation

VOID LfsFlushLbcb (  IN PLFCB  Lfcb, IN PLBCB  Lbcb )

Definition at line 37 of file lbcbsup.c. References Dbg, DebugTrace, Executive, FALSE, KernelMode, KeWaitForSingleObject(), LfsAcquireLfcb, LfsFlushLfcb(), LfsLbcbIsRestart, LfsNoIoInProgress, LfsReleaseLfcb, LSN, NULL, PAGED_CODE, and PLSN. Referenced by LfsFlushToLsnPriv(), and LfsWriteLfsRestart(). : This routine is called to make sure the data within an Lbcb makes it out to disk. The Lbcb must either already be in the workque or it must be a restart Lbcb. Arguments: Lfcb - This is the file control block for the log file. Lbcb - This is the Lbcb to flush. Return Value: None. --*/ { LSN LastLsn; PLSN FlushedLsn; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsFlushLbcb: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "Lbcb -> %08lx\n", Lbcb ); LastLsn = Lbcb->LastEndLsn; // // If this is a restart area we use the restart counter in the // Lfcb. Otherwise we can use the LastFlushedLsn value in the // Lfcb. This way we can determine that the Lbcb that interests // us has made it out to disk. // if (LfsLbcbIsRestart( Lbcb )) { FlushedLsn = &Lfcb->LastFlushedRestartLsn; } else { FlushedLsn = &Lfcb->LastFlushedLsn; } // // We loop here until the desired Lsn has made it to disk. // If we are able to do the I/O, we will perform it. // do { // // // If we can do the Io, call down to flush the Lfcb. // if (Lfcb->LfsIoState == LfsNoIoInProgress) { LfsFlushLfcb( Lfcb, Lbcb ); break; } // // Otherwise we release the Lfcb and immediately wait on the event. // Lfcb->Waiters += 1; LfsReleaseLfcb( Lfcb ); KeWaitForSingleObject( &Lfcb->Sync->Event, Executive, KernelMode, FALSE, NULL ); LfsAcquireLfcb( Lfcb ); Lfcb->Waiters -= 1; } while ( LastLsn.QuadPart > FlushedLsn->QuadPart ); DebugTrace( -1, Dbg, "LfsFlushLbcb: Exit\n", 0 ); return; }

VOID LfsFlushToLsnPriv (  IN PLFCB  Lfcb, IN LSN  Lsn )

Definition at line 134 of file lbcbsup.c. References _LBCB::ActiveLinks, ClearFlag, Dbg, DebugTrace, ExRaiseStatus(), FALSE, FlagOn, _LBCB::Flags, LBCB_ON_ACTIVE_QUEUE, _LBCB::LbcbFlags, LFCB_PACK_LOG, LfsCurrentAvailSpace(), LfsFlushLbcb(), LfsLbcbIsRestart, LOG_PAGE_LOG_RECORD_END, NULL, PAGED_CODE, and TRUE. Referenced by LfsFlushToLsn(), and LfsForceWrite(). : This routine is the worker routine which performs the work of flushing a particular Lsn to disk. This routine is always called with the Lfcb acquired. This routines makes no guarantee about whether the Lfcb is acquired on exit. Arguments: Lfcb - This is the file control block for the log file. Lsn - This is the Lsn to flush to disk. Return Value: None. --*/ { BOOLEAN UseLastRecordLbcb = FALSE; PLBCB LastRecordLbcb = NULL; PAGED_CODE(); DebugTrace( +1, Dbg, "LfsFlushToLsnPriv: Entered\n", 0 ); DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); DebugTrace( 0, Dbg, "Lsn (Low) -> %08lx\n", Lsn.LowPart ); DebugTrace( 0, Dbg, "Lsn (High) -> %08lx\n", Lsn.HighPart ); // // We check if the Lsn is in the valid range. Raising an // exception if not. // if (Lsn.QuadPart > Lfcb->RestartArea->CurrentLsn.QuadPart) { UseLastRecordLbcb = TRUE; } // // If the Lsn has already been flushed we are done. // Otherwise we need to look through the workqueues and the // active queue. // if (Lsn.QuadPart > Lfcb->LastFlushedLsn.QuadPart) { PLIST_ENTRY ThisEntry; PLBCB ThisLbcb; // // Check the workqueue first. We are looking for the last // buffer block of a log page block which contains this // Lsn. // ThisEntry = Lfcb->LbcbWorkque.Flink; // // We keep looping. // while (TRUE) { ThisLbcb = CONTAINING_RECORD( ThisEntry, LBCB, WorkqueLinks ); // // We pass over any restart areas. We also skip any // Lbcb's which do not contain the end of a log record. // if (!LfsLbcbIsRestart( ThisLbcb ) && FlagOn( ThisLbcb->Flags, LOG_PAGE_LOG_RECORD_END )) { LastRecordLbcb = ThisLbcb; // // If the last complete Lsn in this Lbcb is greater or equal // to the desired Lsn, we exit the loop. // if (ThisLbcb->LastEndLsn.QuadPart >= Lsn.QuadPart) { break; } } // // Otherwise move to the next Lbcb. // ThisEntry = ThisEntry->Flink; // // If we have reached the end of the list then break out. We // were given an Lsn which is larger than any flushed Lsn so // we will just flush to the end of the log file. // if (ThisEntry == &Lfcb->LbcbWorkque) { if (UseLastRecordLbcb) { ThisLbcb = LastRecordLbcb; } break; } } if (ThisLbcb != NULL) { // // If we are not supporting a packed log file and this Lbcb is from // the active queue, we need to check that losing the tail of the // will not swallow up any of our reserved space. // if (!FlagOn( Lfcb->Flags, LFCB_PACK_LOG ) && FlagOn( ThisLbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE )) { LONGLONG CurrentAvail; LONGLONG UnusedBytes; // // Find the unused bytes. // UnusedBytes = 0; LfsCurrentAvailSpace( Lfcb, &CurrentAvail, (PULONG)&UnusedBytes ); CurrentAvail = CurrentAvail - Lfcb->TotalUndoCommitment; if (UnusedBytes > CurrentAvail) { DebugTrace( -1, Dbg, "Have to preserve these bytes for possible aborts\n", 0 ); ExRaiseStatus( STATUS_LOG_FILE_FULL ); } // // We want to make sure we don't write any more data into this // page. Remove this from the active queue. // RemoveEntryList( &ThisLbcb->ActiveLinks ); ClearFlag( ThisLbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE ); } // // We now have the Lbcb we want to flush to disk. // LfsFlushLbcb( Lfcb, ThisLbcb ); } } DebugTrace( -1, Dbg, "LfsFlushToLsnPriv: Exit\n", 0 ); return; }

PLBCB LfsGetLbcb (  IN PLFCB  Lfcb  )

Definition at line 311 of file lbcbsup.c. References _LBCB::ActiveLinks, _LBCB::BufferOffset, CcSetBcbOwnerPointer(), CcUnpinData(), ClearFlag, Dbg, DebugTrace, DebugUnwind, ERESOURCE_THREAD, ExGetCurrentResourceThread, _LBCB::FileOffset, FlagOn, _LBCB::Flags, KeBugCheck(), _LBCB::LastEndLsn, _LBCB::LastLsn, LBCB_FLUSH_COPY, LBCB_LOG_WRAPPED, LBCB_ON_ACTIVE_QUEUE, _LBCB::LbcbFlags, _LBCB::Length, LFCB_LOG_WRAPPED, LFCB_NO_LAST_LSN, LFCB_REUSE_TAIL, LFS_SIGNATURE_RECORD_PAGE_ULONG, LfsAllocateLbcb(), LfsDeallocateLbcb(), LfsGetLbcb(), LfsNextLogPageOffset(), LfsPreparePinWriteData, _LBCB::LogPageBcb, NULL, PAGED_CODE, _LBCB::PageHeader, _LBCB::ResourceThread, _LBCB::SeqNumber, and SetFlag. Referenced by LfsGetLbcb(), and LfsPrepareLfcbForLogRecord(). 00317 : 00318 00319 This routine is called to add a Lbcb to the active queue. 00320 00321 Arguments: 00322 00323 Lfcb - This is the file control block for the log file. 00324 00325 Return Value: 00326 00327 PLBCB - Pointer to the Lbcb allocated. 00328 00329 --*/ 00330 00331 { 00332 PLBCB Lbcb = NULL; 00333 PVOID PageHeader; 00334 PBCB PageHeaderBcb = NULL; 00335 00336 BOOLEAN WrappedOrUsaError; 00337 00338 PAGED_CODE(); 00339 00340 DebugTrace( +1, Dbg, "LfsGetLbcb: Entered\n", 0 ); 00341 DebugTrace( 0, Dbg, "Lfcb -> %08lx\n", Lfcb ); 00342 00343 // 00344 // Use a try-finally to facilitate cleanup. 00345 // 00346 00347 try { 00348 00349 // 00350 // Pin the desired record page. 00351 // 00352 00353 LfsPreparePinWriteData( Lfcb, 00354 Lfcb->NextLogPage, 00355 (ULONG)Lfcb->LogPageSize, 00356 &PageHeader, 00357 &PageHeaderBcb ); 00358 00359 // 00360 // Put our signature into the page so we won't fail if we 00361 // see a previous 'BAAD' signature. 00362 // 00363 00364 *((PULONG) PageHeader) = LFS_SIGNATURE_RECORD_PAGE_ULONG; 00365 00366 // 00367 // Now allocate an Lbcb. 00368 // 00369 00370 LfsAllocateLbcb( Lfcb, &Lbcb ); 00371 00372 // 00373 // If we are at the beginning of the file we test that the 00374 // sequence number won't wrap to 0. 00375 // 00376 00377 if (!FlagOn( Lfcb->Flags, LFCB_NO_LAST_LSN | LFCB_REUSE_TAIL ) 00378 && ( Lfcb->NextLogPage == Lfcb->FirstLogPage )) { 00379 00380 Lfcb->SeqNumber = Lfcb->SeqNumber + 1; 00381 00382 // 00383 // If the sequence number is going from 0 to 1, then 00384 // this is the first time the log file has wrapped. We want 00385 // to remember this because it means that we can now do 00386 // large spiral writes. 00387 // 00388 00389 if (Int64ShllMod32( Lfcb->SeqNumber, Lfcb->FileDataBits ) == 0) { 00390 00391 DebugTrace( 0, Dbg, "Log sequence number about to wrap: Lfcb -> %08lx\n", Lfcb ); 00392 KeBugCheck( FILE_SYSTEM ); 00393 } 00394 00395 // 00396 // If this number is greater or equal to the wrap sequence number in 00397 // the Lfcb, set the wrap flag in the Lbcb. 00398 // 00399 00400 if (!FlagOn( Lfcb->Flags, LFCB_LOG_WRAPPED ) 00401 && ( Lfcb->SeqNumber >= Lfcb->SeqNumberForWrap )) { 00402 00403 SetFlag( Lbcb->LbcbFlags, LBCB_LOG_WRAPPED ); 00404 SetFlag( Lfcb->Flags, LFCB_LOG_WRAPPED ); 00405 } 00406 } 00407 00408 // 00409 // Now initialize the rest of the Lbcb fields. 00410 // 00411 00412 Lbcb->FileOffset = Lfcb->NextLogPage; 00413 Lbcb->SeqNumber = Lfcb->SeqNumber; 00414 Lbcb->BufferOffset = Lfcb->LogPageDataOffset; 00415 00416 // 00417 // Store the next page in the Lfcb. 00418 // 00419 00420 LfsNextLogPageOffset( Lfcb, 00421 Lfcb->NextLogPage, 00422 &Lfcb->NextLogPage, 00423 &WrappedOrUsaError ); 00424 00425 Lbcb->Length = Lfcb->LogPageSize; 00426 Lbcb->PageHeader = PageHeader; 00427 Lbcb->LogPageBcb = PageHeaderBcb; 00428 00429 Lbcb->ResourceThread = ExGetCurrentResourceThread(); 00430 Lbcb->ResourceThread = (ERESOURCE_THREAD) ((ULONG) Lbcb->ResourceThread | 3); 00431 00432 // 00433 // If we are reusing a previous page then set a flag in 00434 // the Lbcb to indicate that we should flush a copy 00435 // first. 00436 // 00437 00438 if (FlagOn( Lfcb->Flags, LFCB_REUSE_TAIL )) { 00439 00440 SetFlag( Lbcb->LbcbFlags, LBCB_FLUSH_COPY ); 00441 ClearFlag( Lfcb->Flags, LFCB_REUSE_TAIL ); 00442 00443 (ULONG)Lbcb->BufferOffset = Lfcb->ReusePageOffset; 00444 00445 Lbcb->Flags = ((PLFS_RECORD_PAGE_HEADER) PageHeader)->Flags; 00446 Lbcb->LastLsn = ((PLFS_RECORD_PAGE_HEADER) PageHeader)->Copy.LastLsn; 00447 Lbcb->LastEndLsn = ((PLFS_RECORD_PAGE_HEADER) PageHeader)->Header.Packed.LastEndLsn; 00448 } 00449 00450 // 00451 // Put the Lbcb on the active queue 00452 // 00453 00454 InsertTailList( &Lfcb->LbcbActive, &Lbcb->ActiveLinks ); 00455 00456 SetFlag( Lbcb->LbcbFlags, LBCB_ON_ACTIVE_QUEUE ); 00457 00458 // 00459 // Now that we have succeeded, set the owner thread to Thread + 1 so the resource 00460 // package will know not to peek in this thread. It may be deallocated before 00461 // we release the Bcb during flush. 00462 // 00463 00464 CcSetBcbOwnerPointer( Lbcb->LogPageBcb, (PVOID) Lbcb->ResourceThread ); 00465 00466 } finally { 00467 00468 DebugUnwind( LfsGetLbcb ); 00469 00470 // 00471 // If an error occurred, we need to clean up any blocks which 00472 // have not been added to the active queue. 00473 // 00474 00475 if (AbnormalTermination()) { 00476 00477 if (Lbcb != NULL) { 00478 00479 LfsDeallocateLbcb( Lfcb, Lbcb ); 00480 Lbcb = NULL; 00481 } 00482 00483 // 00484 // Unpin the system page if pinned. 00485 // 00486 00487 if (PageHeaderBcb != NULL) { 00488 00489 CcUnpinData( PageHeaderBcb ); 00490 } 00491 } 00492 00493 DebugTrace( -1, Dbg, "LfsGetLbcb: Exit\n", 0 ); 00494 } 00495 00496 return Lbcb; 00497 } }

---