Subversion Repositories mlite

/*--------------------------------------------------------------------

 * TITLE: Plasma File System

 * AUTHOR: Steve Rhoads (rhoadss@yahoo.com)

 * DATE CREATED: 4/26/07

 * FILENAME: filesys.c

 * PROJECT: Plasma CPU core

 * COPYRIGHT: Software placed into the public domain by the author.

 *    Software 'as is' without warranty.  Author liable for nothing.

 * DESCRIPTION:

 *    Plasma File System.  Supports RAM, flash, and disk file systems.

 *    Possible call tree:

 *      OS_fclose()

 *        FileFindRecursive()      //find the existing file

 *          FileOpen()             //open root file system

 *          FileFind()             //find the next level of directory

 *            OS_fread()           //read the directory file

 *              BlockRead()        //read blocks of directory

 *                MediaBlockRead() //low level read

 *          FileOpen()             //open next directory

 *        OS_fwrite()              //write file entry into directory

 *        BlockRead()              //flush changes to directory

 *--------------------------------------------------------------------*/

#ifdef WIN32

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define  _LIBC

#endif

#include "rtos.h"

#define BLOCK_SIZE      512

#define FILE_NAME_SIZE   40

#define FULL_NAME_SIZE  128

#define BLOCK_MALLOC    0x0

#define BLOCK_EOF       0xffffffff

typedef enum {

   FILE_MEDIA_RAM,

   FILE_MEDIA_FLASH,

   FILE_MEDIA_DISK

} OS_MediaType_e;

typedef struct OS_FileEntry_s {

   char name[FILE_NAME_SIZE];

   uint32 blockIndex;       //first block of file

   uint32 modifiedTime;

   uint32 length;

   uint8 isDirectory;

   uint8 attributes;

   uint8 valid;

   uint8 mediaType;

   uint16 blockSize;        //Normally BLOCK_SIZE

} OS_FileEntry_t;

typedef struct OS_Block_s {

   uint32 next;

   uint8 data[4];

} OS_Block_t;

struct OS_FILE_s {

   OS_FileEntry_t fileEntry;  //written to directory upon OS_fclose()

   uint8 fileModified;

   uint8 blockModified;

   uint32 blockIndex;         //index of block

   uint32 blockOffset;        //byte offset into block

   uint32 fileOffset;         //byte offset into file

   char fullname[FULL_NAME_SIZE]; //includes full path

   OS_Block_t *block;

   OS_Block_t *blockLocal;    //local copy for flash or disk file system

};

static OS_FileEntry_t rootFileEntry;

static OS_Mutex_t *mutexFilesys;

// Public prototypes

#ifndef _FILESYS_

typedef struct OS_FILE_s OS_FILE;

#endif

OS_FILE *OS_fopen(char *name, char *mode);

void OS_fclose(OS_FILE *file);

int OS_fread(void *buffer, int size, int count, OS_FILE *file);

int OS_fwrite(void *buffer, int size, int count, OS_FILE *file);

int OS_fseek(OS_FILE *file, int offset, int mode);

int OS_fmkdir(char *name);

int OS_fdir(OS_FILE *dir, char name[64]);

void OS_fdelete(char *name);

/***************** Media Functions Start ***********************/

#ifdef INCLUDE_FLASH

#define FLASH_BASE 1024*128

#define FLASH_BLOCKS 1024*1024*16/BLOCK_SIZE

#define FLASH_OFFSET (FLASH_BASE+FLASH_BLOCKS/8*2)/BLOCK_SIZE

static unsigned char FlashBlockEmpty[FLASH_BLOCKS/8];

static unsigned char FlashBlockUsed[FLASH_BLOCKS/8];

static int FlashOffset;

//Free unused flash blocks

static int MediaBlockCleanup(void)

{

   int i, j, k, count=0;

   unsigned char *buf;

   printf("FlashCleanup\n");

   buf = (unsigned char*)malloc(1024*128);

   if(buf == NULL)

      return 0;

   for(j = 1; j < 128; ++j)

   {

      FlashRead((uint16*)buf, 1024*128*j, 1024*128);

      if(j == 1)

      {

         for(i = 0; i < FLASH_BLOCKS/8; ++i)

            FlashBlockEmpty[i] |= ~FlashBlockUsed[i];

         memcpy(buf, FlashBlockEmpty, sizeof(FlashBlockEmpty));

         memset(FlashBlockUsed, 0xff, sizeof(FlashBlockUsed));

         memset(buf+sizeof(FlashBlockEmpty), 0xff, sizeof(FlashBlockUsed));

      }

      //Erase empty blocks

      for(k = 0; k < 256; ++k)

      {

         i = j*256 + k;

         if(FlashBlockEmpty[i >> 3] & (1 << (i & 7)))

         {

            memset(buf + BLOCK_SIZE*k, 0xff, BLOCK_SIZE);

            ++count;

         }

      }

      FlashErase(1024*128*j);

      FlashWrite((uint16*)buf, 1024*128*j, 1024*128);

   }

   free(buf);

   return count;

}

int MediaBlockInit(void)

{

   FlashRead((uint16*)FlashBlockEmpty, FLASH_BASE, sizeof(FlashBlockEmpty));

   FlashRead((uint16*)FlashBlockUsed, FLASH_BASE+4096, sizeof(FlashBlockUsed));

   FlashOffset = FLASH_OFFSET;

   return FlashBlockEmpty[FlashOffset >> 3] & (1 << (FlashOffset & 7));

}

#endif

static uint32 MediaBlockMalloc(OS_FILE *file)

{

   int i, j;

   (void)i; (void)j;

   if(file->fileEntry.mediaType == FILE_MEDIA_RAM)

      return (uint32)malloc(file->fileEntry.blockSize);

#ifdef INCLUDE_FLASH

   //Find empty flash block

   for(i = FlashOffset; i < FLASH_BLOCKS; ++i)

   {

      if(FlashBlockEmpty[i >> 3] & (1 << (i & 7)))

      {

         FlashOffset = i + 1;

         FlashBlockEmpty[i >> 3] &= ~(1 << (i & 7));

         j = i >> 3;

         j &= ~1;

         FlashWrite((uint16*)(FlashBlockEmpty + j), FLASH_BASE + j, 2);

         return i;

      }

   }

   i = MediaBlockCleanup();

   if(i == 0)

      return 0;

   FlashOffset = FLASH_OFFSET;

   return MediaBlockMalloc(file);

#else

   return 0;

#endif

}

static void MediaBlockFree(OS_FILE *file, uint32 blockIndex)

{

   if(file->fileEntry.mediaType == FILE_MEDIA_RAM)

      free((void*)blockIndex);

#ifdef INCLUDE_FLASH

   else

   {

      int i=blockIndex, j;

      FlashBlockUsed[i >> 3] &= ~(1 << (i & 7));

      j = i >> 3;

      j &= ~1;

      FlashWrite((uint16*)(FlashBlockUsed + j), FLASH_BASE + sizeof(FlashBlockEmpty) + j, 2);

   }

#endif

}

static void MediaBlockRead(OS_FILE *file, uint32 blockIndex)

{

   if(file->fileEntry.mediaType == FILE_MEDIA_RAM)

      file->block = (OS_Block_t*)blockIndex;

#ifdef INCLUDE_FLASH

   else

   {

      if(file->blockLocal == NULL)

         file->blockLocal = (OS_Block_t*)malloc(BLOCK_SIZE);

      file->block = file->blockLocal;

      FlashRead((uint16*)file->block, blockIndex << 9, BLOCK_SIZE);

   }

#endif

}

static void MediaBlockWrite(OS_FILE *file, uint32 blockIndex)

{

   (void)file;

   (void)blockIndex;

#ifdef INCLUDE_FLASH

   if(file->fileEntry.mediaType != FILE_MEDIA_RAM)

      FlashWrite((uint16*)file->block, blockIndex << 9, BLOCK_SIZE);

#endif

}

/***************** Media Functions End *************************/

// Get the next block and write the old block if it was modified

static void BlockRead(OS_FILE *file, uint32 blockIndex)

{

   uint32 blockIndexSave = blockIndex;

   OS_MutexPend(mutexFilesys);

   if(blockIndex == BLOCK_MALLOC)

   {

      // Get a new block

      blockIndex = MediaBlockMalloc(file);

      if(blockIndex == 0)

         blockIndex = BLOCK_EOF;

      if(file->block)

      {

         // Set next pointer in previous block

         file->block->next = blockIndex;

         file->blockModified = 1;

      }

   }

   if(file->block && file->blockModified)

   {

      // Write block back to flash or disk

      MediaBlockWrite(file, file->blockIndex);

      file->blockModified = 0;

   }

   if(blockIndex == BLOCK_EOF)

   {

      OS_MutexPost(mutexFilesys);

      return;

   }

   file->blockIndex = blockIndex;

   file->blockOffset = 0;

   MediaBlockRead(file, blockIndex);

   if(blockIndexSave == BLOCK_MALLOC)

   {

      memset(file->block, 0xff, file->fileEntry.blockSize);

      file->blockModified = 1;

   }

   OS_MutexPost(mutexFilesys);

}

int OS_fread(void *buffer, int size, int count, OS_FILE *file)

{

   int items, bytes;

   uint8 *buf = (uint8*)buffer;

   for(items = 0; items < count; ++items)

   {

      for(bytes = 0; bytes < size; ++bytes)

      {

         if(file->fileOffset >= file->fileEntry.length &&

            file->fileEntry.isDirectory == 0)

            return items;

         if(file->blockOffset >= file->fileEntry.blockSize - sizeof(uint32))

         {

            if(file->block->next == BLOCK_EOF)

               return items;

            BlockRead(file, file->block->next);

         }

         *buf++ = file->block->data[file->blockOffset++];

         ++file->fileOffset;

      }

   }

   return items;

}

int OS_fwrite(void *buffer, int size, int count, OS_FILE *file)

{

   int items, bytes;

   uint8 *buf = (uint8*)buffer;

   OS_MutexPend(mutexFilesys);

   file->blockModified = 1;

   for(items = 0; items < count; ++items)

   {

      for(bytes = 0; bytes < size; ++bytes)

      {

         if(file->blockOffset >= file->fileEntry.blockSize - sizeof(uint32))

         {

            if(file->block->next == BLOCK_EOF)

               file->block->next = BLOCK_MALLOC;

            BlockRead(file, file->block->next);

            if(file->blockIndex == BLOCK_EOF)

            {

               count = 0;

               --items;

               break;

            }

            file->blockModified = 1;

         }

         file->block->data[file->blockOffset++] = *buf++;

         ++file->fileOffset;

      }

   }

   file->blockModified = 1;

   file->fileModified = 1;

   if(file->fileOffset > file->fileEntry.length)

      file->fileEntry.length = file->fileOffset;

   OS_MutexPost(mutexFilesys);

   return items;

}

int OS_fseek(OS_FILE *file, int offset, int mode)

{

   if(mode == 1)      //SEEK_CUR

      offset += file->fileOffset;

   else if(mode == 2) //SEEK_END

      offset += file->fileEntry.length;

   file->fileOffset = offset;

   BlockRead(file, file->fileEntry.blockIndex);

   while(offset > (int)file->fileEntry.blockSize - (int)sizeof(uint32))

   {

      BlockRead(file, file->block->next);

      offset -= file->fileEntry.blockSize - (int)sizeof(uint32);

   }

   file->blockOffset = offset;

   return 0;

}

static int FileOpen(OS_FILE *file, char *name, OS_FileEntry_t *fileEntry)

{

   memset(file, 0, sizeof(OS_FILE));

   if(fileEntry == NULL)

   {

      // Open root file

      memcpy(&file->fileEntry, &rootFileEntry, sizeof(OS_FileEntry_t));

   }

   else if(fileEntry->valid == 1)

   {

      // Open existing file

      memcpy(&file->fileEntry, fileEntry, sizeof(OS_FileEntry_t));

   }

   else

   {

      // Initialize new file

      file->fileModified = 1;

      file->blockModified = 1;

      memset(&file->fileEntry, 0, sizeof(OS_FileEntry_t));

      file->fileEntry.isDirectory = 0;

      file->fileEntry.length = 0;

      strncpy(file->fileEntry.name, name, FILE_NAME_SIZE-1);

      file->fileEntry.blockIndex = 0;

      file->fileEntry.valid = 1;

      file->fileEntry.blockSize = fileEntry->blockSize;

      file->fileEntry.mediaType = fileEntry->mediaType;

   }

   BlockRead(file, file->fileEntry.blockIndex);    //Get first block

   file->fileEntry.blockIndex = file->blockIndex;

   file->fileOffset = 0;

   if(file->blockIndex == BLOCK_EOF)

      return -1;

   return 0;

}

static int FileFind(OS_FILE *directory, char *name, OS_FileEntry_t *fileEntry)

{

   int count, rc = -1;

   uint32 blockIndex, blockOffset;

   uint32 blockIndexEmpty=BLOCK_EOF, blockOffsetEmpty=0;

   // Loop through files in directory

   for(;;)

   {

      blockIndex = directory->blockIndex;

      blockOffset = directory->blockOffset;

      count = OS_fread(fileEntry, sizeof(OS_FileEntry_t), 1, directory);

      if(count == 0 || fileEntry->blockIndex == BLOCK_EOF)

         break;

      if(fileEntry->valid == 1 && strcmp(fileEntry->name, name) == 0)

      {

         rc = 0;  //Found the file in the directory

         break;

      }

      if(fileEntry->valid != 1 && blockIndexEmpty == BLOCK_EOF)

      {

         blockIndexEmpty = blockIndex;

         blockOffsetEmpty = blockOffset;

      }

   }

   if(rc == 0 || directory->fileEntry.mediaType == FILE_MEDIA_FLASH ||

      blockIndexEmpty == BLOCK_EOF)

   {

      // Backup to start of fileEntry or last entry in directory

      if(directory->blockIndex != blockIndex)

         BlockRead(directory, blockIndex);

      directory->blockOffset = blockOffset;

   }

   else

   {

      // Backup to empty slot

      if(directory->blockIndex != blockIndexEmpty)

         BlockRead(directory, blockIndexEmpty);

      directory->blockOffset = blockOffsetEmpty;

   }

   return rc;

}

static int FileFindRecursive(OS_FILE *directory, char *name,

                             OS_FileEntry_t *fileEntry, char *filename)

{

   int rc, length;

   rc = FileOpen(directory, NULL, NULL);            //Open root directory

   for(;;)

   {

      if(name[0] == '/')

         ++name;

      for(length = 0; length < FILE_NAME_SIZE; ++length)

      {

         if(name[length] == 0 || name[length] == '/')

            break;

         filename[length] = name[length];

      }

      filename[length] = 0;

      rc = FileFind(directory, filename, fileEntry);  //Find file

      if(rc)

      {

         // File not found

         fileEntry->mediaType = directory->fileEntry.mediaType;

         fileEntry->blockSize = directory->fileEntry.blockSize;

         if(strstr(name, "/") == NULL)

            return rc;

         else

            return -2;  //can't find parent directory

      }

      name += length;

      if(name[0])

         rc = FileOpen(directory, filename, fileEntry);  //Open subdir

      else

         break;

   }

   return rc;

}

OS_FILE *OS_fopen(char *name, char *mode)

{

   OS_FILE *file;

   OS_FileEntry_t fileEntry;

   OS_FILE dir;

   char filename[FILE_NAME_SIZE];  //Name without directories

   int rc;

   if(rootFileEntry.blockIndex == 0)

   {

      // Mount file system

      mutexFilesys = OS_MutexCreate("filesys");

      memset(&dir, 0, sizeof(OS_FILE));

      dir.fileEntry.blockSize = BLOCK_SIZE;

      //dir.fileEntry.mediaType = FILE_MEDIA_FLASH;  //Test flash

      BlockRead(&dir, BLOCK_MALLOC);

      strcpy(rootFileEntry.name, "/");

      rootFileEntry.mediaType = dir.fileEntry.mediaType;

      rootFileEntry.blockIndex = dir.blockIndex;

      rootFileEntry.blockSize = dir.fileEntry.blockSize;

      rootFileEntry.isDirectory = 1;

      BlockRead(&dir, BLOCK_EOF);    //Flush data

#ifdef INCLUDE_FLASH

      file = OS_fopen("flash", "w+");

      if(file == NULL)

         return NULL;

      file->fileEntry.isDirectory = 1;

      file->fileEntry.mediaType = FILE_MEDIA_FLASH;

      file->blockLocal = file->block;

      file->block = NULL;

      rc = MediaBlockInit();

      if(rc == 1)

         BlockRead(file, BLOCK_MALLOC);

      else

         BlockRead(file, FLASH_OFFSET);

      file->fileEntry.blockIndex = file->blockIndex;

      OS_fclose(file);

#endif

   }

   file = (OS_FILE*)malloc(sizeof(OS_FILE));

   if(file == NULL)

      return NULL;

   OS_MutexPend(mutexFilesys);

   if(name[0] == 0 || strcmp(name, "/") == 0)

   {

      FileOpen(file, NULL, NULL);

      OS_MutexPost(mutexFilesys);

      return file;

   }

   if(strcmp(mode, "w") == 0)

      OS_fdelete(name);

   rc = FileFindRecursive(&dir, name, &fileEntry, filename);

   if(dir.blockLocal)

      free(dir.blockLocal);

   if(rc == -2 || (rc && mode[0] == 'r'))

   {

      free(file);

      OS_MutexPost(mutexFilesys);

      return NULL;

   }

   rc = FileOpen(file, filename, &fileEntry);  //Open file

   file->fullname[0] = 0;

   strncat(file->fullname, name, FULL_NAME_SIZE);

   OS_MutexPost(mutexFilesys);

   return file;

}

void OS_fclose(OS_FILE *file)

{

   OS_FileEntry_t fileEntry;

   OS_FILE dir;

   char filename[FILE_NAME_SIZE];

   int rc;

   if(file->fileModified)

   {

      // Write file->fileEntry into parent directory

      OS_MutexPend(mutexFilesys);

      BlockRead(file, BLOCK_EOF);

      rc = FileFindRecursive(&dir, file->fullname, &fileEntry, filename);

      if(file->fileEntry.mediaType == FILE_MEDIA_FLASH && rc == 0)

      {

         // Invalidate old entry and add new entry at the end

         fileEntry.valid = 0;

         OS_fwrite(&fileEntry, sizeof(OS_FileEntry_t), 1, &dir);

         FileFind(&dir, "endoffile", &fileEntry);

      }

      OS_fwrite(&file->fileEntry, sizeof(OS_FileEntry_t), 1, &dir);

      BlockRead(&dir, BLOCK_EOF);  //flush data

      if(dir.blockLocal)

         free(dir.blockLocal);

      OS_MutexPost(mutexFilesys);

   }

   if(file->blockLocal)

      free(file->blockLocal);

   free(file);

}

int OS_fmkdir(char *name)

{

   OS_FILE *file;

   file = OS_fopen(name, "w+");

   if(file == NULL)

      return -1;

   file->fileEntry.isDirectory = 1;

   OS_fclose(file);

   return 0;

}

void OS_fdelete(char *name)

{

   OS_FILE dir, file;

   OS_FileEntry_t fileEntry;

   int rc;

   uint32 blockIndex;

   char filename[FILE_NAME_SIZE];  //Name without directories

   OS_MutexPend(mutexFilesys);

   rc = FileFindRecursive(&dir, name, &fileEntry, filename);

   if(rc == 0)

   {

      FileOpen(&file, NULL, &fileEntry);

      for(blockIndex = file.blockIndex; file.block->next != BLOCK_EOF; blockIndex = file.blockIndex)

      {

         BlockRead(&file, file.block->next);

         MediaBlockFree(&file, blockIndex);

      }

      MediaBlockFree(&file, blockIndex);

      fileEntry.valid = 0;

      OS_fwrite((char*)&fileEntry, sizeof(OS_FileEntry_t), 1, &dir);

      BlockRead(&dir, BLOCK_EOF);

      if(file.blockLocal)

         free(file.blockLocal);

   }

   if(dir.blockLocal)

      free(dir.blockLocal);

   OS_MutexPost(mutexFilesys);

}

int OS_fdir(OS_FILE *dir, char name[64])

{

   OS_FileEntry_t *fileEntry = (OS_FileEntry_t*)name;

   int count;

   for(;;)

   {

      count = OS_fread(fileEntry, sizeof(OS_FileEntry_t), 1, dir);

      if(count == 0 || fileEntry->blockIndex == BLOCK_EOF)

         return -1;

      if(fileEntry->valid == 1)

         break;

   }