// ======================================================= 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); }