Kernel/vfs/memfile.c

   1 /*
   2  * Acess 2
   3  * Virtual File System
   4  * - Memory Pseudo Files
   5  */
   6 #include <acess.h>
   7 #include <vfs.h>
   8
   9 // === PROTOTYPES ===
  10 tVFS_Node       *VFS_MemFile_Create(tVFS_Node *Unused, char *Path);
  11 void    VFS_MemFile_Close(tVFS_Node *Node);
  12 Uint64  VFS_MemFile_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
  13 Uint64  VFS_MemFile_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer);
  14
  15 // === GLOBALS ===
  16 tVFS_Node       gVFS_MemRoot = {
  17         .Flags = VFS_FFLAG_DIRECTORY,
  18         .NumACLs = 0,
  19         .FindDir = VFS_MemFile_Create
  20         };
  21
  22 // === CODE ===
  23 /**
  24  * \fn tVFS_Node *VFS_MemFile_Create(tVFS_Node *Unused, char *Path)
  25  * \note Treated as finddir by VFS_ParsePath
  26  */
  27 tVFS_Node *VFS_MemFile_Create(tVFS_Node *Unused, char *Path)
  28 {
  29         Uint    base, size;
  30         char    *str = Path;
  31         tVFS_Node       *ret;
  32
  33         str++;  // Eat '$'
  34
  35         // Read Base address
  36         base = 0;
  37         for( ; ('0' <= *str && *str <= '9') || ('A' <= *str && *str <= 'F'); str++ )
  38         {
  39                 base *= 16;
  40                 if('A' <= *str && *str <= 'F')
  41                         base += *str - 'A' + 10;
  42                 else
  43                         base += *str - '0';
  44         }
  45
  46         // Check separator
  47         if(*str++ != ':')       return NULL;
  48
  49         // Read buffer size
  50         size = 0;
  51         for( ; ('0' <= *str && *str <= '9') || ('A' <= *str && *str <= 'F'); str++ )
  52         {
  53                 size *= 16;
  54                 if('A' <= *str && *str <= 'F')
  55                         size += *str - 'A' + 10;
  56                 else
  57                         size += *str - '0';
  58         }
  59
  60         // Check for NULL byte
  61         if(*str != '\0')        return NULL;
  62
  63         Log(" VFS_MemFile_Create: base=0x%x, size=0x%x", base, size);
  64
  65         // Allocate and fill node
  66         ret = malloc(sizeof(tVFS_Node));
  67         memset(ret, 0, sizeof(tVFS_Node));
  68
  69         // State
  70         ret->ImplPtr = (void*)base;
  71         ret->Size = size;
  72
  73         // ACLs
  74         ret->NumACLs = 1;
  75         ret->ACLs = &gVFS_ACL_EveryoneRWX;
  76
  77         // Functions
  78         ret->Close = VFS_MemFile_Close;
  79         ret->Read = VFS_MemFile_Read;
  80         ret->Write = VFS_MemFile_Write;
  81
  82         return ret;
  83 }
  84
  85 /**
  86  * \fn void VFS_MemFile_Close(tVFS_Node *Node)
  87  * \brief Dereference and clean up a memory file
  88  */
  89 void VFS_MemFile_Close(tVFS_Node *Node)
  90 {
  91         Node->ReferenceCount --;
  92         if( Node->ReferenceCount == 0 ) {
  93                 Node->ImplPtr = NULL;
  94                 free(Node);
  95         }
  96 }
  97
  98 /**
  99  * \fn Uint64 VFS_MemFile_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 100  * \brief Read from a memory file
 101  */
 102 Uint64 VFS_MemFile_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 103 {
 104         // Check for use of free'd file
 105         if(Node->ImplPtr == NULL)       return 0;
 106
 107         // Check for out of bounds read
 108         if(Offset > Node->Size) return 0;
 109
 110         // Truncate data read if needed
 111         if(Offset + Length > Node->Size)
 112                 Length = Node->Size - Offset;
 113
 114         // Copy Data
 115         memcpy(Buffer, Node->ImplPtr+Offset, Length);
 116
 117         return Length;
 118 }
 119
 120 /**
 121  * \fn Uint64 VFS_MemFile_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 122  * \brief Write to a memory file
 123  */
 124 Uint64 VFS_MemFile_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
 125 {
 126         // Check for use of free'd file
 127         if(Node->ImplPtr == NULL)       return 0;
 128
 129         // Check for out of bounds read
 130         if(Offset > Node->Size) return 0;
 131
 132         // Truncate data read if needed
 133         if(Offset + Length > Node->Size)
 134                 Length = Node->Size - Offset;
 135
 136         // Copy Data
 137         memcpy(Node->ImplPtr+Offset, Buffer, Length);
 138
 139         return Length;
 140 }