KernelLand/Modules/Filesystems/RAMDisk/ramdisk.c

   1 /*
   2  * Acess2 Kernel - RAM Disk Support
   3  * - By John Hodge (thePowersGang)
   4  *
   5  * ramdisk.c
   6  * - Core File
   7  */
   8 #define DEBUG   1
   9 #include <acess.h>
  10 #include <modules.h>
  11 #include "ramdisk.h"
  12 #define VERSION VER2(0,1)
  13
  14 #define MIN_RAMDISK_SIZE        (1*1024*1024)
  15 #define MAX_RAMDISK_SIZE        (64*1024*1024)
  16
  17 // === PROTOTYPES ===
  18  int    RAMFS_Install(char **Arguments);
  19 void    RAMFS_Cleanup(void);
  20 // --- Mount/Unmount ---
  21 tVFS_Node       *RAMFS_InitDevice(const char *Device, const char **Options);
  22 void    RAMFS_Unmount(tVFS_Node *Node);
  23 // --- Directories ---
  24 char    *RAMFS_ReadDir(tVFS_Node *Node, int Index);
  25 tVFS_Node       *RAMFS_FindDir(tVFS_Node *Node, const char *Name);
  26  int    RAMFS_MkNod(tVFS_Node *Node, const char *Name, Uint Flags);
  27  int    RAMFS_Link(tVFS_Node *DirNode, const char *Name, tVFS_Node *Node);
  28  int    RAMFS_Unlink(tVFS_Node *Node, const char *Name);
  29 // --- Files ---
  30 size_t  RAMFS_Read(tVFS_Node *Node, off_t Offset, size_t Size, void *Buffer);
  31 size_t  RAMFS_Write(tVFS_Node *Node, off_t Offset, size_t Size, const void *Buffer);
  32 // --- Internals --
  33 void    RAMFS_int_RefFile(tRAMFS_Inode *Inode);
  34 void    RAMFS_int_DerefFile(tRAMFS_Inode *Inode);
  35 void    *RAMFS_int_GetPage(tRAMFS_File *File, int Page, int bCanAlloc);
  36 void    RAMFS_int_DropPage(void *Page);
  37 Uint32  RAMFS_int_AllocatePage(tRAMDisk *Disk);
  38 void    RAMFS_int_RefFile(tRAMFS_Inode *Inode);
  39 void    RAMFS_int_DerefFile(tRAMFS_Inode *Inode);
  40
  41 // === GLOBALS ===
  42 MODULE_DEFINE(0, VERSION, FS_RAMDisk, RAMFS_Install, RAMFS_Cleanup, NULL);
  43 tVFS_Driver     gRAMFS_Driver = {
  44         .Name = "ramfs",
  45         .InitDevice = RAMFS_InitDevice,
  46         .Unmount = RAMFS_Unmount
  47         // TODO: GetNodeFromInode
  48         };
  49 tVFS_NodeType   gRAMFS_DirNodeType = {
  50         .ReadDir = RAMFS_ReadDir,
  51         .FindDir = RAMFS_FindDir,
  52         .MkNod   = RAMFS_MkNod,
  53         .Link    = RAMFS_Link,
  54         .Unlink  = RAMFS_Unlink
  55         };
  56 tVFS_NodeType   gRAMFS_FileNodeType = {
  57         .Read  = RAMFS_Read,
  58         .Write = RAMFS_Write
  59         };
  60
  61 // === CODE ===
  62 int RAMFS_Install(char **Arguments)
  63 {
  64         VFS_AddDriver( &gRAMFS_Driver );
  65         return 0;
  66 }
  67
  68 void RAMFS_Cleanup(void)
  69 {
  70
  71 }
  72
  73
  74 // --- Mount/Unmount
  75 const char *_GetOption(const char *Data, const char *Option)
  76 {
  77          int    len = strlen(Option);
  78         if( strncmp(Data, Option, len) != 0 )
  79                 return NULL;
  80         if( Data[len] != '=' )
  81                 return NULL;
  82         return Data + len + 1;
  83 }
  84
  85 tVFS_Node *RAMFS_InitDevice(const char *Device, const char **Options)
  86 {
  87         size_t  size = 0;
  88         tRAMDisk        *rd;
  89
  90         if( Options )
  91         {
  92                 const char *v;
  93                 for( int i = 0; Options[i]; i ++ )
  94                 {
  95                         LOG("Options[%i] = '%s'", i, Options[i]);
  96                         if( (v = _GetOption(Options[i], "megs")) )
  97                         {
  98                                 size = atoi(v) * 1024 * 1024;
  99                                 LOG("Size set to %iMiB", size>>20);
 100                         }
 101                 }
 102         }
 103
 104         LOG("Disk Size %iKiB", size>>10);
 105
 106         if( size > MAX_RAMDISK_SIZE || size < MIN_RAMDISK_SIZE )
 107                 return NULL;
 108
 109          int    n_pages = size / PAGE_SIZE;
 110
 111         rd = calloc(1, sizeof(tRAMDisk) + n_pages * sizeof(tPAddr) + n_pages / 8);
 112         rd->MaxPages = n_pages;
 113         rd->RootDir.Inode.Disk = rd;
 114         rd->RootDir.Inode.Node.ImplPtr = &rd->RootDir;
 115         rd->RootDir.Inode.Node.Flags = VFS_FFLAG_DIRECTORY;
 116         rd->RootDir.Inode.Node.Size = -1;
 117         rd->RootDir.Inode.Node.Type = &gRAMFS_DirNodeType;
 118         rd->Bitmap = (void*)&rd->PhysPages[ n_pages ];
 119
 120         for( int i = 0; i < n_pages; i ++ )
 121         {
 122                 rd->PhysPages[i] = MM_AllocPhys();
 123                 if( !rd->PhysPages[i] ) {
 124                         // Um... oops?
 125                         break;
 126                 }
 127         }
 128
 129         LOG("Mounted");
 130         return &rd->RootDir.Inode.Node;
 131 }
 132
 133 void RAMFS_Unmount(tVFS_Node *Node)
 134 {
 135         Log_Warning("RAMDisk", "TODO: Impliment unmounting");
 136 }
 137
 138 // --- Directories ---
 139 char *RAMFS_ReadDir(tVFS_Node *Node, int Index)
 140 {
 141         tRAMFS_Dir      *dir = Node->ImplPtr;
 142         for( tRAMFS_DirEnt *d = dir->FirstEnt; d; d = d->Next )
 143         {
 144                 if( Index -- == 0 ) {
 145                         LOG("Return %s", d->Name);
 146                         return strdup(d->Name);
 147                 }
 148         }
 149         LOG("Return NULL");
 150         return NULL;
 151 }
 152
 153 tVFS_Node *RAMFS_FindDir(tVFS_Node *Node, const char *Name)
 154 {
 155         tRAMFS_Dir      *dir = Node->ImplPtr;
 156
 157         for( tRAMFS_DirEnt *d = dir->FirstEnt; d; d = d->Next )
 158         {
 159                 if( strcmp(d->Name, Name) == 0 ) {
 160                         LOG("Return %p", &d->Inode->Node);
 161                         return &d->Inode->Node;
 162                 }
 163         }
 164
 165         LOG("Return NULL");
 166         return NULL;
 167 }
 168
 169 int RAMFS_MkNod(tVFS_Node *Node, const char *Name, Uint Flags)
 170 {
 171         tRAMFS_Dir      *dir = Node->ImplPtr;
 172         if( RAMFS_FindDir(Node, Name) != NULL )
 173                 return -1;
 174
 175         tRAMFS_DirEnt   *de = malloc( sizeof(tRAMFS_DirEnt) + strlen(Name) + 1 );
 176         de->Next = NULL;
 177         de->NameLen = strlen(Name);
 178         strcpy(de->Name, Name);
 179
 180         if( Flags & VFS_FFLAG_DIRECTORY ) {
 181                 tRAMFS_Dir      *newdir = calloc(1, sizeof(tRAMFS_Dir));
 182                 newdir->Inode.Node.Type = &gRAMFS_DirNodeType;
 183                 de->Inode = &newdir->Inode;
 184         }
 185         else {
 186                 tRAMFS_File     *newfile = calloc(1, sizeof(tRAMFS_File));
 187                 newfile->Inode.Node.Type = &gRAMFS_FileNodeType;
 188                 de->Inode = &newfile->Inode;
 189         }
 190         de->Inode->Disk = dir->Inode.Disk;
 191         de->Inode->Node.Flags = Flags;
 192         de->Inode->Node.ImplPtr = de->Inode;
 193
 194         RAMFS_int_RefFile(de->Inode);
 195
 196         // TODO: Lock?
 197         if(dir->FirstEnt)
 198                 dir->LastEnt->Next = de;
 199         else
 200                 dir->FirstEnt = de;
 201         dir->LastEnt = de;
 202
 203         return 0;
 204 }
 205
 206 int RAMFS_Link(tVFS_Node *DirNode, const char *Name, tVFS_Node *FileNode)
 207 {
 208         tRAMFS_Dir      *dir = DirNode->ImplPtr;
 209         tRAMFS_DirEnt   *dp;
 210
 211         for( dp = dir->FirstEnt; dp; dp = dp->Next )
 212         {
 213                 if( strcmp(dp->Name, Name) == 0 )
 214                         return -1;
 215         }
 216
 217         dp = malloc( sizeof(tRAMFS_DirEnt) + strlen(Name) + 1 );
 218         dp->Next = NULL;
 219         dp->Inode = FileNode->ImplPtr;
 220         RAMFS_int_RefFile(dp->Inode);
 221         strcpy(dp->Name, Name);
 222
 223         // TODO: Lock?
 224         if(dir->FirstEnt)
 225                 dir->LastEnt->Next = dp;
 226         else
 227                 dir->FirstEnt = dp;
 228         dir->LastEnt = dp;
 229
 230         return 0;
 231 }
 232
 233 int RAMFS_Unlink(tVFS_Node *Node, const char *Name)
 234 {
 235         tRAMFS_Dir      *dir = Node->ImplPtr;
 236         tRAMFS_DirEnt   *dp, *p = NULL;
 237
 238         // TODO: Is locking needed?
 239
 240         // Find the directory entry
 241         for( dp = dir->FirstEnt; dp; p = dp, dp = dp->Next )
 242         {
 243                 if( strcmp(dp->Name, Name) == 0 )
 244                         break ;
 245         }
 246         if( !dp )       return -1;
 247
 248         // Dereference the file
 249         RAMFS_int_DerefFile( dp->Inode );
 250
 251         // Remove and free directory entry
 252         if(!p)
 253                 dir->FirstEnt = dp->Next;
 254         else
 255                 p->Next = dp->Next;
 256         if( dir->LastEnt == dp )
 257                 dir->LastEnt = p;
 258         free(dp);
 259
 260         return 0;
 261 }
 262
 263 // --- Files ---
 264 size_t RAMFS_int_DoIO(tRAMFS_File *File, off_t Offset, size_t Size, void *Buffer, int bRead)
 265 {
 266         size_t  rem;
 267         Uint8   *page_virt;
 268          int    page;
 269
 270         if( Offset >= File->Size )      return 0;
 271
 272         if( Offset + Size > File->Size )        Size = File->Size - Size;
 273
 274         if( Size == 0 )         return 0;
 275
 276         page = Offset / PAGE_SIZE;
 277         Offset %= PAGE_SIZE;
 278         rem = Size;
 279
 280         page_virt = RAMFS_int_GetPage(File, page++, !bRead);
 281         if(!page_virt)  return 0;
 282
 283         if( Offset + Size <= PAGE_SIZE )
 284         {
 285                 if( bRead )
 286                         memcpy(Buffer, page_virt + Offset, Size);
 287                 else
 288                         memcpy(page_virt + Offset, Buffer, Size);
 289                 return 0;
 290         }
 291
 292         if( bRead )
 293                 memcpy(Buffer, page_virt + Offset, PAGE_SIZE - Offset);
 294         else
 295                 memcpy(page_virt + Offset, Buffer, PAGE_SIZE - Offset);
 296         Buffer += PAGE_SIZE - Offset;
 297         rem -= PAGE_SIZE - Offset;
 298
 299         while( rem >= PAGE_SIZE )
 300         {
 301                 RAMFS_int_DropPage(page_virt);
 302                 page_virt = RAMFS_int_GetPage(File, page++, !bRead);
 303                 if(!page_virt)  return Size - rem;
 304
 305                 if( bRead )
 306                         memcpy(Buffer, page_virt, PAGE_SIZE);
 307                 else
 308                         memcpy(page_virt, Buffer, PAGE_SIZE);
 309
 310                 Buffer += PAGE_SIZE;
 311                 rem -= PAGE_SIZE;
 312         }
 313
 314         if( rem > 0 )
 315         {
 316                 page_virt = RAMFS_int_GetPage(File, page, !bRead);
 317                 if(!page_virt)  return Size - rem;
 318                 if( bRead )
 319                         memcpy(Buffer, page_virt, rem);
 320                 else
 321                         memcpy(page_virt, Buffer, rem);
 322         }
 323
 324         RAMFS_int_DropPage(page_virt);
 325
 326         return Size;
 327 }
 328
 329 size_t RAMFS_Read(tVFS_Node *Node, off_t Offset, size_t Size, void *Buffer)
 330 {
 331         tRAMFS_File     *file = Node->ImplPtr;
 332
 333         return RAMFS_int_DoIO(file, Offset, Size, Buffer, 1);
 334 }
 335
 336 size_t RAMFS_Write(tVFS_Node *Node, off_t Offset, size_t Size, const void *Buffer)
 337 {
 338         tRAMFS_File     *file = Node->ImplPtr;
 339
 340         // TODO: Limit checks?
 341         if( Offset == file->Size )
 342                 file->Size += Size;
 343
 344         return RAMFS_int_DoIO(file, Offset, Size, (void*)Buffer, 0);
 345 }
 346
 347 // --- Internals ---
 348 void *RAMFS_int_GetPage(tRAMFS_File *File, int Page, int bCanAlloc)
 349 {
 350         Uint32  page_id = 0;
 351         Uint32  *page_in_1 = NULL;
 352         Uint32  *page_in_2 = NULL;
 353
 354          int    ofs = 0, block;
 355
 356         if( Page < 0 )  return NULL;
 357
 358         if( Page < RAMFS_NDIRECT )
 359         {
 360                 if( File->PagesDirect[Page] )
 361                         page_id = File->PagesDirect[Page];
 362         }
 363         else if( Page - RAMFS_NDIRECT < PAGE_SIZE/4 )
 364         {
 365                 ofs = Page - RAMFS_NDIRECT;
 366                 if( File->Indirect1Page == 0 ) {
 367                         if( !bCanAlloc )
 368                                 return NULL;
 369                         else
 370                                 File->Indirect1Page = RAMFS_int_AllocatePage(File->Inode.Disk) + 1;
 371                 }
 372                 page_in_1 = MM_MapTemp( File->Inode.Disk->PhysPages[File->Indirect1Page-1] );
 373                 page_id = page_in_1[ofs];
 374         }
 375         else if( Page - RAMFS_NDIRECT - PAGE_SIZE/4 < (PAGE_SIZE/4)*(PAGE_SIZE/4) )
 376         {
 377                 block = (Page - RAMFS_NDIRECT - PAGE_SIZE/4) / (PAGE_SIZE/4);
 378                 ofs   = (Page - RAMFS_NDIRECT - PAGE_SIZE/4) % (PAGE_SIZE/4);
 379                 if( File->Indirect2Page == 0 ){
 380                         if( !bCanAlloc )
 381                                 return NULL;
 382                         else
 383                                 File->Indirect2Page = RAMFS_int_AllocatePage(File->Inode.Disk) + 1;
 384                 }
 385
 386                 page_in_2 = MM_MapTemp( File->Inode.Disk->PhysPages[File->Indirect2Page-1] );
 387                 if( page_in_2[block] == 0 ) {
 388                         if( !bCanAlloc )
 389                                 return NULL;
 390                         else
 391                                 page_in_2[block] = RAMFS_int_AllocatePage(File->Inode.Disk) + 1;
 392                 }
 393
 394                 page_in_1 = MM_MapTemp( File->Inode.Disk->PhysPages[page_in_2[block] - 1] );
 395                 page_id = page_in_1[ofs];
 396         }
 397
 398         if( page_id == 0 )
 399         {
 400                 if( !bCanAlloc )
 401                         return NULL;
 402
 403                 page_id = RAMFS_int_AllocatePage(File->Inode.Disk) + 1;
 404                 if(page_in_1)
 405                         page_in_1[ofs] = page_id;
 406                 else
 407                         File->PagesDirect[Page] = page_id;
 408         }
 409
 410         MM_FreeTemp( page_in_1 );
 411         MM_FreeTemp( page_in_2 );
 412
 413         return MM_MapTemp( File->Inode.Disk->PhysPages[page_id - 1] );
 414 }
 415
 416 void RAMFS_int_DropPage(void *Page)
 417 {
 418         MM_FreeTemp( Page );
 419 }
 420
 421 Uint32 RAMFS_int_AllocatePage(tRAMDisk *Disk)
 422 {
 423          int    i, j;
 424
 425         // Quick check
 426         if( Disk->nUsedPages == Disk->MaxPages )
 427                 return 0;
 428
 429         // Find a chunk with at least one free page
 430         for( i = 0; i < Disk->MaxPages / 32; i ++ )
 431         {
 432                 if( Disk->Bitmap[i] != -1 )
 433                         break;
 434         }
 435         if( i == Disk->MaxPages / 32 ) {
 436                 Log_Error("RAMFS", "Bookkeeping error, count and bitmap disagree");
 437                 return 0;
 438         }
 439
 440         // Find the exact page
 441         for( j = 0; j < 32; j ++ )
 442         {
 443                 if( !(Disk->Bitmap[i] & (1U << j)) )
 444                         break ;
 445         }
 446         ASSERT(j < 32);
 447
 448         return i * 32 + j;
 449 }
 450
 451 void RAMFS_int_RefFile(tRAMFS_Inode *Inode)
 452 {
 453         Inode->nLink ++;
 454 }
 455
 456 void RAMFS_int_DerefFile(tRAMFS_Inode *Inode)
 457 {
 458         Inode->nLink --;
 459         if( Inode->nLink >= 0 )
 460                 return ;
 461
 462         Log_Error("RAMFS", "TODO: Clean up files when deleted");
 463
 464         // Need to delete file
 465         switch( Inode->Type )
 466         {
 467         case 0: // File
 468                 break ;
 469         case 1: // Directory
 470                 break ;
 471         case 2: // Symlink
 472                 break ;
 473         }
 474         free(Inode);
 475 }