rmfsalloc.c

This is a resource based on j2me embedded,if you dont understand,you can connection with me .

      }

      i++;
    }

    curDataBlockNum = i;

    if ((minSizeDiff >= 0) && (fitBlock >= 0)) {

      rmfsDataBlockHdrArray[fitBlock].flag = 0x01 | blockType;
      rmfsDataBlockHdrArray[fitBlock].identifier = fileID;
      rmfsDataBlockHdrArray[fitBlock].next = 0;

      dataBlockHdr.flag = rmfsDataBlockHdrArray[fitBlock].flag;
      dataBlockHdr.dataSize = fileSize;
      dataBlockHdr.blockSize = rmfsDataBlockHdrArray[fitBlock].size;

      dataBlockHdr.nameID = fileID;

      rmfsDataBlockHdrArray[fitBlock].dataSize = fileSize;
      dataBlockHdr.next = 0;


      /*
         If the remain of the block is larger than the Block Head and the total block number doesn't exceed the Maximum,
         split the block
       */

      if (((unsigned int)minSizeDiff > sizeof(_RmfsBlockHdr))
	  && (i < (MAX_DATABLOCK_NUMBER - 1))) {
	nextBlockHdr.flag = 0x00;
	nextBlockHdr.blockSize = minSizeDiff - sizeof(_RmfsBlockHdr);

	rmfsDataBlockHdrArray[fitBlock].size =
	    rmfsDataBlockHdrArray[fitBlock].size - minSizeDiff;
	dataBlockHdr.blockSize = rmfsDataBlockHdrArray[fitBlock].size;
	nextBlockHdr.dataSize = 0;

	nextBlockHdr.nameID = 0;
	nextBlockHdr.next = 0;

	WriteDataToStorage(&nextBlockHdr,
			   (rmfsDataBlockHdrArray[fitBlock].offset +
			    dataBlockHdr.blockSize +
			    sizeof(_RmfsBlockHdr)), sizeof(_RmfsBlockHdr));

	/*
	   copy the block head info. behind the fitBlock slot in rmfsDataBlockHdrArray 
	 */

	while (i > (fitBlock + 1)) {
	  rmfsDataBlockHdrArray[i].flag = rmfsDataBlockHdrArray[i - 1].flag;
	  rmfsDataBlockHdrArray[i].identifier =
	      rmfsDataBlockHdrArray[i - 1].identifier;
	  rmfsDataBlockHdrArray[i].offset = rmfsDataBlockHdrArray[i - 1].offset;
	  rmfsDataBlockHdrArray[i].size = rmfsDataBlockHdrArray[i - 1].size;
	  rmfsDataBlockHdrArray[i].dataSize =
	      rmfsDataBlockHdrArray[i - 1].dataSize;

	  i--;
	}

	rmfsDataBlockHdrArray[fitBlock + 1].flag = nextBlockHdr.flag;
	rmfsDataBlockHdrArray[fitBlock + 1].identifier = 0;
	rmfsDataBlockHdrArray[fitBlock + 1].offset =
	    rmfsDataBlockHdrArray[fitBlock].offset +
	    dataBlockHdr.blockSize + sizeof(_RmfsBlockHdr);
	rmfsDataBlockHdrArray[fitBlock + 1].size = nextBlockHdr.blockSize;
	rmfsDataBlockHdrArray[fitBlock + 1].dataSize = 0;

	curDataBlockNum++;

#ifdef TRACE_STORAGE
	printf ("Split the Free Block:Index %d, Flag %d,  Remain Size: %d\n",
	     fitBlock + 1, nextBlockHdr.flag, nextBlockHdr.blockSize);
#endif

      }
      /* end of spliting */
      WriteDataToStorage(&dataBlockHdr,
			 rmfsDataBlockHdrArray[fitBlock].offset,
			 sizeof(_RmfsBlockHdr));

      WriteDataToStorage(dataBuffer,
			 rmfsDataBlockHdrArray[fitBlock].offset +
			 sizeof(_RmfsBlockHdr), dataBlockHdr.dataSize);

      return rmfsDataBlockHdrArray[fitBlock].offset;

    }

    /* end of best fit allocation */
    /*
       allocating one block for this file at the end of JAD/JAR/RMS space 
     */
    if (((RmfsNameTableEnd - sizeof(_RmfsBlockHdr) - newBytesToAllocate) >=
	 (unsigned int) RmfsDataBufferEnd)  
        && ((unsigned int)curDataBlockNum < MAX_DATABLOCK_NUMBER)) {
      /*
         If the last data block belongs to the same file, just enlarge the file 
       */
      if ((rmfsDataBlockHdrArray[curDataBlockNum - 1].identifier == fileID)
	  && (rmfsDataBlockHdrArray[curDataBlockNum - 1].next == 0)) {
	rmfsDataBlockHdrArray[curDataBlockNum - 1].size += newBytesToAllocate;
	rmfsDataBlockHdrArray[curDataBlockNum - 1].dataSize += fileSize;

	dataBlockHdr.flag = rmfsDataBlockHdrArray[curDataBlockNum - 1].flag;
	dataBlockHdr.blockSize =
	    rmfsDataBlockHdrArray[curDataBlockNum - 1].size;
	dataBlockHdr.dataSize =
	    rmfsDataBlockHdrArray[curDataBlockNum - 1].dataSize;
	dataBlockHdr.nameID =
	    rmfsDataBlockHdrArray[curDataBlockNum - 1].identifier;
	dataBlockHdr.next = rmfsDataBlockHdrArray[curDataBlockNum - 1].next;

	WriteDataToStorage(&dataBlockHdr,
			   rmfsDataBlockHdrArray[curDataBlockNum -
						 1].offset,
			   sizeof(_RmfsBlockHdr));

	if (fileSize > 0) {
	  WriteDataToStorage(dataBuffer, RmfsDataBufferEnd, fileSize);
	}

	RmfsDataBufferEnd += newBytesToAllocate;

	return RmfsDataBufferEnd - sizeof(_RmfsBlockHdr) -
	    dataBlockHdr.blockSize;

      }
      rmfsDataBlockHdrArray[curDataBlockNum].flag = 0x01 | blockType;
      rmfsDataBlockHdrArray[curDataBlockNum].identifier = fileID;
      rmfsDataBlockHdrArray[curDataBlockNum].size = newBytesToAllocate;
      rmfsDataBlockHdrArray[curDataBlockNum].offset = RmfsDataBufferEnd;
      rmfsDataBlockHdrArray[curDataBlockNum].dataSize = fileSize;
      rmfsDataBlockHdrArray[curDataBlockNum].next = 0;

      dataBlockHdr.flag = 0x01 | blockType;
      dataBlockHdr.blockSize = newBytesToAllocate;
      dataBlockHdr.dataSize = fileSize;
      dataBlockHdr.nameID = fileID;
      dataBlockHdr.next = 0;

      WriteDataToStorage(&dataBlockHdr, RmfsDataBufferEnd,
			 sizeof(_RmfsBlockHdr));

      if (dataBlockHdr.dataSize > 0) {
	WriteDataToStorage(dataBuffer,
			   RmfsDataBufferEnd + sizeof(_RmfsBlockHdr),
			   dataBlockHdr.dataSize);
      }

      RmfsDataBufferEnd += (sizeof(_RmfsBlockHdr) + dataBlockHdr.blockSize);

      curDataBlockNum++;

      return RmfsDataBufferEnd - sizeof(_RmfsBlockHdr) - dataBlockHdr.blockSize;


    }


    /* end of allocating new block for file at the end of the JAD/JAR/RMS space */
    /* Linked Blocks are allocated for the file */
    /* The free blocks are allocated to this file in order */
    /* Check the space of all holes (include free storage ) is sufficient for the new file */
    for (i = 0; i < curDataBlockNum; i++) {
      if ((rmfsDataBlockHdrArray[i].flag & 0x01) == 0) {
	totalSpace += rmfsDataBlockHdrArray[i].size;
      }
    }

    if ((unsigned int)(RmfsNameTableEnd - RmfsDataBufferEnd) > sizeof(_RmfsBlockHdr)) {
      totalSpace +=
	  RmfsNameTableEnd - RmfsDataBufferEnd - sizeof(_RmfsBlockHdr);
    }

    if (totalSpace < newBytesToAllocate) {
#ifdef TRACE_STORAGE
      printf("Free space is not sufficient for the new file or record \n");
#endif
      return -1;
    }

    totalSpace = 0;

    /*
       Allocate free blocks for the new file in order 
     */
    for (i = 0; i < curDataBlockNum; i++) {

      if ((rmfsDataBlockHdrArray[i].flag & 0x01) == 0) {
	if (!firstBlock) {
	  dataBlockHdr.next = rmfsDataBlockHdrArray[i].offset;
	  rmfsDataBlockHdrArray[prevIndex].next =
	      rmfsDataBlockHdrArray[i].offset;

	  /*
	     Non-frist block 
	   */
	  rmfsDataBlockHdrArray[i].flag = 0x80 | blockType;

	  WriteDataToStorage(&dataBlockHdr, prevBlockOffset,
			     sizeof(_RmfsBlockHdr));

	  if (dataBlockHdr.dataSize > 0) {
	    WriteDataToStorage(dataBuffer,
			       prevBlockOffset + sizeof(_RmfsBlockHdr),
			       dataBlockHdr.dataSize);
	  }

	  firstBlock = RMFS_FALSE;

	}

	prevIndex = i;

	rmfsDataBlockHdrArray[i].flag = 0x01 | blockType;
	rmfsDataBlockHdrArray[i].identifier = fileID;

	totalSpace += rmfsDataBlockHdrArray[i].size;

	if (totalSpace < newBytesToAllocate) {
	  dataBlockHdr.blockSize = rmfsDataBlockHdrArray[i].size;

	  if (fileSize > 0) {
	    dataBlockHdr.dataSize = rmfsDataBlockHdrArray[i].size;
	  } else {
	    dataBlockHdr.dataSize = 0;
	  }

	  dataBlockHdr.flag = 0x01 | blockType;
	  dataBlockHdr.nameID = fileID;

	  prevBlockOffset = rmfsDataBlockHdrArray[i].offset;

	  if (firstBlock) {
	    firstBlockOffset = prevBlockOffset;
	  }
	} else {		/* This is the last block of the file */

	  if (fileSize > 0) {
	    dataBlockHdr.dataSize =
		newBytesToAllocate - (totalSpace -
				      rmfsDataBlockHdrArray[i].size);
	  } else {
	    dataBlockHdr.dataSize = 0;
	  }


	  /*
	     if it is necessary, split the block 
	   */
	  if ((unsigned int)(rmfsDataBlockHdrArray[i].size - dataBlockHdr.dataSize) >
	      sizeof(_RmfsBlockHdr)
	      || ((unsigned int)curDataBlockNum < MAX_DATABLOCK_NUMBER)) {

	    nextBlockHdr.flag = 0x00;
	    nextBlockHdr.blockSize =
		rmfsDataBlockHdrArray[i].size - dataBlockHdr.dataSize -
		sizeof(_RmfsBlockHdr);

	    rmfsDataBlockHdrArray[i].dataSize = dataBlockHdr.dataSize;
	    dataBlockHdr.blockSize =
		newBytesToAllocate - (totalSpace -
				      rmfsDataBlockHdrArray[i].size);
	    rmfsDataBlockHdrArray[i].size = dataBlockHdr.blockSize;
	    dataBlockHdr.next = 0;
	    nextBlockHdr.dataSize = 0;

	    nextBlockHdr.nameID = 0;
	    nextBlockHdr.next = 0;

	    WriteDataToStorage(&nextBlockHdr,
			       (rmfsDataBlockHdrArray[i].offset +
				dataBlockHdr.blockSize +
				sizeof(_RmfsBlockHdr)), sizeof(_RmfsBlockHdr));

	    /*
	       copy the block head info. behind the fitBlock slot in rmfsDataBlockHdrArray 
	     */

	    for (j = curDataBlockNum; j > i + 1; j--) {
	      rmfsDataBlockHdrArray[j].flag = rmfsDataBlockHdrArray[j - 1].flag;
	      rmfsDataBlockHdrArray[j].identifier =
		  rmfsDataBlockHdrArray[j - 1].identifier;
	      rmfsDataBlockHdrArray[j].offset =
		  rmfsDataBlockHdrArray[j - 1].offset;
	      rmfsDataBlockHdrArray[j].size = rmfsDataBlockHdrArray[j - 1].size;
	      rmfsDataBlockHdrArray[j].dataSize =
		  rmfsDataBlockHdrArray[j - 1].dataSize;

	    }

	    rmfsDataBlockHdrArray[i + 1].flag = nextBlockHdr.flag;
	    rmfsDataBlockHdrArray[i + 1].identifier = nextBlockHdr.nameID;
	    rmfsDataBlockHdrArray[i + 1].offset =
		rmfsDataBlockHdrArray[i].offset + dataBlockHdr.dataSize +
		sizeof(_RmfsBlockHdr);
	    rmfsDataBlockHdrArray[i + 1].size = nextBlockHdr.blockSize;
	    rmfsDataBlockHdrArray[i + 1].dataSize = nextBlockHdr.dataSize;

	    curDataBlockNum++;

	  } else {
	    dataBlockHdr.blockSize = rmfsDataBlockHdrArray[i].size;
	    rmfsDataBlockHdrArray[i].dataSize = dataBlockHdr.dataSize;
	    dataBlockHdr.flag = 0x01 | blockType;
	    dataBlockHdr.nameID = fileID;
	    dataBlockHdr.next = 0;
	  }			/* End of split block */

	  WriteDataToStorage(&dataBlockHdr,
			     rmfsDataBlockHdrArray[i].offset,
			     sizeof(_RmfsBlockHdr));

	  if (dataBlockHdr.dataSize > 0) {
	    WriteDataToStorage(&dataBuffer + totalSpace -
			       rmfsDataBlockHdrArray[i].size,
			       rmfsDataBlockHdrArray[i].offset +
			       sizeof(_RmfsBlockHdr), dataBlockHdr.dataSize);
	  }

	  return firstBlockOffset;

	}			/* End of last block check */
      }
      /* End of free block check */
    }				/* End of For-Loop */

    /*
       If the space of all holes is insufficient for this new file, use the free space 
     */
    if ((totalSpace < newBytesToAllocate)
	&& (curDataBlockNum < MAX_DATABLOCK_NUMBER)) {
      /*
         Write the previous new allocated block  to storage 
       */
      dataBlockHdr.next = RmfsDataBufferEnd;

      WriteDataToStorage(&dataBlockHdr, prevBlockOffset, sizeof(_RmfsBlockHdr));

      WriteDataToStorage(dataBuffer,
			 prevBlockOffset + sizeof(_RmfsBlockHdr),
			 dataBlockHdr.dataSize);


      rmfsDataBlockHdrArray[curDataBlockNum].flag = 0x01 | blockType;
      rmfsDataBlockHdrArray[curDataBlockNum].identifier = fileID;
      rmfsDataBlockHdrArray[curDataBlockNum].size =
	  newBytesToAllocate - totalSpace;

      if (fileSize > 0) {
	rmfsDataBlockHdrArray[curDataBlockNum].dataSize =
	    rmfsDataBlockHdrArray[curDataBlockNum].size;
      } else {
	rmfsDataBlockHdrArray[curDataBlockNum].dataSize = 0;
      }

      rmfsDataBlockHdrArray[curDataBlockNum].offset = RmfsDataBufferEnd;

      dataBlockHdr.flag = 0x01 | blockType;
      dataBlockHdr.blockSize = newBytesToAllocate - totalSpace;

      if (fileSize > 0) {
	dataBlockHdr.dataSize = numBytesToAllocate - totalSpace;
      } else {
	dataBlockHdr.dataSize = 0;
      }

      dataBlockHdr.nameID = fileID;
      dataBlockHdr.next = 0;

      WriteDataToStorage(&dataBlockHdr, RmfsDataBufferEnd,
			 sizeof(_RmfsBlockHdr));

      if (dataBlockHdr.dataSize > 0) {
	WriteDataToStorage(dataBuffer,
			   RmfsDataBufferEnd + sizeof(_RmfsBlockHdr),
			   dataBlockHdr.dataSize);
      }

      RmfsDataBufferEnd += sizeof(_RmfsBlockHdr) + dataBlockHdr.blockSize;

      curDataBlockNum++;

      return firstBlockOffset;
    }
    break;
  }				/* End of While-Loop */

  return rmfsDataBlockHdrArray[i].offset;

}



/**
 * FUNCTION:      rmfsFreeDataBlock()
 * TYPE:          public operation
 * OVERVIEW:      Free one Data Block in JAD/JAR/RMS space.
 *                 
 * INTERFACE:
 *   parameters:  jint        the index of the data block (From 0 to curDataBlockNum -1 )
 *                
 *   returns:     pointer to newly cleared storage data block
 *                
 */
jint rmfsFreeDataBlock(jint index)
{
  _RmfsBlockHdr blockHdr;
  RMFS_BOOLEAN prevFree = RMFS_FALSE;
  RMFS_BOOLEAN nextFree = RMFS_FALSE;
  RMFS_BOOLEAN lastBlock = RMFS_FALSE;

  jint freeBlockPos = -1;
  jint i;

#ifdef TRACE_STORAGE
  printf("rmfsFreeDataBlock: index:  %d; size %d\n", index,
	 rmfsDataBlockHdrArray[index].size);
#endif

  if (index >= curDataBlockNum - 1) {
    lastBlock = RMFS_TRUE;
  }

  if (ReadDataFromStorage
      (&blockHdr, rmfsDataBlockHdrArray[index].offset,
       sizeof(_RmfsBlockHdr)) <= 0) {
#ifdef TRACE_STORAGE
    printf("Read data from persistent storage failed \n");
#endif
    return -1;
  }

  if (index > 0) {
    if ((rmfsDataBlockHdrArray[index - 1].flag & 0x01) == 0) {
      prevFree = RMFS_TRUE;
    }
  }

  if (index < (curDataBlockNum - 1)) {
    if ((rmfsDataBlockHdrArray[index + 1].flag & 0x01) == 0) {
      nextFree = RMFS_TRUE;
    }
  }

  blockHdr.flag = 0x00;
  blockHdr.next = 0;
  blockHdr.dataSize = 0;
  blockHdr.nameID = 0;

  rmfsDataBlockHdrArray[index].flag = 0x00;
  rmfsDataBlockHdrArray[index].identifier = 0;

  if (nextFree == RMFS_TRUE) {

    rmfsDataBlockHdrArray[index].size +=
	rmfsDataBlockHdrArray[index + 1].size + sizeof(_RmfsBlockHdr);
    for (i = index + 1; i < curDataBlockNum; i++) {
      rmfsDataBlockHdrArray[i].flag = rmfsDataBlockHdrArray[i + 1].flag;
      rmfsDataBlockHdrArray[i].offset = rmfsDataBlockHdrArray[i + 1].offset;
      rmfsDataBlockHdrArray[i].identifier =
	  rmfsDataBlockHdrArray[i + 1].identifier;
      rmfsDataBlockHdrArray[i].size = rmfsDataBlockHdrArray[i + 1].size;
      rmfsDataBlockHdrArray[i].dataSize = rmfsDataBlockHdrArray[i + 1].dataSize;
    }

    blockHdr.blockSize = rmfsDataBlockHdrArray[index].size;

    memset(&rmfsDataBlockHdrArray[curDataBlockNum - 1], 0xFF,
	   sizeof(_RmfsDataBlockHdr));
    curDataBlockNum--;
  }

  if (prevFree == RMFS_TRUE) {
    rmfsDataBlockHdrArray[index - 1].identifier = 0;
    rmfsDataBlockHdrArray[index - 1].size +=
	rmfsDataBlockHdrArray[index].size + sizeof(_RmfsBlockHdr);


    blockHdr.blockSize = rmfsDataBlockHdrArray[index - 1].size;
    for (i = index; i < curDataBlockNum; i++) {
      rmfsDataBlockHdrArray[i].flag = rmfsDataBlockHdrArray[i + 1].flag;
      rmfsDataBlockHdrArray[i].offset = rmfsDataBlockHdrArray[i + 1].offset;
      rmfsDataBlockHdrArray[i].identifier =
	  rmfsDataBlockHdrArray[i + 1].identifier;
      rmfsDataBlockHdrArray[i].size = rmfsDataBlockHdrArray[i + 1].size;
      rmfsDataBlockHdrArray[i].dataSize = rmfsDataBlockHdrArray[i + 1].dataSize;
    }

    memset(&rmfsDataBlockHdrArray[curDataBlockNum - 1], 0xFF,
	   sizeof(_RmfsDataBlockHdr));
    curDataBlockNum--;

    WriteDataToStorage(&blockHdr, rmfsDataBlockHdrArray[index - 1].offset,
		       sizeof(_RmfsBlockHdr));

    freeBlockPos = rmfsDataBlockHdrArray[index - 1].size;

  } else {
    WriteDataToStorage(&blockHdr, rmfsDataBlockHdrArray[index].offset,
		       sizeof(_RmfsBlockHdr));
    freeBlockPos = rmfsDataBlockHdrArray[index].size;
  }

  if (lastBlock == RMFS_TRUE) {

    if (curDataBlockNum < 2) {
      RmfsDataBufferEnd = RmfsMemoryStart + sizeof(_RmfsHdr);
      return 0;
    }

    if (rmfsDataBlockHdrArray[curDataBlockNum - 2].flag != 0xFF) {
      RmfsDataBufferEnd =
	  rmfsDataBlockHdrArray[curDataBlockNum - 2].offset +
	  rmfsDataBlockHdrArray[curDataBlockNum - 2].size +
	  sizeof(_RmfsBlockHdr);
    } else {
#ifdef TRACE_STORAGE
      printf("Exception happens in FreeDataBlock \n");
#endif
    }

    memset(&rmfsDataBlockHdrArray[index], 0xFF, sizeof(_RmfsDataBlockHdr));
    curDataBlockNum--;
  }

  return freeBlockPos;

}


/**
 * FUNCTION:      rmfsDelFile(const char* filename)
 * TYPE:          public operation
 * OVERVIEW:      Delete all blocks assigned for one file
 * INTERFACE:
 *   parameters:  const char* filename   Filename 
 *                
 *   return:      void             
 */
void rmfsDelFile(const char *filename)