rmfsalloc.c

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

    if ((curLength + nameTabHdr->nameLen) > tabLength) {
#ifdef TRACE_STORAGE
      printf("No entity match \n");
#endif
      return -1;
    }

    nameTab.filename = nameTabBuffer + curLength;

    if ((strcmp(filename, nameTab.filename) == 0)) {
      curLength = curLength - sizeof(_RmfsNameTabHdr);
      done = RMFS_TRUE;
      break;
    }

    curLength += nameTabHdr->nameLen;

    if ((curLength + sizeof(_RmfsNameTabHdr)) > (unsigned int)tabLength) {
#ifdef TRACE_STORAGE
      printf("No entity match \n");
#endif

      // jvmFree (nameTabBuffer);
      return -1;
    }
  }


  *identifier = nameTabHdr->identifier;

  // jvmFree (nameTabBuffer);
  return RmfsNameTableEnd + curLength;


}


/**
 * FUNCTION:      searchNameTabStartWith()
 * TYPE:          public operation
 * OVERVIEW:      Search one entity NameTable Space, whose filename starts with one string;
 * INTERFACE:
 *   parameters:  <char* filename, jint *identifier>
 *   returns:     < jint position>
 *                
 */

jint searchNameTabStartWith(const char *filename, uchar *identifier)
{
  char *nameTabBuffer;
  _RmfsNameTab nameTab;
  _RmfsNameTabHdrPtr nameTabHdr = NULL;
  RMFS_BOOLEAN done = RMFS_FALSE;
  RMFS_BOOLEAN findNext = RMFS_FALSE;
  jint tabLength = 0;
  jint curLength = 0;
  jint matchLen = 0;

  matchLen = strlen(filename);

#ifdef TRACE_STORAGE
  printf("searchNameTabByStartWith: filename %s\n", filename);
#endif

  tabLength = RmfsMemoryEnd - RmfsNameTableEnd;

  if ((unsigned int)tabLength < sizeof(_RmfsNameTabHdr)) {
#ifdef TRACE_STORAGE
    printf("No entity in Name Table\n");
#endif

    return -1;
  }

  nameTabBuffer = (char *) RmfsNameTableEnd;
  /*
     nameTabBuffer = (char *) jvmMalloc (RmfsMemoryEnd - RmfsNameTableEnd);

     if (nameTabBuffer == NULL) {
#ifdef TRACE_STORAGE
     printf ("Memory Allocation Failed \n");
#endif
     return -1;
     }

     if (ReadDataFromStorage (nameTabBuffer, RmfsNameTableEnd, tabLength) < 0) {
     jvmFree (nameTabBuffer);
     return -1;
     }
   */
  while (!done) {
    nameTabHdr = (_RmfsNameTabHdrPtr) (nameTabBuffer + curLength);

    curLength += sizeof(_RmfsNameTabHdr);

    if ((curLength + nameTabHdr->nameLen) > tabLength) {
#ifdef TRACE_STORAGE
      printf("No entity match \n");
#endif
      // jvmFree (nameTabBuffer);
      return -1;
    }

    nameTab.filename = nameTabBuffer + curLength;

#ifdef TRACE_STORAGE
    printf("filename: %s; nameTab.filename: %s, matchlen: %d \n", filename,
	   nameTab.filename, matchLen);
#endif
    if (strncmp(filename, nameTab.filename, matchLen) == 0) {
      if ((prevFilename == NULL) || (findNext == RMFS_TRUE)) {
	curLength = curLength - sizeof(_RmfsNameTabHdr);
	done = RMFS_TRUE;
	break;
      } else if (strcmp(prevFilename, nameTab.filename) == 0) {
	findNext = RMFS_TRUE;
      }
    }

    curLength += nameTabHdr->nameLen;

    if ((curLength + sizeof(_RmfsNameTabHdr)) > (unsigned int)tabLength) {
#ifdef TRACE_STORAGE
      printf("No entity match \n");
#endif

      prevFilename = NULL;
      // jvmFree (nameTabBuffer);
      return -1;
    }
  }


  *identifier = nameTabHdr->identifier;

  // jvmFree (nameTabBuffer);

  prevFilename =
      (char *) (RmfsNameTableEnd + curLength + sizeof(_RmfsNameTabHdr));

#ifdef TRACE_STORAGE
  printf("preFilename: %s; RmfsNameTableEnd %d \n", prevFilename,
	 RmfsNameTableEnd);
#endif
  return RmfsNameTableEnd + curLength;


}

/**
 * FUNCTION:      delNameTabByID()
 * TYPE:          public operation
 * OVERVIEW:      Delete one entity whose identifier is equal to input integer in NameTable Space;
 * INTERFACE:
 *   parameters:  <char* filename, jint identifier>
 *   returns:     < jint position>
 *                
 */


RMFS_BOOLEAN delNameTabByID(jint identifier)
{
  char *filename = NULL;
  int lastNameLen = 0;
  jint entityPos = 0;
  uchar nameID;

#ifdef TRACE_STORAGE
  printf("delNameTabById: identifier %d\n", identifier);
#endif
  entityPos = searchNameTabByID(&filename, identifier);

  if ((entityPos < 0) || (filename == NULL)) {
#ifdef TRACE_STORAGE
    printf("No match entity in Name Table\n");
#endif

    return RMFS_FALSE;
  }


  /*
     nameTab = (_RmfsNameTabHdrPtr) jvmMalloc (sizeof (_RmfsNameTabHdr) + fileNameLen);

     if (nameTab == NULL) {
     return RMFS_FALSE;
     }

     nameTab.identifier = 0;
     nameTab.nameLen = fileNameLen;
   */
  nameID = 0;
  WriteDataToStorage(&nameID, entityPos + sizeof(uchar),
		     sizeof(uchar));

  /*
     If the entity is the last Name Table entity, move the RmfsNameTabEnd Pointer 
   */
  if (entityPos == RmfsNameTableEnd) {
    lastNameLen = sizeof(_RmfsNameTabHdr) + strlen(filename) + 1;

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

    RmfsNameTableEnd += lastNameLen;

  }

  // jvmFree(filename);
  // jvmFree (nameTab);
  return RMFS_TRUE;


}


/**
 * FUNCTION:      delNameTabByString()
 * TYPE:          public operation
 * OVERVIEW:      Delete one entity whose identifier is equal to input integer in NameTable Space;
 * INTERFACE:
 *   parameters:  <char* filename, jint identifier>
 *   returns:     < jint position>
 *                
 */


RMFS_BOOLEAN delNameTabByString(const char *filename)
{
  uchar identifier = 0;
  jint  nameTabLen;
  jint entityPos = 0;
  //  jint fileNameLen;

#ifdef TRACE_STORAGE
  printf("delNameTabByString: filename %s\n", filename);
#endif
  entityPos = searchNameTabByString(filename, &identifier);

  if (entityPos < 0) {
#ifdef TRACE_STORAGE
    printf("No match entity in Name Table\n");
#endif

    return RMFS_FALSE;
  }

/*
    fileNameLen = strlen (filename) + 1;


    nameTab =
      (_RmfsNameTabHdrPtr) jvmMalloc (sizeof (_RmfsNameTabHdr) + fileNameLen);

    if (nameTab == NULL) {
      return RMFS_FALSE;
    }

    nameTab->identifier = 0;
    nameTab->nameLen = fileNameLen;
    memset ((void *) (nameTab + 1), 0x00, nameTab->nameLen);
*/

  identifier = 0;
  WriteDataToStorage(&identifier, entityPos + sizeof(uchar),
		     sizeof(uchar));

  //    jvmFree (nameTab);

  /*
     If the entity is the last Name Table entity, move the RmfsNameTabEnd Pointer 
   */
  if (entityPos == RmfsNameTableEnd) {
    nameTabLen =  sizeof(_RmfsNameTabHdr) + strlen(filename) + 1;
    if(nameTabLen != (nameTabLen/ALIGNMENT_BYTE) * ALIGNMENT_BYTE ) { 
      nameTabLen = (nameTabLen/ALIGNMENT_BYTE + 1) * ALIGNMENT_BYTE;
    }
	     
    RmfsNameTableEnd += nameTabLen;
  }

  return RMFS_TRUE;


}

/**
 * FUNCTION:      rmfsTruncateNameTable()
 * TYPE:          public operation
 * OVERVIEW:      Eliminate all holes in Name Table Space
 *                Call once before exits
 * INTERFACE:
 *   parameters:  None
 *
 *   returns:     0: Success;   Other values: Failed
 *                
 */
jint rmfsTruncateNameTable()
{
  char *nameTabBuffer;
  _RmfsNameTabHdr nameTabHdr;
  jint tabLength = 0;
  jint curLength = 0;
  jint remainByte = 0;
  char *tempAddress = 0;

#ifdef TRACE_STORAGE
  printf("rmfsTruncateNameTable: \n");
#endif
  tabLength = RmfsMemoryEnd - RmfsNameTableEnd;

  if ((unsigned int)tabLength < sizeof(_RmfsNameTabHdr)) {
#ifdef TRACE_STORAGE
    printf("No entity in Name Table\n");
#endif

    return -1;
  }

  nameTabBuffer = (char *) RmfsNameTableEnd;
  /*
     nameTabBuffer = (char *) jvmMalloc (RmfsMemoryEnd - RmfsNameTableEnd);

     if (nameTabBuffer == NULL) {
#ifdef TRACE_STORAGE
     printf ("Memory Allocation Failed \n");
#endif
     return -1;
     }

     if (ReadDataFromStorage (nameTabBuffer, RmfsNameTableEnd, tabLength) < 0) {
     jvmFree (nameTabBuffer);
     return -1;
     }
   */
  while ((curLength + sizeof(_RmfsNameTabHdr)) <= (unsigned int)tabLength) {
    nameTabHdr.nameLen = (uchar) *(nameTabBuffer + curLength);

    curLength += sizeof(jint);

    nameTabHdr.identifier = (uchar) *(nameTabBuffer + curLength);

    curLength += sizeof(jint);

    if (nameTabHdr.identifier == 0x00) {
      /*
         This Name Table entity is empty, advance all subsequence data to fill this hole
         * In order to avoid employ another large RAM heap, just move the data segment by segment 
       */

      remainByte =
	  tabLength - curLength - (nameTabHdr.nameLen +
				   sizeof(_RmfsNameTabHdr));
      tempAddress = nameTabBuffer + curLength - sizeof(_RmfsNameTabHdr);
      while ((unsigned int)remainByte >= (nameTabHdr.nameLen + sizeof(_RmfsNameTabHdr))) {
	tempAddress =
	    tempAddress + sizeof(_RmfsNameTabHdr) + nameTabHdr.nameLen;

	memcpy((tempAddress - sizeof(_RmfsNameTabHdr) -
		nameTabHdr.nameLen), tempAddress,
	       (nameTabHdr.nameLen + sizeof(_RmfsNameTabHdr)));

	remainByte =
	    remainByte - (nameTabHdr.nameLen + sizeof(_RmfsNameTabHdr));

      }

      if (remainByte > 0) {
	memcpy(tempAddress,
	       (tempAddress + sizeof(_RmfsNameTabHdr) +
		nameTabHdr.nameLen), remainByte);

      }

      tabLength = tabLength - (nameTabHdr.nameLen + sizeof(_RmfsNameTabHdr));

      curLength = curLength - sizeof(_RmfsNameTabHdr);

      continue;
    }

    if ((curLength + nameTabHdr.nameLen) > tabLength) {
      break;
    }

    curLength += nameTabHdr.nameLen;
  }

  WriteDataToStorage(nameTabBuffer, RmfsMemoryEnd - tabLength, tabLength);

  RmfsNameTableEnd = RmfsMemoryEnd - tabLength;

  // jvmFree (nameTabBuffer);


  return 0;

}


/**
 * FUNCTION:      rmfsInitDataBlockHdrArray()
 * TYPE:          public operation
 * OVERVIEW:      Allocate space from the raw memory block for one file 
 * INTERFACE:
 *   parameters:  None
 *
 *   returns:     pointer to the newly allocated memory
 *                
 */
void rmfsInitDataBlockHdrArray()
{
  jint rmfsDataBlockPtr;
  _RmfsBlockHdr dataBlockHdr;
  short i = 0;

#ifdef TRACE_STORAGE
  printf("rmfsInitDataBlockHdrArray: \n");
#endif
  memset(rmfsDataBlockHdrArray, 0xFF,
	 sizeof(_RmfsDataBlockHdr) * MAX_DATABLOCK_NUMBER);

  rmfsDataBlockPtr = RmfsMemoryStart + sizeof(_RmfsHdr);

  while (((unsigned int)rmfsDataBlockPtr <= (RmfsDataBufferEnd - sizeof(_RmfsBlockHdr)))
	 && (i < MAX_DATABLOCK_NUMBER)) {

    if (ReadDataFromStorage
	(&dataBlockHdr, rmfsDataBlockPtr, sizeof(_RmfsBlockHdr)) < 0) {
#ifdef TRACE_STORAGE
      printf("Read Persistent Storage Failed \n");
#endif
    }

    rmfsDataBlockHdrArray[i].flag = dataBlockHdr.flag;
    rmfsDataBlockHdrArray[i].identifier = dataBlockHdr.nameID;
    rmfsDataBlockHdrArray[i].offset = rmfsDataBlockPtr;
    rmfsDataBlockHdrArray[i].size = dataBlockHdr.blockSize;
    rmfsDataBlockHdrArray[i].dataSize = dataBlockHdr.dataSize;
    rmfsDataBlockHdrArray[i].next = dataBlockHdr.next;
    i++;

    rmfsDataBlockPtr += dataBlockHdr.blockSize + sizeof(_RmfsBlockHdr);
  }

  curDataBlockNum = i;
}



/**
 * FUNCTION:      rmfsFileAlloc()
 * TYPE:          public operation
 * OVERVIEW:      Allocate space from the raw memory block for one file 
 * INTERFACE:
 *   parameters:  numBytesToAllocate       Number of byte to allocate
 *                filename   Filename where allocation occured
 *                dataBuffer The data buffer of the new file
 *                blockType  File Type (JAD/JAR/RMS )
 *   returns:     pointer to the newly allocated block
 *                
 */
jint
rmfsFileAlloc(jint numBytesToAllocate, const char *filename,
	      const void *dataBuffer, jboolean blockType)
{

  jint sizeDiff = -1;
  jint minSizeDiff = -1;
  short fitBlock = -1;
  jint rmfsMemoryPtr;
  _RmfsBlockHdr dataBlockHdr;
  _RmfsBlockHdr nextBlockHdr;
  jint i = 0;
  jint j = 0;
  jint minsizeDiff = -1;
  uchar fileID = 0;
  jint totalSpace = 0;
  RMFS_BOOLEAN firstBlock = RMFS_TRUE;
  jint prevBlockOffset = -1;
  jint firstBlockOffset = -1;
  jint prevIndex = 0;
  jint fileSize;	/* Byte number written to the file */
  jint newBytesToAllocate = numBytesToAllocate;

#ifdef TRACE_STORAGE
  printf("rmfsFileAlloc: numBytes: %d, filename: %s, blockType %d\n",
	 numBytesToAllocate, filename, blockType);
#endif
  /*
     When the dataBuffer is NULL, just allocate space for the file, doesn't write data into it 
   */
  if (dataBuffer == NULL) {
    fileSize = 0;
  } else {
    fileSize = numBytesToAllocate;
  }

  if((newBytesToAllocate/ALIGNMENT_BYTE) * ALIGNMENT_BYTE != numBytesToAllocate) { 
    newBytesToAllocate = (newBytesToAllocate/ALIGNMENT_BYTE + 1) * ALIGNMENT_BYTE; 
  }

  if ((searchNameTabByString(filename, &fileID) <= 0) || (fileID <= 0)) {
    fileID = rmfsNewNameTable(filename);

    if (fileID == 0) {

      return -1;
    }
  }

  rmfsMemoryPtr = RmfsMemoryStart + sizeof(_RmfsHdr);

  while ((unsigned int)rmfsMemoryPtr <= (RmfsNameTableEnd - sizeof(_RmfsBlockHdr))) {

    if (ReadDataFromStorage
	(&dataBlockHdr, rmfsMemoryPtr, sizeof(_RmfsBlockHdr)) < 0) {
#ifdef TRACE_STORAGE
      printf("Read Persistent Storage Failed \n");
#endif
    }

    /*
       Best Fit Algorithm 
     */
    while ((rmfsDataBlockHdrArray[i].flag != 0xFF)
	   && (i < MAX_DATABLOCK_NUMBER)) {
      /*
         allocating 
       */
      if ((rmfsDataBlockHdrArray[i].flag & 0x01) == 0) {
	/*
	   The block is free 
	 */
	if ((rmfsDataBlockHdrArray[i].size >= newBytesToAllocate) && 
		((rmfsDataBlockHdrArray[i].size != MAX_BLOCKSIZE_4_INSTALL_TEMP) || 
	        (newBytesToAllocate == MAX_BLOCKSIZE_4_INSTALL_TEMP)))	{
	  sizeDiff = rmfsDataBlockHdrArray[i].size - newBytesToAllocate;
	  if ((minSizeDiff == -1) || (sizeDiff < minsizeDiff)) {
	    minSizeDiff = sizeDiff;
	    fitBlock = i;
	  }
	}