rmfsalloc.c

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

{
  uchar filenameID = 0;
  jint i;

#ifdef TRACE_STORAGE
  printf("rmfsDelFile: filename:  %s\n", filename);
#endif
  if ((searchNameTabByString(filename, &filenameID) <= 0)
      || (filenameID <= 0)) {
    return;
  }

  for (i = curDataBlockNum - 1; i >= 0; i--) {
    if (rmfsDataBlockHdrArray[i].identifier == filenameID) {
      rmfsFreeDataBlock(i);
    }
  }

  return;

}


/**
 * FUNCTION:      rmfsFree(jint start, jint size )
 * TYPE:          public operation
 * OVERVIEW:      Free the whole RMFS storage, just rewrite the MAGIC and Head
 *                
 * INTERFACE:
 *   parameters:  size   Size of Raw Memory Storage to use
 *                start  start address of the Raw memory storage
 *   returns:     0 on succes; != 0 on failure
 *                
 */
/*jint rmfsFree(jint start, jint size) */

jint rmfsFree(jint start, jint size)
{
  _RmfsHdr rmfsHdr;


#ifdef TRACE_STORAGE
  printf("rmfsFree: start: %d; size: %d\n", start, size);
#endif
  if ((unsigned int)size < sizeof(_RmfsBlockHdr) + sizeof(_RmfsHdr)) {
#ifdef TRACE_STORAGE
    printf("Can't initialize. Not enough memory.\n");
#endif
    return -1;
  }

  if ((start < MIN_RAW_MEMORY_ADDR)
      || ((unsigned int)(start + size) > MAX_RAW_MEMORY_ADDR)) {
#ifdef TRACE_STORAGE
    printf("Start address of the memory block is invalid \n");
#endif
    return -1;
  }

  rmfsHdr.magic = 0;
  rmfsHdr.dataBufferEndPos = 0;
  RmfsDataBufferEnd = rmfsHdr.dataBufferEndPos;

  rmfsHdr.nameTableEndPos = 0;
  RmfsNameTableEnd = rmfsHdr.nameTableEndPos;

  rmfsHdr.maxFileID = 0;
  RmfsGlobalNameID = 0;

  WriteDataToStorage(&rmfsHdr, start, sizeof(_RmfsHdr));


  return 0;
}

/**
 * FUNCTION:      rmfsWriteDataToBlock()
 * TYPE:          public operation
 * OVERVIEW:      Wirte data buffer to one RMFS  Data Block
 * INTERFACE:
 *   parameters:  index:   DataBlock Index
 *                buffer   the data buffer will be written into RMFS Data Block.
 *                offset   start address in RMFS DataBlock
 *                size     the byte number 
 *   returns:     byte number of written buffer ; < 0 on failure
 *                
 */
jint rmfsReadBlock(jint index, void *buffer, jint size, jint offset)
{
  jint storePos;

#ifdef TRACE_STORAGE
  printf("rmfsReadBlock: index: %d; size: %d; offset %d\n", index, size,
	 offset);
#endif
  if ((offset + size) > rmfsDataBlockHdrArray[index].size) {
    return -1;
  }

  storePos =
      rmfsDataBlockHdrArray[index].offset + offset + sizeof(_RmfsBlockHdr);

  ReadDataFromStorage(buffer, storePos, size);

  return size;
}

/**
 * FUNCTION:      rmfsWriteDataToBlock()
 * TYPE:          public operation
 * OVERVIEW:      Wirte data buffer to one RMFS  Data Block
 * INTERFACE:
 *   parameters:  index:   DataBlock Index
 *                buffer   the data buffer will be written into RMFS Data Block.
 *                offset   start address in RMFS DataBlock
 *                size     the byte number 
 *   returns:     byte number of written buffer ; < 0 on failure
 *                
 */
jint rmfsWriteDataToBlock(jint index, const void *buffer, jint size, jint offset)
{
  jint storePos;
  _RmfsBlockHdr blockHdr;

#ifdef TRACE_STORAGE
  printf("rmfsWriteDataToBlock: index: %d; size: %d; offset %d\n", index,
	 size, offset);
#endif

  if ((offset + size) > rmfsDataBlockHdrArray[index].size) {
    return -1;
  }

  if ((offset + size) > rmfsDataBlockHdrArray[index].dataSize) {
    rmfsDataBlockHdrArray[index].dataSize = offset + size;
  }

  /*
     Write the new header to the storage 
   */
  blockHdr.blockSize = rmfsDataBlockHdrArray[index].size;
  blockHdr.dataSize = rmfsDataBlockHdrArray[index].dataSize;
  blockHdr.flag = rmfsDataBlockHdrArray[index].flag;
  blockHdr.nameID = rmfsDataBlockHdrArray[index].identifier;
  blockHdr.next = rmfsDataBlockHdrArray[index].next;

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

  /*
     Write the contents to the storage 
   */
  storePos =
      rmfsDataBlockHdrArray[index].offset + offset + sizeof(_RmfsBlockHdr);

  WriteDataToStorage(buffer, storePos, size);

  return size;
}

/**
 * FUNCTION:      rmfsAllocLinkedBlock()
 * TYPE:          public operation
 * OVERVIEW:      Allocate new Data Block behind one allocated Data Block for same file
 * INTERFACE:
 *   parameters:  index:   DataBlock Index
 *                buffer   the data buffer will be written into the new allocated RMFS Data Block.
 *                size     the byte number 
 *   returns:     byte number of written buffer ; < 0 on failure
 *                
 */

jint rmfsAllocLinkedBlock(jint index, const void *buffer, jint size)
{
  jint storePos;
  char *filename = NULL;
  jboolean fileType;
  _RmfsBlockHdr blockHdr;
  jint freeSize = 0;
  jint i;

#ifdef TRACE_STORAGE
  printf("rmfsAllocLinkedBlock: index: %d; size: %d\n", index, size);
#endif
  fileType = rmfsDataBlockHdrArray[index].flag & 0x3E;

  if ((searchNameTabByID
       (&filename, rmfsDataBlockHdrArray[index].identifier)) < 0) {
    return -1;
  }

  if (filename == NULL) {
    return -1;
  }

  fileType |= 0x80;		/* It is not the first block */

  if ((index == curDataBlockNum - 1)) {
    if ((RmfsNameTableEnd - RmfsDataBufferEnd) >= size) {
      rmfsDataBlockHdrArray[index].size += size;
      rmfsDataBlockHdrArray[index].dataSize += size;

      /*
         Write the new header to the storage 
       */
      blockHdr.blockSize = rmfsDataBlockHdrArray[index].size;
      blockHdr.dataSize = rmfsDataBlockHdrArray[index].dataSize;
      blockHdr.flag = rmfsDataBlockHdrArray[index].flag;
      blockHdr.nameID = rmfsDataBlockHdrArray[index].identifier;
      blockHdr.next = rmfsDataBlockHdrArray[index].next;
      WriteDataToStorage(&blockHdr, rmfsDataBlockHdrArray[index].offset,
			 sizeof(_RmfsBlockHdr));

      /*
         Write data buffer to storage 
       */
      WriteDataToStorage(buffer, RmfsDataBufferEnd, size);

      /*
         Update RmfsDataBufferEnd 
       */
      RmfsDataBufferEnd += size;
    } else {
#ifdef TRACE_STORAGE
      printf("No enough space \n");
#endif
      return -1;
    }

    return size;

  }

  if ((rmfsDataBlockHdrArray[index + 1].flag & 0x01) == 0x00) {

    if (rmfsDataBlockHdrArray[index + 1].size > size) {
      rmfsDataBlockHdrArray[index].size += size;
      rmfsDataBlockHdrArray[index].dataSize += size;

      /*
         Write the new header to the storage 
       */
      blockHdr.blockSize = rmfsDataBlockHdrArray[index].size;
      blockHdr.dataSize = rmfsDataBlockHdrArray[index].dataSize;
      blockHdr.flag = rmfsDataBlockHdrArray[index].flag;
      blockHdr.nameID = rmfsDataBlockHdrArray[index].identifier;
      blockHdr.next = rmfsDataBlockHdrArray[index].next;
      WriteDataToStorage(&blockHdr, rmfsDataBlockHdrArray[index].offset,
			 sizeof(_RmfsBlockHdr));

      /*
         Write data buffer to storage 
       */
      WriteDataToStorage(buffer,
			 rmfsDataBlockHdrArray[index].offset +
			 sizeof(_RmfsBlockHdr)
			 + blockHdr.dataSize - size, size);

      /*
         Update next free block 
       */
      rmfsDataBlockHdrArray[index + 1].size -= size;

      /*
         Write the new header to the storage 
       */
      blockHdr.blockSize = rmfsDataBlockHdrArray[index + 1].size;
      blockHdr.dataSize = rmfsDataBlockHdrArray[index + 1].dataSize;
      blockHdr.flag = rmfsDataBlockHdrArray[index + 1].flag;
      blockHdr.nameID = rmfsDataBlockHdrArray[index + 1].identifier;
      blockHdr.next = rmfsDataBlockHdrArray[index + 1].next;

      rmfsDataBlockHdrArray[index + 1].offset =
	  rmfsDataBlockHdrArray[index].offset +
	  rmfsDataBlockHdrArray[index].size + sizeof(_RmfsBlockHdr);

      WriteDataToStorage(&blockHdr,
			 rmfsDataBlockHdrArray[index].offset +
			 rmfsDataBlockHdrArray[index].size +
			 sizeof(_RmfsBlockHdr), sizeof(_RmfsBlockHdr));

      return size;

    } else if ((rmfsDataBlockHdrArray[index + 1].size +
		sizeof(_RmfsBlockHdr)) >= (unsigned int)size) {

      rmfsDataBlockHdrArray[index].size +=
	  (rmfsDataBlockHdrArray[index + 1].size + sizeof(_RmfsBlockHdr));
      rmfsDataBlockHdrArray[index].dataSize += size;

      /*
         Write the new header to the storage 
       */
      blockHdr.blockSize = rmfsDataBlockHdrArray[index].size;
      blockHdr.dataSize = rmfsDataBlockHdrArray[index].dataSize;
      blockHdr.flag = rmfsDataBlockHdrArray[index].flag;
      blockHdr.nameID = rmfsDataBlockHdrArray[index].identifier;
      blockHdr.next = rmfsDataBlockHdrArray[index].next;
      WriteDataToStorage(&blockHdr, rmfsDataBlockHdrArray[index].offset,
			 sizeof(_RmfsBlockHdr));

      /*
         Write data buffer to storage 
       */
      WriteDataToStorage(buffer,
			 rmfsDataBlockHdrArray[index].offset +
			 sizeof(_RmfsBlockHdr)
			 + blockHdr.dataSize - size, size);


      /*
         Remove the Free Data Block record 
       */
      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;
      }

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

      curDataBlockNum--;
      return size;
    } else {

      freeSize = rmfsDataBlockHdrArray[index + 1].size + sizeof(_RmfsBlockHdr);

      rmfsDataBlockHdrArray[index].size += freeSize;
      rmfsDataBlockHdrArray[index].dataSize += freeSize;

      /*
         Write the new header to the storage 
       */
      blockHdr.blockSize = rmfsDataBlockHdrArray[index].size;
      blockHdr.dataSize = rmfsDataBlockHdrArray[index].dataSize;
      blockHdr.flag = rmfsDataBlockHdrArray[index].flag;
      blockHdr.nameID = rmfsDataBlockHdrArray[index].identifier;
      blockHdr.next = rmfsDataBlockHdrArray[index].next;
      WriteDataToStorage(&blockHdr, rmfsDataBlockHdrArray[index].offset,
			 sizeof(_RmfsBlockHdr));

      /*
         Write data buffer to storage 
       */
      WriteDataToStorage(buffer,
			 rmfsDataBlockHdrArray[index].offset +
			 sizeof(_RmfsBlockHdr) + blockHdr.dataSize -
			 freeSize, freeSize);

      /*
         Remove the Free Data Block record 
       */
      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;
      }

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

      curDataBlockNum--;
    }
  }

  storePos = rmfsFileAlloc(size - freeSize, filename, buffer, fileType);

  // jvmFree(filename);

  if (storePos < 0) {
#ifdef TRACE_STORAGE
    printf("No aviable space \n");
#endif
    return -1;
  }

  if (rmfsDataBlockHdrArray[index].offset != storePos) {

#ifdef TRACE_STORAGE
    printf("Really create a linked blocked \n");
#endif

    rmfsDataBlockHdrArray[index].next = storePos;

    /*
       Write the new header to the storage 
     */
    blockHdr.blockSize = rmfsDataBlockHdrArray[index].size;
    blockHdr.dataSize = rmfsDataBlockHdrArray[index].dataSize;
    blockHdr.flag = rmfsDataBlockHdrArray[index].flag;
    blockHdr.nameID = rmfsDataBlockHdrArray[index].identifier;
    blockHdr.next = rmfsDataBlockHdrArray[index].next;
    WriteDataToStorage(&blockHdr, rmfsDataBlockHdrArray[index].offset,
		       sizeof(_RmfsBlockHdr));
  }

  return size;
}

/**
 * FUNCTION:      rmfsSearchBlockByPos()
 * TYPE:          public operation
 * OVERVIEW:      Search the RMFS Data Block per the start address of the Data Block
 * INTERFACE:
 *   parameters:  index:   matched DataBlock Index
 *                address  the start address of the RMFS Data Block.
 *
 *   returns:     >=0 success ; < 0 on failure
 *                
 */
jint rmfsSearchBlockByPos(uchar *index, jint address)
{
  jint i;

#ifdef TRACE_STORAGE
  printf("rmfsSearchBlockByPos: index: %d; address: %d\n", *index, address);
#endif

  if (address <= 0) {
    return -1;
  }

  for (i = 0; i < MAX_DATABLOCK_NUMBER; i++) {
    if (rmfsDataBlockHdrArray[i].offset == address) {
      *index = i;
      return i;
    }
  }

  *index = 0;

  return -1;
}

/**
 * FUNCTION:      rmfsSplitBlock()
 * TYPE:          public operation
 * OVERVIEW:      Split one RMFS Data Block to two Data Blcoks, the second one is free
 * JINTERFACE:
 *   parameters:  index:   DataBlock Index
 *                address  the start address of the second RMFS Data Block.
 *
 *   returns:     >=0 success ; < 0 on failure
 *                
 */
jint rmfsSplitBlock(jint index, jint offset)
{
  _RmfsBlockHdr dataBlockHdr;
  _RmfsBlockHdr nextBlockHdr;
  jint j;
  jint orgBlockSize;
  jint newBlockSize = offset;

#ifdef TRACE_STORAGE
  printf("rmfsSplitBlock: index: %d; offset: %d\n", index, offset);
#endif

  if((newBlockSize/ALIGNMENT_BYTE) * ALIGNMENT_BYTE != offset) { 
    newBlockSize = (newBlockSize/ALIGNMENT_BYTE + 1) * ALIGNMENT_BYTE; 
  }

  dataBlockHdr.blockSize = newBlockSize;
  dataBlockHdr.dataSize = offset;
  dataBlockHdr.flag = rmfsDataBlockHdrArray[index].flag;
  dataBlockHdr.nameID = rmfsDataBlockHdrArray[index].identifier;
  dataBlockHdr.next = 0;

  orgBlockSize = rmfsDataBlockHdrArray[index].size;

  rmfsDataBlockHdrArray[index].size = newBlockSize;

  /*
     If the current block is the last block, just free the remain space 
   */
  if (index == (curDataBlockNum - 1)) {

    RmfsDataBufferEnd -= (orgBlockSize - newBlockSize);

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

    return 0;

  } else {

    if (curDataBlockNum >= MAX_DATABLOCK_NUMBER) {
      return -1;
    }

    nextBlockHdr.flag = 0x00;
    nextBlockHdr.blockSize = orgBlockSize - newBlockSize - sizeof(_RmfsBlockHdr);
    nextBlockHdr.dataSize = 0;
    nextBlockHdr.nameID = 0;
    nextBlockHdr.next = 0;

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

    /*
       move the block head info. behind the index slot in rmfsDataBlockHdrArray 
     */
    for (j = curDataBlockNum; j > index + 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[j].next = rmfsDataBlockHdrArray[j - 1].next;

    }

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

    curDataBlockNum++;
  }

  return 0;
}

#ifdef __cplusplus
}
#endif