// =======================================================
void CXfsPart::readBitmap(COptions *options)
{
BEGIN;
int nRes;
DWORD i;
QWORD j;
xfs_agf agf;
// init bitmap -> all blocks marked as used (1)
m_bitmap.init(m_header.qwBitmapSize+1024);
for (j=0; j < m_header.qwBlocksCount; j++)
m_bitmap.setBit(j, true);
// ---- process allocation groups
// 1. go to the beginning of the disk
nRes = fseek(m_fDeviceFile, 0, SEEK_SET);
if (nRes == -1)
THROW(ERR_ERRNO, errno);
// 2. loop for each AG of the file system
for (i=0; i < m_info.dwAgCount; i++)
{
nRes = readData(&agf, convertAgToDaddr(i, XFS_AGF_DADDR), sizeof(xfs_agf));
if (nRes == -1)
THROW(ERR_ERRNO, errno);
if (((DWORD)BeToCpu(agf.agf_magicnum)) != XFS_AGF_MAGIC)
{
g_interface -> ErrorReadingSuperblock(errno);
THROW(ERR_READING, (DWORD)0, errno);
}
showDebug(3, "\n\n== ALLOCATION GROUP %lu ===\nagf_flfirst=%lu\nagf_fllast=%lu\nagf_flcount=%lu\nagf_freeblks=%lu\nagf_longest=%lu\n"
"agf_roots[0]=%lu and agf_roots[1]=%lu\nagf_levels[0]=%lu and agf_levels[1]=%lu\n", (DWORD)i,
(DWORD)BeToCpu(agf.agf_flfirst), (DWORD)BeToCpu(agf.agf_fllast),
(DWORD)BeToCpu(agf.agf_flcount), (DWORD)BeToCpu(agf.agf_freeblks),
(DWORD)BeToCpu(agf.agf_longest), (DWORD)BeToCpu(agf.agf_roots[0]),
(DWORD)BeToCpu(agf.agf_roots[1]), (DWORD)BeToCpu(agf.agf_levels[0]),
(DWORD)BeToCpu(agf.agf_levels[1]));
scanFreelist(&agf);
scanSbtree(&agf, BeToCpu(agf.agf_roots[XFS_BTNUM_BNO]), BeToCpu(agf.agf_levels[XFS_BTNUM_BNO]));
}
// fill informations about free/used clusters count
calculateSpaceFromBitmap();
RETURN;
}
// =======================================================
void CHfsPart::readBitmap(COptions *options)
{
BEGIN;
QWORD qwBlocksInRegularAlloc;
QWORD i, j, k;
BYTE *cTempData;
DWORD *dwTempData;
QWORD qwCurSector;
QWORD qwLastAllocSector;
DWORD dwBitmapData;
int nRes;
// init bitmap
const DWORD dwHighBit= 1<<31;
showDebug(10, "m_header.qwBitmapSize=%llu\n",m_header.qwBitmapSize);
m_bitmap.init(m_header.qwBitmapSize+1024);
// special sectors (begin and end of volume) are used
qwBlocksInRegularAlloc = m_info.dwBlocksPerAlloc * m_info.qwAllocCount;
qwLastAllocSector = m_info.qwFirstAllocBlock+qwBlocksInRegularAlloc;
for (i=0; i < m_info.qwFirstAllocBlock; i++)
{
showDebug(10, "Block [%llu] is special\n", i);
m_bitmap.setBit(i, true);
}
showDebug(10, "Blocks [%llu] and [%llu] are special\n", qwLastAllocSector, qwLastAllocSector+1);
m_bitmap.setBit(qwLastAllocSector, true); // alternate superblock
m_bitmap.setBit(qwLastAllocSector+1LL, true); // last volume of sector
// regular allocation blocks
cTempData = (BYTE*)malloc(m_header.qwBitmapSize+1024);
if (!cTempData)
THROW(ERR_NOMEM);
nRes = readData(cTempData, (QWORD)(3*512), m_header.qwBitmapSize+512);
if (nRes == -1)
{
showDebug(10, "ERROR 5\n");
g_interface -> ErrorReadingSuperblock(errno);
THROW(ERR_READING, (DWORD)0, errno);
}
dwTempData = (DWORD*)cTempData;
qwCurSector = m_info.qwFirstAllocBlock;
for (i=0; i < m_info.qwAllocCount; i+=32)
{
dwBitmapData = Be32ToCpu(*dwTempData);
dwTempData++;
for (j=0; j < 32; j++)
{
if (dwBitmapData & dwHighBit) // block is free
{
for (k=0; k < m_info.dwBlocksPerAlloc; k++, qwCurSector++)
{
if (qwCurSector < qwLastAllocSector)
{
m_bitmap.setBit(qwCurSector, true);
showDebug(10, "used -> %llu\n", qwCurSector);
}
}
}
else // block is used
{
for (k=0; k < m_info.dwBlocksPerAlloc; k++, qwCurSector++)
{
if (qwCurSector < qwLastAllocSector)
{
m_bitmap.setBit(qwCurSector, false);
showDebug(10, "free -> %llu\n", qwCurSector);
}
}
}
dwBitmapData<<=1;
}
}
free(cTempData);
calculateSpaceFromBitmap();
RETURN;
}
// =======================================================
void CExt2Part::readBitmap(COptions *options) // FULLY WORKING
{
BEGIN;
DWORD i, j;
CExt2GroupDesc *desc;
int nRes;
DWORD dwBlocksInThisGroup;
DWORD dwBootBlocks;
char *cTempBitmap;
DWORD dwBit, dwByte;
DWORD dwExt2DataBlock;
char *cPtr;
int group = 0;
// debug
DWORD dwUsed;
DWORD dwFree;
dwBootBlocks = m_info.dwFirstBlock / m_info.dwLogicalBlocksPerExt2Block;
//debugWin("dwBootBlocks=%lu and m_info.dwLogicalBlocksPerExt2Block=%lu",dwBootBlocks,m_info.dwLogicalBlocksPerExt2Block);
cTempBitmap = new char[((m_info.dwTotalBlocksCount+7)/8)+4096];
if (!cTempBitmap)
{
showDebug(1, "CExt2Part::readBitmap(): Error 001\n");
goto error_readBitmap;
}
// init bitmap size
nRes = m_bitmap.init(m_header.qwBitmapSize);
showDebug(1, "m_bitmap.init(m_header.qwBitmapSize = %lu)\n", m_header.qwBitmapSize);
if (nRes == -1)
{
showDebug(1, "CExt2Part::readBitmap(): Error 002\n");
goto error_readBitmap;
}
// load group descriptors
desc = new CExt2GroupDesc[m_info.dwGroupsCount+m_info.dwDescPerBlock];
showDebug(1, "dwGroupsCount = %lu, m_info.dwDescPerBlock = %lu\n",m_info.dwGroupsCount, m_info.dwDescPerBlock);
if (!desc)
{
showDebug(1, "CExt2Part::readBitmap(): Error 003\n");
goto error_readBitmap;
}
// for each descriptor BLOCK (not group descriptor!)
showDebug(1, "readData m_info.dwBlockSize = %lu\n", m_info.dwBlockSize);
for (cPtr=(char*)desc, i=0; i < m_info.dwDescBlocks; i++,cPtr+=m_info.dwBlockSize)
{
nRes = readData(cPtr, ((QWORD)m_info.dwBlockSize) * ((QWORD)(m_info.dwFirstBlock+1+i)), m_info.dwBlockSize);
if (nRes == -1)
{
showDebug(1, "CExt2Part::readBitmap(): Error 004\n");
goto error_readBitmap;
}
}
dwUsed=0;
dwFree=0;
showDebug(1, "m_info.dwBlocksPerGroup = %lu\n", m_info.dwBlocksPerGroup);
for (i = 0; i < m_info.dwGroupsCount; i++)
{
if (m_info.dwFirstBlock+((i+1)*m_info.dwBlocksPerGroup) > m_info.dwTotalBlocksCount)
dwBlocksInThisGroup = (m_info.dwTotalBlocksCount-m_info.dwFirstBlock) - (i*m_info.dwBlocksPerGroup);
else
dwBlocksInThisGroup = m_info.dwBlocksPerGroup;
if (Le32ToCpu(desc[i].bg_block_bitmap))
{
// -- read the bitmap block
errno = 0;
nRes = readData(cTempBitmap+(i*(m_info.dwBlocksPerGroup/8)), ((QWORD)m_info.dwBlockSize) *
((QWORD)Le32ToCpu(desc[i].bg_block_bitmap)), (m_info.dwBlocksPerGroup/8));
if (nRes == -1)
{
showDebug(1, "CExt2Part::readBitmap(): Error 005\n");
showDebug(1, "CExt2Part::readBitmap(): err=%d=%d\n", errno, strerror(errno));
goto error_readBitmap;
}
}
else
{
memset(cTempBitmap+(i*(m_info.dwBlocksPerGroup/8)), 0, (m_info.dwBlocksPerGroup/8));
}
}
// convert bitmap to little endian
DWORD *dwPtr;
DWORD dwLen;
dwLen = sizeof(cTempBitmap) / sizeof(DWORD);
dwPtr = (DWORD *)cTempBitmap;
for (i=0; i < dwLen; i++, dwPtr++)
*dwPtr = CpuToLe32(*dwPtr);
// bitmap is full of 0 at init, then we just have to
// write 1 for used blocks
// the boot block of 1024 bytes = used
for (i=0; i < dwBootBlocks; i++)
m_bitmap.setBit(i, true);
dwUsed=0; dwFree=0;
for (i=dwBootBlocks, dwExt2DataBlock=0; dwExt2DataBlock < ( m_info.dwTotalBlocksCount- m_info.dwFirstBlock); dwExt2DataBlock++)
{
dwBit = dwExt2DataBlock % 8;
dwByte = (dwExt2DataBlock - dwBit) / 8;
group = (dwExt2DataBlock/m_info.dwBlocksPerGroup);
if ((cTempBitmap[dwByte] & (1 << dwBit)) != 0)
{
for (j=0; j < m_info.dwLogicalBlocksPerExt2Block; j++, i++)
m_bitmap.setBit(i, true);
showDebug(3, "m_bitmap.setBit(%1u, true), g = %i\n", (i/4), group);
dwUsed++;
}
else
{
for (j=0; j < m_info.dwLogicalBlocksPerExt2Block; j++, i++)
m_bitmap.setBit(i, false);
showDebug(3, "m_bitmap.setBit(%1u, false), g = %i\n", (i/4), group);
dwFree++;
}
}
showDebug(1,"used=%lu\nfree=%lu\ntotal=%lu\n",dwUsed,dwFree,dwUsed+dwFree);
calculateSpaceFromBitmap();
//success_readBitmap:
delete []cTempBitmap;
showDebug(1, "end success\n");
RETURN; // auccess
error_readBitmap:
delete []cTempBitmap;
showDebug(1, "end error\n");
g_interface->msgBoxError(i18n("There was an error while reading the bitmap"));
THROW(ERR_READ_BITMAP);
}
// =======================================================
void CAfsPart::readBitmap(COptions *options)
{
BEGIN;
//DWORD i, j, k;
int nRes;
//char cBuffer[8192];
/* DWORD dwWordsPerBlock;
DWORD dwBlocksPerGroup;
QWORD qwCurBlock;
// init
dwWordsPerBlock = m_header.qwBlockSize/4;
qwCurBlock = 0LL;
dwBlocksPerGroup = m_info.dwBlockPerGroup / (m_header.qwBlockSize * 8); */
// init bitmap size
nRes = m_bitmap.init(m_header.qwBitmapSize);
if (nRes == -1)
goto error_readBitmap;
// init to false: because real code not implemented
//for (i=0; i < m_header.qwBlocksCount; i++)
// m_bitmap.setBit(i, true);
// ******************************************************************************
/*for (i=0; i < m_header.qwBlocksCount; ++i)
{
int nGroup = nBlock / psVolume->av_psSuperBlock->as_nBlockPerGroup;
int nStart = nBlock % psVolume->av_psSuperBlock->as_nBlockPerGroup;
bool bFree;
panBlock = afs_alloc_block_buffer( psVolume );
if ( panBlock == NULL ) {
printk( "Error: afs_is_block_free() no memory for bitmap block\n" );
return( false );
}
if ( afs_logged_read( psVolume, panBlock, psVolume->av_nBitmapStart + nGroup ) < 0 ) {
printk( "Panic: afs_is_block_free() failed to load bitmap block\n" );
return( false );
}
if ( panBlock[ nStart / 32 ] & (1 << (nStart % 32)) ) {
bFree = false;
} else {
bFree = true;
}
}*/
// ******************************************************************************
/*for ( i = 0 ; i < m_info.dwAllocGroupCount * dwBlocksPerGroup ; ++i )
{
nRes = readData(cBuffer, (m_info.qwBitmapStart+i)*m_header.qwBlockSize, m_header.qwBlockSize);
memcpy(m_bitmap.data()+(i*m_header.qwBlockSize), cBuffer, m_header.qwBlockSize);
for ( j = 0 ; j < dwWordsPerBlock ; ++j )
{
for ( k = 0 ; k < 32 ; ++k )
{
if ( (cBuffer[j] & (1L << k)) != 0 )
{
//nCount++;
m_bitmap.setBit(qwCurBlock++, true);
}
else
m_bitmap.setBit(qwCurBlock++, false);
}
}
}*/
// ******************************************************************************
nRes = readData(m_bitmap.data(), m_info.qwBitmapStart, m_header.qwBitmapSize);
if (nRes == -1)
goto error_readBitmap;
calculateSpaceFromBitmap();
showDebug(1, "end success\n");
RETURN; // auccess
error_readBitmap:
showDebug(1, "end error\n");
g_interface->msgBoxError(i18n("There was an error while reading the bitmap"));
THROW(ERR_READ_BITMAP);
}
