filehdr.cc

来自「操作系统课程设计。在UNIX平台下实现Solary操作系统的一些功能」· CC 代码 · 共 792 行 · 第 1/2 页

				tmp += writeSize;
			}//end for(int...)

			int firstAddrsSlot = zMap->Find();
			synchDisk->s_WriteDataInSector(firstAddrsSlot, 0, 128, (char*)firstAddrs);
			s_dataSectors[3] = firstAddrsSlot;
			if (leftSize > 0)
				second = 1;
		}//end if (direct == 1)
		///
		///begin to write data in first indirect index
		///
		else
		{
			int firstAddrSlot;	
			int firstLastSlot = (numBytes - maxDirect*128) / 128;

			if (lastOffset == 0 && firstLastSlot == 0)
			{
				int firstAddr = zMap->Find();
				s_dataSectors[3] = firstAddr;
				firstLastSlot = 0;
			}//end if (lastOffset != 0)
			else
			{
				firstAddrSlot = s_dataSectors[3];
				synchDisk->s_ReadDataInSector(firstAddrSlot, 0, 128, (char*)firstAddrs);
			}//end if (lastOffset != 0) else
			
			if (lastOffset != 0 &&
				second == 0)
			{
				int leftInOneSlot = 128 - lastOffset;
				int writeSector = s_dataSectors[firstLastSlot];

				synchDisk->s_WriteDataInSector(writeSector, lastOffset,
												leftInOneSlot, tmp);
				tmp += leftInOneSlot;
				leftSize -= leftInOneSlot;	
				firstLastSlot += 1;
			}//end if (lastOffset!=0)

			for (int i = firstLastSlot; 
				i < 32 && leftSize > 0; 
				i++, leftSize-=128)
			{
				int writeSlot = zMap->Find();	
				int writeSize = 128;
				if (leftSize < 128)
					writeSize = leftSize;
				
				firstAddrs[i] = writeSlot;
				synchDisk->s_WriteDataInSector(writeSlot, 0, writeSize, tmp);
				tmp += writeSize;
			}//end for (int i ...)

			synchDisk->s_WriteDataInSector(s_dataSectors[3], 0, 128, (char*)firstAddrs);
		
			///
			///determine whether to use second indirect index
			///
			if (leftSize > 0)
				second = 1;
		}//end if (direct == 1) else
	}//end if (first == 1)

///
///second indirect index
///
	if (second == 1)
	{
		if (first == 1)
		{
			int secondAddrs[32];
			int secondMidAddrs[32];
			for (int j = 0;
				j < 32 && leftSize > 0;
				j++)
			{
			for (int i = 0; 
				i < 32 && leftSize > 0; 
				i++, leftSize-=128)
			{
				int writeSlot = zMap->Find();	
				int writeSize = 128;
				if (leftSize < 128)
					writeSize = leftSize;
				
				secondAddrs[i] = writeSlot;
				synchDisk->s_WriteDataInSector(writeSlot, 0, writeSize, tmp);
				tmp += writeSize;
			}//for (int i...)
			int midSlot = zMap->Find();
			secondMidAddrs[j] = midSlot;
			synchDisk->s_WriteDataInSector(midSlot, 0, 128, (char*)secondAddrs);
			}//for (int j...)

			int secondAddr = zMap->Find();
			s_dataSectors[4] = secondAddr;
			synchDisk->s_WriteDataInSector(secondAddr, 0, 128, (char*)secondMidAddrs);
			if (leftSize > 0)
				third = 1;
		}//end if (first == 1)
		else
		{
			int secondAddrs[32];
			int secondMidAddrs[32];

			int lastMid = (leftSize / 128 - maxFirst)/32;
			int lastOffsetSlot = (leftSize / 128 - maxFirst)%32;

			synchDisk->s_ReadDataInSector(s_dataSectors[4], 0, 128, (char*)secondMidAddrs);
			
			for (int j = lastMid;
				j < 32 && leftSize > 0;
				j++)
			{
			synchDisk->s_ReadDataInSector(secondMidAddrs[j], 0, 128, (char*)secondAddrs);
			if (lastOffset != 0 &&
				j == lastMid)
			{
				int leftInOneSlot = 128 - lastOffset;
				int writeSector = secondAddrs[lastOffsetSlot];

				synchDisk->s_WriteDataInSector(writeSector, lastOffset,
												leftInOneSlot, tmp);
				tmp += leftInOneSlot;
				leftSize -= leftInOneSlot;	
				lastOffsetSlot += 1;
			}//end if (lastOffset!=0)

			for (int i = 0; 
				i < 32 && leftSize > 0; 
				i++, leftSize-=128)
			{
				int writeSlot = zMap->Find();	
				int writeSize = 128;
				if (leftSize < 128)
					writeSize = leftSize;
				
				secondAddrs[i] = writeSlot;
				synchDisk->s_WriteDataInSector(writeSlot, 0, writeSize, tmp);
				tmp += writeSize;
			}//for (int i...)
			if (j != lastMid)
			{
			int midSlot = zMap->Find();
			secondMidAddrs[j] = midSlot;
			synchDisk->s_WriteDataInSector(midSlot, 0, 128, (char*)secondAddrs);
			}//end if (j != lastMid)
			}//for (int j...)

			synchDisk->s_WriteDataInSector(s_dataSectors[4], 0, 128, (char*)secondMidAddrs);
			
			///
			///determine whether to use third indirect index
			///
			if (leftSize > 0)
				third = 1;
		}//end if (first == 1) else
	}//end if (second == 1) 

///
/// third indirect index
///
	if (third == 1)
	{
		if (second == 1)
		{
			int thirdAddrs[32];
			int thirdFirstMidAddrs[32];
			int thirdSecMidAddrs[32];

			for (int k = 0;
				k < 32 && leftSize > 0;
				k++)
			{
			for (int j = 0;
				j < 32 && leftSize > 0;
				j++)
			{
			for (int i = 0; 
				i < 32 && leftSize > 0; 
				i++, leftSize-=128)
			{
				int writeSlot = zMap->Find();	
				int writeSize = 128;
				if (leftSize < 128)
					writeSize = leftSize;
				
				thirdAddrs[i] = writeSlot;
				synchDisk->s_WriteDataInSector(writeSlot, 0, writeSize, tmp);
				tmp += writeSize;
			}//for (int i...)
			int midSlot = zMap->Find();
			thirdSecMidAddrs[j] = midSlot;
			synchDisk->s_WriteDataInSector(midSlot, 0, 128, (char*)thirdAddrs);
			}//for (int j...)
			int secMidSlot = zMap->Find();
			thirdFirstMidAddrs[k] = secMidSlot;
			synchDisk->s_WriteDataInSector(secMidSlot, 0, 128, (char*)thirdSecMidAddrs);
			}//for (int k...)

			int thirdAddr = zMap->Find();
			s_dataSectors[5] = thirdAddr;
			synchDisk->s_WriteDataInSector(thirdAddr, 0, 128, (char*)thirdFirstMidAddrs);
			if (leftSize > 0)
				third = 1;
		}//end if (second == 1)
		else
		{
			int thirdFirstMidAddrs[32];
			synchDisk->s_ReadDataInSector(s_dataSectors[5], 0, 128, (char*)thirdFirstMidAddrs);

			int lastFirstMid = (leftSize / 128 - maxSecond) / 32 / 32;

			for (int k = lastFirstMid;
				k < 32 && leftSize > 0;
				k++)
			{
			int thirdAddrs[32];
			int thirdSecMidAddrs[32];

			synchDisk->s_ReadDataInSector(thirdFirstMidAddrs[k], 0, 128, (char*)thirdSecMidAddrs);

			int lastSecMid = (leftSize / 128 - maxSecond) / 32 % 32;

			for (int j = lastSecMid;
				j < 32 && leftSize > 0;
				j++)
			{

			synchDisk->s_ReadDataInSector(thirdSecMidAddrs[lastSecMid], 0, 128, (char*)thirdAddrs);

			int lastOffsetSlot = (leftSize / 128 - maxSecond) % 32;
			if (lastOffset != 0 &&
				j == lastSecMid)
			{
				int leftInOneSlot = 128 - lastOffset;
				int writeSector = thirdAddrs[lastOffsetSlot];

				synchDisk->s_WriteDataInSector(writeSector, lastOffset,
												leftInOneSlot, tmp);
				tmp += leftInOneSlot;
				leftSize -= leftInOneSlot;	
				lastOffsetSlot += 1;
			}//end if (lastOffset!=0)

			for (int i = 0; 
				i < 32 && leftSize > 0; 
				i++, leftSize-=128)
			{
				int writeSlot = zMap->Find();	
				int writeSize = 128;
				if (leftSize < 128)
					writeSize = leftSize;
				
				thirdAddrs[i] = writeSlot;
				synchDisk->s_WriteDataInSector(writeSlot, 0, writeSize, tmp);
				tmp += writeSize;
			}//end for (int i
			int midSlot = zMap->Find();
			thirdSecMidAddrs[j] = midSlot;
			synchDisk->s_WriteDataInSector(midSlot, 0, 128, (char*)thirdAddrs);
			}//end for (int j...)
			int secMidSlot = zMap->Find();
			thirdFirstMidAddrs[k] = secMidSlot;
			synchDisk->s_WriteDataInSector(secMidSlot, 0, 128, (char*)thirdSecMidAddrs);
			}//end for (int k...)

			synchDisk->s_WriteDataInSector(s_dataSectors[5], 0, 128, (char*)thirdFirstMidAddrs);
		}//end if (second == 1) else	
	}//end if (third==1)	

	numBytes += size;
}


//////////////////////////////////////////////////////
// Function name	: FileHeader::s_DeAllocate
// Creator			: Fang Wenbin(0410706)
// CreateTime		: 2007-1-9 21:45:04
//
// Function Desc    : deallocate the blocks file covers
// 	The steps of FileHeader::s_DeAllocate
//
//	Fails if:
//
// Note				:
// Return type		: void 
// Argument         : s_Bitmap *zMap
//////////////////////////////////////////////////////
void FileHeader::s_DeAllocate(s_Bitmap *zMap)
{
	char direct = 0;
	char first = 0;
	char second = 0;
	char third = 0;
	
	int lastSlot = numBytes / 128;
	int lastOffset = numBytes % 128;

	int maxDirect = 3;
	int maxFirst = maxDirect + 32;
	int maxSecond = maxFirst + 32*32;
	int maxThird = maxSecond + 32*32*32;
	
	if (lastSlot < maxDirect)
		direct = 1;
	else if (lastSlot < maxFirst)
		direct = first = 1;
	else if (lastSlot < maxSecond)
		direct = first = second = 1;
	else if (lastSlot < maxThird)
		direct = first = second = third = 1;
	else 
		;

	int leftSize = numBytes;

///
///direct index
///
	if (direct == 1)
	{
		for (int i = 0; i < 3 && leftSize > 0; i++, leftSize -= 128)
		{
			zMap->Clear(s_dataSectors[i]);
		}//end for (int i...)	
	}//end if (direct == 1)

///
///first indirect index
///
	if (first == 1)
	{
		int firstAddrs[32];
		synchDisk->s_ReadDataInSector(s_dataSectors[3], 0, 128, (char*)firstAddrs);
		for (int j = 0; j < 32 && leftSize > 0; j++, leftSize -= 128)
		{
			int slot = firstAddrs[j];
			zMap->Clear(slot);
		}//end for (int j...)
		zMap->Clear(s_dataSectors[3]);
	}//end if (first==1)

///
///second indirect index
///
	if (second == 1)
	{
		int secondAddrs[32];
		int secondMidAddrs[32];
		
		synchDisk->ReadSector(s_dataSectors[4], (char*)secondMidAddrs);
		for (int j = 0; j < 32 && leftSize > 0; j++)
		{
			synchDisk->ReadSector(secondMidAddrs[j], (char*)secondAddrs);
			for (int i = 0; i < 32 && leftSize > 0; i++, leftSize-=128)
			{
				zMap->Clear(secondAddrs[i]);
			}//end for (int i...)
			zMap->Clear(secondMidAddrs[j]);
		}//end for (int j...)
		zMap->Clear(s_dataSectors[4]);
	}//end if (second==1)

///
///third indirect index
///
	if (third == 1)
	{
		int thirdAddrs[32];
		int thirdFirstMidAddrs[32];
		int thirdSecondMidAddrs[32];

		synchDisk->ReadSector(s_dataSectors[5], (char*)thirdFirstMidAddrs);
		for (int k = 0; k < 32 && leftSize > 0; k++)
		{
			synchDisk->ReadSector(thirdFirstMidAddrs[k], (char*)thirdSecondMidAddrs);
			for (int j = 0; j < 32 && leftSize > 0; j++)
			{
				synchDisk->ReadSector(thirdSecondMidAddrs[j], (char*)thirdAddrs);
				for (int i = 0; i < 32 && leftSize > 0; i++, leftSize-=128)
				{
					zMap->Clear(thirdAddrs[i]);
				}//end for (int i...)
				
				zMap->Clear(thirdSecondMidAddrs[j]);
			}//end for (int j...)
			zMap->Clear(thirdFirstMidAddrs[k]);
		}//end for (int k...)
		zMap->Clear(s_dataSectors[5]);
	}//if (third==1)
}