SHARE
TWEET

Untitled

a guest Nov 19th, 2019 84 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. static void bitmap_init(int start, int num, int nbits, int type)
  2. {
  3.   /* YOUR CODE */
  4.   dprintf("...start bitmap initialization with start=%d, num=%d, nbits=%d\n",start, num, nbits);
  5.   //create bitmap with size of arry of chars neccessary to support num bits
  6.   char *bitmap;
  7.   //get size of bit array in bytes
  8.   //if type then bitmap sector, else inode sector
  9.   int size = -1;
  10.   if(type){
  11.      size = array_size(SECTOR_BITMAP_SIZE * CHARBITS);
  12.   }else{
  13.      size = array_size(INODE_BITMAP_SIZE * CHARBITS);
  14.   }
  15.   //allocate the neccessary bytes for the num size bitmap
  16.   bitmap = (char *)calloc(size, sizeof(char));
  17.  
  18.   //initialize all bits to 0 (clear all bits)
  19.   for (int i = 0; i < num; i++)
  20.   {
  21.     clear_bit(bitmap,i);
  22.   }
  23.  
  24.   //for nbits set the bit (bit = 1)
  25.    for (int i = 0; i < nbits; i++)
  26.   {
  27.     set_bit(bitmap,i);
  28.   }
  29.  
  30.   //set the bits of the sector that thec current bitmap occupies
  31.   for(int i = start; i < start + num; i++) set_bit(bitmap, i);
  32.  
  33.   //print all bits for testing
  34.   /*
  35.   for (int i = 0; i < num; i++)
  36.   {
  37.     printf("%d: %lu\n",i, test_bit(bitmap,i));
  38.   }
  39.  */
  40.  // check if bitmap will fit in one sector (SECTOR_SIZE > size(bitmap))
  41.  if(SECTOR_SIZE >= size)
  42.  {
  43.      //printf("SECTOR_SIZE >= size -> %d > %lu", SECTOR_SIZE, size);
  44.      if(Disk_Write(start, bitmap)<0)
  45.           {
  46.             dprintf("Error initializing bitmap, func=bitmap_init\n");
  47.           }
  48.       else{
  49.         dprintf("...bitmap wrote to disk successfully using 1 sector to store, func=bitmap_init\n");
  50.       }
  51.      
  52.      
  53.  }
  54.  else
  55.  {
  56.      //printf("size > SECTOR_SIZE -> %lu > %d", size, SECTOR_SIZE );
  57.      char buff[SECTOR_SIZE];
  58.      int toXfr = size;//track total bytes to write to disk
  59.      int numBytes = 0;
  60.      int i = -1;
  61.      int numSectorUsed = 0;
  62.  
  63.      for (i = 0; i<= size; i+=SECTOR_SIZE)
  64.       {
  65.         if(toXfr>SECTOR_SIZE)
  66.         {
  67.             numBytes = SECTOR_SIZE;
  68.         }
  69.         else
  70.         {
  71.             numBytes = toXfr;
  72.         }
  73.         memcpy(buff, &bitmap[i], numBytes);//copy to buff numBytes of bitmap
  74.         if(Disk_Write(start++, buff)<0)
  75.           {
  76.             dprintf("Error initializing bitmap");
  77.           }
  78.          numSectorUsed +=1;
  79.          bzero(buff, SECTOR_SIZE);
  80.         toXfr = toXfr - numBytes;//update number of bytes remaining to write to disk
  81.        
  82.         //for testing
  83.         /*
  84.         for(int y = 0; y < numBytes; y++)
  85.         {
  86.             printf("%d",buff[y]);
  87.         }    
  88.        
  89.         printf("\n");
  90.         printf("Copied %d bytes, %d remaining\n", numBytes, toXfr);
  91.         */
  92.       }
  93.         dprintf("...bitmap written to disk using %d sectors to store on disk, func=bitmap_init\n", numSectorUsed);
  94.  }
  95.   free(bitmap);
  96.   dprintf("... mem freed for bitmap, func=bitmap_init\n");
  97. }
  98.  
  99. // set the first unused bit from a bitmap of 'nbits' bits (flip the
  100. // first zero appeared in the bitmap to one) and return its location;
  101. // return -1 if the bitmap is already full (no more zeros)
  102. static int bitmap_first_unused(int start, int num, int nbits)
  103. {
  104.   /* YOUR CODE */
  105.  
  106.   dprintf("... bitmap_first_unused called start=%d, num=%d, nbits=%d\n", start, num, nbits);
  107.  
  108.   char buff[SECTOR_SIZE];
  109.  
  110.   //determine number of sectors the bitmap occupies
  111.   //int secRemain = (nbits / CHARBITS)%SECTOR_SIZE;
  112.   //int numSec = (nbits / CHARBITS)/SECTOR_SIZE;
  113.   int numSec = num;
  114.   dprintf("... numsec=%d\n", numSec);
  115.   int found = 0;
  116.   int firstUnused = -1;
  117.  
  118.   //determine number of bytes needed to represent bitmap with nbits
  119.   int bmpARRLen = array_size(nbits);
  120.   int realBMPLen = nbits;
  121.   dprintf("... real len of bm(in bytes)=%d\n", realBMPLen);
  122.   int currSec = start;
  123.  
  124.   //prep bitmap array
  125.   char *bitmap;
  126.   //bitmap = (char*)calloc(bmpARRLen, sizeof(char));
  127.   bitmap = (char*)malloc(realBMPLen);
  128.   int index = 0; //track index in bmp where next chunk from buff will be stored
  129.   int numBytes = bmpARRLen; //track remaining bytes to be copied to form complete bitmap
  130.   int bytesToCopy = -1;
  131.  
  132.   for(int i = 0; i < numSec; i++)
  133.   {
  134.       //read each sector and build full bitmap
  135.       if(Disk_Read(currSec, buff) < 0)
  136.       {
  137.           dprintf("... could not retrieve bitmap from disk in func bitmap_first_unused\n");
  138.           return -1;
  139.       }
  140.       //copy buff to bitmap
  141.       index = SECTOR_SIZE * i;
  142.       if(numBytes<=SECTOR_SIZE)
  143.       {
  144.           bytesToCopy = numBytes;
  145.       }
  146.       else
  147.       {
  148.           bytesToCopy = SECTOR_SIZE;
  149.           numBytes -= SECTOR_SIZE;
  150.       }
  151.       memcpy(&bitmap[index], buff, bytesToCopy);
  152.       bzero(buff, SECTOR_SIZE);
  153.   }
  154.  /*if(nbits*CHARBITS == 1000){
  155.  for(int i=0; i <nbits*CHARBITS; i++){
  156.      dprintf("%d=%d ", i, test_bit(bitmap, i));
  157.  }}*/
  158.  int act_size = (int)malloc_usable_size(bitmap);
  159.  dprintf("... act size of bmp=%d", act_size);
  160.  
  161.   dprintf("... bits for bmp=%d", nbits*CHARBITS);
  162.   //search for first bit equal to 0
  163.   for(int i =0; i < nbits*CHARBITS; i++)
  164.   {
  165.       //if equal to 0 set bit and return i
  166.       if (test_bit(bitmap, i) == 0)
  167.       {
  168.           //set ith bit to 1
  169.           set_bit(bitmap, i);
  170.           found = 1;
  171.           firstUnused = i;
  172.       }
  173.       if(found){
  174.           dprintf("... found unused bit in bitmap at index %d, func=bitmap_first_unused\n", firstUnused);
  175.           break;
  176.       }
  177.   }
  178.  
  179.   //write new bit map to disk
  180.   numBytes = bmpARRLen;
  181.   currSec = start;
  182.   index = 0;
  183.   for(int i = 0; i < numSec; i++)
  184.   {
  185.       //check if remaining bytes to be copied (numBytes) is less than sector size
  186.       if(numBytes <= SECTOR_SIZE)
  187.       {
  188.           bytesToCopy = numBytes;
  189.       }
  190.       else
  191.       {
  192.           bytesToCopy = SECTOR_SIZE;
  193.       }
  194.       //copy from bitmap to buff
  195.       memcpy(buff, &bitmap[index], bytesToCopy);
  196.       //write to currSec full bitmap or part of full bitmap
  197.       if(Disk_Write(currSec, buff) < 0) return -1;
  198.       //update index, beginning of next section of bitmap to copy
  199.       index = SECTOR_SIZE * i;
  200.       //update remaining number of bytes needing to be written to disk
  201.       numBytes -= bytesToCopy;
  202.   }
  203.   //free allocated memory of bitmap
  204.   free(bitmap);
  205.  
  206.   //if unused is found return its index, else return -1
  207.   if(found)
  208.   {
  209.       return firstUnused;
  210.   }
  211.   else
  212.   {
  213.       dprintf("...no unused bits in bitmap, func=bitmap_first_unused\n");
  214.       return -1;
  215.   }
  216. }
  217.  
  218. // reset the i-th bit of a bitmap with 'num' sectors starting from
  219. // 'start' sector; return 0 if successful, -1 otherwise
  220. static int bitmap_reset(int start, int num, int ibit)
  221. {
  222.     dprintf("... called bitmap_reset\n");
  223.   /* YOUR CODE */
  224.   char buff[SECTOR_SIZE];
  225.  //determine bitmap length
  226.  int bmpARRLen = -1;
  227.  
  228.  //check if num of bits is a multiple of 8, if there is a remainder then the neccessary length
  229.  //of an array to hold num bits is 1 + (number of bits / bits in a char = 8) otherwise its just (number of bits / bits in a char = 8)
  230.  bmpARRLen = num*SECTOR_SIZE;
  231.  
  232.  //initialize bitmap arrary with length equal to bmpARRLen
  233.  char *bitmap;
  234.  
  235.  //allocate the neccessary bytes for the num size bitmap
  236.  bitmap = (char *)calloc(bmpARRLen, sizeof(char));
  237.  
  238.  //determine number of sectors the bitmap occupies
  239.  int numSec = num;
  240.  
  241.  //check if bitmap only occupies one sector
  242.  if(numSec == 1)
  243.  {
  244.      //bitmap only ooccupies one sector, read the bitmap from start sector
  245.      if(Disk_Read(start, buff) < 0) {
  246.        dprintf("...cannot read bitmap from disk, func=bitmap_reset\n");
  247.            return -1;}
  248.      
  249.      //copy from buffer to bitmap
  250.      memcpy(bitmap, buff, bmpARRLen);
  251.      bzero(buff, SECTOR_SIZE);
  252.      
  253.  }
  254.  else
  255.  {
  256.      for(int i = 0; i < numSec; i++)
  257.      {
  258.          int secRd = start + i;
  259.          //read from sector
  260.          if(Disk_Read(secRd, buff) < 0) {
  261.              dprintf("...cannot read bitmap from disk, func=bitmap_reset\n");
  262.              return -1;}
  263.          //copy to bitmap
  264.          int index = i * SECTOR_SIZE;
  265.          
  266.          memcpy(&bitmap[index], buff, SECTOR_SIZE);
  267.          bzero(buff, SECTOR_SIZE);
  268.      }
  269.   }
  270.  
  271.   if(test_bit(bitmap, ibit) == 0)
  272.   {
  273.       dprintf("...error cannot clear bit in %d index, func=bitmap_reset\n", ibit);
  274.       return -1;
  275.   }
  276.   else
  277.   {
  278.       clear_bit(bitmap, ibit);
  279.       dprintf("...bit in %d index cleared successfully, func=bitmap_reset\n", ibit);
  280.   }
  281.   //bytes to transfer from bitmap to buffer then write to disk
  282.   int toXfr = bmpARRLen;
  283.   //track num bytes to write to disk for each write to disk
  284.     int numBytes = -1;
  285.   //write bitmap to memory
  286.   for (int i = 0; i<= num; i+=SECTOR_SIZE)
  287.       {
  288.         if(toXfr>SECTOR_SIZE)//num bytes to write larger than sector size
  289.         {
  290.             numBytes = SECTOR_SIZE;
  291.         }
  292.         else
  293.         {
  294.             numBytes = toXfr;
  295.         }
  296.         memcpy(buff, &bitmap[i], numBytes);//copy to buff numBytes of bitmap
  297.         if(Disk_Write(start++, buff)<0)
  298.           {
  299.             dprintf("...writing bitmap to disk, func=bitmap_reset\n");
  300.             return -1;
  301.           }
  302.         toXfr = toXfr - numBytes;//update number of bytes remaining to write to disk
  303.         bzero(buff, SECTOR_SIZE);
  304.        
  305.       }  
  306.    
  307.  
  308.   return 0;
  309. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top