ext.c File Reference

#include <freeldr.h>
#include "fs/stat.h"
#include <debug.h>

Include dependency graph for ext.c:

Go to the source code of this file.

Classes
struct	_EXT_VOLUME_INFO

Macros
#define	TAG_EXT_BLOCK_LIST   'LtxE'
#define	TAG_EXT_FILE   'FtxE'
#define	TAG_EXT_BUFFER   'BtxE'
#define	TAG_EXT_SUPER_BLOCK   'StxE'
#define	TAG_EXT_GROUP_DESC   'GtxE'
#define	TAG_EXT_VOLUME   'VtxE'

Typedefs
typedef struct _EXT_VOLUME_INFO	EXT_VOLUME_INFO

Functions
	DBG_DEFAULT_CHANNEL (FILESYSTEM)
BOOLEAN	ExtOpenVolume (PEXT_VOLUME_INFO Volume)
PEXT_FILE_INFO	ExtOpenFile (PEXT_VOLUME_INFO Volume, PCSTR FileName)
BOOLEAN	ExtLookupFile (PEXT_VOLUME_INFO Volume, PCSTR FileName, PEXT_FILE_INFO ExtFileInfo)
BOOLEAN	ExtSearchDirectoryBufferForFile (PVOID DirectoryBuffer, ULONG DirectorySize, PCHAR FileName, PEXT_DIR_ENTRY DirectoryEntry)
BOOLEAN	ExtReadVolumeSectors (PEXT_VOLUME_INFO Volume, ULONGLONG SectorNumber, ULONG SectorCount, PVOID Buffer)
BOOLEAN	ExtReadFileBig (PEXT_FILE_INFO ExtFileInfo, ULONGLONG BytesToRead, ULONGLONG *BytesRead, PVOID Buffer)
BOOLEAN	ExtReadSuperBlock (PEXT_VOLUME_INFO Volume)
BOOLEAN	ExtReadGroupDescriptors (PEXT_VOLUME_INFO Volume)
BOOLEAN	ExtReadDirectory (PEXT_VOLUME_INFO Volume, ULONG Inode, PVOID *DirectoryBuffer, PEXT_INODE InodePointer)
BOOLEAN	ExtReadBlock (PEXT_VOLUME_INFO Volume, ULONG BlockNumber, PVOID Buffer)
BOOLEAN	ExtReadPartialBlock (PEXT_VOLUME_INFO Volume, ULONG BlockNumber, ULONG StartingOffset, ULONG Length, PVOID Buffer)
BOOLEAN	ExtReadInode (PEXT_VOLUME_INFO Volume, ULONG Inode, PEXT_INODE InodeBuffer)
BOOLEAN	ExtReadGroupDescriptor (PEXT_VOLUME_INFO Volume, ULONG Group, PEXT_GROUP_DESC GroupBuffer)
ULONG *	ExtReadBlockPointerList (PEXT_VOLUME_INFO Volume, PEXT_INODE Inode)
ULONGLONG	ExtGetInodeFileSize (PEXT_INODE Inode)
BOOLEAN	ExtCopyBlockPointersByExtents (PEXT_VOLUME_INFO Volume, ULONG *BlockList, ULONG *CurrentBlockInList, ULONG BlockCount, PEXT4_EXTENT_HEADER ExtentHeader)
BOOLEAN	ExtCopyIndirectBlockPointers (PEXT_VOLUME_INFO Volume, ULONG *BlockList, ULONG *CurrentBlockInList, ULONG BlockCount, ULONG IndirectBlock)
BOOLEAN	ExtCopyDoubleIndirectBlockPointers (PEXT_VOLUME_INFO Volume, ULONG *BlockList, ULONG *CurrentBlockInList, ULONG BlockCount, ULONG DoubleIndirectBlock)
BOOLEAN	ExtCopyTripleIndirectBlockPointers (PEXT_VOLUME_INFO Volume, ULONG *BlockList, ULONG *CurrentBlockInList, ULONG BlockCount, ULONG TripleIndirectBlock)
ULONG	ExtGetInodeGroupNumber (PEXT_VOLUME_INFO Volume, ULONG Inode)
ULONG	ExtGetInodeBlockNumber (PEXT_VOLUME_INFO Volume, ULONG Inode)
ULONG	ExtGetInodeOffsetInBlock (PEXT_VOLUME_INFO Volume, ULONG Inode)
ARC_STATUS	ExtClose (ULONG FileId)
ARC_STATUS	ExtGetFileInformation (ULONG FileId, FILEINFORMATION *Information)
ARC_STATUS	ExtOpen (CHAR *Path, OPENMODE OpenMode, ULONG *FileId)
ARC_STATUS	ExtRead (ULONG FileId, VOID *Buffer, ULONG N, ULONG *Count)
ARC_STATUS	ExtSeek (ULONG FileId, LARGE_INTEGER *Position, SEEKMODE SeekMode)
ULONGLONG	ExtGetVolumeSize (_In_ ULONG DeviceId)
	Returns the size of the EXT2/3/4 volume laid on the storage media device opened via DeviceId.
const DEVVTBL *	ExtMount (ULONG DeviceId)

Variables
PEXT_VOLUME_INFO	ExtVolumes [MAX_FDS]
const DEVVTBL	ExtFuncTable

Macro Definition Documentation

TAG_EXT_BLOCK_LIST

#define TAG_EXT_BLOCK_LIST   'LtxE'

Definition at line 72 of file ext.c.

TAG_EXT_BUFFER

#define TAG_EXT_BUFFER   'BtxE'

Definition at line 74 of file ext.c.

TAG_EXT_FILE

#define TAG_EXT_FILE   'FtxE'

Definition at line 73 of file ext.c.

TAG_EXT_GROUP_DESC

#define TAG_EXT_GROUP_DESC   'GtxE'

Definition at line 76 of file ext.c.

TAG_EXT_SUPER_BLOCK

#define TAG_EXT_SUPER_BLOCK   'StxE'

Definition at line 75 of file ext.c.

TAG_EXT_VOLUME

#define TAG_EXT_VOLUME   'VtxE'

Definition at line 77 of file ext.c.

Typedef Documentation

EXT_VOLUME_INFO

typedef struct _EXT_VOLUME_INFO EXT_VOLUME_INFO

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

FILESYSTEM

)

ExtClose()

ARC_STATUS ExtClose

(

ULONG

FileId

)

Definition at line 1302 of file ext.c.

{
    PEXT_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
    FrLdrTempFree(FileHandle, TAG_EXT_FILE);
    return ESUCCESS;
}

ExtCopyBlockPointersByExtents()

BOOLEAN ExtCopyBlockPointersByExtents	(	PEXT_VOLUME_INFO	Volume,
		ULONG *	BlockList,
		ULONG *	CurrentBlockInList,
		ULONG	BlockCount,
		PEXT4_EXTENT_HEADER	ExtentHeader
	)

Definition at line 1134 of file ext.c.

{
    TRACE("ExtCopyBlockPointersByExtents() BlockCount = 0x%p\n", BlockCount);
 
    if (ExtentHeader->Magic != EXT4_EXTENT_HEADER_MAGIC ||
        ExtentHeader->Depth > EXT4_EXTENT_MAX_LEVEL)
        return FALSE;
 
    ULONG Level = ExtentHeader->Depth;
    ULONG Entries = ExtentHeader->Entries;
 
    TRACE("Level: %d\n", Level);
    TRACE("Entries: %d\n", Entries);
 
    // If the level is 0, we have a direct extent block mapping
    if (!Level)
    {
        PEXT4_EXTENT Extent = (PVOID)&ExtentHeader[1];
 
        while ((*CurrentBlockInList) < BlockCount && Entries--)
        {
            BOOLEAN SparseExtent = (Extent->Length > EXT4_EXTENT_MAX_LENGTH);
            ULONG Length = SparseExtent ? (Extent->Length - EXT4_EXTENT_MAX_LENGTH) : Extent->Length; 
            ULONG CurrentBlock = SparseExtent ? 0 : Extent->Start;
 
            // Copy the pointers to the block list
            while ((*CurrentBlockInList) < BlockCount && Length--)
            {
                BlockList[(*CurrentBlockInList)++] = CurrentBlock;
 
                if (!SparseExtent)
                    CurrentBlock++;
            }
 
            Extent++;
        }
    }
    else
    {
        PEXT4_EXTENT_IDX Extent = (PVOID)&ExtentHeader[1];
 
        PEXT4_EXTENT_HEADER BlockBuffer = FrLdrTempAlloc(Volume->BlockSizeInBytes, TAG_EXT_BUFFER);
        if (!BlockBuffer)
        {
            return FALSE;
        }
 
        // Recursively copy the pointers to the block list
        while ((*CurrentBlockInList) < BlockCount && Entries--)
        {
            if (!(ExtReadBlock(Volume, Extent->Leaf, BlockBuffer) &&
                  ExtCopyBlockPointersByExtents(Volume, BlockList, CurrentBlockInList, BlockCount, BlockBuffer)))
            {
                FrLdrTempFree(BlockBuffer, TAG_EXT_BUFFER);
                return FALSE;
            }
 
            Extent++;
        }
 
        FrLdrTempFree(BlockBuffer, TAG_EXT_BUFFER);
    }
 
    return TRUE;
}

Referenced by ExtCopyBlockPointersByExtents(), and ExtReadBlockPointerList().

ExtCopyDoubleIndirectBlockPointers()

BOOLEAN ExtCopyDoubleIndirectBlockPointers	(	PEXT_VOLUME_INFO	Volume,
		ULONG *	BlockList,
		ULONG *	CurrentBlockInList,
		ULONG	BlockCount,
		ULONG	DoubleIndirectBlock
	)

Definition at line 1232 of file ext.c.

{
    ULONG*    BlockBuffer;
    ULONG    CurrentBlock;
    ULONG    BlockPointersPerBlock;
 
    TRACE("ExtCopyDoubleIndirectBlockPointers() BlockCount = %d\n", BlockCount);
 
    BlockPointersPerBlock = Volume->BlockSizeInBytes / sizeof(ULONG);
 
    BlockBuffer = (ULONG*)FrLdrTempAlloc(Volume->BlockSizeInBytes, TAG_EXT_BUFFER);
    if (BlockBuffer == NULL)
    {
        return FALSE;
    }
 
    if (!ExtReadBlock(Volume, DoubleIndirectBlock, BlockBuffer))
    {
        FrLdrTempFree(BlockBuffer, TAG_EXT_BUFFER);
        return FALSE;
    }
 
    for (CurrentBlock=0; (*CurrentBlockInList)<BlockCount && CurrentBlock<BlockPointersPerBlock; CurrentBlock++)
    {
        if (!ExtCopyIndirectBlockPointers(Volume, BlockList, CurrentBlockInList, BlockCount, BlockBuffer[CurrentBlock]))
        {
            FrLdrTempFree(BlockBuffer, TAG_EXT_BUFFER);
            return FALSE;
        }
    }
 
    FrLdrTempFree(BlockBuffer, TAG_EXT_BUFFER);
    return TRUE;
}

Referenced by ExtCopyTripleIndirectBlockPointers(), and ExtReadBlockPointerList().

ExtCopyIndirectBlockPointers()

BOOLEAN ExtCopyIndirectBlockPointers	(	PEXT_VOLUME_INFO	Volume,
		ULONG *	BlockList,
		ULONG *	CurrentBlockInList,
		ULONG	BlockCount,
		ULONG	IndirectBlock
	)

Definition at line 1200 of file ext.c.

{
    ULONG*    BlockBuffer;
    ULONG    CurrentBlock;
    ULONG    BlockPointersPerBlock;
 
    TRACE("ExtCopyIndirectBlockPointers() BlockCount = %d\n", BlockCount);
 
    BlockPointersPerBlock = Volume->BlockSizeInBytes / sizeof(ULONG);
 
    BlockBuffer = FrLdrTempAlloc(Volume->BlockSizeInBytes, TAG_EXT_BUFFER);
    if (!BlockBuffer)
    {
        return FALSE;
    }
 
    if (!ExtReadBlock(Volume, IndirectBlock, BlockBuffer))
    {
        return FALSE;
    }
 
    for (CurrentBlock=0; (*CurrentBlockInList)<BlockCount && CurrentBlock<BlockPointersPerBlock; CurrentBlock++)
    {
        BlockList[(*CurrentBlockInList)] = BlockBuffer[CurrentBlock];
        (*CurrentBlockInList)++;
    }
 
    FrLdrTempFree(BlockBuffer, TAG_EXT_BUFFER);
 
    return TRUE;
}

Referenced by ExtCopyDoubleIndirectBlockPointers(), and ExtReadBlockPointerList().

ExtCopyTripleIndirectBlockPointers()

BOOLEAN ExtCopyTripleIndirectBlockPointers	(	PEXT_VOLUME_INFO	Volume,
		ULONG *	BlockList,
		ULONG *	CurrentBlockInList,
		ULONG	BlockCount,
		ULONG	TripleIndirectBlock
	)

Definition at line 1267 of file ext.c.

{
    ULONG*    BlockBuffer;
    ULONG    CurrentBlock;
    ULONG    BlockPointersPerBlock;
 
    TRACE("ExtCopyTripleIndirectBlockPointers() BlockCount = %d\n", BlockCount);
 
    BlockPointersPerBlock = Volume->BlockSizeInBytes / sizeof(ULONG);
 
    BlockBuffer = (ULONG*)FrLdrTempAlloc(Volume->BlockSizeInBytes, TAG_EXT_BUFFER);
    if (BlockBuffer == NULL)
    {
        return FALSE;
    }
 
    if (!ExtReadBlock(Volume, TripleIndirectBlock, BlockBuffer))
    {
        FrLdrTempFree(BlockBuffer, TAG_EXT_BUFFER);
        return FALSE;
    }
 
    for (CurrentBlock=0; (*CurrentBlockInList)<BlockCount && CurrentBlock<BlockPointersPerBlock; CurrentBlock++)
    {
        if (!ExtCopyDoubleIndirectBlockPointers(Volume, BlockList, CurrentBlockInList, BlockCount, BlockBuffer[CurrentBlock]))
        {
            FrLdrTempFree(BlockBuffer, TAG_EXT_BUFFER);
            return FALSE;
        }
    }
 
    FrLdrTempFree(BlockBuffer, TAG_EXT_BUFFER);
    return TRUE;
}

Referenced by ExtReadBlockPointerList().

ExtGetFileInformation()

ARC_STATUS ExtGetFileInformation	(	ULONG	FileId,
		FILEINFORMATION *	Information
	)

Definition at line 1309 of file ext.c.

{
    PEXT_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
 
    RtlZeroMemory(Information, sizeof(*Information));
    Information->EndingAddress.QuadPart = FileHandle->FileSize;
    Information->CurrentAddress.QuadPart = FileHandle->FilePointer;
 
    /* Set the ARC file attributes */
    Information->Attributes = FileHandle->Attributes;
 
    /* Copy the file name, perhaps truncated, and NUL-terminated */
    Information->FileNameLength = min(FileHandle->FileNameLength, sizeof(Information->FileName) - 1);
    RtlCopyMemory(Information->FileName, FileHandle->FileName, Information->FileNameLength);
    Information->FileName[Information->FileNameLength] = ANSI_NULL;
 
    TRACE("ExtGetFileInformation(%lu) -> FileSize = %llu, FilePointer = 0x%llx\n",
          FileId, Information->EndingAddress.QuadPart, Information->CurrentAddress.QuadPart);
 
    return ESUCCESS;
}

ExtGetInodeBlockNumber()

ULONG ExtGetInodeBlockNumber	(	PEXT_VOLUME_INFO	Volume,
		ULONG	Inode
	)

Definition at line 930 of file ext.c.

{
    return (((Inode - 1) % Volume->SuperBlock->InodesPerGroup) / Volume->InodesPerBlock);
}

Referenced by ExtReadInode().

ExtGetInodeFileSize()

ULONGLONG ExtGetInodeFileSize

(

PEXT_INODE

Inode

)

Definition at line 1126 of file ext.c.

{
    if (_S_ISDIR(Inode->Mode))
        return (ULONGLONG)(Inode->Size);
    else
        return ((ULONGLONG)(Inode->Size) | ((ULONGLONG)(Inode->DirACL) << 32));
}

Referenced by ExtLookupFile(), ExtReadBlockPointerList(), and ExtReadDirectory().

ExtGetInodeGroupNumber()

ULONG ExtGetInodeGroupNumber	(	PEXT_VOLUME_INFO	Volume,
		ULONG	Inode
	)

Definition at line 925 of file ext.c.

{
    return ((Inode - 1) / Volume->SuperBlock->InodesPerGroup);
}

Referenced by ExtReadInode().

ExtGetInodeOffsetInBlock()

ULONG ExtGetInodeOffsetInBlock	(	PEXT_VOLUME_INFO	Volume,
		ULONG	Inode
	)

Definition at line 935 of file ext.c.

{
    return (((Inode - 1) % Volume->SuperBlock->InodesPerGroup) % Volume->InodesPerBlock);
}

Referenced by ExtReadInode().

ExtGetVolumeSize()

ULONGLONG ExtGetVolumeSize

(

_In_ ULONG

DeviceId

)

Returns the size of the EXT2/3/4 volume laid on the storage media device opened via DeviceId.

Definition at line 1404 of file ext.c.

{
    PEXT_VOLUME_INFO Volume;
    ULARGE_INTEGER BlocksCount;
 
    Volume = ExtVolumes[DeviceId];
    ASSERT(Volume);
 
    BlocksCount.LowPart  = Volume->SuperBlock->BlocksCountLo;
    BlocksCount.HighPart = Volume->SuperBlock->BlocksCountHi;
 
    /* NOTE: Volume->BlockSizeInBytes == Volume->BlockSizeInSectors * Volume->BytesPerSector */
    return BlocksCount.QuadPart * Volume->BlockSizeInBytes;
}

Referenced by FsGetVolumeSize().

ExtLookupFile()

BOOLEAN ExtLookupFile	(	PEXT_VOLUME_INFO	Volume,
		PCSTR	FileName,
		PEXT_FILE_INFO	ExtFileInfo
	)

Definition at line 210 of file ext.c.

{
    ULONG        NumberOfPathParts;
    ULONG        i;
    CHAR        PathPart[261];
    PVOID        DirectoryBuffer;
    ULONG        DirectoryInode = EXT_ROOT_INODE;
    EXT_INODE    InodeData;
    EXT_DIR_ENTRY    DirectoryEntry;
 
    TRACE("ExtLookupFile() FileName = \"%s\"\n", FileName);
 
    RtlZeroMemory(ExtFileInfo, sizeof(EXT_FILE_INFO));
 
    /* Skip leading path separator, if any */
    if (*FileName == '\\' || *FileName == '/')
        ++FileName;
    //
    // Figure out how many sub-directories we are nested in
    //
    NumberOfPathParts = FsGetNumPathParts(FileName);
 
    //
    // Loop once for each part
    //
    for (i=0; i<NumberOfPathParts; i++)
    {
        //
        // Get first path part
        //
        FsGetFirstNameFromPath(PathPart, FileName);
 
        //
        // Advance to the next part of the path
        //
        for (; (*FileName != '\\') && (*FileName != '/') && (*FileName != '\0'); FileName++)
        {
        }
        FileName++;
 
        //
        // Buffer the directory contents
        //
        if (!ExtReadDirectory(Volume, DirectoryInode, &DirectoryBuffer, &InodeData))
        {
            return FALSE;
        }
 
        //
        // Search for file name in directory
        //
        if (!ExtSearchDirectoryBufferForFile(DirectoryBuffer, (ULONG)ExtGetInodeFileSize(&InodeData), PathPart, &DirectoryEntry))
        {
            FrLdrTempFree(DirectoryBuffer, TAG_EXT_BUFFER);
            return FALSE;
        }
 
        FrLdrTempFree(DirectoryBuffer, TAG_EXT_BUFFER);
 
        DirectoryInode = DirectoryEntry.Inode;
    }
 
    if (!ExtReadInode(Volume, DirectoryInode, &InodeData))
    {
        return FALSE;
    }
 
    if (!_S_ISREG(InodeData.Mode) && !_S_ISLNK(InodeData.Mode))
    {
        FileSystemError("Inode is not a regular file or symbolic link.");
        return FALSE;
    }
 
    // Set the associated volume
    ExtFileInfo->Volume = Volume;
 
    // If it's a regular file or a regular symbolic link
    // then get the block pointer list otherwise it must
    // be a fast symbolic link which doesn't have a block list
    if (_S_ISREG(InodeData.Mode) ||
        (_S_ISLNK(InodeData.Mode) && InodeData.Size > FAST_SYMLINK_MAX_NAME_SIZE))
    {
        ExtFileInfo->FileBlockList = ExtReadBlockPointerList(Volume, &InodeData);
        if (ExtFileInfo->FileBlockList == NULL)
        {
            return FALSE;
        }
    }
    else
    {
        ExtFileInfo->FileBlockList = NULL;
    }
 
    ExtFileInfo->FilePointer = 0;
    ExtFileInfo->FileSize = ExtGetInodeFileSize(&InodeData);
    RtlCopyMemory(&ExtFileInfo->Inode, &InodeData, sizeof(InodeData));
 
    /* Map the attributes to ARC file attributes */
    ExtFileInfo->Attributes = 0;
    if (!(InodeData.Mode & (_S_IWUSR | _S_IWGRP | _S_IWOTH)))
        ExtFileInfo->Attributes |= ReadOnlyFile;
    if (_S_ISDIR(InodeData.Mode))
        ExtFileInfo->Attributes |= DirectoryFile;
 
    /* Set hidden attribute for all entries starting with '.' */
    if ((DirectoryEntry.NameLen >= 2 && DirectoryEntry.Name[0] == '.') &&
         ((DirectoryEntry.NameLen == 2 && DirectoryEntry.Name[1] != '.') ||
           DirectoryEntry.NameLen >= 3))
    {
        ExtFileInfo->Attributes |= HiddenFile;
    }
 
    /* Copy the file name, perhaps truncated */
    ExtFileInfo->FileNameLength = DirectoryEntry.NameLen; // (ULONG)strlen(PathPart);
    ExtFileInfo->FileNameLength = min(ExtFileInfo->FileNameLength, sizeof(ExtFileInfo->FileName) - 1);
    RtlCopyMemory(ExtFileInfo->FileName, DirectoryEntry.Name /*PathPart*/, ExtFileInfo->FileNameLength);
 
    return TRUE;
}

Referenced by ExtOpenFile().

ExtMount()

const DEVVTBL * ExtMount

(

ULONG

DeviceId

)

Definition at line 1431 of file ext.c.

{
    PEXT_VOLUME_INFO Volume;
    EXT_SUPER_BLOCK SuperBlock;
    LARGE_INTEGER Position;
    ULONG Count;
    ARC_STATUS Status;
 
    TRACE("Enter ExtMount(%lu)\n", DeviceId);
 
    /* Allocate data for volume information */
    Volume = FrLdrTempAlloc(sizeof(EXT_VOLUME_INFO), TAG_EXT_VOLUME);
    if (!Volume)
        return NULL;
    RtlZeroMemory(Volume, sizeof(EXT_VOLUME_INFO));
 
    /* Read the SuperBlock */
    Position.QuadPart = 2 * 512;
    Status = ArcSeek(DeviceId, &Position, SeekAbsolute);
    if (Status != ESUCCESS)
    {
        FrLdrTempFree(Volume, TAG_EXT_VOLUME);
        return NULL;
    }
    Status = ArcRead(DeviceId, &SuperBlock, sizeof(SuperBlock), &Count);
    if (Status != ESUCCESS || Count != sizeof(SuperBlock))
    {
        FrLdrTempFree(Volume, TAG_EXT_VOLUME);
        return NULL;
    }
 
    /* Check if SuperBlock is valid. If yes, return Ext function table. */
    if (SuperBlock.Magic != EXT_SUPERBLOCK_MAGIC)
    {
        FrLdrTempFree(Volume, TAG_EXT_VOLUME);
        return NULL;
    }
 
    Volume->DeviceId = DeviceId;
 
    /* Really open the volume */
    if (!ExtOpenVolume(Volume))
    {
        FrLdrTempFree(Volume, TAG_EXT_VOLUME);
        return NULL;
    }
 
    /* Remember EXT volume information */
    ExtVolumes[DeviceId] = Volume;
 
    /* Return success */
    TRACE("ExtMount(%lu) success\n", DeviceId);
    return &ExtFuncTable;
}

ExtOpen()

ARC_STATUS ExtOpen	(	CHAR *	Path,
		OPENMODE	OpenMode,
		ULONG *	FileId
	)

Definition at line 1331 of file ext.c.

{
    PEXT_VOLUME_INFO Volume;
    PEXT_FILE_INFO FileHandle;
    ULONG DeviceId;
 
    /* Check parameters */
    if (OpenMode != OpenReadOnly)
        return EACCES;
 
    /* Get underlying device */
    DeviceId = FsGetDeviceId(*FileId);
    Volume = ExtVolumes[DeviceId];
 
    TRACE("ExtOpen() FileName = \"%s\"\n", Path);
 
    /* Call the internal open method */
    // Status = ExtOpenFile(Volume, Path, &FileHandle);
    FileHandle = ExtOpenFile(Volume, Path);
    if (!FileHandle)
        return ENOENT;
 
    /* Success, remember the handle */
    FsSetDeviceSpecific(*FileId, FileHandle);
    return ESUCCESS;
}

ExtOpenFile()

PEXT_FILE_INFO ExtOpenFile	(	PEXT_VOLUME_INFO	Volume,
		PCSTR	FileName
	)

Definition at line 108 of file ext.c.

{
    EXT_FILE_INFO        TempExtFileInfo;
    PEXT_FILE_INFO        FileHandle;
    CHAR            SymLinkPath[EXT_DIR_ENTRY_MAX_NAME_LENGTH];
    CHAR            FullPath[EXT_DIR_ENTRY_MAX_NAME_LENGTH * 2];
    SIZE_T Index;
 
    TRACE("ExtOpenFile() FileName = \"%s\"\n", FileName);
 
    RtlZeroMemory(SymLinkPath, sizeof(SymLinkPath));
 
    // Lookup the file in the file system
    if (!ExtLookupFile(Volume, FileName, &TempExtFileInfo))
    {
        return NULL;
    }
 
    // If we got a symbolic link then fix up the path
    // and re-call this function
    if (_S_ISLNK(TempExtFileInfo.Inode.Mode))
    {
        TRACE("File is a symbolic link\n");
 
        // Now read in the symbolic link path
        if (!ExtReadFileBig(&TempExtFileInfo, TempExtFileInfo.FileSize, NULL, SymLinkPath))
        {
            if (TempExtFileInfo.FileBlockList != NULL)
            {
                FrLdrTempFree(TempExtFileInfo.FileBlockList, TAG_EXT_BLOCK_LIST);
            }
 
            return NULL;
        }
 
        TRACE("Symbolic link path = \"%s\"\n", SymLinkPath);
 
        // Get the full path
        if (SymLinkPath[0] == '/' || SymLinkPath[0] == '\\')
        {
            // Symbolic link is an absolute path
            // So copy it to FullPath, but skip over
            // the '/' character at the beginning
            strcpy(FullPath, &SymLinkPath[1]);
        }
        else
        {
            // Symbolic link is a relative path
            // Copy the first part of the path
            strcpy(FullPath, FileName);
 
            // Remove the last part of the path
            for (Index=strlen(FullPath); Index>0; )
            {
                Index--;
                if (FullPath[Index] == '/' || FullPath[Index] == '\\')
                {
                    break;
                }
            }
            FullPath[Index] = '\0';
 
            // Concatenate the symbolic link
            strcat(FullPath, Index == 0 ? "" : "/");
            strcat(FullPath, SymLinkPath);
        }
 
        TRACE("Full file path = \"%s\"\n", FullPath);
 
        if (TempExtFileInfo.FileBlockList != NULL)
        {
            FrLdrTempFree(TempExtFileInfo.FileBlockList, TAG_EXT_BLOCK_LIST);
        }
 
        return ExtOpenFile(Volume, FullPath);
    }
    else
    {
        FileHandle = FrLdrTempAlloc(sizeof(EXT_FILE_INFO), TAG_EXT_FILE);
        if (FileHandle == NULL)
        {
            if (TempExtFileInfo.FileBlockList != NULL)
            {
                FrLdrTempFree(TempExtFileInfo.FileBlockList, TAG_EXT_BLOCK_LIST);
            }
 
            return NULL;
        }
 
        RtlCopyMemory(FileHandle, &TempExtFileInfo, sizeof(EXT_FILE_INFO));
 
        return FileHandle;
    }
}

Referenced by ExtOpen(), and ExtOpenFile().

ExtOpenVolume()

BOOLEAN ExtOpenVolume

(

PEXT_VOLUME_INFO

Volume

)

Definition at line 79 of file ext.c.

{
    TRACE("ExtOpenVolume() DeviceId = %d\n", Volume->DeviceId);
 
#if 0
    /* Initialize the disk cache for this drive */
    if (!CacheInitializeDrive(DriveNumber))
    {
        return FALSE;
    }
#endif
    Volume->BytesPerSector = SECTOR_SIZE;
 
    /* Read in the super block */
    if (!ExtReadSuperBlock(Volume))
        return FALSE;
 
    /* Read in the group descriptors */
    if (!ExtReadGroupDescriptors(Volume))
        return FALSE;
 
    return TRUE;
}

Referenced by ExtMount().

ExtRead()

ARC_STATUS ExtRead	(	ULONG	FileId,
		VOID *	Buffer,
		ULONG	N,
		ULONG *	Count
	)

Definition at line 1358 of file ext.c.

{
    PEXT_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
    ULONGLONG BytesReadBig;
    BOOLEAN Success;
 
    /* Read data */
    Success = ExtReadFileBig(FileHandle, N, &BytesReadBig, Buffer);
    *Count = (ULONG)BytesReadBig;
    if (Success)
        return ESUCCESS;
    else
        return EIO;
}

ExtReadBlock()

BOOLEAN ExtReadBlock	(	PEXT_VOLUME_INFO	Volume,
		ULONG	BlockNumber,
		PVOID	Buffer
	)

Definition at line 873 of file ext.c.

{
    CHAR    ErrorString[80];
 
    TRACE("ExtReadBlock() BlockNumber = %d Buffer = 0x%x\n", BlockNumber, Buffer);
 
    // Make sure its a valid block
    if (BlockNumber > Volume->SuperBlock->BlocksCountLo)
    {
        sprintf(ErrorString, "Error reading block %d - block out of range.", (int) BlockNumber);
        FileSystemError(ErrorString);
        return FALSE;
    }
 
    // Check to see if this is a sparse block
    if (BlockNumber == 0)
    {
        TRACE("Block is part of a sparse file. Zeroing input buffer.\n");
 
        RtlZeroMemory(Buffer, Volume->BlockSizeInBytes);
 
        return TRUE;
    }
 
    return ExtReadVolumeSectors(Volume, (ULONGLONG)BlockNumber * Volume->BlockSizeInSectors, Volume->BlockSizeInSectors, Buffer);
}

Referenced by ExtCopyBlockPointersByExtents(), ExtCopyDoubleIndirectBlockPointers(), ExtCopyIndirectBlockPointers(), ExtCopyTripleIndirectBlockPointers(), ExtReadFileBig(), ExtReadGroupDescriptor(), ExtReadGroupDescriptors(), and ExtReadPartialBlock().

ExtReadBlockPointerList()

ULONG * ExtReadBlockPointerList	(	PEXT_VOLUME_INFO	Volume,
		PEXT_INODE	Inode
	)

Definition at line 1041 of file ext.c.

{
    ULONGLONG        FileSize;
    ULONG        BlockCount;
    ULONG*    BlockList;
    ULONG        CurrentBlockInList;
    ULONG        CurrentBlock;
 
    TRACE("ExtReadBlockPointerList()\n");
 
    // Get the number of blocks this file occupies
    // I would just use Inode->i_blocks but it
    // doesn't seem to be the number of blocks
    // the file size corresponds to, but instead
    // it is much bigger.
    //BlockCount = Inode->i_blocks;
    FileSize = ExtGetInodeFileSize(Inode);
    FileSize = ROUND_UP(FileSize, Volume->BlockSizeInBytes);
    BlockCount = (ULONG)(FileSize / Volume->BlockSizeInBytes);
 
    // Allocate the memory for the block list
    BlockList = FrLdrTempAlloc(BlockCount * sizeof(ULONG), TAG_EXT_BLOCK_LIST);
    if (BlockList == NULL)
    {
        return NULL;
    }
 
    RtlZeroMemory(BlockList, BlockCount * sizeof(ULONG));
 
    // If the file is stored in extents, copy the block pointers by reading the
    // extent entries.
    if (Inode->Flags & EXT4_INODE_FLAG_EXTENTS)
    {
        CurrentBlockInList = 0;
 
        if (!ExtCopyBlockPointersByExtents(Volume, BlockList, &CurrentBlockInList, BlockCount, &Inode->ExtentHeader))
        {
            FrLdrTempFree(BlockList, TAG_EXT_BLOCK_LIST);
            return NULL;
        }
 
        return BlockList;
    }
 
    // Copy the direct block pointers
    for (CurrentBlockInList = CurrentBlock = 0;
         CurrentBlockInList < BlockCount && CurrentBlock < sizeof(Inode->Blocks.DirectBlocks) / sizeof(*Inode->Blocks.DirectBlocks);
         CurrentBlock++, CurrentBlockInList++)
    {
        BlockList[CurrentBlockInList] = Inode->Blocks.DirectBlocks[CurrentBlock];
    }
 
    // Copy the indirect block pointers
    if (CurrentBlockInList < BlockCount)
    {
        if (!ExtCopyIndirectBlockPointers(Volume, BlockList, &CurrentBlockInList, BlockCount, Inode->Blocks.IndirectBlock))
        {
            FrLdrTempFree(BlockList, TAG_EXT_BLOCK_LIST);
            return NULL;
        }
    }
 
    // Copy the double indirect block pointers
    if (CurrentBlockInList < BlockCount)
    {
        if (!ExtCopyDoubleIndirectBlockPointers(Volume, BlockList, &CurrentBlockInList, BlockCount, Inode->Blocks.DoubleIndirectBlock))
        {
            FrLdrTempFree(BlockList, TAG_EXT_BLOCK_LIST);
            return NULL;
        }
    }
 
    // Copy the triple indirect block pointers
    if (CurrentBlockInList < BlockCount)
    {
        if (!ExtCopyTripleIndirectBlockPointers(Volume, BlockList, &CurrentBlockInList, BlockCount, Inode->Blocks.TripleIndirectBlock))
        {
            FrLdrTempFree(BlockList, TAG_EXT_BLOCK_LIST);
            return NULL;
        }
    }
 
    return BlockList;
}

Referenced by ExtLookupFile(), and ExtReadDirectory().

ExtReadDirectory()

BOOLEAN ExtReadDirectory	(	PEXT_VOLUME_INFO	Volume,
		ULONG	Inode,
		PVOID *	DirectoryBuffer,
		PEXT_INODE	InodePointer
	)

Definition at line 813 of file ext.c.

{
    EXT_FILE_INFO DirectoryFileInfo;
 
    TRACE("ExtReadDirectory() Inode = %d\n", Inode);
 
    // Read the directory inode
    if (!ExtReadInode(Volume, Inode, InodePointer))
    {
        return FALSE;
    }
 
    // Make sure it is a directory inode
    if (!_S_ISDIR(InodePointer->Mode))
    {
        FileSystemError("Inode is not a directory.");
        return FALSE;
    }
 
    // Fill in file info struct so we can call ExtReadFileBig()
    RtlZeroMemory(&DirectoryFileInfo, sizeof(EXT_FILE_INFO));
    DirectoryFileInfo.Volume = Volume;
    DirectoryFileInfo.FileBlockList = ExtReadBlockPointerList(Volume, InodePointer);
    DirectoryFileInfo.FilePointer = 0;
    DirectoryFileInfo.FileSize = ExtGetInodeFileSize(InodePointer);
 
    if (DirectoryFileInfo.FileBlockList == NULL)
    {
        return FALSE;
    }
 
    //
    // Now allocate the memory to hold the group descriptors
    //
    ASSERT(DirectoryFileInfo.FileSize <= 0xFFFFFFFF);
    *DirectoryBuffer = (PEXT_DIR_ENTRY)FrLdrTempAlloc((ULONG)DirectoryFileInfo.FileSize, TAG_EXT_BUFFER);
 
    //
    // Make sure we got the memory
    //
    if (*DirectoryBuffer == NULL)
    {
        FrLdrTempFree(DirectoryFileInfo.FileBlockList, TAG_EXT_BLOCK_LIST);
        FileSystemError("Out of memory.");
        return FALSE;
    }
 
    // Now read the root directory data
    if (!ExtReadFileBig(&DirectoryFileInfo, DirectoryFileInfo.FileSize, NULL, *DirectoryBuffer))
    {
        FrLdrTempFree(*DirectoryBuffer, TAG_EXT_BUFFER);
        *DirectoryBuffer = NULL;
        FrLdrTempFree(DirectoryFileInfo.FileBlockList, TAG_EXT_BLOCK_LIST);
        return FALSE;
    }
 
    FrLdrTempFree(DirectoryFileInfo.FileBlockList, TAG_EXT_BLOCK_LIST);
    return TRUE;
}

Referenced by ExtLookupFile().

ExtReadFileBig()

BOOLEAN ExtReadFileBig	(	PEXT_FILE_INFO	ExtFileInfo,
		ULONGLONG	BytesToRead,
		ULONGLONG *	BytesRead,
		PVOID	Buffer
	)

Definition at line 387 of file ext.c.

{
    PEXT_VOLUME_INFO Volume = ExtFileInfo->Volume;
    ULONG                BlockNumber;
    ULONG                BlockNumberIndex;
    ULONG                OffsetInBlock;
    ULONG                LengthInBlock;
    ULONG                NumberOfBlocks;
 
    TRACE("ExtReadFileBig() BytesToRead = %d Buffer = 0x%x\n", (ULONG)BytesToRead, Buffer);
 
    if (BytesRead != NULL)
    {
        *BytesRead = 0;
    }
 
    // Make sure we have the block pointer list if we need it
    if (ExtFileInfo->FileBlockList == NULL)
    {
        // Block pointer list is NULL
        // so this better be a fast symbolic link or else
        if (!_S_ISLNK(ExtFileInfo->Inode.Mode) ||
            (ExtFileInfo->FileSize > FAST_SYMLINK_MAX_NAME_SIZE))
        {
            FileSystemError("Block pointer list is NULL and file is not a fast symbolic link.");
            return FALSE;
        }
    }
 
    //
    // If the user is trying to read past the end of
    // the file then return success with BytesRead == 0.
    //
    if (ExtFileInfo->FilePointer >= ExtFileInfo->FileSize)
    {
        return TRUE;
    }
 
    //
    // If the user is trying to read more than there is to read
    // then adjust the amount to read.
    //
    if ((ExtFileInfo->FilePointer + BytesToRead) > ExtFileInfo->FileSize)
    {
        BytesToRead = (ExtFileInfo->FileSize - ExtFileInfo->FilePointer);
    }
 
    // Check if this is a fast symbolic link
    // if so then the read is easy
    if (_S_ISLNK(ExtFileInfo->Inode.Mode) &&
        (ExtFileInfo->FileSize <= FAST_SYMLINK_MAX_NAME_SIZE))
    {
        TRACE("Reading fast symbolic link data\n");
 
        // Copy the data from the link
        RtlCopyMemory(Buffer, (PVOID)((ULONG_PTR)ExtFileInfo->FilePointer + ExtFileInfo->Inode.SymLink), (ULONG)BytesToRead);
 
        if (BytesRead != NULL)
        {
            *BytesRead = BytesToRead;
        }
        // ExtFileInfo->FilePointer += BytesToRead;
 
        return TRUE;
    }
 
    //
    // Ok, now we have to perform at most 3 calculations
    // I'll draw you a picture (using nifty ASCII art):
    //
    // CurrentFilePointer -+
    //                     |
    //    +----------------+
    //    |
    // +-----------+-----------+-----------+-----------+
    // | Block 1   | Block 2   | Block 3   | Block 4   |
    // +-----------+-----------+-----------+-----------+
    //    |                                    |
    //    +---------------+--------------------+
    //                    |
    // BytesToRead -------+
    //
    // 1 - The first calculation (and read) will align
    //     the file pointer with the next block.
    //     boundary (if we are supposed to read that much)
    // 2 - The next calculation (and read) will read
    //     in all the full blocks that the requested
    //     amount of data would cover (in this case
    //     blocks 2 & 3).
    // 3 - The last calculation (and read) would read
    //     in the remainder of the data requested out of
    //     the last block.
    //
 
    //
    // Only do the first read if we
    // aren't aligned on a block boundary
    //
    if (ExtFileInfo->FilePointer % Volume->BlockSizeInBytes)
    {
        //
        // Do the math for our first read
        //
        BlockNumberIndex = (ULONG)(ExtFileInfo->FilePointer / Volume->BlockSizeInBytes);
        BlockNumber = ExtFileInfo->FileBlockList[BlockNumberIndex];
        OffsetInBlock = (ExtFileInfo->FilePointer % Volume->BlockSizeInBytes);
        LengthInBlock = (ULONG)((BytesToRead > (Volume->BlockSizeInBytes - OffsetInBlock)) ? (Volume->BlockSizeInBytes - OffsetInBlock) : BytesToRead);
 
        //
        // Now do the read and update BytesRead, BytesToRead, FilePointer, & Buffer
        //
        if (!ExtReadPartialBlock(Volume, BlockNumber, OffsetInBlock, LengthInBlock, Buffer))
        {
            return FALSE;
        }
        if (BytesRead != NULL)
        {
            *BytesRead += LengthInBlock;
        }
        BytesToRead -= LengthInBlock;
        ExtFileInfo->FilePointer += LengthInBlock;
        Buffer = (PVOID)((ULONG_PTR)Buffer + LengthInBlock);
    }
 
    //
    // Do the math for our second read (if any data left)
    //
    if (BytesToRead > 0)
    {
        //
        // Determine how many full clusters we need to read
        //
        NumberOfBlocks = (ULONG)(BytesToRead / Volume->BlockSizeInBytes);
 
        while (NumberOfBlocks > 0)
        {
            BlockNumberIndex = (ULONG)(ExtFileInfo->FilePointer / Volume->BlockSizeInBytes);
            BlockNumber = ExtFileInfo->FileBlockList[BlockNumberIndex];
 
            //
            // Now do the read and update BytesRead, BytesToRead, FilePointer, & Buffer
            //
            if (!ExtReadBlock(Volume, BlockNumber, Buffer))
            {
                return FALSE;
            }
            if (BytesRead != NULL)
            {
                *BytesRead += Volume->BlockSizeInBytes;
            }
            BytesToRead -= Volume->BlockSizeInBytes;
            ExtFileInfo->FilePointer += Volume->BlockSizeInBytes;
            Buffer = (PVOID)((ULONG_PTR)Buffer + Volume->BlockSizeInBytes);
            NumberOfBlocks--;
        }
    }
 
    //
    // Do the math for our third read (if any data left)
    //
    if (BytesToRead > 0)
    {
        BlockNumberIndex = (ULONG)(ExtFileInfo->FilePointer / Volume->BlockSizeInBytes);
        BlockNumber = ExtFileInfo->FileBlockList[BlockNumberIndex];
 
        //
        // Now do the read and update BytesRead & FilePointer
        //
        if (!ExtReadPartialBlock(Volume, BlockNumber, 0, (ULONG)BytesToRead, Buffer))
        {
            return FALSE;
        }
        if (BytesRead != NULL)
        {
            *BytesRead += BytesToRead;
        }
        ExtFileInfo->FilePointer += BytesToRead;
    }
 
    return TRUE;
}

Referenced by ExtOpenFile(), ExtRead(), and ExtReadDirectory().

ExtReadGroupDescriptor()

BOOLEAN ExtReadGroupDescriptor	(	PEXT_VOLUME_INFO	Volume,
		ULONG	Group,
		PEXT_GROUP_DESC	GroupBuffer
	)

Definition at line 1016 of file ext.c.

{
    TRACE("ExtReadGroupDescriptor()\n");
 
#if 0
    if (!ExtReadBlock(Volume, ExtGetGroupDescBlockNumber(Volume, Group), (PVOID)FILESYSBUFFER))
    {
        return FALSE;
    }
    RtlCopyMemory(GroupBuffer, (PVOID)(FILESYSBUFFER + ExtGetGroupDescOffsetInBlock(Volume, Group)), sizeof(EXT_GROUP_DESC));
#endif
 
    RtlCopyMemory(GroupBuffer, &((PUCHAR)Volume->GroupDescriptors)[Volume->GroupDescSizeInBytes * Group], sizeof(EXT_GROUP_DESC));
 
    TRACE("Dumping group descriptor:\n");
    TRACE("BlockBitmap = %d\n", GroupBuffer->BlockBitmap);
    TRACE("InodeBitmap = %d\n", GroupBuffer->InodeBitmap);
    TRACE("InodeTable = %d\n", GroupBuffer->InodeTable);
    TRACE("FreeBlocksCount = %d\n", GroupBuffer->FreeBlocksCount);
    TRACE("FreeInodesCount = %d\n", GroupBuffer->FreeInodesCount);
    TRACE("UsedDirsCount = %d\n", GroupBuffer->UsedDirsCount);
 
    return TRUE;
}

Referenced by ExtReadInode().

ExtReadGroupDescriptors()

BOOLEAN ExtReadGroupDescriptors

(

PEXT_VOLUME_INFO

Volume

)

Definition at line 771 of file ext.c.

{
    ULONG GroupDescBlockCount;
    ULONG BlockNumber;
    PUCHAR CurrentGroupDescBlock;
 
    TRACE("ExtReadGroupDescriptors()\n");
 
    /* Free any memory previously allocated */
    if (Volume->GroupDescriptors != NULL)
    {
        FrLdrTempFree(Volume->GroupDescriptors, TAG_EXT_GROUP_DESC);
        Volume->GroupDescriptors = NULL;
    }
 
    /* Now allocate the memory to hold the group descriptors */
    GroupDescBlockCount = ROUND_UP(Volume->GroupCount, Volume->GroupDescPerBlock) / Volume->GroupDescPerBlock;
    Volume->GroupDescriptors = (PEXT_GROUP_DESC)FrLdrTempAlloc(GroupDescBlockCount * Volume->BlockSizeInBytes, TAG_EXT_GROUP_DESC);
    if (Volume->GroupDescriptors == NULL)
    {
        FileSystemError("Out of memory.");
        return FALSE;
    }
 
    // Now read the group descriptors
    CurrentGroupDescBlock = (PUCHAR)Volume->GroupDescriptors;
    BlockNumber = Volume->SuperBlock->FirstDataBlock + 1;
 
    while (GroupDescBlockCount--)
    {
        if (!ExtReadBlock(Volume, BlockNumber, CurrentGroupDescBlock))
        {
            return FALSE;
        }
 
        BlockNumber++;
        CurrentGroupDescBlock += Volume->BlockSizeInBytes;
    }
 
    return TRUE;
}

Referenced by ExtOpenVolume().

ExtReadInode()

BOOLEAN ExtReadInode	(	PEXT_VOLUME_INFO	Volume,
		ULONG	Inode,
		PEXT_INODE	InodeBuffer
	)

Definition at line 940 of file ext.c.

{
    ULONG        InodeGroupNumber;
    ULONG        InodeBlockNumber;
    ULONG        InodeOffsetInBlock;
    CHAR        ErrorString[80];
    EXT_GROUP_DESC    GroupDescriptor;
 
    TRACE("ExtReadInode() Inode = %d\n", Inode);
 
    // Make sure its a valid inode
    if ((Inode < 1) || (Inode > Volume->SuperBlock->InodesCount))
    {
        sprintf(ErrorString, "Error reading inode %ld - inode out of range.", Inode);
        FileSystemError(ErrorString);
        return FALSE;
    }
 
    // Get inode group & block number and offset in block
    InodeGroupNumber = ExtGetInodeGroupNumber(Volume, Inode);
    InodeBlockNumber = ExtGetInodeBlockNumber(Volume, Inode);
    InodeOffsetInBlock = ExtGetInodeOffsetInBlock(Volume, Inode);
    TRACE("InodeGroupNumber = %d\n", InodeGroupNumber);
    TRACE("InodeBlockNumber = %d\n", InodeBlockNumber);
    TRACE("InodeOffsetInBlock = %d\n", InodeOffsetInBlock);
 
    // Read the group descriptor
    if (!ExtReadGroupDescriptor(Volume, InodeGroupNumber, &GroupDescriptor))
    {
        return FALSE;
    }
 
    // Add the start block of the inode table to the inode block number
    InodeBlockNumber += GroupDescriptor.InodeTable;
    TRACE("InodeBlockNumber (after group desc correction) = %d\n", InodeBlockNumber);
 
    // Read the block
    if (!ExtReadPartialBlock(Volume,
                              InodeBlockNumber,
                              (InodeOffsetInBlock * Volume->InodeSizeInBytes),
                              sizeof(EXT_INODE),
                              InodeBuffer))
    {
        return FALSE;
    }
 
    TRACE("Dumping inode information:\n");
    TRACE("Mode = 0x%x\n", InodeBuffer->Mode);
    TRACE("UID = %d\n", InodeBuffer->UID);
    TRACE("Size = %d\n", InodeBuffer->Size);
    TRACE("Atime = %d\n", InodeBuffer->Atime);
    TRACE("Ctime = %d\n", InodeBuffer->Ctime);
    TRACE("Mtime = %d\n", InodeBuffer->Mtime);
    TRACE("Dtime = %d\n", InodeBuffer->Dtime);
    TRACE("GID = %d\n", InodeBuffer->GID);
    TRACE("LinksCount = %d\n", InodeBuffer->LinksCount);
    TRACE("Blocks = %d\n", InodeBuffer->Blocks);
    TRACE("Flags = 0x%x\n", InodeBuffer->Flags);
    TRACE("OSD1 = 0x%x\n", InodeBuffer->OSD1);
    TRACE("DirectBlocks = { %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u }\n",
        InodeBuffer->Blocks.DirectBlocks[0], InodeBuffer->Blocks.DirectBlocks[1], InodeBuffer->Blocks.DirectBlocks[2], InodeBuffer->Blocks.DirectBlocks[3],
        InodeBuffer->Blocks.DirectBlocks[4], InodeBuffer->Blocks.DirectBlocks[5], InodeBuffer->Blocks.DirectBlocks[6], InodeBuffer->Blocks.DirectBlocks[7],
        InodeBuffer->Blocks.DirectBlocks[8], InodeBuffer->Blocks.DirectBlocks[9], InodeBuffer->Blocks.DirectBlocks[10], InodeBuffer->Blocks.DirectBlocks[11]);
    TRACE("IndirectBlock = %u\n", InodeBuffer->Blocks.IndirectBlock);
    TRACE("DoubleIndirectBlock = %u\n", InodeBuffer->Blocks.DoubleIndirectBlock);
    TRACE("TripleIndirectBlock = %u\n", InodeBuffer->Blocks.TripleIndirectBlock);
    TRACE("Generation = %d\n", InodeBuffer->Generation);
    TRACE("FileACL = %d\n", InodeBuffer->FileACL);
    TRACE("DirACL = %d\n", InodeBuffer->DirACL);
    TRACE("FragAddress = %d\n", InodeBuffer->FragAddress);
    TRACE("OSD2 = { %d, %d, %d }\n",
        InodeBuffer->OSD2[0], InodeBuffer->OSD2[1], InodeBuffer->OSD2[2]);
 
    return TRUE;
}

Referenced by ExtLookupFile(), and ExtReadDirectory().

ExtReadPartialBlock()

BOOLEAN ExtReadPartialBlock	(	PEXT_VOLUME_INFO	Volume,
		ULONG	BlockNumber,
		ULONG	StartingOffset,
		ULONG	Length,
		PVOID	Buffer
	)

Definition at line 904 of file ext.c.

{
    PVOID TempBuffer;
 
    TRACE("ExtReadPartialBlock() BlockNumber = %d StartingOffset = %d Length = %d Buffer = 0x%x\n", BlockNumber, StartingOffset, Length, Buffer);
 
    TempBuffer = FrLdrTempAlloc(Volume->BlockSizeInBytes, TAG_EXT_BUFFER);
 
    if (!ExtReadBlock(Volume, BlockNumber, TempBuffer))
    {
        FrLdrTempFree(TempBuffer, TAG_EXT_BUFFER);
        return FALSE;
    }
 
    RtlCopyMemory(Buffer, ((PUCHAR)TempBuffer + StartingOffset), Length);
 
    FrLdrTempFree(TempBuffer, TAG_EXT_BUFFER);
 
    return TRUE;
}

Referenced by ExtReadFileBig(), and ExtReadInode().

ExtReadSuperBlock()

BOOLEAN ExtReadSuperBlock

(

PEXT_VOLUME_INFO

Volume

)

Definition at line 600 of file ext.c.

{
    PEXT_SUPER_BLOCK SuperBlock = Volume->SuperBlock;
    LARGE_INTEGER Position;
    ULONG Count;
    ARC_STATUS Status;
 
    TRACE("ExtReadSuperBlock()\n");
 
#if 0
    /* Free any memory previously allocated */
    if (SuperBlock != NULL)
    {
        FrLdrTempFree(SuperBlock, TAG_EXT_SUPER_BLOCK);
        SuperBlock = NULL;
    }
#endif
 
    /* Allocate the memory to hold the super block if needed */
    if (SuperBlock == NULL)
    {
        SuperBlock = (PEXT_SUPER_BLOCK)FrLdrTempAlloc(1024, TAG_EXT_SUPER_BLOCK);
        if (SuperBlock == NULL)
        {
            FileSystemError("Out of memory.");
            return FALSE;
        }
    }
    Volume->SuperBlock = SuperBlock;
 
    /* Reset its contents */
    RtlZeroMemory(SuperBlock, 1024);
 
    /* Read the SuperBlock */
    Position.QuadPart = 2 * 512;
    Status = ArcSeek(Volume->DeviceId, &Position, SeekAbsolute);
    if (Status != ESUCCESS)
        return FALSE;
    Status = ArcRead(Volume->DeviceId, SuperBlock, 2 * 512, &Count);
    if (Status != ESUCCESS || Count != 2 * 512)
        return FALSE;
 
    TRACE("Dumping super block:\n");
    TRACE("InodesCount: %d\n", SuperBlock->InodesCount);
    TRACE("BlocksCountLo: %d\n", SuperBlock->BlocksCountLo);
    TRACE("RBlocksCountLo: %d\n", SuperBlock->RBlocksCountLo);
    TRACE("FreeBlocksCountLo: %d\n", SuperBlock->FreeBlocksCountLo);
    TRACE("FreeInodesCount: %d\n", SuperBlock->FreeInodesCount);
    TRACE("FirstDataBlock: %d\n", SuperBlock->FirstDataBlock);
    TRACE("LogBlockSize: %d\n", SuperBlock->LogBlockSize);
    TRACE("LogFragSize: %d\n", SuperBlock->LogFragSize);
    TRACE("BlocksPerGroup: %d\n", SuperBlock->BlocksPerGroup);
    TRACE("FragsPerGroup: %d\n", SuperBlock->FragsPerGroup);
    TRACE("InodesPerGroup: %d\n", SuperBlock->InodesPerGroup);
    TRACE("MTime: %d\n", SuperBlock->MTime);
    TRACE("WTime: %d\n", SuperBlock->WTime);
    TRACE("MntCount: %d\n", SuperBlock->MntCount);
    TRACE("MaxMntCount: %d\n", SuperBlock->MaxMntCount);
    TRACE("Magic: 0x%x\n", SuperBlock->Magic);
    TRACE("State: 0x%x\n", SuperBlock->State);
    TRACE("Errors: 0x%x\n", SuperBlock->Errors);
    TRACE("MinorRevisionLevel: %d\n", SuperBlock->MinorRevisionLevel);
    TRACE("LastCheck: %d\n", SuperBlock->LastCheck);
    TRACE("CheckInterval: %d\n", SuperBlock->CheckInterval);
    TRACE("CreatorOS: %d\n", SuperBlock->CreatorOS);
    TRACE("RevisionLevel: %d\n", SuperBlock->RevisionLevel);
    TRACE("DefResUID: %d\n", SuperBlock->DefResUID);
    TRACE("DefResGID: %d\n", SuperBlock->DefResGID);
    TRACE("FirstInode: %d\n", SuperBlock->FirstInode);
    TRACE("InodeSize: %d\n", SuperBlock->InodeSize);
    TRACE("BlockGroupNr: %d\n", SuperBlock->BlockGroupNr);
    TRACE("FeatureCompat: 0x%x\n", SuperBlock->FeatureCompat);
    TRACE("FeatureIncompat: 0x%x\n", SuperBlock->FeatureIncompat);
    TRACE("FeatureROCompat: 0x%x\n", SuperBlock->FeatureROCompat);
    TRACE("UUID: { ");
    for (ULONG i = 0; i < sizeof(SuperBlock->UUID); i++)
    {
        TRACE("0x%02x", SuperBlock->UUID[i]);
        if (i < sizeof(SuperBlock->UUID) - 1)
            TRACE(", ");
    }
    TRACE(" }\n");
    TRACE("VolumeName: \"%s\"\n", SuperBlock->VolumeName);
    TRACE("LastMounted: \"%s\"\n", SuperBlock->LastMounted);
    TRACE("AlgorithmUsageBitmap: 0x%x\n", SuperBlock->AlgorithmUsageBitmap);
    TRACE("PreallocBlocks: %d\n", SuperBlock->PreallocBlocks);
    TRACE("PreallocDirBlocks: %d\n", SuperBlock->PreallocDirBlocks);
    TRACE("ReservedGdtBlocks: %d\n", SuperBlock->ReservedGdtBlocks);
    TRACE("JournalUUID: { ");
    for (ULONG i = 0; i < sizeof(SuperBlock->JournalUUID); i++)
    {
        TRACE("0x%02x", SuperBlock->JournalUUID[i]);
        if (i < sizeof(SuperBlock->JournalUUID) - 1)
            TRACE(", ");
    }
    TRACE(" }\n");
    TRACE("JournalInum: %d\n", SuperBlock->JournalInum);
    TRACE("JournalDev: %d\n", SuperBlock->JournalDev);
    TRACE("LastOrphan: %d\n", SuperBlock->LastOrphan);
    TRACE("HashSeed: { 0x%02x, 0x%02x, 0x%02x, 0x%02x }\n",
        SuperBlock->HashSeed[0], SuperBlock->HashSeed[1],
        SuperBlock->HashSeed[2], SuperBlock->HashSeed[3]);
    TRACE("DefHashVersion: %d\n", SuperBlock->DefHashVersion);
    TRACE("JournalBackupType: %d\n", SuperBlock->JournalBackupType);
    TRACE("GroupDescSize: %d\n", SuperBlock->GroupDescSize);
    TRACE("DefaultMountOpts: %d\n", SuperBlock->DefaultMountOpts);
    TRACE("FirstMetaBg: %d\n", SuperBlock->FirstMetaBg);
    TRACE("MkfsTime: %d\n", SuperBlock->MkfsTime);
    // ULONG JnlBlocks[17];
    TRACE("BlocksCountHi: %d\n", SuperBlock->BlocksCountHi);
    TRACE("RBlocksCountHi: %d\n", SuperBlock->RBlocksCountHi);
    TRACE("FreeBlocksCountHi: %d\n", SuperBlock->FreeBlocksCountHi);
 
    //
    // Check the super block magic
    //
    if (SuperBlock->Magic != EXT_SUPERBLOCK_MAGIC)
    {
        FileSystemError("Invalid super block magic (0xef53)");
        return FALSE;
    }
 
    // Calculate the group count
    Volume->GroupCount = (SuperBlock->BlocksCountLo - SuperBlock->FirstDataBlock + SuperBlock->BlocksPerGroup - 1) / SuperBlock->BlocksPerGroup;
    TRACE("ExtGroupCount: %d\n", Volume->GroupCount);
 
    // Calculate the block size
    Volume->BlockSizeInBytes = 1024 << SuperBlock->LogBlockSize;
    Volume->BlockSizeInSectors = Volume->BlockSizeInBytes / Volume->BytesPerSector;
    TRACE("ExtBlockSizeInBytes: %d\n", Volume->BlockSizeInBytes);
    TRACE("ExtBlockSizeInSectors: %d\n", Volume->BlockSizeInSectors);
 
    // Calculate the fragment size
    if (SuperBlock->LogFragSize >= 0)
    {
        Volume->FragmentSizeInBytes = 1024 << SuperBlock->LogFragSize;
    }
    else
    {
        Volume->FragmentSizeInBytes = 1024 >> -(SuperBlock->LogFragSize);
    }
    Volume->FragmentSizeInSectors = Volume->FragmentSizeInBytes / Volume->BytesPerSector;
    TRACE("ExtFragmentSizeInBytes: %d\n", Volume->FragmentSizeInBytes);
    TRACE("ExtFragmentSizeInSectors: %d\n", Volume->FragmentSizeInSectors);
 
    // Verify that the fragment size and the block size are equal
    if (Volume->BlockSizeInBytes != Volume->FragmentSizeInBytes)
    {
        FileSystemError("The fragment size must be equal to the block size.");
        return FALSE;
    }
 
    // Set the volume inode size in bytes
    Volume->InodeSizeInBytes = EXT_INODE_SIZE(SuperBlock);
    TRACE("InodeSizeInBytes: %d\n", Volume->InodeSizeInBytes);
 
    // Set the volume group descriptor size in bytes
    Volume->GroupDescSizeInBytes = EXT_GROUP_DESC_SIZE(SuperBlock);
    TRACE("GroupDescSizeInBytes: %d\n", Volume->GroupDescSizeInBytes);
 
    // Calculate the number of inodes in one block
    Volume->InodesPerBlock = Volume->BlockSizeInBytes / Volume->InodeSizeInBytes;
    TRACE("ExtInodesPerBlock: %d\n", Volume->InodesPerBlock);
 
    // Calculate the number of group descriptors in one block
    Volume->GroupDescPerBlock = Volume->BlockSizeInBytes / Volume->GroupDescSizeInBytes;
    TRACE("ExtGroupDescPerBlock: %d\n", Volume->GroupDescPerBlock);
 
    return TRUE;
}

Referenced by ExtOpenVolume().

ExtReadVolumeSectors()

BOOLEAN ExtReadVolumeSectors	(	PEXT_VOLUME_INFO	Volume,
		ULONGLONG	SectorNumber,
		ULONG	SectorCount,
		PVOID	Buffer
	)

Definition at line 569 of file ext.c.

{
#if 0
    return CacheReadDiskSectors(DriveNumber, SectorNumber + ExtVolumeStartSector, SectorCount, Buffer);
#endif
 
    LARGE_INTEGER Position;
    ULONG Count;
    ARC_STATUS Status;
 
    /* Seek to right position */
    Position.QuadPart = (ULONGLONG)SectorNumber * 512;
    Status = ArcSeek(Volume->DeviceId, &Position, SeekAbsolute);
    if (Status != ESUCCESS)
    {
        TRACE("ExtReadVolumeSectors() Failed to seek\n");
        return FALSE;
    }
 
    /* Read data */
    Status = ArcRead(Volume->DeviceId, Buffer, SectorCount * 512, &Count);
    if (Status != ESUCCESS || Count != SectorCount * 512)
    {
        TRACE("ExtReadVolumeSectors() Failed to read\n");
        return FALSE;
    }
 
    /* Return success */
    return TRUE;
}

Referenced by ExtReadBlock().

ExtSearchDirectoryBufferForFile()

BOOLEAN ExtSearchDirectoryBufferForFile	(	PVOID	DirectoryBuffer,
		ULONG	DirectorySize,
		PCHAR	FileName,
		PEXT_DIR_ENTRY	DirectoryEntry
	)

Definition at line 330 of file ext.c.

{
    PEXT_DIR_ENTRY CurrentDirectoryEntry;
    ULONG CurrentOffset = 0;
    SIZE_T FileNameLen;
 
    TRACE("ExtSearchDirectoryBufferForFile() DirectoryBuffer = 0x%x DirectorySize = %d FileName = \"%s\"\n", DirectoryBuffer, DirectorySize, FileName);
 
    FileNameLen = strlen(FileName);
 
    while (CurrentOffset < DirectorySize)
    {
        CurrentDirectoryEntry = (PEXT_DIR_ENTRY)((ULONG_PTR)DirectoryBuffer + CurrentOffset);
 
        if (!CurrentDirectoryEntry->EntryLen)
            break;
 
        if ((CurrentDirectoryEntry->EntryLen + CurrentOffset) > DirectorySize)
        {
            FileSystemError("Directory entry extends past end of directory file.");
            return FALSE;
        }
 
        if (!CurrentDirectoryEntry->Inode)
            goto NextDirectoryEntry;
 
        TRACE("EXT Directory Entry:\n");
        TRACE("Inode = %d\n", CurrentDirectoryEntry->Inode);
        TRACE("EntryLen = %d\n", CurrentDirectoryEntry->EntryLen);
        TRACE("NameLen = %d\n", CurrentDirectoryEntry->NameLen);
        TRACE("FileType = %d\n", CurrentDirectoryEntry->FileType);
        TRACE("Name = \"");
        for (ULONG NameOffset = 0; NameOffset < CurrentDirectoryEntry->NameLen; NameOffset++)
        {
            TRACE("%c", CurrentDirectoryEntry->Name[NameOffset]);
        }
        TRACE("\"\n\n");
 
        if ((FileNameLen == CurrentDirectoryEntry->NameLen) &&
            (_strnicmp(FileName, CurrentDirectoryEntry->Name, FileNameLen) == 0))
        {
            RtlCopyMemory(DirectoryEntry, CurrentDirectoryEntry, sizeof(EXT_DIR_ENTRY));
            return TRUE;
        }
 
NextDirectoryEntry:
        CurrentOffset += CurrentDirectoryEntry->EntryLen;
    }
 
    return FALSE;
}

Referenced by ExtLookupFile().

ExtSeek()

ARC_STATUS ExtSeek	(	ULONG	FileId,
		LARGE_INTEGER *	Position,
		SEEKMODE	SeekMode
	)

Definition at line 1373 of file ext.c.

{
    PEXT_FILE_INFO FileHandle = FsGetDeviceSpecific(FileId);
    LARGE_INTEGER NewPosition = *Position;
 
    switch (SeekMode)
    {
        case SeekAbsolute:
            break;
        case SeekRelative:
            NewPosition.QuadPart += FileHandle->FilePointer;
            break;
        default:
            ASSERT(FALSE);
            return EINVAL;
    }
 
    if (NewPosition.QuadPart >= FileHandle->FileSize)
        return EINVAL;
 
    FileHandle->FilePointer = NewPosition.QuadPart;
    return ESUCCESS;
}

Variable Documentation

ExtFuncTable

const DEVVTBL ExtFuncTable

Initial value:

=
{
    ExtClose,
    ExtGetFileInformation,
    ExtOpen,
    ExtRead,
    ExtSeek,
    L"ext2fs",
}

Definition at line 1421 of file ext.c.

Referenced by ExtMount().

ExtVolumes

PEXT_VOLUME_INFO ExtVolumes[MAX_FDS]

Definition at line 70 of file ext.c.

Referenced by ExtGetVolumeSize(), ExtMount(), and ExtOpen().