public byte *Get(int size, out NativeMemory.ThreadStats thread)
{
size = Bits.NextPowerOf2(size);
if (size > Constants.Size.Megabyte * 16)
{
// We don't want to pool large buffers
return(NativeMemory.Allocate4KbAlignedMemory(size, out thread));
}
var index = Bits.MostSignificantBit(size);
if (_items[index].TryPop(out var allocation))
{
thread = allocation.AllocatingThread;
return((byte *)allocation.Ptr);
}
return(NativeMemory.Allocate4KbAlignedMemory(size, out thread));
}
private bool TryReadAndValidateHeader(StorageEnvironmentOptions options, out TransactionHeader *current)
{
if (_readAt4Kb > _journalPagerNumberOfAllocated4Kb)
{
current = null;
return(false); // end of jouranl
}
const int pageTo4KbRatio = Constants.Storage.PageSize / (4 * Constants.Size.Kilobyte);
var pageNumber = _readAt4Kb / pageTo4KbRatio;
var positionInsidePage = (_readAt4Kb % pageTo4KbRatio) * (4 * Constants.Size.Kilobyte);
current = (TransactionHeader *)
(_journalPager.AcquirePagePointer(this, pageNumber) + positionInsidePage);
// due to the reuse of journals we no longer can assume we have zeros in the end of the journal
// we might have there random garbage or old transactions we can ignore, so we have the following scenarios:
// * TxId <= current Id :: we can ignore old transaction of the reused journal and continue
// * TxId == current Id + 1 :: valid, but if hash is invalid. Transaction hasn't been committed
// * TxId > current Id + 1 :: if hash is invalid we can ignore reused/random, but if hash valid then we might missed TXs
if (current->HeaderMarker != Constants.TransactionHeaderMarker)
{
// not a transaction page,
// if the header marker is zero or garbage, we are probably in the area at the end of the log file, and have no additional log records
// to read from it. This can happen if the next transaction was too big to fit in the current log file. We stop reading
// this log file and move to the next one, or it might have happened becuase of reuse of journal file
// note : we might encounter a "valid" TransactionHeaderMarker which is still garbage, so we will test that later on
RequireHeaderUpdate = false;
return(false);
}
if (current->TransactionId < 0)
{
return(false);
}
current = EnsureTransactionMapped(current, pageNumber, positionInsidePage);
if (options.EncryptionEnabled)
{
// We use temp buffers to hold the transaction before decrypting, and release the buffers afterwards.
var pagesSize = current->CompressedSize != -1 ? current->CompressedSize : current->UncompressedSize;
var size = (4 * Constants.Size.Kilobyte) * GetNumberOf4KbFor(sizeof(TransactionHeader) + pagesSize);
var ptr = NativeMemory.Allocate4KbAlignedMemory(size, out var thread);
var buffer = new EncryptionBuffer
{
Pointer = ptr,
Size = size,
AllocatingThread = thread
};
_encryptionBuffers.Add(buffer);
Memory.Copy(buffer.Pointer, (byte *)current, size);
current = (TransactionHeader *)buffer.Pointer;
try
{
DecryptTransaction((byte *)current, options);
}
catch (InvalidOperationException ex)
{
RequireHeaderUpdate = true;
options.InvokeRecoveryError(this, "Transaction " + current->TransactionId + " was not committed", ex);
return(false);
}
}
bool hashIsValid = ValidatePagesHash(options, current);
if (LastTransactionHeader == null)
{
return(hashIsValid);
}
var txIdDiff = current->TransactionId - LastTransactionHeader->TransactionId;
// 1 is a first storage transaction which does not increment transaction counter after commit
if (current->TransactionId != 1)
{
if (txIdDiff < 0)
{
return(false);
}
if (txIdDiff > 1 || txIdDiff == 0)
{
if (hashIsValid)
{
// TxId is bigger then the last one by nore the '1' but has valid hash which mean we lost transactions in the middle
throw new InvalidDataException(
$"Transaction has valid(!) hash with invalid transaction id {current->TransactionId}, the last valid transaction id is {LastTransactionHeader->TransactionId}." +
$" Journal file {_journalPager.FileName} might be corrupted");
}
}
// if (txIdDiff == 1) :
if (current->LastPageNumber <= 0)
{
throw new InvalidDataException("Last page number after committed transaction must be greater than 0");
}
}
if (hashIsValid == false)
{
RequireHeaderUpdate = true;
options.InvokeRecoveryError(this, "Transaction " + current->TransactionId + " was not committed",
null);
return(false);
}
return(true);
}