1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <ctype.h>  
  4. #include <string.h>  
  5. #include <time.h>  
  6.  
  7.  
  8. #define SYS_SIZE 0XFFFFF*100          
  9. #define BLOCK_SIZE 512                
  10.  
  11. FILE *f;  
  12.  
  13. struct filsys{                        
  14.     int s_nfree;                      
  15.     long s_free[100];                 
  16.     int s_ninode;                     
  17.     int s_inode[96];                  
  18.                                       
  19. }*p;  
  20.  
  21. struct index_block{                   
  22.     int s_nfree;  
  23.     long s_free[96];  
  24. }q;  
  25.  
  26. struct filelist{                      
  27.     char name[14];                    
  28.     int inode_num;                    
  29. }file;  
  30.  
  31. struct inode{                         
  32.     int i_size;                       
  33.     int block_amount;                 
  34.     long i_addr[16];                  
  35.     char create_time[25];             
  36. }inode;  
  37.  
  38. struct fcb{                           
  39.     char name[12];                    
  40.     int inode_num;                    
  41.     int used;                         
  42.     int i_size;                       
  43.     int block_amount;                 
  44.     long i_addr[16];                  
  45. }fcb[5],*ptr;  
  46.  
  47. struct open_file_table{               
  48.     int offset;                       
  49.     struct fcb* f_node;               
  50. }table[5];  
  51.  
  52. struct fd{                            
  53.     struct open_file_table* t_node;   
  54. }fd[5];  
  55.  
  56. FILE* apply_room(char *sys_name)      
  57. {    
  58.  f = fopen(sys_name,"w+b");       //创建一个新的可读写的二进制文件  
  59.     fseek(f,SYS_SIZE,SEEK_SET);       
  60.     fputc(EOF, f);                    
  61.     fclose(f);  
  62.     return fopen(sys_name,"r+b");     //打开一个可读写的二进制文件  
  63. }  
  64.  
  65. void myfree(long block_num)           
  66. {    
  67.  int i;  
  68.     if(p->s_nfree<100)                
  69.  {               
  70.        p->s_free[p->s_nfree]=block_num;  
  71.        p->s_nfree++;  
  72.     }  
  73.  else         
  74.  {                            
  75.        q.s_nfree=p->s_nfree;          
  76.        for(i=0;i<100;i++)  
  77.           q.s_free[i]=p->s_free[i];  
  78.        fseek(f,(block_num-1)*BLOCK_SIZE,SEEK_SET);  
  79.        fwrite(&q,sizeof(struct index_block),1,f);   
  80.        p->s_nfree=1;                  
  81.        p->s_free[0]=block_num;  
  82.     }  
  83. }  
  84.  
  85. long myalloc()        
  86. {                       
  87.     int i;  
  88.     long a;  
  89.     p->s_nfree--;  
  90.     if(p->s_nfree==0){                
  91.        a=p->s_free[0];  
  92.        fseek(f,(a-1)*BLOCK_SIZE,SEEK_SET);  
  93.        fread(&q,sizeof(struct index_block),1,f);  
  94.        p->s_nfree=q.s_nfree;          
  95.        for(i=0;i<100;i++)  
  96.           p->s_free[i]=q.s_free[i];  
  97.        return a;  
  98.     }else return p->s_free[p->s_nfree];  
  99. }  
  100.  
  101. void init()                           
  102. {    
  103.  int j;  
  104.     long i;  
  105.     p->s_nfree=1;  
  106.     p->s_free[0]=0;  
  107.     p->s_ninode=96;  
  108.     for(i=0;i<96;i++)  
  109.        p->s_inode[i]=-1;              
  110.     for(i=22;i<=SYS_SIZE/BLOCK_SIZE;i++)  
  111.        myfree(i);                     
  112.     j=p->s_nfree+1;  
  113.     while(j<100)  
  114.        p->s_free[j++]=0;              
  115.     fseek(f,0,SEEK_SET);  
  116.     fwrite(p,sizeof(struct filsys),1,f);  
  117. }  
  118.  
  119. int ialloc(){                         
  120.     int i=0;  
  121.     while(p->s_inode[i]>=0) i++;      
  122.     p->s_inode[i]=0;                  
  123.     p->s_ninode--;  
  124.     return i;  
  125. }  
  126.  
  127. int namei(char *name)               
  128. {    
  129.  int k=0;  
  130.     while(k<96){  
  131.        if(p->s_inode[k]!=-1){       
  132.           fseek(f,BLOCK_SIZE+k*16,SEEK_SET);  
  133.           fread(&file,sizeof(struct filelist),1,f);  
  134.           if(!strcmp(file.name,name))  
  135.              return file.inode_num;  
  136.        }  
  137.        k++;  
  138.     };  
  139.     return -1;                     
  140. }  
  141.  
  142. int name_i(char *name)             
  143. {    
  144.  int k=0;  
  145.     do 
  146.  {  
  147.        if(fcb[k].used==1)            
  148.     {        
  149.           if(!strcmp(fcb[k].name,name))   
  150.             return fcb[k].inode_num;  
  151.        }  
  152.        k++;  
  153.     }while(k<5);  
  154.     return -1;                     
  155. }  
  156.  
  157. void create()                      
  158. {    
  159.  int i,inode_num;  
  160.     long t;  
  161.     char name[12];  
  162.     printf("input file name:");  
  163.     scanf("%s",name);  
  164.     getchar();  
  165.     if(namei(name)!=-1) printf("file exited!\n");  
  166.     else 
  167.  {                             
  168.        inode_num=ialloc();        
  169.        strcpy(file.name,name);  
  170.        file.inode_num=inode_num;  
  171.        fseek(f,BLOCK_SIZE+inode_num*16,SEEK_SET);  
  172.        fwrite(&file,sizeof(struct filelist),1,f);  
  173.        inode.i_size=0;                       
  174.        inode.block_amount=0;  
  175.        for(i=0;i<16;i++) inode.i_addr[i]=0;  
  176.        time(&t);  
  177.        strcpy(inode.create_time,ctime(&t));  
  178.        fseek(f,4*BLOCK_SIZE+inode_num*sizeof(struct inode),SEEK_SET);  
  179.        fwrite(&inode,sizeof(struct inode),1,f);  
  180.        p->s_inode[inode_num]=0;      
  181.        printf("create sucessfully!\n");  
  182.     }  
  183. }  
  184.  
  185. void display()                 
  186. {    
  187.  int k;  
  188.     for(k=0;k<96;k++)  
  189.  {  
  190.        if(p->s_inode[k]>=0)    
  191.     {  
  192.           fseek(f,BLOCK_SIZE+k*16,SEEK_SET);  
  193.           fread(&file,sizeof(struct filelist),1,f);   
  194.           printf("%s     ",file.name);  
  195.           fseek(f,4*BLOCK_SIZE+file.inode_num*sizeof(struct inode),SEEK_SET);  
  196.           fread(&inode,sizeof(struct inode),1,f);    
  197.           printf("size:�     ",inode.i_size);  
  198.           printf("time:%s\n",inode.create_time);  
  199.        }  
  200.     };  
  201.     printf("\n");  
  202.     getchar();  
  203. }  
  204.  
  205. void open_file()                  
  206. {   int i=0,j=0,k=0;  
  207.     int m,n;  
  208.     char name[12];  
  209.     printf("input file's name:");  
  210.     scanf("%s",name);  
  211.     getchar();  
  212.     n=namei(name);               
  213.     if(n==-1) printf("file not exits!\n");  
  214.     else if(p->s_inode[n]>0) printf("file have already been opened!\n");  
  215.     else{  
  216.        while(fcb[i].used==1) i++;      
  217.        while(table[j].f_node) j++;     
  218.        while(fd[k].t_node) k++;        
  219.        fd[k].t_node=&table[j];         
  220.        table[j].f_node=&fcb[i];        
  221.        strcpy(fcb[i].name,name);  
  222.        fcb[i].inode_num=n;  
  223.        fcb[i].used=1;  
  224.        fseek(f,4*BLOCK_SIZE+n*sizeof(struct inode),SEEK_SET);  
  225.        fread(&inode,sizeof(struct inode),1,f);  
  226.        fcb[i].i_size=inode.i_size;  
  227.        fcb[i].block_amount=inode.block_amount;  
  228.        for(m=0;m<16;m++) fcb[i].i_addr[m]=inode.i_addr[m];  
  229.        p->s_inode[n]=k+100;            
  230.        printf("file is open!\n");  
  231.     }  
  232. }  
  233.  
  234. void write_file()              
  235. {    
  236.  int k,block_amount,n,size=0,i=0;  
  237.     long block_num;  
  238.     char ch,name[12];  
  239.     printf("input file's name:");  
  240.     scanf("%s",name);  
  241.     getchar();  
  242.     n=name_i(name);            
  243.     if(n==-1) printf("file not exits or not open!\n");  
  244.     else{  
  245.        k=p->s_inode[n]-100;    
  246.        ptr=fd[k].t_node->f_node;  
  247.        while(i<ptr->block_amount)  
  248.     {  
  249.           block_num=ptr->i_addr[i];  
  250.           myfree(block_num);  
  251.           i++;  
  252.        }  
  253.        block_amount=0;  
  254.        printf("input the context of the file:(end the file with '*')\n");  
  255.        while((ch=getchar())!='*'&&block_amount<16){  
  256.           size++;  
  257.           if(sizeQ2==1){            
  258.              block_num=myalloc();     
  259.              inode.i_addr[block_amount]=ptr->i_addr[block_amount]=block_num;  
  260.              block_amount++;  
  261.              fseek(f,(block_num-1)*BLOCK_SIZE,SEEK_SET);  
  262.           }  
  263.           fputc(ch,f);  
  264.        }  
  265.        getchar();  
  266.        inode.i_size=ptr->i_size=size;  
  267.        inode.block_amount=ptr->block_amount=block_amount;  
  268.        fseek(f,4*BLOCK_SIZE+n*sizeof(struct inode),SEEK_SET);  
  269.        fwrite(&inode,sizeof(struct inode),1,f);     
  270.     }  
  271. }  
  272.  
  273. void read_file()             
  274. {    
  275.  int k,n,block_amount,size;  
  276.     int i=0;  
  277.     long block_num;  
  278.     char name[12],buf[512];  
  279.     printf("input file's name:");  
  280.     scanf("%s",name);  
  281.     getchar();  
  282.     n=name_i(name);          
  283.     if(n==-1) printf("file not exits or not open!");  
  284.     else 
  285.  {  
  286.        k=p->s_inode[n]-100;  
  287.        ptr=fd[k].t_node->f_node;  
  288.        size=ptr->i_size;  
  289.        block_amount=ptr->block_amount;  
  290.        for(i=0;i<block_amount;i++)  
  291.     {  
  292.           block_num=ptr->i_addr[i];                      
  293.           fseek(f,(block_num-1)*BLOCK_SIZE,SEEK_SET);    
  294.           if(size>512) {fread(buf,sizeof(char),512,f);   size=size-512;}  
  295.           else 
  296.     {  
  297.              fread(buf,sizeof(char),size,f);     
  298.              buf[size]='\0';  
  299.           }  
  300.           printf("%s",buf);  
  301.        }  
  302.     }  
  303.     printf("\n");  
  304. }  
  305.  
  306. void del_file()               
  307. {   int n,i=0;  
  308.     long block_num;  
  309.     char name[12];  
  310.     printf("input file's name:");  
  311.     scanf("%s",name);  
  312.     getchar();  
  313.     n=namei(name);            
  314.     if(n==-1) printf("file not exits!\n");       
  315.     else if(p->s_inode[n]>0) printf("file is open now!Close it first\n");  
  316.     else{  
  317.        p->s_inode[n]=-1;      
  318.        fseek(f,4*BLOCK_SIZE+n*sizeof(struct inode),SEEK_SET);  
  319.        fread(&inode,sizeof(struct inode),1,f);    
  320.        while(i<inode.block_amount){  
  321.           block_num=inode.i_addr[i];  
  322.           myfree(block_num);       
  323.           i++;  
  324.        }  
  325.        strcpy(file.name,"");       
  326.        file.inode_num=0;  
  327.        fseek(f,BLOCK_SIZE+n*16,SEEK_SET);  
  328.        fwrite(&file,sizeof(struct filelist),1,f);  
  329.        printf("file is deleted\n");  
  330.     }  
  331. }  
  332.  
  333. void close_file()             
  334. {   int k,n;  
  335.     char name[12];  
  336.     printf("input file's name:");  
  337.     scanf("%s",name);  
  338.     getchar();  
  339.     n=name_i(name);           
  340.     if(n==-1) printf("file not exits or not open\n");  
  341.     else{  
  342.        k=p->s_inode[n]-100;    
  343.        fd[k].t_node->f_node->used=0;     
  344.        fd[k].t_node->f_node=NULL;        
  345.        fd[k].t_node=NULL;                
  346.        p->s_inode[n]=0;        
  347.        printf("file is closed!\n");  
  348.     }  
  349. }  
  350.  
  351. void myexit()              
  352. {   int i=0;  
  353.     char ch;  
  354.     while(fcb[i].used==0) i++;     
  355.     if(i<5){               
  356.        getchar();  
  357.        printf("some files are still open!!!\n");  
  358.        printf("input 'q' to quit or other key to return:\n");  
  359.        scanf("%c",&ch);  
  360.        if(ch=='q'){        
  361.           while(i<5){  
  362.              if(fcb[i].used==1) p->s_inode[fcb[i].inode_num]=0;  
  363.              i++;  
  364.           }  
  365.           fseek(f,0,SEEK_SET);  
  366.           fwrite(p,sizeof(struct filsys),1,f);  
  367.           exit(0);  
  368.        }  
  369.        getchar();  
  370.     }else{                 
  371.        fseek(f,0,SEEK_SET);  
  372.        fwrite(p,sizeof(struct filsys),1,f);  
  373.        exit(0);  
  374.     }  
  375. }  
  376.  
  377. void main()  
  378. {    
  379.  int i;  
  380.     char ch,sys_name[15];  
  381.     p=(struct filsys *)malloc(sizeof(struct filsys));    
  382.     while(1)  
  383.  {  
  384.        printf("1:Create a new file system\n");  
  385.        printf("2:open an existed file system\n");  
  386.        printf("choose:");  
  387.        if((ch=getchar())=='1')          
  388.     {         
  389.           printf("input file system's name:");  
  390.           scanf("%s",sys_name);  
  391.           getchar();  
  392.           f=apply_room(sys_name);       
  393.           init();                       
  394.           break;                       //这里的break用来跳出while(1)的循环  
  395.        }  
  396.     else if(ch=='2')        
  397.     {              
  398.           printf("input file system's name:");  
  399.           scanf("%s",sys_name);  
  400.           getchar();  
  401.           f=fopen(sys_name,"r+b");  
  402.           fseek(f,0,SEEK_SET);  
  403.           fread(p,sizeof(struct filsys),1,f);      
  404.           break;  
  405.        }  
  406.        else 
  407.     {  
  408.           printf("wrong input!\n");  
  409.           getchar();  
  410.        }  
  411.     };  
  412.     for(i=0;i<5;i++)                        
  413.  {              
  414.        fcb[i].used=0;  
  415.        table[i].f_node=NULL;  
  416.        fd[i].t_node=NULL;  
  417.     }  
  418.     while(1)  
  419.  {  
  420.        printf("--------------------------------------------------------------------\n");  
  421.        printf("1:create 2:open 3:write 4:read 5:close 6:delete 7:display 8:exit\n");  
  422.        printf("choose:");  
  423.        switch(getchar()-'0')      
  424.     {       
  425.     case 1:create();break;  
  426.     case 2:open_file();break;  
  427.     case 3:write_file();break;  
  428.     case 4:read_file();break;  
  429.     case 5:close_file();break;  
  430.     case 6:del_file();break;  
  431.     case 7:display();break;  
  432.     case 8:myexit();break;  
  433.     default:getchar(); printf("wrong input!\n"); break;  
  434.        }  
  435.     };  
  436.     free(p);  
  437.     fclose(f);  
  438. }  
  439.