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
204 block = Offset / disk->BlockSize;
\r
205 Offset = Offset / disk->BlockSize;
\r
206 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
209 if(Length <= disk->BlockSize - Offset)
\r
211 VFS_ReadAt( disk->FD, base+Offset, Length, Buffer);
\r
212 LEAVE('X', Length);
\r
216 // Read first block
\r
218 VFS_ReadAt( disk->FD, base + Offset, disk->BlockSize - Offset, Buffer);
\r
219 remLen -= disk->BlockSize - Offset;
\r
220 Buffer += disk->BlockSize - Offset;
\r
223 // Read middle blocks
\r
224 while(remLen > disk->BlockSize)
\r
226 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
227 VFS_ReadAt( disk->FD, base, disk->BlockSize, Buffer);
\r
228 Buffer += disk->BlockSize;
\r
229 remLen -= disk->BlockSize;
\r
234 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
235 VFS_ReadAt( disk->FD, base, remLen, Buffer);
\r
237 LEAVE('X', Length);
\r
242 * \fn Uint64 Ext2_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
\r
243 * \brief Write to a file
\r
245 Uint64 Ext2_Write(tVFS_Node *Node, Uint64 Offset, Uint64 Length, void *Buffer)
\r
247 tExt2_Disk *disk = Node->ImplPtr;
\r
253 int bNewBlocks = 0;
\r
255 Ext2_int_GetInode(Node, &inode);
\r
257 // Round size up to block size
\r
258 // block size is a power of two, so this will work
\r
259 allocSize = (inode.i_size + disk->BlockSize) & ~(disk->BlockSize-1);
\r
260 if( Offset < allocSize )
\r
262 if(Offset + Length > allocSize) {
\r
264 retLen = allocSize - Offset;
\r
267 // Within the allocated space
\r
268 block = Offset / disk->BlockSize;
\r
269 Offset %= disk->BlockSize;
\r
270 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
272 // Write only block (if only one)
\r
273 if(Offset + retLen <= disk->BlockSize) {
\r
274 VFS_WriteAt(disk->FD, base+Offset, retLen, Buffer);
\r
275 if(bNewBlocks) return Length;
\r
276 goto addBlocks; // Ugh! A goto, but it seems unavoidable
\r
279 // Write First Block
\r
280 VFS_WriteAt(disk->FD, base+Offset, disk->BlockSize-Offset, Buffer);
\r
281 Buffer += disk->BlockSize-Offset;
\r
282 retLen -= disk->BlockSize-Offset;
\r
285 // Write middle blocks
\r
286 while(retLen > disk->BlockSize)
\r
288 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
289 VFS_WriteAt(disk->FD, base, disk->BlockSize, Buffer);
\r
290 Buffer += disk->BlockSize;
\r
291 retLen -= disk->BlockSize;
\r
295 // Write last block
\r
296 base = Ext2_int_GetBlockAddr(disk, inode.i_block, block);
\r
297 VFS_WriteAt(disk->FD, base, retLen, Buffer);
\r
298 if(bNewBlocks) return Length; // Writing in only allocated space
\r
302 ///\todo Implement block allocation
\r
303 Warning("[EXT2] File extending is not yet supported");
\r
309 * \fn void Ext2_CloseFile(vfs_node *Node)
\r
310 * \brief Close a file (Remove it from the cache)
\r
312 void Ext2_CloseFile(tVFS_Node *Node)
\r
314 tExt2_Disk *disk = Node->ImplPtr;
\r
315 Inode_UncacheNode(disk->CacheID, Node->Inode);
\r
320 \fn char *Ext2_ReadDir(tVFS_Node *Node, int Pos)
\r
321 \brief Reads a directory entry
\r
323 char *Ext2_ReadDir(tVFS_Node *Node, int Pos)
\r
326 char namebuf[EXT2_NAME_LEN+1];
\r
327 tExt2_DirEnt dirent;
\r
328 Uint64 Base; // Block's Base Address
\r
329 int block = 0, ofs = 0;
\r
331 tExt2_Disk *disk = Node->ImplPtr;
\r
334 ENTER("pNode iPos", Node, Pos);
\r
336 // Read directory's inode
\r
337 Ext2_int_GetInode(Node, &inode);
\r
338 size = inode.i_size;
\r
340 LOG("inode.i_block[0] = 0x%x\n", inode.i_block[0]);
\r
344 // - Do this ourselves as it is a simple operation
\r
345 Base = inode.i_block[0] * disk->BlockSize;
\r
346 while(Pos -- && size > 0)
\r
348 VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent);
\r
349 ofs += dirent.rec_len;
\r
350 size -= dirent.rec_len;
\r
353 if(ofs >= disk->BlockSize) {
\r
355 if( ofs > disk->BlockSize ) {
\r
356 Warning("[EXT2] Directory Entry %i of inode %i extends over a block boundary, ignoring\n",
\r
357 entNum-1, Node->Inode);
\r
360 Base = Ext2_int_GetBlockAddr( disk, inode.i_block, block );
\r
364 if(size <= 0) return NULL;
\r
367 VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent );
\r
368 //LOG("dirent.inode = %i\n", dirent.inode);
\r
369 //LOG("dirent.rec_len = %i\n", dirent.rec_len);
\r
370 //LOG("dirent.name_len = %i\n", dirent.name_len);
\r
371 VFS_ReadAt( disk->FD, Base+ofs+sizeof(tExt2_DirEnt), dirent.name_len, namebuf );
\r
372 namebuf[ dirent.name_len ] = '\0'; // Cap off string
\r
375 // Ignore . and .. (these are done in the VFS)
\r
376 if( (namebuf[0] == '.' && namebuf[1] == '\0')
\r
377 || (namebuf[0] == '.' && namebuf[1] == '.' && namebuf[2]=='\0')) {
\r
378 LEAVE('p', VFS_SKIP);
\r
379 return VFS_SKIP; // Skip
\r
382 LEAVE('s', namebuf);
\r
384 return strdup(namebuf);
\r
388 \fn tVFS_Node *Ext2_FindDir(tVFS_Node *node, char *filename)
\r
389 \brief Gets information about a file
\r
390 \param node vfs node - Parent Node
\r
391 \param filename String - Name of file
\r
392 \return VFS Node of file
\r
394 tVFS_Node *Ext2_FindDir(tVFS_Node *Node, char *Filename)
\r
396 tExt2_Disk *disk = Node->ImplPtr;
\r
398 char namebuf[EXT2_NAME_LEN+1];
\r
399 tExt2_DirEnt dirent;
\r
400 Uint64 Base; // Block's Base Address
\r
401 int block = 0, ofs = 0;
\r
405 // Read directory's inode
\r
406 Ext2_int_GetInode(Node, &inode);
\r
407 size = inode.i_size;
\r
410 // - Do this ourselves as it is a simple operation
\r
411 Base = inode.i_block[0] * disk->BlockSize;
\r
415 VFS_ReadAt( disk->FD, Base+ofs, sizeof(tExt2_DirEnt), &dirent);
\r
416 VFS_ReadAt( disk->FD, Base+ofs+sizeof(tExt2_DirEnt), dirent.name_len, namebuf );
\r
417 namebuf[ dirent.name_len ] = '\0'; // Cap off string
\r
418 // If it matches, create a node and return it
\r
419 if(strcmp(namebuf, Filename) == 0)
\r
420 return Ext2_int_CreateNode( disk, dirent.inode, namebuf );
\r
421 // Increment pointers
\r
422 ofs += dirent.rec_len;
\r
423 size -= dirent.rec_len;
\r
426 // Check for end of block
\r
427 if(ofs >= disk->BlockSize) {
\r
429 if( ofs > disk->BlockSize ) {
\r
430 Warning("[EXT2 ] Directory Entry %i of inode %i extends over a block boundary, ignoring\n",
\r
431 entNum-1, Node->Inode);
\r
434 Base = Ext2_int_GetBlockAddr( disk, inode.i_block, block );
\r
442 * \fn int Ext2_MkNod(tVFS_Node *Parent, char *Name, Uint Flags)
\r
443 * \brief Create a new node
\r
445 int Ext2_MkNod(tVFS_Node *Parent, char *Name, Uint Flags)
\r
450 //==================================
\r
451 //= INTERNAL FUNCTIONS =
\r
452 //==================================
\r
457 \fn int Ext2_int_GetInode(vfs_node *Node, tExt2_Inode *Inode)
\r
458 \brief Gets the inode descriptor for a node
\r
459 \param node node to get the Inode of
\r
460 \param inode Destination
\r
462 int Ext2_int_GetInode(tVFS_Node *Node, tExt2_Inode *Inode)
\r
464 return Ext2_int_ReadInode(Node->ImplPtr, Node->Inode, Inode);
\r
468 * \fn vfs_node *Ext2_int_CreateNode(tExt2_Disk *Disk, Uint InodeID, char *Name)
\r
469 * \brief Create a new VFS Node
\r
471 tVFS_Node *Ext2_int_CreateNode(tExt2_Disk *Disk, Uint InodeID, char *Name)
\r
475 tVFS_Node *tmpNode;
\r
477 if( !Ext2_int_ReadInode(Disk, InodeID, &inode) )
\r
480 if( (tmpNode = Inode_GetCache(Disk->CacheID, InodeID)) )
\r
485 retNode.Inode = InodeID;
\r
486 retNode.ImplPtr = Disk;
\r
489 retNode.Size = inode.i_size;
\r
491 // Set Access Permissions
\r
492 retNode.UID = inode.i_uid;
\r
493 retNode.GID = inode.i_gid;
\r
494 retNode.NumACLs = 3;
\r
495 retNode.ACLs = VFS_UnixToAcessACL(inode.i_mode & 0777, inode.i_uid, inode.i_gid);
\r
497 // Set Function Pointers
\r
498 retNode.Read = Ext2_Read;
\r
499 retNode.Write = Ext2_Write;
\r
500 retNode.Close = Ext2_CloseFile;
\r
502 switch(inode.i_mode & EXT2_S_IFMT)
\r
506 retNode.Flags = VFS_FFLAG_SYMLINK;
\r
514 retNode.ReadDir = Ext2_ReadDir;
\r
515 retNode.FindDir = Ext2_FindDir;
\r
516 retNode.MkNod = Ext2_MkNod;
\r
517 //retNode.Relink = Ext2_Relink;
\r
518 retNode.Flags = VFS_FFLAG_DIRECTORY;
\r
520 // Unknown, Write protect and hide it to be safe
\r
522 retNode.Flags = VFS_FFLAG_READONLY;//|VFS_FFLAG_HIDDEN;
\r
526 // Check if the file should be hidden
\r
527 //if(Name[0] == '.') retNode.Flags |= VFS_FFLAG_HIDDEN;
\r
530 retNode.ATime = now();
\r
531 retNode.MTime = inode.i_mtime * 1000;
\r
532 retNode.CTime = inode.i_ctime * 1000;
\r
534 // Save in node cache and return saved node
\r
535 return Inode_CacheNode(Disk->CacheID, &retNode);
\r
539 * \fn int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint InodeId, tExt2_Inode *Inode)
\r
540 * \brief Read an inode into memory
\r
542 int Ext2_int_ReadInode(tExt2_Disk *Disk, Uint InodeId, tExt2_Inode *Inode)
\r
546 //LogF("Ext2_int_ReadInode: (Disk=%p, InodeId=%i, Inode=%p)\n", Disk, InodeId, Inode);
\r
548 if(InodeId == 0) return 0;
\r
550 InodeId --; // Inodes are numbered starting at 1
\r
552 group = InodeId / Disk->SuperBlock.s_inodes_per_group;
\r
553 subId = InodeId % Disk->SuperBlock.s_inodes_per_group;
\r
555 //LogF(" Ext2_int_ReadInode: group=%i, subId = %i\n", group, subId);
\r
558 VFS_ReadAt(Disk->FD,
\r
559 Disk->Groups[group].bg_inode_table * Disk->BlockSize + sizeof(tExt2_Inode)*subId,
\r
560 sizeof(tExt2_Inode),
\r
566 * \fn Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum)
\r
567 * \brief Get the address of a block from an inode's list
\r
568 * \param Disk Disk information structure
\r
569 * \param Blocks Pointer to an inode's block list
\r
570 * \param BlockNum Block index in list
\r
572 Uint64 Ext2_int_GetBlockAddr(tExt2_Disk *Disk, Uint32 *Blocks, int BlockNum)
\r
577 return (Uint64)Blocks[BlockNum] * Disk->BlockSize;
\r
579 // Single Indirect Blocks
\r
580 iBlocks = malloc( Disk->BlockSize );
\r
581 VFS_ReadAt(Disk->FD, (Uint64)Blocks[12]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
584 if(BlockNum < 256) {
\r
585 BlockNum = iBlocks[BlockNum];
\r
587 return (Uint64)BlockNum * Disk->BlockSize;
\r
590 // Double Indirect Blocks
\r
591 if(BlockNum < 256*256)
\r
593 VFS_ReadAt(Disk->FD, (Uint64)Blocks[13]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
594 VFS_ReadAt(Disk->FD, (Uint64)iBlocks[BlockNum/256]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
595 BlockNum = iBlocks[BlockNum%256];
\r
597 return (Uint64)BlockNum * Disk->BlockSize;
\r
599 // Triple Indirect Blocks
\r
600 VFS_ReadAt(Disk->FD, (Uint64)Blocks[14]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
601 VFS_ReadAt(Disk->FD, (Uint64)iBlocks[BlockNum/(256*256)]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
602 VFS_ReadAt(Disk->FD, (Uint64)iBlocks[(BlockNum/256)%256]*Disk->BlockSize, Disk->BlockSize, iBlocks);
\r
603 BlockNum = iBlocks[BlockNum%256];
\r
605 return (Uint64)BlockNum * Disk->BlockSize;
\r