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 // === STRUCTURES ===
\r
22 tExt2_SuperBlock SuperBlock;
\r
26 tExt2_Group Groups[];
\r
29 // === PROTOTYPES ===
\r
30 int Ext2_Install(char **Arguments);
\r
31 // Interface Functions
\r
32 tVFS_Node *Ext2_InitDevice(char *Device, char **Options);
\r
33 void Ext2_Unmount(tVFS_Node *Node);
\r
34 Uint64 Ext2_Read(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);
\r
35 Uint64 Ext2_Write(tVFS_Node *node, Uint64 offset, Uint64 length, void *buffer);
\r
36 void Ext2_CloseFile(tVFS_Node *Node);
\r
37 char *Ext2_ReadDir(tVFS_Node *Node, int Pos);
\r
38 tVFS_Node *Ext2_FindDir(tVFS_Node *Node, char *FileName);
\r
39 int Ext2_MkNod(tVFS_Node *Node, char *Name, Uint Flags);
\r
41 int Ext2_int_GetInode(tVFS_Node *Node, tExt2_Inode *Inode);
\r
42 tVFS_Node *Ext2_int_CreateNode(tExt2_Disk *Disk, Uint InodeId, char *Name);
\r
43 int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint InodeId, tExt2_Inode *Inode);
\r
44 Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum);
\r
46 // === SEMI-GLOBALS ===
\r
47 MODULE_DEFINE(0, 0x5B /*v0.90*/, EXT2, Ext2_Install, NULL);
\r
48 tExt2_Disk gExt2_disks[6];
\r
49 int giExt2_count = 0;
\r
50 tVFS_Driver gExt2_FSInfo = {
\r
51 "ext2", 0, Ext2_InitDevice, Ext2_Unmount, NULL
\r
57 * \fn int Ext2_Install(char **Arguments)
\r
58 * \brief Install the Ext2 Filesystem Driver
\r
60 int Ext2_Install(char **Arguments)
\r
62 VFS_AddDriver( &gExt2_FSInfo );
\r
67 \fn tVFS_Node *Ext2_initDevice(char *Device, char **Options)
\r
68 \brief Initializes a device to be read by by the driver
\r
69 \param Device String - Device to read from
\r
70 \param Options NULL Terminated array of option strings
\r
73 tVFS_Node *Ext2_InitDevice(char *Device, char **Options)
\r
78 tExt2_SuperBlock sb;
\r
81 ENTER("sDevice pOptions", Device, Options);
\r
84 fd = VFS_Open(Device, VFS_OPENFLAG_READ|VFS_OPENFLAG_WRITE); //Open Device
\r
86 Warning("[EXT2 ] Unable to open '%s'\n", Device);
\r
91 // Read Superblock at offset 1024
\r
92 VFS_ReadAt(fd, 1024, 1024, &sb); // Read Superblock
\r
94 // Sanity Check Magic value
\r
95 if(sb.s_magic != 0xEF53) {
\r
96 Warning("[EXT2 ] Volume '%s' is not an EXT2 volume\n", Device);
\r
103 groupCount = DivUp(sb.s_blocks_count, sb.s_blocks_per_group);
\r
104 LOG("groupCount = %i", groupCount);
\r
106 // Allocate Disk Information
\r
107 disk = malloc(sizeof(tExt2_Disk) + sizeof(tExt2_Group)*groupCount);
\r
109 Warning("[EXT2 ] Unable to allocate disk structure\n");
\r
115 memcpy(&disk->SuperBlock, &sb, 1024);
\r
116 disk->GroupCount = groupCount;
\r
118 // Get an inode cache handle
\r
119 disk->CacheID = Inode_GetHandle();
\r
122 LOG("s_log_block_size = 0x%x", sb.s_log_block_size);
\r
123 disk->BlockSize = 1024 << sb.s_log_block_size;
\r
125 // Read Group Information
\r
128 sb.s_first_data_block * disk->BlockSize + 1024,
\r
129 sizeof(tExt2_Group)*groupCount,
\r
134 LOG("Block Group 0");
\r
135 LOG(".bg_block_bitmap = 0x%x", disk->Groups[0].bg_block_bitmap);
\r
136 LOG(".bg_inode_bitmap = 0x%x", disk->Groups[0].bg_inode_bitmap);
\r
137 LOG(".bg_inode_table = 0x%x", disk->Groups[0].bg_inode_table);
\r
138 LOG("Block Group 1");
\r
139 LOG(".bg_block_bitmap = 0x%x", disk->Groups[1].bg_block_bitmap);
\r
140 LOG(".bg_inode_bitmap = 0x%x", disk->Groups[1].bg_inode_bitmap);
\r
141 LOG(".bg_inode_table = 0x%x", disk->Groups[1].bg_inode_table);
\r
145 Ext2_int_ReadInode(disk, 2, &inode);
\r
147 // Create Root Node
\r
148 memset(&disk->RootNode, 0, sizeof(tVFS_Node));
\r
149 disk->RootNode.Inode = 2; // Root inode ID
\r
150 disk->RootNode.ImplPtr = disk; // Save disk pointer
\r
151 disk->RootNode.Size = -1; // Fill in later (on readdir)
\r
152 disk->RootNode.Flags = VFS_FFLAG_DIRECTORY;
\r
154 disk->RootNode.ReadDir = Ext2_ReadDir;
\r
155 disk->RootNode.FindDir = Ext2_FindDir;
\r
156 //disk->RootNode.Relink = Ext2_Relink;
\r
158 // Complete root node
\r
159 disk->RootNode.UID = inode.i_uid;
\r
160 disk->RootNode.GID = inode.i_gid;
\r
161 disk->RootNode.NumACLs = 1;
\r
162 disk->RootNode.ACLs = &gVFS_ACL_EveryoneRW;
\r
165 LOG("inode.i_size = 0x%x", inode.i_size);
\r
166 LOG("inode.i_block[0] = 0x%x", inode.i_block[0]);
\r
169 LEAVE('p', &disk->RootNode);
\r
170 return &disk->RootNode;
\r
174 * \fn void Ext2_Unmount(tVFS_Node *Node)
\r
175 * \brief Close a mounted device
\r
177 void Ext2_Unmount(tVFS_Node *Node)
\r
179 tExt2_Disk *disk = Node->ImplPtr;
\r
181 VFS_Close( disk->FD );
\r
182 Inode_ClearCache( disk->CacheID );
\r
183 memset(disk, 0, sizeof(tExt2_Disk)+disk->GroupCount*sizeof(tExt2_Group));
\r
188 * \fn Uint64 Ext2_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
\r
189 * \brief Read from a file
\r
191 Uint64 Ext2_Read(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
\r
193 tExt2_Disk *disk = Node->ImplPtr;
\r
199 ENTER("pNode XOffset XLength pBuffer", Node, Offset, Length, Buffer);
\r
202 Ext2_int_GetInode(Node, &inode);
\r
205 if(Offset >= inode.i_size) {
\r
209 if(Offset + Length > inode.i_size)
\r
210 Length = inode.i_size - Offset;
\r
212 block = Offset / disk->BlockSize;
\r
213 Offset = Offset / disk->BlockSize;
\r
214 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
216 Warning("[EXT2 ] NULL Block Detected in INode 0x%llx\n", Node->Inode);
\r
222 if(Length <= disk->BlockSize - Offset)
\r
224 VFS_ReadAt( disk->FD, base+Offset, Length, Buffer);
\r
225 LEAVE('X', Length);
\r
229 // Read first block
\r
231 VFS_ReadAt( disk->FD, base + Offset, disk->BlockSize - Offset, Buffer);
\r
232 remLen -= disk->BlockSize - Offset;
\r
233 Buffer += disk->BlockSize - Offset;
\r
236 // Read middle blocks
\r
237 while(remLen > disk->BlockSize)
\r
239 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
241 Warning("[EXT2 ] NULL Block Detected in INode 0x%llx\n", Node->Inode);
\r
245 VFS_ReadAt( disk->FD, base, disk->BlockSize, Buffer);
\r
246 Buffer += disk->BlockSize;
\r
247 remLen -= disk->BlockSize;
\r
252 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
253 VFS_ReadAt( disk->FD, base, remLen, Buffer);
\r
255 LEAVE('X', Length);
\r
260 * \fn Uint64 Ext2_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
\r
261 * \brief Write to a file
\r
263 Uint64 Ext2_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
\r
265 tExt2_Disk *disk = Node->ImplPtr;
\r
271 int bNewBlocks = 0;
\r
273 Debug_HexDump("Ext2_Write", Buffer, Length);
\r
275 Ext2_int_GetInode(Node, &inode);
\r
277 // Get the ammount of space already allocated
\r
278 // - Round size up to block size
\r
279 // - block size is a power of two, so this will work
\r
280 allocSize = (inode.i_size + disk->BlockSize) & ~(disk->BlockSize-1);
\r
282 // Are we writing to inside the allocated space?
\r
283 if( Offset < allocSize )
\r
285 // Will we go out of it?
\r
286 if(Offset + Length > allocSize) {
\r
288 retLen = allocSize - Offset;
\r
292 // Within the allocated space
\r
293 block = Offset / disk->BlockSize;
\r
294 Offset %= disk->BlockSize;
\r
295 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
297 // Write only block (if only one)
\r
298 if(Offset + retLen <= disk->BlockSize) {
\r
299 VFS_WriteAt(disk->FD, base+Offset, retLen, Buffer);
\r
300 if(!bNewBlocks) return Length;
\r
301 goto addBlocks; // Ugh! A goto, but it seems unavoidable
\r
304 // Write First Block
\r
305 VFS_WriteAt(disk->FD, base+Offset, disk->BlockSize-Offset, Buffer);
\r
306 Buffer += disk->BlockSize-Offset;
\r
307 retLen -= disk->BlockSize-Offset;
\r
310 // Write middle blocks
\r
311 while(retLen > disk->BlockSize)
\r
313 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
314 VFS_WriteAt(disk->FD, base, disk->BlockSize, Buffer);
\r
315 Buffer += disk->BlockSize;
\r
316 retLen -= disk->BlockSize;
\r
320 // Write last block
\r
321 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
322 VFS_WriteAt(disk->FD, base, retLen, Buffer);
\r
323 if(!bNewBlocks) return Length; // Writing in only allocated space
\r
327 ///\todo Implement block allocation
\r
328 Warning("[EXT2] File extending is not yet supported");
\r
334 * \fn void Ext2_CloseFile(vfs_node *Node)
\r
335 * \brief Close a file (Remove it from the cache)
\r
337 void Ext2_CloseFile(tVFS_Node *Node)
\r
339 tExt2_Disk *disk = Node->ImplPtr;
\r
340 Inode_UncacheNode(disk->CacheID, Node->Inode);
\r
345 \fn char *Ext2_ReadDir(tVFS_Node *Node, int Pos)
\r
346 \brief Reads a directory entry
\r
348 char *Ext2_ReadDir(tVFS_Node *Node, int Pos)
\r
351 char namebuf[EXT2_NAME_LEN+1];
\r
352 tExt2_DirEnt dirent;
\r
353 Uint64 Base; // Block's Base Address
\r
354 int block = 0, ofs = 0;
\r
356 tExt2_Disk *disk = Node->ImplPtr;
\r
359 ENTER("pNode iPos", Node, Pos);
\r
361 // Read directory's inode
\r
362 Ext2_int_GetInode(Node, &inode);
\r
363 size = inode.i_size;
\r
365 LOG("inode.i_block[0] = 0x%x\n", inode.i_block[0]);
\r
369 // - Do this ourselves as it is a simple operation
\r
370 Base = inode.i_block[0] * disk->BlockSize;
\r
371 while(Pos -- && size > 0)
\r
373 VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent);
\r
374 ofs += dirent.rec_len;
\r
375 size -= dirent.rec_len;
\r
378 if(ofs >= disk->BlockSize) {
\r
380 if( ofs > disk->BlockSize ) {
\r
381 Warning("[EXT2] Directory Entry %i of inode %i extends over a block boundary, ignoring\n",
\r
382 entNum-1, Node->Inode);
\r
385 Base = Ext2_int_GetBlockAddr( disk, inode.i_block, block );
\r
389 if(size <= 0) return NULL;
\r
392 VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent );
\r
393 //LOG("dirent.inode = %i\n", dirent.inode);
\r
394 //LOG("dirent.rec_len = %i\n", dirent.rec_len);
\r
395 //LOG("dirent.name_len = %i\n", dirent.name_len);
\r
396 VFS_ReadAt( disk->FD, Base+ofs+sizeof(tExt2_DirEnt), dirent.name_len, namebuf );
\r
397 namebuf[ dirent.name_len ] = '\0'; // Cap off string
\r
400 // Ignore . and .. (these are done in the VFS)
\r
401 if( (namebuf[0] == '.' && namebuf[1] == '\0')
\r
402 || (namebuf[0] == '.' && namebuf[1] == '.' && namebuf[2]=='\0')) {
\r
403 LEAVE('p', VFS_SKIP);
\r
404 return VFS_SKIP; // Skip
\r
407 LEAVE('s', namebuf);
\r
409 return strdup(namebuf);
\r
413 \fn tVFS_Node *Ext2_FindDir(tVFS_Node *node, char *filename)
\r
414 \brief Gets information about a file
\r
415 \param node vfs node - Parent Node
\r
416 \param filename String - Name of file
\r
417 \return VFS Node of file
\r
419 tVFS_Node *Ext2_FindDir(tVFS_Node *Node, char *Filename)
\r
421 tExt2_Disk *disk = Node->ImplPtr;
\r
423 char namebuf[EXT2_NAME_LEN+1];
\r
424 tExt2_DirEnt dirent;
\r
425 Uint64 Base; // Block's Base Address
\r
426 int block = 0, ofs = 0;
\r
430 // Read directory's inode
\r
431 Ext2_int_GetInode(Node, &inode);
\r
432 size = inode.i_size;
\r
435 // - Do this ourselves as it is a simple operation
\r
436 Base = inode.i_block[0] * disk->BlockSize;
\r
440 VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent);
\r
441 VFS_ReadAt( disk->FD, Base+ofs+sizeof(tExt2_DirEnt), dirent.name_len, namebuf );
\r
442 namebuf[ dirent.name_len ] = '\0'; // Cap off string
\r
443 // If it matches, create a node and return it
\r
444 if(strcmp(namebuf, Filename) == 0)
\r
445 return Ext2_int_CreateNode( disk, dirent.inode, namebuf );
\r
446 // Increment pointers
\r
447 ofs += dirent.rec_len;
\r
448 size -= dirent.rec_len;
\r
451 // Check for end of block
\r
452 if(ofs >= disk->BlockSize) {
\r
454 if( ofs > disk->BlockSize ) {
\r
455 Warning("[EXT2 ] Directory Entry %i of inode %i extends over a block boundary, ignoring\n",
\r
456 entNum-1, Node->Inode);
\r
459 Base = Ext2_int_GetBlockAddr( disk, inode.i_block, block );
\r
467 * \fn int Ext2_MkNod(tVFS_Node *Parent, char *Name, Uint Flags)
\r
468 * \brief Create a new node
\r
470 int Ext2_MkNod(tVFS_Node *Parent, char *Name, Uint Flags)
\r
475 //==================================
\r
476 //= INTERNAL FUNCTIONS =
\r
477 //==================================
\r
482 \fn int Ext2_int_GetInode(vfs_node *Node, tExt2_Inode *Inode)
\r
483 \brief Gets the inode descriptor for a node
\r
484 \param node node to get the Inode of
\r
485 \param inode Destination
\r
487 int Ext2_int_GetInode(tVFS_Node *Node, tExt2_Inode *Inode)
\r
489 return Ext2_int_ReadInode(Node->ImplPtr, Node->Inode, Inode);
\r
493 * \fn vfs_node *Ext2_int_CreateNode(tExt2_Disk *Disk, Uint InodeID, char *Name)
\r
494 * \brief Create a new VFS Node
\r
496 tVFS_Node *Ext2_int_CreateNode(tExt2_Disk *Disk, Uint InodeID, char *Name)
\r
500 tVFS_Node *tmpNode;
\r
502 if( !Ext2_int_ReadInode(Disk, InodeID, &inode) )
\r
505 if( (tmpNode = Inode_GetCache(Disk->CacheID, InodeID)) )
\r
510 retNode.Inode = InodeID;
\r
511 retNode.ImplPtr = Disk;
\r
514 retNode.Size = inode.i_size;
\r
516 // Set Access Permissions
\r
517 retNode.UID = inode.i_uid;
\r
518 retNode.GID = inode.i_gid;
\r
519 retNode.NumACLs = 3;
\r
520 retNode.ACLs = VFS_UnixToAcessACL(inode.i_mode & 0777, inode.i_uid, inode.i_gid);
\r
522 // Set Function Pointers
\r
523 retNode.Read = Ext2_Read;
\r
524 retNode.Write = Ext2_Write;
\r
525 retNode.Close = Ext2_CloseFile;
\r
527 switch(inode.i_mode & EXT2_S_IFMT)
\r
531 retNode.Flags = VFS_FFLAG_SYMLINK;
\r
539 retNode.ReadDir = Ext2_ReadDir;
\r
540 retNode.FindDir = Ext2_FindDir;
\r
541 retNode.MkNod = Ext2_MkNod;
\r
542 //retNode.Relink = Ext2_Relink;
\r
543 retNode.Flags = VFS_FFLAG_DIRECTORY;
\r
545 // Unknown, Write protect and hide it to be safe
\r
547 retNode.Flags = VFS_FFLAG_READONLY;//|VFS_FFLAG_HIDDEN;
\r
551 // Check if the file should be hidden
\r
552 //if(Name[0] == '.') retNode.Flags |= VFS_FFLAG_HIDDEN;
\r
555 retNode.ATime = now();
\r
556 retNode.MTime = inode.i_mtime * 1000;
\r
557 retNode.CTime = inode.i_ctime * 1000;
\r
559 // Save in node cache and return saved node
\r
560 return Inode_CacheNode(Disk->CacheID, &retNode);
\r
564 * \fn int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint InodeId, tExt2_Inode *Inode)
\r
565 * \brief Read an inode into memory
\r
567 int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint InodeId, tExt2_Inode *Inode)
\r
571 //LogF("Ext2_int_ReadInode: (Disk=%p, InodeId=%i, Inode=%p)\n", Disk, InodeId, Inode);
\r
573 if(InodeId == 0) return 0;
\r
575 InodeId --; // Inodes are numbered starting at 1
\r
577 group = InodeId / Disk->SuperBlock.s_inodes_per_group;
\r
578 subId = InodeId % Disk->SuperBlock.s_inodes_per_group;
\r
580 //LogF(" Ext2_int_ReadInode: group=%i, subId = %i\n", group, subId);
\r
583 VFS_ReadAt(Disk->FD,
\r
584 Disk->Groups[group].bg_inode_table * Disk->BlockSize + sizeof(tExt2_Inode)*subId,
\r
585 sizeof(tExt2_Inode),
\r
591 * \fn Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum)
\r
592 * \brief Get the address of a block from an inode's list
\r
593 * \param Disk Disk information structure
\r
594 * \param Blocks Pointer to an inode's block list
\r
595 * \param BlockNum Block index in list
\r
597 Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum)
\r
602 return (Uint64)Blocks[BlockNum] * Disk->BlockSize;
\r
604 // Single Indirect Blocks
\r
605 iBlocks = malloc( Disk->BlockSize );
\r
606 VFS_ReadAt(Disk->FD, (Uint64)Blocks[12]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
609 if(BlockNum < 256) {
\r
610 BlockNum = iBlocks[BlockNum];
\r
612 return (Uint64)BlockNum * Disk->BlockSize;
\r
615 // Double Indirect Blocks
\r
616 if(BlockNum < 256*256)
\r
618 VFS_ReadAt(Disk->FD, (Uint64)Blocks[13]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
619 VFS_ReadAt(Disk->FD, (Uint64)iBlocks[BlockNum/256]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
620 BlockNum = iBlocks[BlockNum%256];
\r
622 return (Uint64)BlockNum * Disk->BlockSize;
\r
624 // Triple Indirect Blocks
\r
625 VFS_ReadAt(Disk->FD, (Uint64)Blocks[14]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
626 VFS_ReadAt(Disk->FD, (Uint64)iBlocks[BlockNum/(256*256)]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
627 VFS_ReadAt(Disk->FD, (Uint64)iBlocks[(BlockNum/256)%256]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
628 BlockNum = iBlocks[BlockNum%256];
\r
630 return (Uint64)BlockNum * Disk->BlockSize;
\r