开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
file.c
资源名称：os2.tar.gz　[点击查看]
上传用户：kin20054
上传日期：2022-06-28
资源大小：4k
文件大小：12k
源码类别：

操作系统开发

开发平台：

Unix_Linux

file.c：源码内容
  1. #include "file.h"
  2. #include "bitmap.h"
  3. int max(int a,int b)
  4. {
  5.   return a>b?a:b;
  6. }
  7. int add_item(const char* name,int inode_a)
  8. {
  9.   struct item temp;
  10.   memcpy(temp.name,name,4);
  11.   temp.add = inode_a;
  12.   struct inode temp_inode;
  13.   char mem_area[B];
  14.   char mem_area2[B];
  15.       
  16.   read_block(1,mem_area);
  17.   memcpy((char*)&temp_inode,mem_area,16);
  18.   temp_inode.sa[0] += 8;
  19.   int i,root_block,ifend;
  20.   for(i = 3; i > 0; i--)
  21.   {
  22.     if(temp_inode.sa[i] > -1)
  23.     {
  24.       root_block = temp_inode.sa[i];
  25.       read_block(root_block,mem_area2);
  26.       ifend = i;
  27.       break;
  28.     }
  29.   }
  30.   for(i = 0; i < 16; i++)
  31.   {
  32.     if(ldisk[root_block][8*i] == 0)
  33.     {
  34.       memcpy(&mem_area2[8*i],(char*)&temp,8);
  35.       memcpy(mem_area,(char*)&temp_inode,16);
  36.       write_block(root_block,mem_area2);
  37.       write_block(1,mem_area);
  38.       /*
  39.       memcpy(&ldisk[root_block][8*i],(char*)&temp,8);  
  40.       memcpy(ldisk[1],(char*)&temp_inode,16);*/
  41.       return 0;
  42.     }
  43.   }
  44.   
  45.   if(ifend == 3)
  46.     return -1;
  47.   int add = find_block();
  48.   if(add > 0)
  49.   {
  50.     fill_full(add);
  51.     temp_inode.sa[ifend+1] = add;
  52.     char mem_area2[B];
  53.       read_block(root_block,mem_area2);
  54.       memcpy(mem_area2,(char*)&temp,8);
  55.       memcpy(mem_area,(char*)&temp_inode,16);
  56.       write_block(root_block,mem_area2);
  57.       write_block(1,mem_area);/*
  58.     memcpy(ldisk[1],(char*)&temp_inode,16);
  59.     root_block = add;
  60.     memcpy(ldisk[root_block],(char*)&temp,8);*/
  61.     return 0;
  62.   }
  63.   else 
  64.     return -2;
  65. }
  66. int create(const char* name)
  67. {
  68.   char mem_area[B];
  69.   int add = find_block();
  70.   if(add > 0)
  71.   {
  72.     fill_full(add);
  73.     int i,j;
  74.     for(i = 1; i < 32; i++)
  75.       for(j = 0; j < 8; j++)
  76.       {
  77. read_block(i,mem_area);
  78. if(mem_area[16*j] == 0
  79.   &&mem_area[16*j+1] == 0&&mem_area[16*j+2] == 0&&mem_area[16*j+3] == 0&&
  80.   mem_area[16*j+4] == 0&&mem_area[16*j+5] == 0&&mem_area[16*j+6] == 0&&mem_area[16*j+7] == 0&&
  81.   mem_area[16*j+8] == 0&&mem_area[16*j+9] == 0&&mem_area[16*j+10] == 0&&mem_area[16*j+11] == 0&&
  82.   mem_area[16*j+12] == 0&&mem_area[16*j+13] == 0&&mem_area[16*j+14] == 0&&mem_area[16*j+15] == 0)
  83. {
  84.   struct inode new_inode;
  85.   new_inode.sa[0] = 0;
  86.   new_inode.sa[1] = add;new_inode.sa[2] = -1;new_inode.sa[3] = -1;
  87.   //memcpy(&ldisk[i][16*j],(char*)&new_inode,16);
  88.   memcpy(&mem_area[16*j],(char*)&new_inode,16);
  89.   write_block(i,mem_area);
  90.   add_item(name,8*(i-1)+j);
  91.   return 0;
  92. }
  93.       }
  94.   }
  95.   else 
  96.     return -1;
  97. }
  98. int destroy(const char* name)
  99. {
  100.   struct item temp;
  101.   struct inode root_inode;
  102.   struct inode temp_inode;
  103.   char mem_area[B];
  104.   char mem_area2[B];
  105.   read_block(1,mem_area);
  106.   memcpy((char*)&root_inode,mem_area,16);
  107.   root_inode.sa[0] -= 8;
  108.   int i,j,root_block,k;
  109.   for(i = 1; i < 4; i++)
  110.   {
  111.     root_block = root_inode.sa[i];
  112.     read_block(root_block,mem_area2);
  113.     if(root_block > 0)
  114.     {
  115.       for(j = 0; j < 16; j++)
  116.       {
  117. memcpy((char*)&temp,&mem_area2[8*j],8);
  118. if(strcmp(temp.name,name) == 0)
  119. {
  120.   memset(&mem_area2[8*j],0,8);
  121.   int add;
  122.   add = temp.add;
  123.   char mem[B];
  124.   read_block(add/8+1,mem);
  125.   memcpy((char*)&temp_inode,&mem[(add%8)*16],16);
  126.   for(k = 1; k < 4; k++)
  127.   {
  128.     if(temp_inode.sa[i] > 0)
  129.     {
  130.       fill_empty(temp_inode.sa[i]);
  131.     }
  132.   }
  133.   memset(&mem[(add%8)*16],0,16);
  134.   write_block(1,mem_area);
  135.   write_block(add/8+1,mem);
  136.   write_block(root_block,mem_area2);
  137.   //memcpy(ldisk[1],(char*)&root_inode,16);
  138.   return 0;
  139. }
  140.       }
  141.     }
  142.     else
  143.       break;
  144.   }
  145.   return -1;
  146. }
  147. int open(const char* name)
  148. {
  149.   struct item temp;
  150.   struct inode root_inode;
  151.   struct inode temp_inode;
  152.   char mem_area[B];
  153.   char mem_area2[B];
  154.   char mem_area3[B];
  155.   read_block(1,mem_area);
  156.   memcpy((char*)&root_inode,mem_area,16);
  158.   int i,j,root_block,k;
  159.   for(i = 1; i < 4; i++)
  160.   {
  161.     root_block = root_inode.sa[i];
  162.     read_block(root_block,mem_area2);
  163.     if(root_block > 0)
  164.     {
  165.       for(j = 0; j < 16; j++)
  166.       {
  167. memcpy((char*)&temp,&mem_area2[8*j],8);
  168. if(strcmp(temp.name,name) == 0)
  169. {
  170.   for(k = 0; k < 10; k++)
  171.   {
  172.     if(table[k].add == -1)
  173.     {
  174.       table_num = k;
  175.       break;
  176.     }
  177.     else
  178.       table_num = -1;
  179.   }
  180.   if(table_num == -1)
  181.     return -2;
  182.   int add;
  183.   add = temp.add;
  184.   read_block(add/8+1,mem_area3);
  185.   memcpy((char*)&temp_inode,&mem_area3[(add%8)*16],16);
  186.   
  187.   table[table_num].p = 0;
  188.   table[table_num].add = add;
  189.   read_block(temp_inode.sa[1],table[table_num].mem);
  190.   //memcpy(table[table_num].mem,ldisk[temp_inode.sa[1]],B);
  191.   return table_num;
  192. }
  193.       }
  194.     }
  195.     else
  196.       break;
  197.   }
  198.   return -1;
  199. }
  201. int close(int index)
  202. {
  203.   int fsth = table[index].p/B;
  204.   int add = table[index].add;
  205.   char mem_area[B];
  206.   read_block(add/8+1,mem_area);
  207.   struct inode temp_inode;
  208.   memcpy((char*)&temp_inode,&mem_area[(add%8)*16],16);
  209.   int block = temp_inode.sa[fsth+1];
  210.   write_block(block,table[index].mem);
  211.   //memcpy(ldisk[block],table[index].mem,B);
  212.   table[index].add = -1;
  213.   return 0;
  214. }
  216. int read(int index,char* mem,int count)
  217. {
  218.   int add = table[index].add;
  219.   char mem_i[B];
  220.   char mem_area[B];
  221.   read_block(add/8+1,mem_i);
  222.   struct inode temp_inode;
  223.   memcpy((char*)&temp_inode,&mem_i[(add%8)*16],16);
  224.   int p = table[index].p;
  225.   if(count + p > 3*B)
  226.     return -1;
  227.   
  228.   table[index].p += count;
  229.   if(p > 2*B)
  230.   {
  231.     memcpy(mem,&table[index].mem[p%B],count);
  232.     //memcpy(&mem_i[(add%8)*16],(char*)&temp_inode,16);
  233.     //write_block(add/8+1,mem_i);
  234.     return 0;
  235.   }
  236.   if(p > B)
  237.   {
  238.     return 0;
  239.   }
  240.   if(p > B)
  241.   {
  242.     if(count + p > 2*B)
  243.     {
  244.       memcpy(mem,&table[index].mem[p%B],B - p%B);
  245.       read_block(temp_inode.sa[p/B+2],table[index].mem);
  246.       //memcpy(table[index].mem,ldisk[temp_inode.sa[p/B+2]],B);
  247.       memcpy(&mem[B - p%B],table[index].mem,count -B + p%B);
  248.       //memcpy(&ldisk[add/8+1][(add%8)*16],(char*)&temp_inode,16);
  249.       return 0;
  250.     }
  251.     else
  252.     {
  253.       memcpy(mem,&table[index].mem[p%B],count);
  254.       //memcpy(&ldisk[add/8+1][(add%8)*16],(char*)&temp_inode,16);
  255.       return 0;
  256.     }
  257.   }
  258.   if(count + p > 2*B)
  259.   {
  260.     memcpy(mem,&table[index].mem[p%B],B - p%B);
  261.     read_block(temp_inode.sa[p/B+2],table[index].mem);
  262.     //memcpy(table[index].mem,ldisk[temp_inode.sa[p/B+2]],B);
  263.     memcpy(&mem[B - p%B],table[index].mem,B);
  264.     read_block(temp_inode.sa[p/B+3],table[index].mem);
  265.     //memcpy(table[index].mem,ldisk[temp_inode.sa[p/B+3]],B);
  266.     memcpy(&mem[2*B - p%B],table[index].mem,count + p%B - 2*B);
  267.     //memcpy(&ldisk[add/8+1][(add%8)*16],(char*)&temp_inode,16);
  268.     return 0;
  269.   }
  270.   if(count + p > B)
  271.   {
  272.     memcpy(mem,&table[index].mem[p%B],B - p%B);
  273.     read_block(temp_inode.sa[p/B+2],table[index].mem);
  274.     //memcpy(table[index].mem,ldisk[temp_inode.sa[p/B+2]],B);
  275.     memcpy(&mem[B - p%B],table[index].mem,count + p%B - B);
  276.     //memcpy(&ldisk[add/8+1][(add%8)*16],(char*)&temp_inode,16);
  277.     return 0;
  278.   }
  279.   memcpy(mem,&table[index].mem[p%B],count);
  280.   //memcpy(&ldisk[add/8+1][(add%8)*16],(char*)&temp_inode,16);
  281.   return 0;
  282. }
  284. int write(int index,char* mem,int count)
  285. {
  286.   int add = table[index].add;
  287.   char mem_area[B];
  288.   char mem_area2[B];
  289.   read_block(add/8+1,mem_area);
  290.   struct inode temp_inode;
  291.   memcpy((char*)&temp_inode,&mem_area[(add%8)*16],16);
  292.   int p = table[index].p;
  293.   if(count + p > 3*B)
  294.     return -1;
  295.   
  296.   table[index].p += count;
  297.   if(p > 2*B)
  298.   {
  299.     memcpy(&table[index].mem[p%B],mem,count);
  300.     //temp_inode.sa[0] += count;
  301.     temp_inode.sa[0] = max(temp_inode.sa[0],table[index].p);
  302.     memcpy(&mem_area[(add%8)*16],(char*)&temp_inode,16);
  303.     write_block(add/8+1,mem_area);
  304.     return 0;
  305.   }
  306.   if(p > B)
  307.   {
  308.     if(count + p > 2*B)
  309.     {
  310.       if(temp_inode.sa[3] == -1)
  311.       {
  312. int newblock = find_block();
  313. if(newblock > 0)
  314. temp_inode.sa[3] = newblock;
  315. fill_full(newblock);
  316.       }
  317.       memcpy(&table[index].mem[p%B],mem,B - p%B);
  318.       read_block(temp_inode.sa[p/B+2],table[index].mem);
  319.       //memcpy(ldisk[temp_inode.sa[p/B+2]],table[index].mem,B);
  320.       memcpy(table[index].mem,&mem[B - p%B],count -B + p%B);
  321.       temp_inode.sa[0] = max(temp_inode.sa[0],table[index].p);
  322.       //memcpy(&ldisk[add/8+1][(add%8)*16],(char*)&temp_inode,16);
  323.       memcpy(&mem_area[(add%8)*16],(char*)&temp_inode,16);
  324.       write_block(add/8+1,mem_area);
  325.       return 0;
  326.     }
  327.     else
  328.     {
  329.       memcpy(&table[index].mem[p%B],mem,count);
  330.       temp_inode.sa[0] = max(temp_inode.sa[0],table[index].p);
  331.       //memcpy(&ldisk[add/8+1][(add%8)*16],(char*)&temp_inode,16);
  332.       memcpy(&mem_area[(add%8)*16],(char*)&temp_inode,16);
  333.       write_block(add/8+1,mem_area);
  334.       return 0;
  335.     }
  336.   }
  337.   if(count + p > 2*B)
  338.   { 
  339.     if(temp_inode.sa[2] == -1)
  340.     {
  341.       int newblock = find_block();
  342.       if(newblock > 0)
  343.       temp_inode.sa[2] = newblock;
  344.       fill_full(newblock);
  345.     }
  346.     if(temp_inode.sa[3] == -1)
  347.     {
  348.       int newblock = find_block();
  349.       if(newblock > 0)
  350.       temp_inode.sa[3] = newblock;
  351.       fill_full(newblock);
  352.     }
  353.     memcpy(&table[index].mem[p%B],mem,B - p%B);
  354.     read_block(temp_inode.sa[p/B+1],table[index].mem);
  355.    // memcpy(ldisk[temp_inode.sa[p/B+1]],table[index].mem,B);
  356.     memcpy(table[index].mem,mem,B);
  357.     write_block(temp_inode.sa[p/B+2],table[index].mem);
  358.     //memcpy(ldisk[temp_inode.sa[p/B+2]],table[index].mem,B);
  359.     memcpy(table[index].mem,&mem[2*B - p%B],count + p%B - 2*B);
  360.     temp_inode.sa[0] = max(temp_inode.sa[0],table[index].p);
  361.     //memcpy(&ldisk[add/8+1][(add%8)*16],(char*)&temp_inode,16);
  362.     memcpy(&mem_area[(add%8)*16],(char*)&temp_inode,16);
  363.     write_block(add/8+1,mem_area);
  364.     return 0;
  365.   }
  366.   if(count + p > B)
  367.   {
  368.     if(temp_inode.sa[2] == -1)
  369.     {
  370.       int newblock = find_block();
  371.       if(newblock > 0)
  372.       temp_inode.sa[2] = newblock;
  373.       fill_full(newblock);
  374.     }
  375.     memcpy(&table[index].mem[p%B],mem,B - p%B);
  376.     //memcpy(ldisk[temp_inode.sa[p/B+1]],table[index].mem,B);
  377.     read_block(temp_inode.sa[p/B+1],table[index].mem);
  378.     memcpy(table[index].mem,&mem[B - p%B],count + p%B - B);
  379.     temp_inode.sa[0] = max(temp_inode.sa[0],table[index].p);
  380.     //memcpy(&ldisk[add/8+1][(add%8)*16],(char*)&temp_inode,16);
  381.     memcpy(&mem_area[(add%8)*16],(char*)&temp_inode,16);
  382.     write_block(add/8+1,mem_area);
  383.     return 0;
  384.   }
  385.   memcpy(&table[index].mem[p%B],mem,count);
  386.   temp_inode.sa[0] = max(temp_inode.sa[0],table[index].p);
  387.   //memcpy(&ldisk[add/8+1][(add%8)*16],(char*)&temp_inode,16);
  388.   memcpy(&mem_area[(add%8)*16],(char*)&temp_inode,16);
  389.   write_block(add/8+1,mem_area);
  390.   return 0;
  391. }
  393. int lseek(int index,int pos)
  394. {
  395.   int add = table[index].add;
  396.   struct inode temp_inode;
  397.   memcpy((char*)&temp_inode,&ldisk[add/8+1][(add%8)*16],16);
  398.   if(pos > temp_inode.sa[0])
  399.     return -1;
  400.   
  401.   memcpy(ldisk[temp_inode.sa[table[index].p/B+1]],table[index].mem,B);
  402.   table[index].p = pos;
  403.   int p = table[index].p;
  404.   if(p > 2*B)
  405.   {
  406.     read_block(temp_inode.sa[3],temp_inode.sa[p/B+1]);
  407.     //memcpy(table[index].mem,ldisk[temp_inode.sa[3]],B);
  408.     return 0;
  409.   }
  410.   if(p > B)
  411.   {
  412.     read_block(temp_inode.sa[2],temp_inode.sa[p/B+1]);
  413.     //memcpy(table[index].mem,ldisk[temp_inode.sa[2]],B);
  414.     return 0;
  415.   }
  416.   read_block(temp_inode.sa[1],temp_inode.sa[p/B+1]);
  417.   //memcpy(table[index].mem,ldisk[temp_inode.sa[1]],B);
  418.   return 0;
  419. }
  421. int directory()
  422. {
  423.   struct inode root_inode;
  424.   struct inode temp_inode;
  425.   memcpy((char*)&root_inode,ldisk[1],16);
  426.   struct item sub_item;
  427.   int i,add,next = 1,size;
  428.   add = root_inode.sa[next];
  429.   if(root_inode.sa[3] != -1)
  430.     size = 48;
  431.   else if(root_inode.sa[2] != -1)
  432.     size = 32;
  433.   else if(root_inode.sa[1] != -1)
  434.     size = 16;
  435.   int ii = 1;
  436.   int add2;
  437.   char mem_area[B];
  438.   read_block(add,mem_area);
  439.   for(i = 0; i < size; i++)
  440.   {
  441.     
  442.     if(i >= 16*ii)
  443.     {
  444.       add = root_inode.sa[++next];
  445.       printf("a new root blocke number = %dn",add);
  446.       read_block(add,mem_area);
  447.       ii++;
  448.     }
  449.     if(mem_area[8*(i-16*(ii-1))] != 0)
  450.     {
  451.     memcpy((char*)&sub_item,&mem_area[8*(i-16*(ii-1))],8);    
  452.     add2 = sub_item.add;
  453.     memcpy((char*)&temp_inode,&ldisk[add2/8+1][(add2%8)*16],16);
  454.     printf("filename = %s   filesize = %dn",sub_item.name,temp_inode.sa[0]);
  455.     }
  456.   }
  457.   return 0;
  458. }
  459. void print_bit(char b)
  460. {
  461. printf("%c",(b & 0x80)?'1':'0');
  462. printf("%c",(b & 0x40)?'1':'0');
  463. printf("%c",(b & 0x20)?'1':'0');
  464. printf("%c",(b & 0x10)?'1':'0');
  465. printf("%c",(b & 0x08)?'1':'0');
  466. printf("%c",(b & 0x04)?'1':'0');
  467. printf("%c",(b & 0x02)?'1':'0');
  468. printf("%c",(b & 0x01)?'1':'0');
  469. printf("|%c|",b);
  470. }