3 * Ext2 Driver Version 1
\r
7 * \brief Second Extended Filesystem Driver
\r
8 * \todo Implement file read support
\r
13 #include <modules.h>
\r
14 #include "fs_ext2.h"
\r
16 #define EXT2_UPDATE_WRITEBACK 1
\r
18 // === STRUCTURES ===
\r
24 tExt2_SuperBlock SuperBlock;
\r
28 tExt2_Group Groups[];
\r
31 // === PROTOTYPES ===
\r
32 int Ext2_Install(char **Arguments);
\r
33 // Interface Functions
\r
34 tVFS_Node *Ext2_InitDevice(char *Device, char **Options);
\r
35 void Ext2_Unmount(tVFS_Node *Node);
\r
36 Uint64 Ext2_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);
\r
37 Uint64 Ext2_Write(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);
\r
38 void Ext2_CloseFile(tVFS_Node *Node);
\r
39 char *Ext2_ReadDir(tVFS_Node *Node, int Pos);
\r
40 tVFS_Node *Ext2_FindDir(tVFS_Node *Node, char *FileName);
\r
41 int Ext2_MkNod(tVFS_Node *Node, char *Name, Uint Flags);
\r
43 int Ext2_int_GetInode(tVFS_Node *Node, tExt2_Inode *Inode);
\r
44 tVFS_Node *Ext2_int_CreateNode(tExt2_Disk *Disk, Uint InodeId, char *Name);
\r
45 int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint InodeId, tExt2_Inode *Inode);
\r
46 Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum);
\r
47 Uint32 Ext2_int_AllocateInode(tExt2_Disk *Disk, Uint32 Parent);
\r
48 Uint32 Ext2_int_AllocateBlock(tExt2_Disk *Disk, Uint32 PrevBlock);
\r
49 void Ext2_int_UpdateSuperblock(tExt2_Disk *Disk);
\r
51 // === SEMI-GLOBALS ===
\r
52 MODULE_DEFINE(0, 0x5B /*v0.90*/, EXT2, Ext2_Install, NULL);
\r
53 tExt2_Disk gExt2_disks[6];
\r
54 int giExt2_count = 0;
\r
55 tVFS_Driver gExt2_FSInfo = {
\r
56 "ext2", 0, Ext2_InitDevice, Ext2_Unmount, NULL
\r
62 * \fn int Ext2_Install(char **Arguments)
\r
63 * \brief Install the Ext2 Filesystem Driver
\r
65 int Ext2_Install(char **Arguments)
\r
67 VFS_AddDriver( &gExt2_FSInfo );
\r
72 \fn tVFS_Node *Ext2_InitDevice(char *Device, char **Options)
\r
73 \brief Initializes a device to be read by by the driver
\r
74 \param Device String - Device to read from
\r
75 \param Options NULL Terminated array of option strings
\r
78 tVFS_Node *Ext2_InitDevice(char *Device, char **Options)
\r
83 tExt2_SuperBlock sb;
\r
86 ENTER("sDevice pOptions", Device, Options);
\r
89 fd = VFS_Open(Device, VFS_OPENFLAG_READ|VFS_OPENFLAG_WRITE); //Open Device
\r
91 Warning("[EXT2 ] Unable to open '%s'", Device);
\r
96 // Read Superblock at offset 1024
\r
97 VFS_ReadAt(fd, 1024, 1024, &sb); // Read Superblock
\r
99 // Sanity Check Magic value
\r
100 if(sb.s_magic != 0xEF53) {
\r
101 Warning("[EXT2 ] Volume '%s' is not an EXT2 volume", Device);
\r
108 groupCount = DivUp(sb.s_blocks_count, sb.s_blocks_per_group);
\r
109 LOG("groupCount = %i", groupCount);
\r
111 // Allocate Disk Information
\r
112 disk = malloc(sizeof(tExt2_Disk) + sizeof(tExt2_Group)*groupCount);
\r
114 Warning("[EXT2 ] Unable to allocate disk structure");
\r
120 memcpy(&disk->SuperBlock, &sb, 1024);
\r
121 disk->GroupCount = groupCount;
\r
123 // Get an inode cache handle
\r
124 disk->CacheID = Inode_GetHandle();
\r
127 LOG("s_log_block_size = 0x%x", sb.s_log_block_size);
\r
128 disk->BlockSize = 1024 << sb.s_log_block_size;
\r
130 // Read Group Information
\r
133 sb.s_first_data_block * disk->BlockSize + 1024,
\r
134 sizeof(tExt2_Group)*groupCount,
\r
139 LOG("Block Group 0");
\r
140 LOG(".bg_block_bitmap = 0x%x", disk->Groups[0].bg_block_bitmap);
\r
141 LOG(".bg_inode_bitmap = 0x%x", disk->Groups[0].bg_inode_bitmap);
\r
142 LOG(".bg_inode_table = 0x%x", disk->Groups[0].bg_inode_table);
\r
143 LOG("Block Group 1");
\r
144 LOG(".bg_block_bitmap = 0x%x", disk->Groups[1].bg_block_bitmap);
\r
145 LOG(".bg_inode_bitmap = 0x%x", disk->Groups[1].bg_inode_bitmap);
\r
146 LOG(".bg_inode_table = 0x%x", disk->Groups[1].bg_inode_table);
\r
150 Ext2_int_ReadInode(disk, 2, &inode);
\r
152 // Create Root Node
\r
153 memset(&disk->RootNode, 0, sizeof(tVFS_Node));
\r
154 disk->RootNode.Inode = 2; // Root inode ID
\r
155 disk->RootNode.ImplPtr = disk; // Save disk pointer
\r
156 disk->RootNode.Size = -1; // Fill in later (on readdir)
\r
157 disk->RootNode.Flags = VFS_FFLAG_DIRECTORY;
\r
159 disk->RootNode.ReadDir = Ext2_ReadDir;
\r
160 disk->RootNode.FindDir = Ext2_FindDir;
\r
161 //disk->RootNode.Relink = Ext2_Relink;
\r
163 // Complete root node
\r
164 disk->RootNode.UID = inode.i_uid;
\r
165 disk->RootNode.GID = inode.i_gid;
\r
166 disk->RootNode.NumACLs = 1;
\r
167 disk->RootNode.ACLs = &gVFS_ACL_EveryoneRW;
\r
170 LOG("inode.i_size = 0x%x", inode.i_size);
\r
171 LOG("inode.i_block[0] = 0x%x", inode.i_block[0]);
\r
174 LEAVE('p', &disk->RootNode);
\r
175 return &disk->RootNode;
\r
179 * \fn void Ext2_Unmount(tVFS_Node *Node)
\r
180 * \brief Close a mounted device
\r
182 void Ext2_Unmount(tVFS_Node *Node)
\r
184 tExt2_Disk *disk = Node->ImplPtr;
\r
186 VFS_Close( disk->FD );
\r
187 Inode_ClearCache( disk->CacheID );
\r
188 memset(disk, 0, sizeof(tExt2_Disk)+disk->GroupCount*sizeof(tExt2_Group));
\r
193 * \fn Uint64 Ext2_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
\r
194 * \brief Read from a file
\r
196 Uint64 Ext2_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
\r
198 tExt2_Disk *disk = Node->ImplPtr;
\r
204 ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
\r
207 Ext2_int_GetInode(Node, &inode);
\r
210 if(Offset >= inode.i_size) {
\r
214 if(Offset + Length > inode.i_size)
\r
215 Length = inode.i_size - Offset;
\r
217 block = Offset / disk->BlockSize;
\r
218 Offset = Offset / disk->BlockSize;
\r
219 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
221 Warning("[EXT2 ] NULL Block Detected in INode 0x%llx", Node->Inode);
\r
227 if(Length <= disk->BlockSize - Offset)
\r
229 VFS_ReadAt( disk->FD, base+Offset, Length, Buffer);
\r
230 LEAVE('X', Length);
\r
234 // Read first block
\r
236 VFS_ReadAt( disk->FD, base + Offset, disk->BlockSize - Offset, Buffer);
\r
237 remLen -= disk->BlockSize - Offset;
\r
238 Buffer += disk->BlockSize - Offset;
\r
241 // Read middle blocks
\r
242 while(remLen > disk->BlockSize)
\r
244 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
246 Warning("[EXT2 ] NULL Block Detected in INode 0x%llx", Node->Inode);
\r
250 VFS_ReadAt( disk->FD, base, disk->BlockSize, Buffer);
\r
251 Buffer += disk->BlockSize;
\r
252 remLen -= disk->BlockSize;
\r
257 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
258 VFS_ReadAt( disk->FD, base, remLen, Buffer);
\r
260 LEAVE('X', Length);
\r
265 * \fn Uint64 Ext2_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
\r
266 * \brief Write to a file
\r
268 Uint64 Ext2_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
\r
270 tExt2_Disk *disk = Node->ImplPtr;
\r
276 int bNewBlocks = 0;
\r
278 Debug_HexDump("Ext2_Write", Buffer, Length);
\r
280 Ext2_int_GetInode(Node, &inode);
\r
282 // Get the ammount of space already allocated
\r
283 // - Round size up to block size
\r
284 // - block size is a power of two, so this will work
\r
285 allocSize = (inode.i_size + disk->BlockSize) & ~(disk->BlockSize-1);
\r
287 // Are we writing to inside the allocated space?
\r
288 if( Offset < allocSize )
\r
290 // Will we go out of it?
\r
291 if(Offset + Length > allocSize) {
\r
293 retLen = allocSize - Offset;
\r
297 // Within the allocated space
\r
298 block = Offset / disk->BlockSize;
\r
299 Offset %= disk->BlockSize;
\r
300 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
302 // Write only block (if only one)
\r
303 if(Offset + retLen <= disk->BlockSize) {
\r
304 VFS_WriteAt(disk->FD, base+Offset, retLen, Buffer);
\r
305 if(!bNewBlocks) return Length;
\r
306 goto addBlocks; // Ugh! A goto, but it seems unavoidable
\r
309 // Write First Block
\r
310 VFS_WriteAt(disk->FD, base+Offset, disk->BlockSize-Offset, Buffer);
\r
311 Buffer += disk->BlockSize-Offset;
\r
312 retLen -= disk->BlockSize-Offset;
\r
315 // Write middle blocks
\r
316 while(retLen > disk->BlockSize)
\r
318 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
319 VFS_WriteAt(disk->FD, base, disk->BlockSize, Buffer);
\r
320 Buffer += disk->BlockSize;
\r
321 retLen -= disk->BlockSize;
\r
325 // Write last block
\r
326 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
327 VFS_WriteAt(disk->FD, base, retLen, Buffer);
\r
328 if(!bNewBlocks) return Length; // Writing in only allocated space
\r
332 ///\todo Implement block allocation
\r
333 Warning("[EXT2] File extending is not yet supported");
\r
339 * \fn void Ext2_CloseFile(tVFS_Node *Node)
\r
340 * \brief Close a file (Remove it from the cache)
\r
342 void Ext2_CloseFile(tVFS_Node *Node)
\r
344 tExt2_Disk *disk = Node->ImplPtr;
\r
345 Inode_UncacheNode(disk->CacheID, Node->Inode);
\r
350 \fn char *Ext2_ReadDir(tVFS_Node *Node, int Pos)
\r
351 \brief Reads a directory entry
\r
353 char *Ext2_ReadDir(tVFS_Node *Node, int Pos)
\r
356 char namebuf[EXT2_NAME_LEN+1];
\r
357 tExt2_DirEnt dirent;
\r
358 Uint64 Base; // Block's Base Address
\r
359 int block = 0, ofs = 0;
\r
361 tExt2_Disk *disk = Node->ImplPtr;
\r
364 ENTER("pNode iPos", Node, Pos);
\r
366 // Read directory's inode
\r
367 Ext2_int_GetInode(Node, &inode);
\r
368 size = inode.i_size;
\r
370 LOG("inode.i_block[0] = 0x%x", inode.i_block[0]);
\r
374 // - Do this ourselves as it is a simple operation
\r
375 Base = inode.i_block[0] * disk->BlockSize;
\r
376 while(Pos -- && size > 0)
\r
378 VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent);
\r
379 ofs += dirent.rec_len;
\r
380 size -= dirent.rec_len;
\r
383 if(ofs >= disk->BlockSize) {
\r
385 if( ofs > disk->BlockSize ) {
\r
386 Warning("[EXT2] Directory Entry %i of inode %i extends over a block boundary, ignoring",
\r
387 entNum-1, Node->Inode);
\r
390 Base = Ext2_int_GetBlockAddr( disk, inode.i_block, block );
\r
394 // Check for the end of the list
\r
401 VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent );
\r
402 //LOG("dirent.inode = %i", dirent.inode);
\r
403 //LOG("dirent.rec_len = %i", dirent.rec_len);
\r
404 //LOG("dirent.name_len = %i", dirent.name_len);
\r
405 VFS_ReadAt( disk->FD, Base+ofs+sizeof(tExt2_DirEnt), dirent.name_len, namebuf );
\r
406 namebuf[ dirent.name_len ] = '\0'; // Cap off string
\r
409 // Ignore . and .. (these are done in the VFS)
\r
410 if( (namebuf[0] == '.' && namebuf[1] == '\0')
\r
411 || (namebuf[0] == '.' && namebuf[1] == '.' && namebuf[2]=='\0')) {
\r
412 LEAVE('p', VFS_SKIP);
\r
413 return VFS_SKIP; // Skip
\r
416 LEAVE('s', namebuf);
\r
418 return strdup(namebuf);
\r
422 \fn tVFS_Node *Ext2_FindDir(tVFS_Node *node, char *filename)
\r
423 \brief Gets information about a file
\r
424 \param node vfs node - Parent Node
\r
425 \param filename String - Name of file
\r
426 \return VFS Node of file
\r
428 tVFS_Node *Ext2_FindDir(tVFS_Node *Node, char *Filename)
\r
430 tExt2_Disk *disk = Node->ImplPtr;
\r
432 char namebuf[EXT2_NAME_LEN+1];
\r
433 tExt2_DirEnt dirent;
\r
434 Uint64 Base; // Block's Base Address
\r
435 int block = 0, ofs = 0;
\r
439 // Read directory's inode
\r
440 Ext2_int_GetInode(Node, &inode);
\r
441 size = inode.i_size;
\r
444 // - Do this ourselves as it is a simple operation
\r
445 Base = inode.i_block[0] * disk->BlockSize;
\r
449 VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent);
\r
450 VFS_ReadAt( disk->FD, Base+ofs+sizeof(tExt2_DirEnt), dirent.name_len, namebuf );
\r
451 namebuf[ dirent.name_len ] = '\0'; // Cap off string
\r
452 // If it matches, create a node and return it
\r
453 if(strcmp(namebuf, Filename) == 0)
\r
454 return Ext2_int_CreateNode( disk, dirent.inode, namebuf );
\r
455 // Increment pointers
\r
456 ofs += dirent.rec_len;
\r
457 size -= dirent.rec_len;
\r
460 // Check for end of block
\r
461 if(ofs >= disk->BlockSize) {
\r
463 if( ofs > disk->BlockSize ) {
\r
464 Warning("[EXT2 ] Directory Entry %i of inode %i extends over a block boundary, ignoring",
\r
465 entNum-1, Node->Inode);
\r
468 Base = Ext2_int_GetBlockAddr( disk, inode.i_block, block );
\r
476 * \fn int Ext2_MkNod(tVFS_Node *Parent, char *Name, Uint Flags)
\r
477 * \brief Create a new node
\r
479 int Ext2_MkNod(tVFS_Node *Parent, char *Name, Uint Flags)
\r
484 //==================================
\r
485 //= INTERNAL FUNCTIONS =
\r
486 //==================================
\r
490 * \fn int Ext2_int_GetInode(tVFS_Node *Node, tExt2_Inode *Inode)
\r
491 * \brief Gets the inode descriptor for a node
\r
492 * \param Node node to get the Inode of
\r
493 * \param Inode Destination
\r
495 int Ext2_int_GetInode(tVFS_Node *Node, tExt2_Inode *Inode)
\r
497 return Ext2_int_ReadInode(Node->ImplPtr, Node->Inode, Inode);
\r
501 * \fn vfs_node *Ext2_int_CreateNode(tExt2_Disk *Disk, Uint InodeID, char *Name)
\r
502 * \brief Create a new VFS Node
\r
504 tVFS_Node *Ext2_int_CreateNode(tExt2_Disk *Disk, Uint InodeID, char *Name)
\r
508 tVFS_Node *tmpNode;
\r
510 if( !Ext2_int_ReadInode(Disk, InodeID, &inode) )
\r
513 if( (tmpNode = Inode_GetCache(Disk->CacheID, InodeID)) )
\r
518 retNode.Inode = InodeID;
\r
519 retNode.ImplPtr = Disk;
\r
522 retNode.Size = inode.i_size;
\r
524 // Set Access Permissions
\r
525 retNode.UID = inode.i_uid;
\r
526 retNode.GID = inode.i_gid;
\r
527 retNode.NumACLs = 3;
\r
528 retNode.ACLs = VFS_UnixToAcessACL(inode.i_mode & 0777, inode.i_uid, inode.i_gid);
\r
530 // Set Function Pointers
\r
531 retNode.Read = Ext2_Read;
\r
532 retNode.Write = Ext2_Write;
\r
533 retNode.Close = Ext2_CloseFile;
\r
535 switch(inode.i_mode & EXT2_S_IFMT)
\r
539 retNode.Flags = VFS_FFLAG_SYMLINK;
\r
544 retNode.Size |= (Uint64)inode.i_dir_acl << 32;
\r
548 retNode.ReadDir = Ext2_ReadDir;
\r
549 retNode.FindDir = Ext2_FindDir;
\r
550 retNode.MkNod = Ext2_MkNod;
\r
551 //retNode.Relink = Ext2_Relink;
\r
552 retNode.Flags = VFS_FFLAG_DIRECTORY;
\r
554 // Unknown, Write protect and hide it to be safe
\r
556 retNode.Flags = VFS_FFLAG_READONLY;//|VFS_FFLAG_HIDDEN;
\r
560 // Check if the file should be hidden
\r
561 //if(Name[0] == '.') retNode.Flags |= VFS_FFLAG_HIDDEN;
\r
564 retNode.ATime = now();
\r
565 retNode.MTime = inode.i_mtime * 1000;
\r
566 retNode.CTime = inode.i_ctime * 1000;
\r
568 // Save in node cache and return saved node
\r
569 return Inode_CacheNode(Disk->CacheID, &retNode);
\r
573 * \fn int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint InodeId, tExt2_Inode *Inode)
\r
574 * \brief Read an inode into memory
\r
576 int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint InodeId, tExt2_Inode *Inode)
\r
580 //LogF("Ext2_int_ReadInode: (Disk=%p, InodeId=%i, Inode=%p)", Disk, InodeId, Inode);
\r
581 //ENTER("pDisk iInodeId pInode", Disk, InodeId, Inode);
\r
583 if(InodeId == 0) return 0;
\r
585 InodeId --; // Inodes are numbered starting at 1
\r
587 group = InodeId / Disk->SuperBlock.s_inodes_per_group;
\r
588 subId = InodeId % Disk->SuperBlock.s_inodes_per_group;
\r
590 //LOG("group=%i, subId = %i", group, subId);
\r
593 VFS_ReadAt(Disk->FD,
\r
594 Disk->Groups[group].bg_inode_table * Disk->BlockSize + sizeof(tExt2_Inode)*subId,
\r
595 sizeof(tExt2_Inode),
\r
601 * \fn Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum)
\r
602 * \brief Get the address of a block from an inode's list
\r
603 * \param Disk Disk information structure
\r
604 * \param Blocks Pointer to an inode's block list
\r
605 * \param BlockNum Block index in list
\r
607 Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum)
\r
612 return (Uint64)Blocks[BlockNum] * Disk->BlockSize;
\r
614 // Single Indirect Blocks
\r
615 iBlocks = malloc( Disk->BlockSize );
\r
616 VFS_ReadAt(Disk->FD, (Uint64)Blocks[12]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
619 if(BlockNum < 256) {
\r
620 BlockNum = iBlocks[BlockNum];
\r
622 return (Uint64)BlockNum * Disk->BlockSize;
\r
625 // Double Indirect Blocks
\r
626 if(BlockNum < 256*256)
\r
628 VFS_ReadAt(Disk->FD, (Uint64)Blocks[13]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
629 VFS_ReadAt(Disk->FD, (Uint64)iBlocks[BlockNum/256]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
630 BlockNum = iBlocks[BlockNum%256];
\r
632 return (Uint64)BlockNum * Disk->BlockSize;
\r
634 // Triple Indirect Blocks
\r
635 VFS_ReadAt(Disk->FD, (Uint64)Blocks[14]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
636 VFS_ReadAt(Disk->FD, (Uint64)iBlocks[BlockNum/(256*256)]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
637 VFS_ReadAt(Disk->FD, (Uint64)iBlocks[(BlockNum/256)%256]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
638 BlockNum = iBlocks[BlockNum%256];
\r
640 return (Uint64)BlockNum * Disk->BlockSize;
\r
644 * \fn Uint32 Ext2_int_AllocateInode(tExt2_Disk *Disk, Uint32 Parent)
\r
645 * \brief Allocate an inode (from the current group preferably)
\r
646 * \param Disk EXT2 Disk Information Structure
\r
647 * \param Parent Inode ID of the parent (used to locate the child nearby)
\r
649 Uint32 Ext2_int_AllocateInode(tExt2_Disk *Disk, Uint32 Parent)
\r
651 // Uint block = (Parent - 1) / Disk->SuperBlock.s_inodes_per_group;
\r
656 * \fn Uint32 Ext2_int_AllocateBlock(tExt2_Disk *Disk, Uint32 PrevBlock)
\r
657 * \brief Allocate a block from the best possible location
\r
658 * \param Disk EXT2 Disk Information Structure
\r
659 * \param PrevBlock Previous block ID in the file
\r
661 Uint32 Ext2_int_AllocateBlock(tExt2_Disk *Disk, Uint32 PrevBlock)
\r
663 int bpg = Disk->SuperBlock.s_blocks_per_group;
\r
664 Uint blockgroup = PrevBlock / bpg;
\r
665 Uint bitmap[Disk->BlockSize/sizeof(Uint)];
\r
666 Uint bitsperblock = 8*Disk->BlockSize;
\r
670 // Are there any free blocks?
\r
671 if(Disk->SuperBlock.s_free_blocks_count == 0) return 0;
\r
673 if(Disk->Groups[blockgroup].bg_free_blocks_count > 0)
\r
675 // Search block group's bitmap
\r
676 for(i = 0; i < bpg; i++)
\r
678 // Get the block in the bitmap block
\r
679 j = i & (bitsperblock-1);
\r
681 // Read in if needed
\r
685 (Uint64)Disk->Groups[blockgroup].bg_block_bitmap + i / bitsperblock,
\r
692 if( bitmap[j/32] == -1 ) {
\r
693 j = (j + 31) & ~31;
\r
698 if( bitmap[j/32] & (1 << (j%32)) )
\r
701 // Ooh! We found one
\r
705 Warning("[EXT2 ] Inconsistency detected, Group Free Block count is non-zero when no free blocks exist");
\r
706 goto checkAll; // Search the entire filesystem for a free block
\r
707 // Goto needed for neatness
\r
711 bitmap[j/32] |= (1 << (j%32));
\r
714 (Uint64)Disk->Groups[blockgroup].bg_block_bitmap + i / bitsperblock,
\r
719 Disk->Groups[blockgroup].bg_free_blocks_count --;
\r
724 Warning("[EXT2 ] TODO - Implement using blocks outside the current block group");
\r
728 // Reduce global count
\r
729 Disk->SuperBlock.s_free_blocks_count --;
\r
730 #if EXT2_UPDATE_WRITEBACK
\r
731 Ext2_int_UpdateSuperblock(Disk);
\r
738 * \fn void Ext2_int_UpdateSuperblock(tExt2_Disk *Disk)
\r
740 void Ext2_int_UpdateSuperblock(tExt2_Disk *Disk)
\r
742 VFS_WriteAt(Disk->FD, 1024, 1024, &Disk->SuperBlock);
\r