rw.c

来自「参照MINIX3写的操作系统 用GCC+NASM+BOCHS开发」· C语言 代码 · 共 687 行 · 第 1/2 页

	pInode->FileSize+=1024;/
	/*else ((12+256)<=FileBlockSize<(12+256+256*256)//二次间接块
	{
		if(Inode->Block[13]==0)//二次间接块指针为空
		{	
			//申请新块,作为二次间接块
			NewBlock2=OldMallocPhysicalBlock(LPInode pInode);
            //取得该块
			pBuffer=GetPhysicalBlock(NewBlock ,Device);
			Data=pBuffer->Data;
			//清零
			MemorySet((void *)Data,0,1024);
           	//申请新块,作为一次间接块
			NewBlock1=OldMallocPhysicalBlock(LPInode pInode);
            //取得该块
			pBuffer=GetPhysicalBlock(NewBlock ,Device);
			Data=pBuffer->Data;
			//清零
			MemorySet((void *)Data,0,1024);
            //将一次间接块写入二次块间接块
			SetAddressToIndirectBlock(Device,NewBlock2,0,NewBlock1)
			//将PhysicalBlock写入一次块
			SetAddressToIndirectBlock(Device,NewBlock1,0,NewBlock1)
		}
		else //二次间接块存在
		{
	    	if((FileBlockSize-12-256)/256==0)//一次间接块指针为空
			{  
				//申请新块,作为一次间接块
				NewBlock1=OldMallocPhysicalBlock(LPInode pInode);
				//取得该块
				pBuffer=GetPhysicalBlock(NewBlock ,Device);
				Data=pBuffer->Data;
				//清零
				MemorySet((void *)Data,0,1024);
				//将一次间接块写入二次块间接块
				SetAddressToIndirectBlock(Device,Inode->Block[13],0,NewBlock1);

			}
			else//一次间接块存在
			{
				
				//计算一次块在二次块中的位置
				NewBlock1=(FileBlockSize-12-256)/256;
				NewBlock1=GetAddressFromIndirectBlock(Device,Inode->Block[13],NewBlock1);
				//计算新的PhysicalBlock在一次间接块中的位置
				NewBlock=(FileBlockSize-12-256)%256;
            	//将PhysicalBlock写入一次块
		    	SetAddressToIndirectBlock(Device,NewBlock1,NewBlock,PhysicalBlock);
				
			}
		}

	}
	else if (12+256+256*256)<=FileBlockSize<(12+256+256*256+256*256*256)//三次块
	{
        if(Inode->Block[14]==0)//三次间接块指针为空
		{
			//申请新块,作为三次间接块
			NewBlock3=OldMallocPhysicalBlock(LPInode pInode);
            //取得该块
			pBuffer=GetPhysicalBlock(NewBlock3 ,Device);
			Data=pBuffer->Data;
			//清零
			memset((void *)Data,1024,0);
           	//申请新块,作为二次间接块
			NewBlock2=OldMallocPhysicalBlock(LPInode pInode);
            //取得该块
			pBuffer=GetPhysicalBlock(NewBlock3 ,Device);
			Data=pBuffer->Data;
			//清零
			memset((void *)Data,1024,0);
            //申请新块,作为一次间接块
			NewBlock1=OldMallocPhysicalBlock(LPInode pInode);
            //取得该块
			pBuffer=GetPhysicalBlock(NewBlock1 ,Device);
			Data=pBuffer->Data;
			//清零
			memset((void *)Data,1024,0);
            //将二次间接块写入三次块间接块
			SetAddressToIndirectBlock(Device,NewBlock3,0,NewBlock2);
            //将一次间接块写入二次块间接块
			SetAddressToIndirectBlock(Device,NewBlock2,0,NewBlock1);
			//将PhysicalBlock写入一次块
			SetAddressToIndirectBlock(Device,NewBlock2,0,PhysicalBlock);

		}
		else//三次间接块存在
		{
			if((FileBlockSize-12-256-256*256)/(256*256)==0)//二次间接块指针为空
			{  
				//申请新块,作为二次间接块
				NewBlock2=OldMallocPhysicalBlock(LPInode pInode);
				//取得该块
				pBuffer=GetPhysicalBlock(NewBlock3 ,Device);
				Data=pBuffer->Data;
				//清零
				memset((void *)Data,1024,0);
               //申请新块,作为一次间接块
				NewBlock1=OldMallocPhysicalBlock(LPInode pInode);
				//取得该块
				pBuffer=GetPhysicalBlock(NewBlock1 ,Device);
				Data=pBuffer->Data;
				//清零
				memset((void *)Data,1024,0);
				//计算二次间接块在三次间接块中的位置
				NumberInOneBlock=(FileBlockSize-12-256-256*256)%256;
				SetAddressToIndirectBlock(Device,Inode->Block[14],NumberInOneBlock,NewBlock2);
				 //将一次间接块写入二次块间接块
				SetAddressToIndirectBlock(Device,NumberInOneBlock,0,NewBlock1);
				//将PhysicalBlock写入一次块
				SetAddressToIndirectBlock(Device,NewBlock2,0,PhysicalBlock);
			}
			else//二次间接块存在
			{	
				if((FileBlockSize-12-256)/256==0)//一次间接块指针为空
				{  
				    
				//申请新块,作为一次间接块
				NewBlock1=OldMallocPhysicalBlock(LPInode pInode);
				//取得该块
				pBuffer=GetPhysicalBlock(NewBlock1 ,Device);
				Data=pBuffer->Data;
				//清零
				memset((void *)Data,1024,0);
				//计算一次间接块在二次次间接块中的位置
				NumberInOneBlock=(FileBlockSize-12-256-256*256)%(256*256);
				SetAddressToIndirectBlock(Device,Inode->Block[14],NumberInOneBlock,NewBlock2);
				
				}
			    else//一次间接块存在
				{
                	//将PhysicalBlock写入一次块
		        	WritePhysicalBlock
		 		
			   }	
			}
		}
			
	}*/
}
t_32 ReadFile(LPInode pInode,t_32 StartPosition,t_32 Count,t_8 Mode,t_32 Dest)
//
{
	  if(StartPosition+Count>pInode->FileSize)//要读入的数据大于文件
		  Count=pInode->FileSize-StartPosition;//截短
	  if(Count<=0)//小于零返回
		  return 0;
	  //FileBlock数组保存文件在数据内存区中块群的指针
	  t_32 FileBlock=StartPosition/1024;//要读取的文件块,由StartPosition计算第一块的位置
	  t_32 PhysicalBlock;//物理块
	  t_32 LoaclStart=(StartPosition+1)%1024-1;//一块内的开始位置
	  t_32 ReadSize=0; //ReadSize保存已经读取的数据量
	  LPBuffer pBuffer;//块缓冲区
	  char *Data;//数据块指针
	  t_32 i=0;
	  //将文件逻辑块号转换成物理块号
      PhysicalBlock=FileBlockToPhysicalBlock(pInode,FileBlock++,0);
	  //取得物理块
	  pBuffer=GetPhysicalBlock(PhysicalBlock,0);
	  Data=pBuffer->Data;
	  Data+=LoaclStart;//将指针移到要读的位置 
	  ReadSize+=1024-LoaclStart;//第一块要读入的数据量
	  if(ReadSize>=Count)//要读入的数据还不能填满一块
	  {
        
	    MemoryCopy((void *)Dest,(void *)Data,Count);
		ReadSize=Count;//读出的数据
	    return ReadSize;
        
	  }
	  else 
	  {
		//处理数据开始部分,内存区不满一块的情况
	    MemoryCopy((void *)Dest,(void *)Data,ReadSize);
        Dest+=ReadSize;
		Count-=ReadSize;
	
		//循环写入数据(一次一块)
		for(i=0;i<Count/1024;i++)
		{
			//将文件逻辑块号转换成物理块号
			PhysicalBlock=FileBlockToPhysicalBlock(pInode,FileBlock++,0);;
			 //取得物理块
			pBuffer=GetPhysicalBlock(PhysicalBlock,0);
			Data=pBuffer->Data;
      		MemoryCopy((void *)Dest,(void *)Data,1024);
			Dest+=1024;
			ReadSize+=1024;

		}
		if(ReadSize>=Count)//全部数据读入
			 return ReadSize;
		else//剩下还不满一块的数据
		{
		    //将文件逻辑块号转换成物理块号
			PhysicalBlock=FileBlockToPhysicalBlock(pInode,FileBlock++,0);;
			 //取得物理块
			pBuffer=GetPhysicalBlock(PhysicalBlock,0);
			Data=pBuffer->Data;
      		MemoryCopy((void *)Dest,(void *)Data,Count-ReadSize);
			Dest+=1024;
			ReadSize+=Count-ReadSize;
			return ReadSize;

		}
	}

}

t_32 WriteFile(LPSuper Super,LPInode pInode,t_32 Count,t_8 Mode,t_32 Dest)
//fd文件描述符,Count要写入的大小,Mode写入的模式,Dest要写入数据的内存区指针
//CURRENT从当前位置写入,BEGIN从文件开始位置写入,END从文件结束位置写入
{  
	//WriteSize保存已经写入的数据量
	t_32 WriteSize=0;
	t_32 Block;
	t_32 LoaclStart;
	t_32 PhysicalBlock;
	LPBuffer pBuffer;
	char *Data;
	t_32 i=0;
	if(pInode->FileSize==0)//空文件
	{
		//新分配物理块
		Block= NewMallocPhysicalBlock(Super,pInode,25); 
		//将物理块写入Inode
		PhysicalBlockToFileBlock(Super,pInode,Block,0);
		//当前块位置为零
		LoaclStart=0;
	}
	else if(pInode->FileSize%1024==0)//文件刚好满一块
	{
		//分配新的物理块位图
		Block=OldMallocPhysicalBlock(Super,pInode);
		//当前块位置为零
		LoaclStart=0;
		//将物理块写入Inode
		PhysicalBlockToFileBlock(Super,pInode,Block,0);
		
	}
	else
	{
		Block=FileBlockToPhysicalBlock(pInode,pInode->FileSize/1024,0);
		LoaclStart=pInode->FileSize%1024;
	}

	//LPInode pInode;	
	//根据文件的大小计和模式算出要写的第一块的块号FirstWriteBlock
	/*switch(Mode)
	{
	case CURRENT://从当前位置
		 Block=pInode->FileSize/1024
		 break;
	case BEGIN://从文件开始
		break;
	case END://从文件末尾
	
		break;
	default :break;

	}*/
	
	//将其读入
    //取得物理块
	printk("GetPhysicalBlock(Block,0) %d\n",Block);
	pBuffer=GetPhysicalBlock(Block,0);
	printk("pBuffer %x\n",pBuffer);
	Data=pBuffer->Data;
	
	Data+=LoaclStart; 
	WriteSize+=1024-LoaclStart;
	if(WriteSize>=Count)//要写入的数据还不能填满一块或刚满一块
	{
        
	    MemoryCopy((void *)Data,(void *)Dest,Count);

		pBuffer->Dirty=DIRTY;
		FreeBufferBlock(pBuffer);
		WriteSize=Count;//写入的字节
		
        
	}
	else 
	{
		//处理数据开始部分,内存区不满一块的情况
	    MemoryCopy((void *)Data,(void *)Dest,WriteSize);
		pBuffer->Dirty=DIRTY;
		FreeBufferBlock(pBuffer);
        Dest+=WriteSize;
		Count-=WriteSize;
	
		//循环写入数据
		for(i=0;i<Count/1024;i++)
		{
			//分配物理块位图
			PhysicalBlock=OldMallocPhysicalBlock(Super,pInode);
			//将物理块号写入Inode
			//将物理块号写入Inode后物理块就映射到对应的文件块
			PhysicalBlockToFileBlock(Super,pInode,PhysicalBlock,0);
			//取得对应的块PhysicalBlock(物理块)
			pBuffer=GetPhysicalBlock(PhysicalBlock ,0);
			Data=pBuffer->Data;
      		MemoryCopy((void *)Data,(void *)Dest,1024);
			pBuffer->Dirty=DIRTY;
			FreeBufferBlock(pBuffer);
			Dest+=1024;
			WriteSize+=1024;

		}
		
		
		if(WriteSize<Count)
		//剩下还不满一块的数据
		{
			//分配物理块位图
			PhysicalBlock=OldMallocPhysicalBlock(Super,pInode);
			//将物理块号写入Inode
			//将物理块号写入Inode后物理块就映射到对应的文件块
			PhysicalBlockToFileBlock(Super,pInode,PhysicalBlock,0);
			//取得对应的块PhysicalBlock(物理块)
			pBuffer=GetPhysicalBlock(PhysicalBlock ,0);
			Data=pBuffer->Data;
      		MemoryCopy((void *)Data,(void *)Dest,Count-WriteSize);
			pBuffer->Dirty=DIRTY;
			FreeBufferBlock(pBuffer);
			WriteSize+=Count-WriteSize;
		

		}
	}
			pInode->FileSize+=WriteSize;
			pInode->Blocks=pInode->FileSize/1024;
		
	          printk("pInode->FileSize %d\n",pInode->FileSize);
			  printk("pInode %d\n",pInode);
			return WriteSize;

}