VOID
Ext2QueueCloseRequest (IN PEXT2_IRP_CONTEXT IrpContext)
{
ASSERT(IrpContext);
ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
(IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DELAY_CLOSE)) {
if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_FILE_BUSY)) {
Ext2Sleep(500); /* 0.5 sec*/
} else {
Ext2Sleep(50); /* 0.05 sec*/
}
} else {
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DELAY_CLOSE);
IrpContext->Fcb = (PEXT2_FCB) IrpContext->FileObject->FsContext;
IrpContext->Ccb = (PEXT2_CCB) IrpContext->FileObject->FsContext2;
}
ExInitializeWorkItem(
&IrpContext->WorkQueueItem,
Ext2DeQueueCloseRequest,
IrpContext);
ExQueueWorkItem(&IrpContext->WorkQueueItem, DelayedWorkQueue);
}
NTSTATUS
Ext2TruncateBlock(
IN PEXT2_IRP_CONTEXT IrpContext,
IN PEXT2_VCB Vcb,
IN PEXT2_MCB Mcb,
IN ULONG Base,
IN ULONG Start,
IN ULONG Layer,
IN ULONG SizeArray,
IN PULONG BlockArray,
IN PULONG Extra
)
{
NTSTATUS Status = STATUS_SUCCESS;
ULONG i = 0;
ULONG Slot = 0;
ULONG Skip = 0;
LONGLONG Offset;
PBCB Bcb = NULL;
PULONG pData = NULL;
ASSERT(Mcb != NULL);
for (i = 0; i < SizeArray; i++) {
if (Layer == 0) {
ULONG Number = 1;
while (Extra && SizeArray > i + 1 && Number < *Extra) {
if (BlockArray[SizeArray - i - 1] ==
BlockArray[SizeArray - i - 2] + 1) {
BlockArray[SizeArray - i - 1] = 0;
Number++;
SizeArray--;
} else {
break;
}
}
if (BlockArray[SizeArray - i - 1]) {
Status = Ext2FreeBlock(IrpContext, Vcb, BlockArray[SizeArray - i - 1], Number);
if (NT_SUCCESS(Status)) {
ASSERT(Mcb->Inode.i_blocks >= (Number << (BLOCK_BITS - 9)));
if (Mcb->Inode.i_blocks < (Number << (BLOCK_BITS - 9))) {
Mcb->Inode.i_blocks = 0;
DbgBreak();
} else {
Mcb->Inode.i_blocks -= (Number << (BLOCK_BITS - 9));
}
BlockArray[SizeArray - i - 1] = 0;
}
}
if (Extra) {
/* dec blocks count */
ASSERT(*Extra >= Number);
*Extra = *Extra - Number;
/* remove block mapping frm Mcb Extents */
if (!Ext2RemoveBlockExtent(Vcb, Mcb, Base + SizeArray - 1 - i, Number)) {
DbgBreak();
ClearFlag(Mcb->Flags, MCB_ZONE_INITED);
Ext2ClearAllExtents(&Mcb->Extents);
}
}
} else {
ASSERT(Layer <= 3);
if (BlockArray[SizeArray - i - 1] >= TOTAL_BLOCKS) {
DbgBreak();
BlockArray[SizeArray - i - 1] = 0;
}
if (i == 0) {
if (Layer > 1) {
Slot = Start / Vcb->max_blocks_per_layer[Layer - 1];
Start = Start % Vcb->max_blocks_per_layer[Layer - 1];
} else {
Slot = Start;
Start = (BLOCK_SIZE / 4) - 1;
}
} else {
Slot = Start = (BLOCK_SIZE / 4) - 1;
}
Skip = (SizeArray - i - 1) * Vcb->max_blocks_per_layer[Layer];
if (BlockArray[SizeArray - i - 1]) {
Offset = (LONGLONG) (BlockArray[SizeArray - i - 1]);
Offset = Offset << BLOCK_BITS;
if (!CcPinRead( Vcb->Volume,
(PLARGE_INTEGER) (&Offset),
BLOCK_SIZE,
PIN_WAIT,
&Bcb,
(void **)&pData )) {
DEBUG(DL_ERR, ( "Ext2TruncateBlock: PinLock failed on block %xh ...\n",
BlockArray[SizeArray - i - 1]));
Status = STATUS_CANT_WAIT;
DbgBreak();
goto errorout;
}
Status = Ext2TruncateBlock(
IrpContext,
Vcb,
Mcb,
Base + Skip,
Start,
Layer - 1,
Slot + 1,
&pData[0],
Extra
);
if (!NT_SUCCESS(Status)) {
break;
}
CcSetDirtyPinnedData(Bcb, NULL);
Ext2AddVcbExtent(Vcb, Offset, (LONGLONG)BLOCK_SIZE);
if (*Extra || Ext2IsBlockEmpty(pData, BLOCK_SIZE/4)) {
Ext2TruncateBlock(
IrpContext,
Vcb,
Mcb,
Base + Skip, /* base */
0, /* start */
0, /* layer */
1,
&BlockArray[SizeArray - i - 1],
NULL
);
if (!Ext2RemoveMcbMetaExts(Vcb, Mcb, BlockArray[SizeArray - i - 1], 1)) {
DbgBreak();
Ext2Sleep(500);
Ext2RemoveMcbMetaExts(Vcb, Mcb, BlockArray[SizeArray - i - 1], 1);
}
}
if (pData) {
CcUnpinData(Bcb);
Bcb = NULL;
pData = NULL;
}
} else {
if (Layer > 1) {
if (*Extra > Slot * Vcb->max_blocks_per_layer[Layer - 1] + Start + 1) {
*Extra -= (Slot * Vcb->max_blocks_per_layer[Layer - 1] + Start + 1);
} else {
*Extra = 0;
}
} else {
if (*Extra > Slot + 1) {
*Extra -= (Slot + 1);
} else {
*Extra = 0;
}
}
if (!Ext2RemoveBlockExtent(Vcb, Mcb, Base + Skip, (Start + 1))) {
DbgBreak();
ClearFlag(Mcb->Flags, MCB_ZONE_INITED);
Ext2ClearAllExtents(&Mcb->Extents);
}
}
}
if (Extra && *Extra == 0) {
break;
}
}
errorout:
if (pData) {
CcUnpinData(Bcb);
}
return Status;
}
NTSTATUS
Ext2ExpandLast(
IN PEXT2_IRP_CONTEXT IrpContext,
IN PEXT2_VCB Vcb,
IN PEXT2_MCB Mcb,
IN ULONG Base,
IN ULONG Layer,
IN PULONG * Data,
IN PULONG Hint,
IN PULONG Block,
IN OUT PULONG Number
)
{
PULONG pData = NULL;
ULONG i;
NTSTATUS Status = STATUS_SUCCESS;
if (Layer > 0 || IsMcbDirectory(Mcb)) {
/* allocate buffer for new block */
pData = (ULONG *) Ext2AllocatePool(
PagedPool,
BLOCK_SIZE,
EXT2_DATA_MAGIC
);
if (!pData) {
DEBUG(DL_ERR, ( "Ex2ExpandBlock: failed to allocate memory for Data.\n"));
Status = STATUS_INSUFFICIENT_RESOURCES;
goto errorout;
}
RtlZeroMemory(pData, BLOCK_SIZE);
INC_MEM_COUNT(PS_BLOCK_DATA, pData, BLOCK_SIZE);
}
/* allocate block from disk */
Status = Ext2NewBlock(
IrpContext,
Vcb,
(Mcb->Inode.i_ino - 1) / BLOCKS_PER_GROUP,
*Hint,
Block,
Number
);
if (!NT_SUCCESS(Status)) {
goto errorout;
}
/* increase inode i_blocks */
Mcb->Inode.i_blocks += (*Number << (BLOCK_BITS - 9));
if (Layer == 0) {
if (IsMcbDirectory(Mcb)) {
/* for directory we need initialize it's entry structure */
PEXT2_DIR_ENTRY2 pEntry;
pEntry = (PEXT2_DIR_ENTRY2) pData;
pEntry->rec_len = (USHORT)(BLOCK_SIZE);
ASSERT(*Number == 1);
Ext2SaveBlock(IrpContext, Vcb, *Block, (PVOID)pData);
}
/* add new Extent into Mcb */
if (!Ext2AddBlockExtent(Vcb, Mcb, Base, (*Block), *Number)) {
DbgBreak();
ClearFlag(Mcb->Flags, MCB_ZONE_INITED);
Ext2ClearAllExtents(&Mcb->Extents);
}
} else {
/* zero the content of all meta blocks */
for (i = 0; i < *Number; i++) {
Ext2SaveBlock(IrpContext, Vcb, *Block + i, (PVOID)pData);
/* add block to meta extents */
if (!Ext2AddMcbMetaExts(Vcb, Mcb, *Block + i, 1)) {
DbgBreak();
Ext2Sleep(500);
Ext2AddMcbMetaExts(Vcb, Mcb, *Block + i, 1);
}
}
}
errorout:
if (NT_SUCCESS(Status)) {
*Hint = *Block + *Number;
if (Data) {
*Data = pData;
ASSERT(*Number == 1);
} else {
if (pData) {
Ext2FreePool(pData, EXT2_DATA_MAGIC);
DEC_MEM_COUNT(PS_BLOCK_DATA, pData, BLOCK_SIZE);
}
}
} else {
if (pData) {
Ext2FreePool(pData, EXT2_DATA_MAGIC);
DEC_MEM_COUNT(PS_BLOCK_DATA, pData, BLOCK_SIZE);
}
if (*Block) {
Ext2FreeBlock(IrpContext, Vcb, *Block, *Number);
Mcb->Inode.i_blocks -= (*Number << (BLOCK_BITS - 9));
*Block = 0;
}
}
return Status;
}
NTSTATUS
Ext2ExpandBlock(
IN PEXT2_IRP_CONTEXT IrpContext,
IN PEXT2_VCB Vcb,
IN PEXT2_MCB Mcb,
IN ULONG Base,
IN ULONG Layer,
IN ULONG Start,
IN ULONG SizeArray,
IN PULONG BlockArray,
IN PULONG Hint,
IN PULONG Extra
)
{
ULONG i = 0;
ULONG j;
ULONG Slot;
ULONG Block = 0;
LARGE_INTEGER Offset;
PBCB Bcb = NULL;
PULONG pData = NULL;
ULONG Skip = 0;
ULONG Number;
ULONG Wanted;
NTSTATUS Status = STATUS_SUCCESS;
if (Layer == 1) {
/*
* try to make all leaf block continuous to avoid fragments
*/
Number = min(SizeArray, ((*Extra + (Start & (BLOCK_SIZE/4 - 1))) * 4 / BLOCK_SIZE));
Wanted = 0;
DEBUG(DL_BLK, ("Ext2ExpandBlock: SizeArray=%xh Extra=%xh Start=%xh %xh\n",
SizeArray, *Extra, Start, Number ));
for (i=0; i < Number; i++) {
if (BlockArray[i] == 0) {
Wanted += 1;
}
}
i = 0;
while (Wanted > 0) {
Number = Wanted;
Status = Ext2ExpandLast(
IrpContext,
Vcb,
Mcb,
Base,
Layer,
NULL,
Hint,
&Block,
&Number
);
if (!NT_SUCCESS(Status)) {
goto errorout;
}
ASSERT(Number > 0);
Wanted -= Number;
while (Number) {
if (BlockArray[i] == 0) {
BlockArray[i] = Block++;
Number--;
}
i++;
}
}
} else if (Layer == 0) {
/*
* bulk allocation for inode data blocks
*/
i = 0;
while (*Extra && i < SizeArray) {
Wanted = 0;
Number = 1;
for (j = i; j < SizeArray && j < i + *Extra; j++) {
if (BlockArray[j] >= TOTAL_BLOCKS) {
DbgBreak();
BlockArray[j] = 0;
}
if (BlockArray[j] == 0) {
Wanted += 1;
} else {
break;
}
}
if (Wanted == 0) {
/* add block extent into Mcb */
ASSERT(BlockArray[i] != 0);
if (!Ext2AddBlockExtent(Vcb, Mcb, Base + i, BlockArray[i], 1)) {
DbgBreak();
ClearFlag(Mcb->Flags, MCB_ZONE_INITED);
Ext2ClearAllExtents(&Mcb->Extents);
}
} else {
Number = Wanted;
Status = Ext2ExpandLast(
IrpContext,
Vcb,
Mcb,
Base + i,
0,
NULL,
Hint,
&Block,
&Number
);
if (!NT_SUCCESS(Status)) {
goto errorout;
}
ASSERT(Number > 0);
for (j = 0; j < Number; j++) {
BlockArray[i + j] = Block++;
}
}
*Extra -= Number;
i += Number;
}
goto errorout;
}
/*
* only for meta blocks allocation
*/
for (i = 0; *Extra && i < SizeArray; i++) {
if (Layer <= 3) {
if (BlockArray[i] >= TOTAL_BLOCKS) {
DbgBreak();
BlockArray[i] = 0;
}
if (BlockArray[i] == 0) {
Number = 1;
Status = Ext2ExpandLast(
IrpContext,
Vcb,
Mcb,
Base,
Layer,
&pData,
Hint,
&BlockArray[i],
&Number
);
if (!NT_SUCCESS(Status)) {
goto errorout;
}
} else {
Offset.QuadPart = (((LONGLONG)BlockArray[i]) << BLOCK_BITS);
if (!CcPinRead(
Vcb->Volume,
&Offset,
BLOCK_SIZE,
PIN_WAIT,
&Bcb,
(void **)&pData )) {
DEBUG(DL_ERR, ( "Ext2ExpandInode: failed to PinLock offset :%I64xh...\n",
Offset.QuadPart));
Status = STATUS_CANT_WAIT;
DbgBreak();
goto errorout;
}
/* add block to meta extents */
if (!Ext2AddMcbMetaExts(Vcb, Mcb, BlockArray[i], 1)) {
DbgBreak();
Ext2Sleep(500);
Ext2AddMcbMetaExts(Vcb, Mcb, BlockArray[i], 1);
}
}
Skip = Vcb->max_blocks_per_layer[Layer] * i;
if (i == 0) {
if (Layer > 1) {
Slot = Start / Vcb->max_blocks_per_layer[Layer - 1];
Start = Start % Vcb->max_blocks_per_layer[Layer - 1];
Skip += Slot * Vcb->max_blocks_per_layer[Layer - 1];
} else {
Slot = Start;
Start = 0;
Skip += Slot;
}
} else {
Start = 0;
Slot = 0;
}
Status = Ext2ExpandBlock(
IrpContext,
Vcb,
Mcb,
Base + Skip,
Layer - 1,
Start,
BLOCK_SIZE/4 - Slot,
&pData[Slot],
Hint,
Extra
);
if (Bcb) {
CcSetDirtyPinnedData(Bcb, NULL);
if (!Ext2AddBlockExtent(Vcb, NULL,
BlockArray[i],
BlockArray[i], 1)) {
DbgBreak();
Ext2Sleep(500);
if (!Ext2AddBlockExtent(Vcb, NULL,
BlockArray[i],
BlockArray[i], 1)) {
}
}
} else {
Ext2SaveBlock(IrpContext, Vcb, BlockArray[i], (PVOID)pData);
}
if (pData) {
if (Bcb) {
CcUnpinData(Bcb);
Bcb = NULL;
} else {
Ext2FreePool(pData, EXT2_DATA_MAGIC);
DEC_MEM_COUNT(PS_BLOCK_DATA, pData, BLOCK_SIZE);
}
pData = NULL;
}
if (!NT_SUCCESS(Status)) {
DbgBreak();
break;
}
}
}
errorout:
return Status;
}
NTSTATUS
Ext2GetBlock(
IN PEXT2_IRP_CONTEXT IrpContext,
IN PEXT2_VCB Vcb,
IN PEXT2_MCB Mcb,
IN ULONG Base,
IN ULONG Layer,
IN ULONG Start,
IN ULONG SizeArray,
IN PULONG BlockArray,
IN BOOLEAN bAlloc,
IN OUT PULONG Hint,
OUT PULONG Block,
OUT PULONG Number
)
{
NTSTATUS Status = STATUS_SUCCESS;
PBCB Bcb = NULL;
PULONG pData = NULL;
ULONG Slot = 0, i = 0;
ULONG Unit = 1;
LARGE_INTEGER Offset;
if (Layer == 0) {
*Number = 1;
if (BlockArray[0] == 0 && bAlloc) {
/* now allocate new block */
Status = Ext2ExpandLast(
IrpContext,
Vcb,
Mcb,
Base,
Layer,
NULL,
Hint,
&BlockArray[0],
Number
);
if (!NT_SUCCESS(Status)) {
goto errorout;
}
} else {
/* check the block is valid or not */
if (BlockArray[0] >= TOTAL_BLOCKS) {
DbgBreak();
Status = STATUS_DISK_CORRUPT_ERROR;
goto errorout;
}
}
*Block = BlockArray[0];
for (i=1; i < SizeArray; i++) {
if (BlockArray[i] == BlockArray[i-1] + 1) {
*Number = *Number + 1;
} else {
break;
}
}
*Hint = BlockArray[*Number - 1];
} else if (Layer <= 3) {
/* check the block is valid or not */
if (BlockArray[0] == 0 || BlockArray[0] >= TOTAL_BLOCKS) {
DbgBreak();
Status = STATUS_DISK_CORRUPT_ERROR;
goto errorout;
}
/* add block to meta extents */
if (!Ext2AddMcbMetaExts(Vcb, Mcb, BlockArray[0], 1)) {
DbgBreak();
Ext2Sleep(500);
Ext2AddMcbMetaExts(Vcb, Mcb, BlockArray[0], 1);
}
/* map memory in cache for the index block */
Offset.QuadPart = ((LONGLONG)BlockArray[0]) << BLOCK_BITS;
if ( !CcPinRead( Vcb->Volume,
(PLARGE_INTEGER) (&Offset),
BLOCK_SIZE,
PIN_WAIT,
&Bcb,
(void **)&pData )) {
DEBUG(DL_ERR, ( "Ext2GetBlock: Failed to PinLock block: %xh ...\n",
BlockArray[0] ));
Status = STATUS_CANT_WAIT;
goto errorout;
}
if (Layer > 1) {
Unit = Vcb->max_blocks_per_layer[Layer - 1];
} else {
Unit = 1;
}
Slot = Start / Unit;
Start = Start % Unit;
if (pData[Slot] == 0) {
if (bAlloc) {
/* we need allocate new block and zero all data in case
it's an in-direct block. Index stores the new block no. */
ULONG Count = 1;
Status = Ext2ExpandLast(
IrpContext,
Vcb,
Mcb,
Base,
Layer,
NULL,
Hint,
&pData[Slot],
&Count
);
if (!NT_SUCCESS(Status)) {
goto errorout;
}
/* refresh hint block */
*Hint = pData[Slot];
/* set dirty bit to notify system to flush */
CcSetDirtyPinnedData(Bcb, NULL );
SetFlag(Vcb->Volume->Flags, FO_FILE_MODIFIED);
if (!Ext2AddVcbExtent(Vcb, Offset.QuadPart,
(LONGLONG)BLOCK_SIZE)) {
DbgBreak();
Ext2Sleep(100);
if (!Ext2AddVcbExtent(Vcb, Offset.QuadPart,
(LONGLONG)BLOCK_SIZE)) {
Status = STATUS_INSUFFICIENT_RESOURCES;
goto errorout;
}
}
/* save inode information here */
Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
} else {
*Number = 1;
if (Layer == 1) {
for (i = Slot + 1; i < BLOCK_SIZE/4; i++) {
if (pData[i] == 0) {
*Number = *Number + 1;
} else {
break;
}
}
} else if (Layer == 2) {
*Number = BLOCK_SIZE/4 - Start;
} else {
*Number = BLOCK_SIZE/4;
}
goto errorout;
}
}
/* transfer to next recursion call */
Status = Ext2GetBlock(
IrpContext,
Vcb,
Mcb,
Base,
Layer - 1,
Start,
BLOCK_SIZE/4 - Slot,
&pData[Slot],
bAlloc,
Hint,
Block,
Number
);
if (!NT_SUCCESS(Status)) {
goto errorout;
}
}
errorout:
/* free the memory of pData */
if (Bcb) {
CcUnpinData(Bcb);
}
if (!NT_SUCCESS(Status)) {
*Block = 0;
}
return Status;
}
