namei.c~

模拟linux的ext3文件系统。采用位图法。用一个文件模拟硬盘。实现创建、删除目录、文件。读、写文件

#define MAIN
#include "structure.h"

u16 empty_dir_block(u16 block)
{
 u16 i;
 u8 buffer[512];
 struct ext2_dir_entry *de;
 if(!block) 
	 return 1;
 load_block_entry(buffer,block);
 for(i=0,de=(struct ext2_dir_entry *)buffer;i<DIR_ENTRIES_PER_BLOCK;i++,de++){
         if((de->d_inode)&&(strcmp(de->name,"."))&&(strcmp(de->name,"..")))   
		 return 0;
 }
 return 1;
}

int match(u16 len,u8 *name1,u8 *name2)
{
 int i;
 for(i=0;i<len;i++){
      if(name1[i]!=name2[i])   return 0;}
 return 1;
}

u16 search_name_block(u16 block, u8 *name,u16 *offset)
{
 u16 i,ret;
 u8 buffer[512];
 struct ext2_dir_entry *de;
 if(!block)
	 return 0;
 load_block_entry(buffer,block);
 for(i=0,de=(struct ext2_dir_entry *)buffer;i<DIR_ENTRIES_PER_BLOCK;i++,de++){
         if(match(strlen(name),name,(u8 *)&de->name)&&de->d_inode)   
		 break;
 }
 if(i==DIR_ENTRIES_PER_BLOCK){
         ret=0;
         *offset=0;
 }
 else{
         ret=block;
         *offset=((u8 *)de-buffer);
 }
 return ret;
}
u16 search_name_ind(u16 block,u8 *name,u16 *offset)
{
 u16 i,ret;
 u8 buffer[512];
 if(!block) return 0;
 load_block_entry(buffer,block);
 for(i=0;i<256;i++){
        if((ret=search_name_block(buffer[2*i]+buffer[2*i+1]*0x100,name,offset)));
                 break;
 }
 return ret;
}
u16 search_name_dind(u16 block,u8 *name,u16 *offset)
{
 u16 i,ret;
 u8 buffer[512];
 if(!block)  return 0;
 load_block_entry(buffer,block);
 for(i=0;i<256;i++){
         if((ret=search_name_ind(buffer[2*i]+buffer[2*i+1]*0x100,name,offset)));
 }
 return ret;
}
u16 search_name(struct ext2_inode *inode,u8 *name,u16 *offset)
{
 u16 block,i;
 block=0;
 for(i=0;i<6;i++){
          if((block=search_name_block(inode->i_block[i],name,offset)))
                 break;
 }
 if(!block)   block=search_name_ind(inode->i_block[6],name,offset);
 if(!block)   block=search_name_dind(inode->i_block[7],name,offset);
 return block;
}

//function search_entry();  search blank dir_entry;
u16 search_entry_block(u16 block,u16 *offset)
{
 u16 i,ret;
 u8 buffer[512];
 struct ext2_dir_entry *de;
 if(!block)
	 return 0;
 load_block_entry(buffer,block);
 for(i=0,de=(struct ext2_dir_entry *)buffer;i<DIR_ENTRIES_PER_BLOCK;i++,de++){
         if(!de->d_inode)   
		 break;
 }
 if(i==DIR_ENTRIES_PER_BLOCK){
         ret=0;
         *offset=0;
 }
 else{
         ret=block;
         *offset=((u8 *)de-buffer);
 }
 return ret;
}
u16 search_entry_ind(u16 block,u16 *offset)
{
 u16 i,ret;
 u8 buffer[512];
 if(!block) return 0;
 load_block_entry(buffer,block);
 for(i=0;i<256;i++){
        if((ret=search_entry_block(buffer[2*i]+buffer[2*i+1]*0x100,offset)));
                 break;
 }
 return ret;
}
u16 search_entry_dind(u16 block,u16 *offset)
{
 u16 i,ret;
 u8 buffer[512];
 if(!block)  return 0;
 load_block_entry(buffer,block);
 for(i=0;i<256;i++){
         if((ret=search_entry_ind(buffer[2*i]+buffer[2*i+1]*0x100,offset)));
 }
 return ret;
}
u16 search_entry(struct ext2_inode *inode,u16 *offset)
{
 u16 block,i;
 block=0;
 for(i=0;i<6;i++){
          if((block=search_entry_block(inode->i_block[i],offset)))
                 break;
 }
 if(!block)   block=search_entry_ind(inode->i_block[6],offset);
 if(!block)   block=search_entry_dind(inode->i_block[7],offset);
 return block;
}
u16 create_de_block(u16 *block,u8 *name)
{
 u16 i,newi;
 u8 buffer[512];
 struct ext2_dir_entry *de;
 if(!*(block)){
          *block=new_block();
 }
 load_block_entry(buffer,*block);
 for(i=0,de=(struct ext2_dir_entry *)buffer;i<DIR_ENTRIES_PER_BLOCK;i++,de++){
         if(!de->d_inode){
	         newi=new_inode();
	         de->d_inode=newi;
	         strcpy(de->name,name);	 
		 update_block_entry(buffer,*block);
       		 return newi;
	 }
 }
 return 0;
}
u16 create_de_ind(u16 *block,u8 *name)
{
 u16 i,newi;
 u8 buffer[512];
 if(!block){
	 *block=new_block();
 }
 load_block_entry(buffer,*block);
 for(i=0;i<256;i++){
        if((newi=create_de_block((u16 *)&buffer[2*i],name))){
                     update_block_entry(buffer,*block);
		     return newi ;
	}
 }
 return 0;
}
u16 create_de_dind(u16 *block,u8 *name)
{
 u16 i,newi;
 u8 buffer[512];
 if(!block){
	 *block=new_block();
 }
 load_block_entry(buffer,*block);
 for(i=0;i<256;i++){
         if((newi=create_de_ind( (u16 *)&buffer[2*i],name) )){
		 update_block_entry(buffer,*block);
		 return newi;
	 }
 }
 return 0;
}

u16 create_dir_entry(struct ext2_inode *inode,u8 *name)
{
 u16 i,block,inode_num,offset;
 u8 buffer[512];
 if((block=search_entry(inode,&offset))){
         inode_num=new_inode(); 
	 load_block_entry(buffer,block);
         buffer[offset]=inode_num%0x100;
         buffer[offset+1]=inode_num/0x100;
         buffer[offset+5]=tag;
         strcpy(&buffer[offset+6],name);
         update_block_entry(buffer,block);
	 return inode_num;
 }
 for(i=0;i<6;i++)
        if(create_de_block(&(inode->i_block[i]),name)){
                return 1;
	}
 if((create_de_ind(&(inode->i_block[6]),name)))  return 1;
 if((create_de_dind(&(inode->i_block[7]),name)))  return 1;
 return 0;
}


u16 empty_dir_ind(u16 block)
{
 u16 i,ret;
 u8 buffer[512];
 if(!block) return 1;
 load_block_entry(buffer,block);
 for(i=0;i<256;i++){
        if(!(ret=empty_dir_block(buffer[2*i]+buffer[2*i+1]*0x100)));
                 break;
 }
 return ret;
}
u16 empty_dir_dind(u16 block)
{
 u16 i,ret;
 u8 buffer[512];
 if(!block)  return 1;
 load_block_entry(buffer,block);
 for(i=0;i<256;i++){
         if(!(ret=empty_dir_ind(buffer[2*i]+buffer[2*i+1]*0x100)));
	         break;
 }
 return ret;
}
u16 empty_dir(struct ext2_inode *inode)
{
 u16 block,i;
 block=0;
 for(i=0;i<6;i++){
          if(!(block=empty_dir_block(inode->i_block[i])))
                 return 0;
 }
 if(block)   block=empty_dir_ind(inode->i_block[6]);
 if(block)   block=empty_dir_dind(inode->i_block[7]);
 return block;
}

u16 search_name_inode(u16 inode_num,u8 *name,u16 namelen,u16 *offset)
{
 struct ext2_inode inode;
 u16 block;
 u8 buffer[512];
 u8 thisname[128]={0,};
 strcpy(thisname,name);
 thisname[namelen]=0;
 load_inode_entry(&inode,inode_num);
 if(!(block=search_name(&inode,thisname,offset))) return 0;
 load_block_entry(buffer,block);
 return buffer[*offset]+buffer[*offset+1]*0x100;
}
u16 init_dir(struct ext2_inode *inode,u16 current,u16 parent)
{
 u8 buffer[512];
 u16 newb;
 if(!(newb=new_block())){
           printf("no data_block\n");
	   return 0;
 }
 inode->i_block[0]=newb;
 load_block_entry(buffer,newb);
 buffer[0]=current%0x100;
 buffer[1]=current/0x100;
 buffer[5]='2';
 strcpy(&buffer[6],".");
 buffer[32]=parent%0x100;
 buffer[32+1]=parent/0x100;
 buffer[32+5]='2';
 strcpy(&buffer[32+6],"..");
 update_block_entry(buffer,newb);
 return 1;
}
//function get_dir()

u16 get_dir(u8 *path)
{
 u8 ch;
 u16 inode_num;
 u8 *basename,*thisname;
 u16 namelen,offset;
 basename=path;
 if((ch=*path)=='/'){
	inode_num=ROOT_INO;
	path++;
 }
 else if(ch) inode_num=current_dir;
 else return 0;
 while(1){
	thisname=path;
	for(namelen=0;(ch=*path++)&&(ch!='/');namelen++){}
	if(!ch) {return inode_num;}
	if(!(inode_num=search_name_inode(inode_num,thisname,namelen,&offset)))
               return 0;
 }
}



void print_block(u16 block)
{
 u8 buffer[512];
 if(!block)  return;
 load_block_entry(buffer,block);
 printf("%s\n",buffer);
}
void print_ind(u16 block)
{
 u8 buffer[512];
 u16 i;
 if(!block)  return;
 load_block_entry(buffer,block);
 for(i=0;i<256;i++)
	 print_block(buffer[2*i]+buffer[2*i+1]*0x100);
}
void print_dind(u16 block)
{
 u8 buffer[512];
 u16 i;
 if(!block)  return;
 load_block_entry(buffer,block);
 for(i=0;i<256;i++)
	 print_ind(buffer[2*i]+buffer[2*i+1]*0x100);
}

void print(struct ext2_inode *inode)
{
 u16 i;
 for(i=0;i<6;i++)
       print_block(inode->i_block[i]);
 print_ind(inode->i_block[6]);
 print_dind(inode->i_block[7]);
}
void store_block(u16 *block,u8 *string,u16 *start,u16 *end)
{
 u8 buffer[512];
 if(*start>=*end)  return ;
 if(!(*block))  *block=new_block();
 load_block_entry(buffer,*block);
 strcpy(buffer,string+*start);
 update_block_entry(buffer,*block); 
 *start=*start+512;
}
void store_ind(u16 *block,u8 *string, u16 *start,u16 *end)
{
 u8 buffer[512];
 u16 i;
 u16 newb;
 if(*start>=*end)  return ;
 if(!(*block))  *block=new_block();
 load_block_entry(buffer,*block);
 for(i=0;i<256&&*start<=*end;i++){
         store_block(&newb,string,start,end);
    	 buffer[2*i]=newb/0x100;
         buffer[2*i+1]=newb%0x100;
 }
 update_block_entry(buffer,*block);
}
void store_dind(u16 *block,u8 *string,u16 *start,u16 *end)
{
 u8 buffer[512];
 u16 i;
 u16 newb;
 if(*start>=*end)  return ;
 if(!(*block))  *block=new_block();
 load_block_entry(buffer,*block);
 for(i=0;i<256&&*start<=*end;i++){
         store_ind(&newb,string,start,end);
    	 buffer[2*i]=newb/0x100;
         buffer[2*i+1]=newb%0x100;
 }
 update_block_entry(buffer,*block);
}
void store(struct ext2_inode *inode,u8 *string,u16 *start,u16 *end)
{
 u16 i;
 for(i=0;i<6;i++)
       store_block(&inode->i_block[i],string,start,end);
 store_ind(&inode->i_block[6],string,start,end);
 store_dind(&inode->i_block[7],string,start,end);
}

void free_ind(u16 block)
{
 u16 p,i;
 u8 buffer[512];
 if(!block)  return;
 load_block_entry(buffer,block);
 for(i=0;i<256;i++){
        p=buffer[2*i]+buffer[2*i+1]*0x100;
        if(p)  free_block(p);
 }
 free_block(block);
}
void free_dind(u16 block)
{
 u16 i;
 u16 p;
 u8 buffer[512];
 if(!block)  return;
 load_block_entry(buffer,block);
 for(i=0;i<256;i++){
        p=buffer[2*i]+buffer[2*i+1]*0x100;
        if(p)  free_ind(p);
 }
 free_block(block);
}

void free_blocks(struct ext2_inode  *inode)
{
 int i;
 for(i=0;i<6;i++){
    if(inode->i_block[i])  free_block(inode->i_block[i]);
    inode->i_block[i]=0;
 }
 free_ind(inode->i_block[6]);
 free_dind(inode->i_block[7]);
 inode->i_block[6]=0;
 inode->i_block[7]=0;
}