KernelLand/Modules/Filesystems/Ext2/ext2.c

   1 /*\r
   2  * Acess2 Ext2 Driver\r
   3  * - By John Hodge (thePowersGang)\r
   4  *\r
   5  * ext2.c\r
   6  * - Driver core\r
   7  */\r
   8 #define DEBUG   0\r
   9 #define VERSION VER2(0,90)\r
  10 #include "ext2_common.h"\r
  11 #include <modules.h>\r
  12 \r
  13 #define MIN_BLOCKS_PER_GROUP    2\r
  14 #define MAX_BLOCK_LOG_SIZE      10      // 1024 << 10 = 1MiB\r
  15 \r
  16 // === IMPORTS ===\r
  17 extern tVFS_NodeType    gExt2_DirType;\r
  18 \r
  19 // === PROTOTYPES ===\r
  20  int    Ext2_Install(char **Arguments);\r
  21  int    Ext2_Cleanup(void);\r
  22 // - Interface Functions\r
  23  int    Ext2_Detect(int FD);\r
  24 tVFS_Node       *Ext2_InitDevice(const char *Device, const char **Options);\r
  25 void    Ext2_Unmount(tVFS_Node *Node);\r
  26 void    Ext2_CloseFile(tVFS_Node *Node);\r
  27 // - Internal Helpers\r
  28  int    Ext2_int_GetInode(tVFS_Node *Node, tExt2_Inode *Inode);\r
  29 Uint64  Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum);\r
  30 Uint32  Ext2_int_AllocateInode(tExt2_Disk *Disk, Uint32 Parent);\r
  31 void    Ext2_int_DereferenceInode(tExt2_Disk *Disk, Uint32 Inode);\r
  32 void    Ext2_int_UpdateSuperblock(tExt2_Disk *Disk);\r
  33 \r
  34 // === SEMI-GLOBALS ===\r
  35 MODULE_DEFINE(0, VERSION, FS_Ext2, Ext2_Install, Ext2_Cleanup);\r
  36 tExt2_Disk      gExt2_disks[6];\r
  37  int    giExt2_count = 0;\r
  38 tVFS_Driver     gExt2_FSInfo = {\r
  39         .Name = "ext2",\r
  40         .Detect = Ext2_Detect,\r
  41         .InitDevice = Ext2_InitDevice,\r
  42         .Unmount = Ext2_Unmount,\r
  43         .GetNodeFromINode = NULL\r
  44         };\r
  45 \r
  46 // === CODE ===\r
  47 /**\r
  48  * \fn int Ext2_Install(char **Arguments)\r
  49  * \brief Install the Ext2 Filesystem Driver\r
  50  */\r
  51 int Ext2_Install(char **Arguments)\r
  52 {\r
  53         VFS_AddDriver( &gExt2_FSInfo );\r
  54         return MODULE_ERR_OK;\r
  55 }\r
  56 \r
  57 /**\r
  58  * \brief Clean up driver state before unload\r
  59  */\r
  60 int Ext2_Cleanup(void)\r
  61 {\r
  62         return 0;\r
  63 }\r
  64 \r
  65 /**\r
  66  * Detect if a volume is Ext2 formatted\r
  67  */\r
  68 int Ext2_Detect(int FD)\r
  69 {\r
  70         tExt2_SuperBlock        sb;\r
  71         size_t  len;\r
  72         \r
  73         len = VFS_ReadAt(FD, 1024, 1024, &sb);\r
  74 \r
  75         if( len != 1024 ) {\r
  76                 Log_Debug("Ext2", "_Detect: Read failed? (0x%x != 1024)", len);\r
  77                 return 0;\r
  78         }\r
  79         \r
  80         switch(sb.s_magic)\r
  81         {\r
  82         case 0xEF53:\r
  83                 return 2;\r
  84         default:\r
  85                 Log_Debug("Ext2", "_Detect: s_magic = 0x%x", sb.s_magic);\r
  86                 return 0;\r
  87         }\r
  88 }\r
  89 \r
  90 /**\r
  91  \brief Initializes a device to be read by by the driver\r
  92  \param Device  String - Device to read from\r
  93  \param Options NULL Terminated array of option strings\r
  94  \return Root Node\r
  95 */\r
  96 tVFS_Node *Ext2_InitDevice(const char *Device, const char **Options)\r
  97 {\r
  98         tExt2_Disk      *disk = NULL;\r
  99          int    fd;\r
 100          int    groupCount;\r
 101         tExt2_SuperBlock        sb;\r
 102         tExt2_Inode     inode;\r
 103         \r
 104         ENTER("sDevice pOptions", Device, Options);\r
 105         \r
 106         // Open Disk\r
 107         fd = VFS_Open(Device, VFS_OPENFLAG_READ|VFS_OPENFLAG_WRITE);            //Open Device\r
 108         if(fd == -1) {\r
 109                 Log_Warning("EXT2", "Unable to open '%s'", Device);\r
 110                 LEAVE('n');\r
 111                 return NULL;\r
 112         }\r
 113         \r
 114         // Read Superblock at offset 1024\r
 115         VFS_ReadAt(fd, 1024, 1024, &sb);        // Read Superblock\r
 116         \r
 117         // Sanity Check Magic value\r
 118         if(sb.s_magic != 0xEF53) {\r
 119                 Log_Warning("EXT2", "Volume '%s' is not an EXT2 volume (0x%x != 0xEF53)",\r
 120                         Device, sb.s_magic);\r
 121                 goto _error;\r
 122         }\r
 123 \r
 124         if( sb.s_blocks_per_group < MIN_BLOCKS_PER_GROUP ) {\r
 125                 Log_Warning("Ext2", "Blocks per group is too small (%i < %i)",\r
 126                         sb.s_blocks_per_group, MIN_BLOCKS_PER_GROUP);\r
 127                 goto _error;\r
 128         }       \r
 129 \r
 130         // Get Group count\r
 131         groupCount = DivUp(sb.s_blocks_count, sb.s_blocks_per_group);\r
 132         LOG("groupCount = %i", groupCount);\r
 133         \r
 134         // Allocate Disk Information\r
 135         disk = malloc(sizeof(tExt2_Disk) + sizeof(tExt2_Group)*groupCount);\r
 136         if(!disk) {\r
 137                 Log_Warning("EXT2", "Unable to allocate disk structure");\r
 138                 goto _error;\r
 139         }\r
 140         disk->FD = fd;\r
 141         memcpy(&disk->SuperBlock, &sb, 1024);\r
 142         disk->GroupCount = groupCount;\r
 143         \r
 144         // Get an inode cache handle\r
 145         disk->CacheID = Inode_GetHandle();\r
 146         \r
 147         // Get Block Size\r
 148         if( sb.s_log_block_size > MAX_BLOCK_LOG_SIZE ) {\r
 149                 Log_Warning("Ext2", "Block size (log2) too large (%i > %i)",\r
 150                         sb.s_log_block_size, MAX_BLOCK_LOG_SIZE);\r
 151                 goto _error;\r
 152         }\r
 153         disk->BlockSize = 1024 << sb.s_log_block_size;\r
 154         LOG("Disk->BlockSie = 0x%x (1024 << %i)", disk->BlockSize, sb.s_log_block_size);\r
 155         \r
 156         // Read Group Information\r
 157         LOG("sb,s_first_data_block = %x", sb.s_first_data_block);\r
 158         VFS_ReadAt(\r
 159                 disk->FD,\r
 160                 sb.s_first_data_block * disk->BlockSize + 1024,\r
 161                 sizeof(tExt2_Group)*groupCount,\r
 162                 disk->Groups\r
 163                 );\r
 164         \r
 165         LOG("Block Group 0");\r
 166         LOG(".bg_block_bitmap = 0x%x", disk->Groups[0].bg_block_bitmap);\r
 167         LOG(".bg_inode_bitmap = 0x%x", disk->Groups[0].bg_inode_bitmap);\r
 168         LOG(".bg_inode_table = 0x%x", disk->Groups[0].bg_inode_table);\r
 169         LOG("Block Group 1");\r
 170         LOG(".bg_block_bitmap = 0x%x", disk->Groups[1].bg_block_bitmap);\r
 171         LOG(".bg_inode_bitmap = 0x%x", disk->Groups[1].bg_inode_bitmap);\r
 172         LOG(".bg_inode_table = 0x%x", disk->Groups[1].bg_inode_table);\r
 173         \r
 174         // Get root Inode\r
 175         Ext2_int_ReadInode(disk, 2, &inode);\r
 176         \r
 177         // Create Root Node\r
 178         memset(&disk->RootNode, 0, sizeof(tVFS_Node));\r
 179         disk->RootNode.Inode = 2;       // Root inode ID\r
 180         disk->RootNode.ImplPtr = disk;  // Save disk pointer\r
 181         disk->RootNode.Size = -1;       // Fill in later (on readdir)\r
 182         disk->RootNode.Flags = VFS_FFLAG_DIRECTORY;\r
 183 \r
 184         disk->RootNode.Type = &gExt2_DirType;\r
 185         \r
 186         // Complete root node\r
 187         disk->RootNode.UID = inode.i_uid;\r
 188         disk->RootNode.GID = inode.i_gid;\r
 189         disk->RootNode.NumACLs = 1;\r
 190         disk->RootNode.ACLs = &gVFS_ACL_EveryoneRW;\r
 191         \r
 192         #if DEBUG\r
 193         LOG("inode.i_size = 0x%x", inode.i_size);\r
 194         LOG("inode.i_block[0] = 0x%x", inode.i_block[0]);\r
 195         #endif\r
 196         \r
 197         LEAVE('p', &disk->RootNode);\r
 198         return &disk->RootNode;\r
 199 _error:\r
 200         if( disk )\r
 201                 free(disk);\r
 202         VFS_Close(fd);\r
 203         LEAVE('n');\r
 204         return NULL;\r
 205 }\r
 206 \r
 207 /**\r
 208  * \fn void Ext2_Unmount(tVFS_Node *Node)\r
 209  * \brief Close a mounted device\r
 210  */\r
 211 void Ext2_Unmount(tVFS_Node *Node)\r
 212 {\r
 213         tExt2_Disk      *disk = Node->ImplPtr;\r
 214         \r
 215         VFS_Close( disk->FD );\r
 216         Inode_ClearCache( disk->CacheID );\r
 217         memset(disk, 0, sizeof(tExt2_Disk)+disk->GroupCount*sizeof(tExt2_Group));\r
 218         free(disk);\r
 219 }\r
 220 \r
 221 /**\r
 222  * \fn void Ext2_CloseFile(tVFS_Node *Node)\r
 223  * \brief Close a file (Remove it from the cache)\r
 224  */\r
 225 void Ext2_CloseFile(tVFS_Node *Node)\r
 226 {\r
 227         tExt2_Disk      *disk = Node->ImplPtr;\r
 228         ENTER("pNode", Node);\r
 229 \r
 230         if( Mutex_Acquire(&Node->Lock) != 0 )\r
 231         {\r
 232                 LEAVE('-');\r
 233                 return ;\r
 234         }\r
 235 \r
 236         if( Node->Flags & VFS_FFLAG_DIRTY )\r
 237         {\r
 238                 // Commit changes\r
 239                 Log_Warning("Ext2", "TODO: Commit node changes");\r
 240         }\r
 241 \r
 242         int was_not_referenced = (Node->ImplInt == 0);\r
 243         tVFS_ACL        *acls = Node->ACLs;\r
 244         if( Inode_UncacheNode(disk->CacheID, Node->Inode) == 1 )\r
 245         {\r
 246                 if( was_not_referenced )\r
 247                 {\r
 248                         LOG("Removng inode");\r
 249                         // Remove inode\r
 250                         Log_Warning("Ext2", "TODO: Remove inode when not referenced");\r
 251                 }\r
 252                 if( acls != &gVFS_ACL_EveryoneRW ) {\r
 253                         free(acls);\r
 254                 }\r
 255                 LOG("Node cleaned");\r
 256         }\r
 257         else {\r
 258                 LOG("Still referenced, releasing lock");\r
 259                 Mutex_Release(&Node->Lock);\r
 260         }\r
 261         LEAVE('-');\r
 262         return ;\r
 263 }\r
 264 \r
 265 //==================================\r
 266 //=       INTERNAL FUNCTIONS       =\r
 267 //==================================\r
 268 /**\r
 269  * \fn int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint InodeId, tExt2_Inode *Inode)\r
 270  * \brief Read an inode into memory\r
 271  */\r
 272 int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint32 InodeId, tExt2_Inode *Inode)\r
 273 {\r
 274          int    group, subId;\r
 275         \r
 276         ENTER("pDisk iInodeId pInode", Disk, InodeId, Inode);\r
 277         \r
 278         if(InodeId == 0)        return 0;\r
 279         \r
 280         InodeId --;     // Inodes are numbered starting at 1\r
 281         \r
 282         group = InodeId / Disk->SuperBlock.s_inodes_per_group;\r
 283         subId = InodeId % Disk->SuperBlock.s_inodes_per_group;\r
 284         \r
 285         LOG("group=%i, subId = %i", group, subId);\r
 286         \r
 287         // Read Inode\r
 288         VFS_ReadAt(Disk->FD,\r
 289                 Disk->Groups[group].bg_inode_table * Disk->BlockSize + sizeof(tExt2_Inode)*subId,\r
 290                 sizeof(tExt2_Inode),\r
 291                 Inode);\r
 292         \r
 293         LEAVE('i', 1);\r
 294         return 1;\r
 295 }\r
 296 \r
 297 /**\r
 298  * \brief Write a modified inode out to disk\r
 299  */\r
 300 int Ext2_int_WriteInode(tExt2_Disk *Disk, Uint32 InodeId, tExt2_Inode *Inode)\r
 301 {\r
 302          int    group, subId;\r
 303         ENTER("pDisk iInodeId pInode", Disk, InodeId, Inode);\r
 304         \r
 305         if(InodeId == 0) {\r
 306                 LEAVE('i', 0);\r
 307                 return 0;\r
 308         }\r
 309         \r
 310         InodeId --;     // Inodes are numbered starting at 1\r
 311         \r
 312         group = InodeId / Disk->SuperBlock.s_inodes_per_group;\r
 313         subId = InodeId % Disk->SuperBlock.s_inodes_per_group;\r
 314         \r
 315         LOG("group=%i, subId = %i", group, subId);\r
 316         \r
 317         // Write Inode\r
 318         VFS_WriteAt(Disk->FD,\r
 319                 Disk->Groups[group].bg_inode_table * Disk->BlockSize + sizeof(tExt2_Inode)*subId,\r
 320                 sizeof(tExt2_Inode),\r
 321                 Inode\r
 322                 );\r
 323         \r
 324         LEAVE('i', 1);\r
 325         return 1;\r
 326 }\r
 327 \r
 328 /**\r
 329  * \fn Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum)\r
 330  * \brief Get the address of a block from an inode's list\r
 331  * \param Disk  Disk information structure\r
 332  * \param Blocks        Pointer to an inode's block list\r
 333  * \param BlockNum      Block index in list\r
 334  */\r
 335 Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum)\r
 336 {\r
 337         Uint32  *iBlocks;\r
 338          int    dwPerBlock = Disk->BlockSize / 4;\r
 339         \r
 340         // Direct Blocks\r
 341         if(BlockNum < 12)\r
 342                 return (Uint64)Blocks[BlockNum] * Disk->BlockSize;\r
 343         \r
 344         // Single Indirect Blocks\r
 345         iBlocks = malloc( Disk->BlockSize );\r
 346         VFS_ReadAt(Disk->FD, (Uint64)Blocks[12]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
 347         \r
 348         BlockNum -= 12;\r
 349         if(BlockNum < dwPerBlock)\r
 350         {\r
 351                 BlockNum = iBlocks[BlockNum];\r
 352                 free(iBlocks);\r
 353                 return (Uint64)BlockNum * Disk->BlockSize;\r
 354         }\r
 355         \r
 356         BlockNum -= dwPerBlock;\r
 357         // Double Indirect Blocks\r
 358         if(BlockNum < dwPerBlock*dwPerBlock)\r
 359         {\r
 360                 VFS_ReadAt(Disk->FD, (Uint64)Blocks[13]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
 361                 VFS_ReadAt(Disk->FD, (Uint64)iBlocks[BlockNum/dwPerBlock]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
 362                 BlockNum = iBlocks[BlockNum%dwPerBlock];\r
 363                 free(iBlocks);\r
 364                 return (Uint64)BlockNum * Disk->BlockSize;\r
 365         }\r
 366         \r
 367         BlockNum -= dwPerBlock*dwPerBlock;\r
 368         // Triple Indirect Blocks\r
 369         VFS_ReadAt(Disk->FD, (Uint64)Blocks[14]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
 370         VFS_ReadAt(Disk->FD, (Uint64)iBlocks[BlockNum/(dwPerBlock*dwPerBlock)]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
 371         VFS_ReadAt(Disk->FD, (Uint64)iBlocks[(BlockNum/dwPerBlock)%dwPerBlock]*Disk->BlockSize, Disk->BlockSize, iBlocks);\r
 372         BlockNum = iBlocks[BlockNum%dwPerBlock];\r
 373         free(iBlocks);\r
 374         return (Uint64)BlockNum * Disk->BlockSize;\r
 375 }\r
 376 \r
 377 /**\r
 378  * \fn Uint32 Ext2_int_AllocateInode(tExt2_Disk *Disk, Uint32 Parent)\r
 379  * \brief Allocate an inode (from the current group preferably)\r
 380  * \param Disk  EXT2 Disk Information Structure\r
 381  * \param Parent        Inode ID of the parent (used to locate the child nearby)\r
 382  */\r
 383 Uint32 Ext2_int_AllocateInode(tExt2_Disk *Disk, Uint32 Parent)\r
 384 {\r
 385         Uint    start_group = (Parent - 1) / Disk->SuperBlock.s_inodes_per_group;\r
 386         Uint    group = start_group;\r
 387 \r
 388         if( Disk->SuperBlock.s_free_inodes_count == 0 ) \r
 389         {\r
 390                 Log_Notice("Ext2", "Ext2_int_AllocateInode - Out of inodes on %p", Disk);\r
 391                 return 0;\r
 392         }\r
 393 \r
 394         while( group < Disk->GroupCount && Disk->Groups[group].bg_free_inodes_count == 0 )\r
 395                 group ++;\r
 396         if( group == Disk->GroupCount )\r
 397         {\r
 398                 group = 0;\r
 399                 while( group < start_group && Disk->Groups[group].bg_free_inodes_count == 0 )\r
 400                         group ++;\r
 401         }\r
 402         \r
 403         if( Disk->Groups[group].bg_free_inodes_count == 0 )\r
 404         {\r
 405                 Log_Notice("Ext2", "Ext2_int_AllocateInode - Out of inodes on %p, but superblock says some free", Disk);\r
 406                 return 0;\r
 407         }\r
 408 \r
 409         // Load bitmap for group\r
 410         //  (s_inodes_per_group / 8) bytes worth\r
 411         // - Allocate a buffer the size of a sector/block\r
 412         // - Read in part of the bitmap\r
 413         // - Search for a free inode\r
 414         tExt2_Group     *bg = &Disk->Groups[group];\r
 415          int    ofs = 0;\r
 416         do {\r
 417                 const int sector_size = 512;\r
 418                 Uint8 buf[sector_size];\r
 419                 VFS_ReadAt(Disk->FD, Disk->BlockSize*bg->bg_inode_bitmap+ofs, sector_size, buf);\r
 420 \r
 421                 int byte, bit;\r
 422                 for( byte = 0; byte < sector_size && buf[byte] != 0xFF; byte ++ )\r
 423                         ;\r
 424                 if( byte < sector_size )\r
 425                 {\r
 426                         for( bit = 0; bit < 8 && buf[byte] & (1 << bit); bit ++)\r
 427                                 ;\r
 428                         ASSERT(bit != 8);\r
 429                         buf[byte] |= 1 << bit;\r
 430                         VFS_WriteAt(Disk->FD, Disk->BlockSize*bg->bg_inode_bitmap+ofs, sector_size, buf);\r
 431 \r
 432                         bg->bg_free_inodes_count --;\r
 433                         Disk->SuperBlock.s_free_inodes_count --;\r
 434 \r
 435                         Uint32  ret = group * Disk->SuperBlock.s_inodes_per_group + byte * 8 + bit + 1;\r
 436                         Log_Debug("Ext2", "Ext2_int_AllocateInode - Allocated 0x%x", ret);\r
 437                         return ret;\r
 438                 }\r
 439 \r
 440                 ofs += sector_size;\r
 441         } while(ofs < Disk->SuperBlock.s_inodes_per_group / 8);\r
 442 \r
 443         Log_Notice("Ext2", "Ext2_int_AllocateInode - Out of inodes in group %p:%i but header reported free",\r
 444                 Disk, group);\r
 445 \r
 446         return 0;\r
 447 }\r
 448 \r
 449 /**\r
 450  * \brief Reduce the reference count on an inode\r
 451  */\r
 452 void Ext2_int_DereferenceInode(tExt2_Disk *Disk, Uint32 Inode)\r
 453 {\r
 454         Log_Warning("Ext2", "TODO: Impliment Ext2_int_DereferenceInode");\r
 455 }\r
 456 \r
 457 /**\r
 458  * \fn void Ext2_int_UpdateSuperblock(tExt2_Disk *Disk)\r
 459  * \brief Updates the superblock\r
 460  */\r
 461 void Ext2_int_UpdateSuperblock(tExt2_Disk *Disk)\r
 462 {\r
 463          int    bpg = Disk->SuperBlock.s_blocks_per_group;\r
 464          int    ngrp = Disk->SuperBlock.s_blocks_count / bpg;\r
 465          int    i;\r
 466          \r
 467         // Update Primary\r
 468         VFS_WriteAt(Disk->FD, 1024, 1024, &Disk->SuperBlock);\r
 469         \r
 470         // Secondaries\r
 471         // at Block Group 1, 3^n, 5^n, 7^n\r
 472         \r
 473         // 1\r
 474         if(ngrp <= 1)   return;\r
 475         VFS_WriteAt(Disk->FD, 1*bpg*Disk->BlockSize, 1024, &Disk->SuperBlock);\r
 476         \r
 477         #define INT_MAX (((long long int)1<<(sizeof(int)*8))-1)\r
 478         \r
 479         // Powers of 3\r
 480         for( i = 3; i < ngrp && i < INT_MAX/3; i *= 3 )\r
 481                 VFS_WriteAt(Disk->FD, i*bpg*Disk->BlockSize, 1024, &Disk->SuperBlock);\r
 482         \r
 483         // Powers of 5\r
 484         for( i = 5; i < ngrp && i < INT_MAX/5; i *= 5 )\r
 485                 VFS_WriteAt(Disk->FD, i*bpg*Disk->BlockSize, 1024, &Disk->SuperBlock);\r
 486         \r
 487         // Powers of 7\r
 488         for( i = 7; i < ngrp && i < INT_MAX/7; i *= 7 )\r
 489                 VFS_WriteAt(Disk->FD, i*bpg*Disk->BlockSize, 1024, &Disk->SuperBlock);\r
 490 }\r