rmfsalloc.c

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

/*
 * 	
 *
 * Copyright  1990-2007 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt).
 * 
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 * 
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions.
 */

/**
 * @file
 */

/**
 * RMFS storage management and file allocation functions.
 *
 * With these functions, we have the ability to manage RMFS
 * raw memory pool. Please refer to the RMFS design document for details
 *
 * warning This code is not thread safe.
 *
 */

#include <stdio.h>
#include <string.h>

#include <rmfsAlloc.h>


#ifdef __cplusplus
extern "C"
{
#endif

#define   MIN_RAW_MEMORY_ADDR    0x00000000
#define   MAX_RAW_MEMORY_ADDR    0xFFFFFFFF
#define   ALIGNMENT_BYTE         0x04


/*
 * Constant to verify a RMFS storage's validity
 */
#define MAGIC         0xCAFE
//#define TRACE_STORAGE 1

static jint RmfsGlobalNameID = 0x01;


/* Initialize the Open File Table */
extern void rmfsInitOpenFileTab();

static char *prevFilename = NULL;

_RmfsDataBlockHdr rmfsDataBlockHdrArray[MAX_DATABLOCK_NUMBER];
jint curDataBlockNum = 0;


static jint RmfsMemoryStart;	/* Start Address of RMFS memory space */
static jint RmfsNameTableEnd;	/* End Address of RMFS Name Table Space */
static jint RmfsDataBufferEnd;	/* End Address of RMFS DataBufferEnd */
static jint RmfsMemoryEnd;	/* End Address of RMFS memory space */

static jint totalStorageSpace = -1;

unsigned char tempBuf[300];      /* This buffer is used to avoid jvmMalloc and jvmFree */

/**
 * FUNCTION:      ReadDataFromStorage()
 * TYPE:          public operation
 * OVERVIEW:      Read data buffer from RMFS raw memory storage
 *                 NOTE: This function should be replaced by Raw Memory interface provided by vendor
 * INTERFACE:
 *   parameters:  buffer   put the data into this buffer.
 *                addr     start address in Raw memory storage to be read
 *                size     the byte number 
 *   returns:     0 on succes; != 0 on failure
 *                
 */
/*jint ReadDataFromStorage(jint start, jint size) */

jint ReadDataFromStorage(void *buffer, jint addr, jint size)
{
  if (((jint) buffer == 0) || (addr == 0)) {
#ifdef TRACE_STORAGE
    printf("Exception Happens: buffer: %d; addr: %d; size: %d \n",
	   (jint) buffer, addr, size);
#endif
    return -1;
  }
  memcpy(buffer, (void *) addr, size);
  return 1;
}

/**
 * FUNCTION:      WriteDataToStorage()
 * TYPE:          public operation
 * OVERVIEW:      Write data buffer to RMFS raw memory storage
 *                 NOTE: This function should be replaced by Raw Memory interface provided by vendor
 * INTERFACE:
 *   parameters:  buffer   put this data into RMFS storage.
 *                addr     start address in Raw memory storage to be written
 *                size     the byte number 
 *   returns:     0 on succes; != 0 on failure
 *                
 *//*
   jint WriteDataToStorage(jint start, jint size) 
 */
jint WriteDataToStorage(const void *buffer, jint addr, jint size)
{
  if (((jint) buffer == 0) || (addr == 0)) {
#ifdef TRACE_STORAGE
    printf("Exception Happens: buffer: %d; addr: %d size: %d\n",
	   (jint) buffer, addr, size);
#endif

    return -1;
  }

  memcpy((void *) addr, buffer, size);
  return 1;
}


/**
 * FUNCTION:      rmfsInitialize()
 * TYPE:          public operation
 * OVERVIEW:      Initialize the RMFS raw memory storage
 *                 NOTE: This must only be called once
 * 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 rmfsInitialize(jint start, jint size) */
jint rmfsInitialize(jint start, jint size)
{
  _RmfsHdr rmfsHdr;


#ifdef TRACE_STORAGE
  printf("rmfsInitiallize: start: %d, size: %d\n", start, size);
#endif

  memset(&rmfsHdr, 0, sizeof(_RmfsHdr));
  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;
  }

  /*
     assign the value for the Memory Block Head 
   */

  /* For RAM RMFS no need to read next sentence */
  // ReadDataFromStorage(&rmfsHdr, start, sizeof(_RmfsHdr));

  RmfsMemoryStart = start;
  RmfsMemoryEnd = start + size;

  if (rmfsHdr.magic != MAGIC) {
    rmfsHdr.magic = MAGIC;
    rmfsHdr.dataBufferEndPos = start + sizeof(_RmfsHdr);
    RmfsDataBufferEnd = rmfsHdr.dataBufferEndPos;

    rmfsHdr.nameTableEndPos = start + size;
    RmfsNameTableEnd = rmfsHdr.nameTableEndPos;


    WriteDataToStorage(&rmfsHdr, start, sizeof(_RmfsHdr));
  } else {
    RmfsGlobalNameID = rmfsHdr.maxFileID;
    RmfsDataBufferEnd = rmfsHdr.dataBufferEndPos;
    RmfsNameTableEnd = rmfsHdr.nameTableEndPos;
  }

  /*
     Initialize Open File Table 
   */
  rmfsInitOpenFileTab();

  /*
     Initialize the Data Block Array in RAM 
   */
  rmfsInitDataBlockHdrArray();

  return 0;
}

/**
 * FUNCTION:      rmfsFinalizeHead()
 * TYPE:          public operation
 * OVERVIEW:      Finalize the Raw memory head
 *                 NOTE: This must only be called once before KVM exist
 * INTERFACE:
 *   None   
 *
 *   returns:     0 on succes; != 0 on failure
 *                
 */
/*jint rmfsFinalizeHead( ) */
jint rmfsFinalizeHead()
{
  _RmfsHdr rmfsHdr;

#ifdef TRACE_STORAGE
  printf("rmfsFinalizeHead\n");
#endif

  rmfsHdr.magic = MAGIC;
  rmfsHdr.maxFileID = RmfsGlobalNameID;

  rmfsHdr.dataBufferEndPos = RmfsDataBufferEnd;

  rmfsHdr.nameTableEndPos = RmfsNameTableEnd;

  WriteDataToStorage(&rmfsHdr, RmfsMemoryStart, sizeof(_RmfsHdr));
  return 0;
}

/**
 * FUNCTION:      getUsedSpace()
 * TYPE:          public operation
 * OVERVIEW:      Get the used space size in RMFS
 * INTERFACE:
 *   None   
 *
 *   returns:     the byte numer was used
 *                
 */
jint getUsedSpace() {
    int i; 
    int usedSpace = 0;

    for (i = 0; i < curDataBlockNum; i++) {
      if ((rmfsDataBlockHdrArray[i].flag & 0x01) == 1) {
	usedSpace += rmfsDataBlockHdrArray[i].size;
      }
    }
    usedSpace += (RmfsMemoryEnd - RmfsNameTableEnd);

    return usedSpace;
}


/**
 * FUNCTION:      getFreeSpace()
 * TYPE:          public operation
 * OVERVIEW:      Get the free space size in RMFS
 * INTERFACE:
 *   None   
 *
 *   returns:     the byte numer was used
 *                
 */
jint getFreeSpace()
{
    int i;
    int freeSpace = 0;

    for (i = 0; i < curDataBlockNum; i++) {
      if ((rmfsDataBlockHdrArray[i].flag & 0x01) == 0) {
	freeSpace += rmfsDataBlockHdrArray[i].size;
      }
    }

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

    //return RmfsNameTableEnd - RmfsDataBufferEnd;
    return freeSpace;


}

/**
 * FUNCTION:      searchNameTabByID()
 * TYPE:          public operation
 * OVERVIEW:      Search one entity whose filename is equal to input string in NameTable Space;
 * INTERFACE:
 *   parameters:  <char* filename, jint *identifier>
 *   returns:     < jint position>
 *                
 */
jint searchNameTabByID(char **filename, jint identifier)
{
  char *nameTabBuffer;
  char *tempNameStr;
  _RmfsNameTab nameTab;
  _RmfsNameTabHdrPtr nameTabHdr;

  jint tabLength = 0;
  jint curLength = 0;
  RMFS_BOOLEAN done = RMFS_FALSE;

#ifdef TRACE_STORAGE
  printf("searchNameTabByID: identifier %d\n", identifier);
#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;
  if (nameTabBuffer == NULL) {
#ifdef TRACE_STORAGE
    printf("Name Table is not ready \n");
#endif
    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
      return -1;
    }

    nameTab.filename = (char *) (nameTabBuffer + curLength);

    if (nameTabHdr->identifier == identifier) {
      tempNameStr = (char *) tempBuf;
      if (tempNameStr == NULL) {
#ifdef TRACE_STORAGE
	printf("Memory Allocation Failed \n");
#endif

	return -1;
      }
      strcpy(tempNameStr, nameTab.filename);

      *filename = tempNameStr;
      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

      return -1;
    }
  }


  return RmfsNameTableEnd + curLength;


}


/**
 * FUNCTION:      rmfsNewNameTable()
 * TYPE:          public operation
 * OVERVIEW:      Create one new Name Table entity in NameTable Space;
 * INTERFACE:
 *   parameters:  <char* filename>
 *   returns:     <jint identifier>
 *                
 */

uchar rmfsNewNameTable(const char *filename)
{
  _RmfsNameTabHdrPtr nameTab;
  char *tempName;
  uchar fileID = 0;
  jint entityPos;


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

  RmfsGlobalNameID++;
  if ((entityPos = searchNameTabByString(filename, &fileID)) > 0) {
    if (fileID == 0) {
      fileID = RmfsGlobalNameID;
      WriteDataToStorage(&fileID, entityPos + sizeof(uchar),
			 sizeof(uchar));
      return fileID;
    }

    return fileID;
  }

  /* nameTab = (_RmfsNameTabHdrPtr) jvmMalloc(strlen(filename) + 1 +
					   sizeof(_RmfsNameTabHdr));
					   */
  nameTab = (_RmfsNameTabHdrPtr)tempBuf;

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

  memset(nameTab, 0x00, (strlen(filename) + sizeof(_RmfsNameTabHdr) + ALIGNMENT_BYTE));

  nameTab->nameLen = (strlen(filename) / ALIGNMENT_BYTE + 1) * ALIGNMENT_BYTE;

  tempName = (char *) (nameTab + 1);
  strcpy(tempName, filename);

  nameTab->identifier = RmfsGlobalNameID;

  if (((unsigned int)RmfsNameTableEnd - RmfsDataBufferEnd) <=
      (((unsigned int)nameTab->nameLen) + sizeof(_RmfsNameTabHdr))) {
#ifdef TRACE_STORAGE
    printf("Not enough space in Raw Storage \n");
#endif

    // jvmFree(nameTab);
    return 0;
  }

  RmfsNameTableEnd =
      RmfsNameTableEnd - sizeof(_RmfsNameTabHdr) - nameTab->nameLen;

  if (WriteDataToStorage
      (nameTab, RmfsNameTableEnd,
       sizeof(_RmfsNameTabHdr) + nameTab->nameLen) < 0) {
#ifdef TRACE_STORAGE
    printf("Persistent Storage Write failed \n");
#endif

    // jvmFree(nameTab);

    RmfsNameTableEnd =
	RmfsNameTableEnd + sizeof(_RmfsNameTabHdr) + nameTab->nameLen;
    return 0;
  }

  fileID = nameTab->identifier;

  return fileID;
}

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

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

#ifdef TRACE_STORAGE
  printf("searchNameTabByString: 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);

    if((jint)nameTabHdr != (jint)(nameTabBuffer + curLength)) {
#ifdef TRACE_STORAGE
    printf("address alignment:%d \n",(int)nameTabHdr);
#endif
    }
 
    curLength += sizeof(_RmfsNameTabHdr);