Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-18 21:13:52 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/sdk/lib/fslib/ext2lib/Inode.c

695 lines
16 KiB
C
Raw Blame History

/*
* PROJECT: Mke2fs
* FILE: Inode.c
* PROGRAMMER: Matt Wu <mattwu@163.com>
* HOMEPAGE: http://ext2.yeah.net
*/
/* INCLUDES **************************************************************/
#include "Mke2fs.h"
#include <debug.h>
/* DEFINITIONS ***********************************************************/
extern char *device_name;
/* FUNCTIONS *************************************************************/
bool ext2_get_inode_lba(PEXT2_FILESYS Ext2Sys, ULONG no, LONGLONG *offset)
{
LONGLONG loc = 0;
PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
if (no < 1 || no > pExt2Sb->s_inodes_count)
{
DPRINT1("Mke2fs: Inode value %lu was out of range in load_inode.(1-%ld)\n",
no, pExt2Sb->s_inodes_count);
*offset = 0;
return false;
}
loc = (LONGLONG)(Ext2Sys->blocksize) * Ext2Sys->group_desc[(no - 1) / pExt2Sb->s_inodes_per_group].bg_inode_table +
((no - 1) % pExt2Sb->s_inodes_per_group) * sizeof(EXT2_INODE);
*offset = loc;
return true;
}
bool ext2_load_inode(PEXT2_FILESYS Ext2Sys, ULONG no, PEXT2_INODE pInode)
{
LONGLONG Offset;
bool bRet = false;
if (ext2_get_inode_lba(Ext2Sys, no, &Offset))
{
bRet = NT_SUCCESS(Ext2ReadDisk(
Ext2Sys,
Offset,
sizeof(EXT2_INODE),
(unsigned char *)pInode));
}
return bRet;
}
bool ext2_save_inode(PEXT2_FILESYS Ext2Sys, ULONG no, PEXT2_INODE pInode)
{
LONGLONG offset;
bool bRet = false;
if (ext2_get_inode_lba(Ext2Sys, no, &offset))
{
bRet = NT_SUCCESS(Ext2WriteDisk(
Ext2Sys,
offset,
sizeof(EXT2_INODE),
(unsigned char *)pInode));
}
return bRet;
}
/*
* Right now, just search forward from the parent directory's block
* group to find the next free inode.
*
* Should have a special policy for directories.
*/
bool ext2_new_inode(PEXT2_FILESYS fs, ULONG dir, int mode,
PEXT2_INODE_BITMAP map, ULONG *ret)
{
ULONG dir_group = 0;
ULONG i;
ULONG start_inode;
if (!map)
map = fs->inode_map;
if (!map)
return false;
if (dir > 0)
dir_group = (dir - 1) / EXT2_INODES_PER_GROUP(fs->ext2_sb);
start_inode = (dir_group * EXT2_INODES_PER_GROUP(fs->ext2_sb)) + 1;
if (start_inode < EXT2_FIRST_INODE(fs->ext2_sb))
start_inode = EXT2_FIRST_INODE(fs->ext2_sb);
i = start_inode;
do
{
if (!ext2_test_inode_bitmap(map, i))
break;
i++;
if (i > fs->ext2_sb->s_inodes_count)
i = EXT2_FIRST_INODE(fs->ext2_sb);
} while (i != start_inode);
if (ext2_test_inode_bitmap(map, i))
return false;
*ret = i;
return true;
}
bool ext2_expand_block( PEXT2_FILESYS Ext2Sys, PEXT2_INODE Inode,
ULONG dwContent, ULONG Index, int layer,
ULONG newBlk, ULONG *dwRet, ULONG *off )
{
ULONG *pData = NULL;
ULONG i = 0, j = 0, temp = 1;
ULONG dwBlk;
ULONG dwNewBlk = newBlk;
bool bDirty = false;
bool bRet = true;
ULONG Offset = 0;
PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
pData = (ULONG *)RtlAllocateHeap(RtlGetProcessHeap(), 0, Ext2Sys->blocksize);
if (!pData)
{
bRet = false;
goto errorout;
}
if (!ext2_read_block(Ext2Sys, dwContent, (void *)pData))
{
bRet = false;
goto errorout;
}
if (layer == 1)
{
*dwRet = dwContent;
*off = Index;
pData[Index] = newBlk;
bDirty = TRUE;
}
else if (layer <= 3)
{
temp = 1 << ((10 + pExt2Sb->s_log_block_size - 2) * (layer - 1));
i = Index / temp;
j = Index % temp;
dwBlk = pData[i];
if (dwBlk == 0)
{
if (ext2_alloc_block(Ext2Sys, 0, &dwBlk) )
{
pData[i] = dwBlk;
bDirty = true;
Inode->i_blocks += (Ext2Sys->blocksize / SECTOR_SIZE);
}
if (!bDirty)
goto errorout;
}
if (!ext2_expand_block(Ext2Sys, Inode, dwBlk, j, layer - 1, bDirty, &dwNewBlk, &Offset))
{
bRet = false;
DPRINT1("Mke2fs: ext2_expand_block: ... error recuise...\n");
goto errorout;
}
}
if (bDirty)
{
bRet = ext2_write_block(Ext2Sys, dwContent, (void *)pData);
}
errorout:
if (pData)
RtlFreeHeap(RtlGetProcessHeap(), 0, pData);
if (bRet && dwRet)
*dwRet = dwNewBlk;
return bRet;
}
bool ext2_expand_inode( PEXT2_FILESYS Ext2Sys,
PEXT2_INODE Inode,
ULONG newBlk )
{
ULONG dwSizes[4] = {12, 1, 1, 1};
ULONG Index = 0;
ULONG dwTotal = 0;
ULONG dwBlk = 0, dwNewBlk = 0, Offset = 0;
PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
int i = 0;
bool bRet = true;
ULONG TotalBlocks;
TotalBlocks = Inode->i_blocks / (Ext2Sys->blocksize / SECTOR_SIZE);
Index = Ext2DataBlocks(Ext2Sys, TotalBlocks);
for (i = 0; i < 4; i++)
{
dwSizes[i] = dwSizes[i] << ((10 + pExt2Sb->s_log_block_size - 2) * i);
dwTotal += dwSizes[i];
}
if (Index >= dwTotal)
{
DPRINT1("Mke2fs: ext2_expand_inode: beyond the maxinum size of an inode.\n");
return false;
}
for (i = 0; i < 4; i++)
{
if (Index < dwSizes[i])
{
if (i == 0)
{
Inode->i_block[Index] = newBlk;
}
else
{
dwBlk = Inode->i_block[(i + 12 - 1)];
if (dwBlk == 0)
{
if (ext2_alloc_block(Ext2Sys, 0, &dwBlk))
{
Inode->i_block[(i + 12 - 1)] = dwBlk;
Inode->i_blocks += (Ext2Sys->blocksize / SECTOR_SIZE);
}
else
{
break;
}
}
dwNewBlk = 0;
bRet = ext2_expand_block(
Ext2Sys,
Inode,
dwBlk,
Index,
i,
newBlk,
&dwNewBlk,
&Offset );
}
break;
}
Index -= dwSizes[i];
}
return bRet;
}
bool ext2_get_block(PEXT2_FILESYS Ext2Sys, ULONG dwContent, ULONG Index, int layer, ULONG *dwRet)
{
ULONG *pData = NULL;
LONGLONG Offset = 0;
ULONG i = 0, j = 0, temp = 1;
ULONG dwBlk = 0;
bool bRet = true;
PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
Offset = (LONGLONG) dwContent;
Offset = Offset * Ext2Sys->blocksize;
pData = (ULONG *)RtlAllocateHeap(RtlGetProcessHeap(), 0, Ext2Sys->blocksize);
if (!pData)
{
return false;
}
memset(pData, 0, Ext2Sys->blocksize);
if (layer == 0)
{
dwBlk = dwContent;
}
else if (layer <= 3)
{
if (!ext2_read_block(Ext2Sys, dwContent, (void *)pData))
{
bRet = false;
goto errorout;
}
temp = 1 << ((10 + pExt2Sb->s_log_block_size - 2) * (layer - 1));
i = Index / temp;
j = Index % temp;
if (!ext2_get_block(Ext2Sys, pData[i], j, layer - 1, &dwBlk))
{
bRet = false;
DPRINT1("Mke2fs: ext2_get_block: ... error recuise...\n");
goto errorout;
}
}
errorout:
if (pData)
RtlFreeHeap(RtlGetProcessHeap(), 0, pData);
if (bRet && dwRet)
*dwRet = dwBlk;
return bRet;
}
bool ext2_block_map(PEXT2_FILESYS Ext2Sys, PEXT2_INODE inode, ULONG block, ULONG *dwRet)
{
ULONG dwSizes[4] = { 12, 1, 1, 1 };
ULONG Index = 0;
ULONG dwBlk = 0;
PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
UINT i;
bool bRet = false;
Index = block;
for (i = 0; i < 4; i++)
{
dwSizes[i] = dwSizes[i] << ((10 + pExt2Sb->s_log_block_size - 2) * i);
}
if (Index >= inode->i_blocks / (Ext2Sys->blocksize / SECTOR_SIZE))
{
DPRINT1("Mke2fs: ext2_block_map: beyond the size of the inode.\n");
return false;
}
for (i = 0; i < 4; i++)
{
if (Index < dwSizes[i])
{
dwBlk = inode->i_block[i==0 ? (Index):(i + 12 - 1)];
bRet = ext2_get_block(Ext2Sys, dwBlk, Index , i, &dwBlk);
break;
}
Index -= dwSizes[i];
}
if (bRet && dwBlk)
{
if (dwRet)
*dwRet = dwBlk;
return true;
}
else
return false;
}
ULONG ext2_build_bdl(PEXT2_FILESYS Ext2Sys,
PEXT2_INODE ext2_inode,
IN ULONG offset,
IN ULONG size,
OUT PEXT2_BDL *ext2_bdl )
{
ULONG nBeg, nEnd, nBlocks;
ULONG dwBlk;
ULONG i;
ULONG dwBytes = 0;
LONGLONG lba;
PEXT2_BDL ext2bdl = NULL;
*ext2_bdl = NULL;
if (offset >= ext2_inode->i_size)
{
DPRINT1("Mke2fs: ext2_build_bdl: beyond the file range.\n");
return 0;
}
/*
if (offset + size > ext2_inode->i_size)
{
size = ext2_inode->i_size - offset;
}
*/
nBeg = offset / Ext2Sys->blocksize;
nEnd = (size + offset + Ext2Sys->blocksize - 1) / Ext2Sys->blocksize;
nBlocks = nEnd - nBeg;
if (nBlocks > 0)
{
ext2bdl = (PEXT2_BDL)
RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(EXT2_BDL) * nBlocks);
if (ext2bdl)
{
memset(ext2bdl, 0, sizeof(EXT2_BDL) * nBlocks);
for (i = nBeg; i < nEnd; i++)
{
if (!ext2_block_map(Ext2Sys, ext2_inode, i, &dwBlk))
{
goto fail;
}
lba = (LONGLONG) dwBlk;
lba = lba * Ext2Sys->blocksize;
if (nBlocks == 1) // ie. (nBeg == nEnd - 1)
{
dwBytes = size;
ext2bdl[i - nBeg].Lba = lba + (LONGLONG)(offset % (Ext2Sys->blocksize));
ext2bdl[i - nBeg].Length = dwBytes;
ext2bdl[i - nBeg].Offset = 0;
}
else
{
if (i == nBeg)
{
dwBytes = Ext2Sys->blocksize - (offset % (Ext2Sys->blocksize));
ext2bdl[i - nBeg].Lba = lba + (LONGLONG)(offset % (Ext2Sys->blocksize));
ext2bdl[i - nBeg].Length = dwBytes;
ext2bdl[i - nBeg].Offset = 0;
}
else if (i == nEnd - 1)
{
ext2bdl[i - nBeg].Lba = lba;
ext2bdl[i - nBeg].Length = size - dwBytes;
ext2bdl[i - nBeg].Offset = dwBytes;
dwBytes = size;
}
else
{
ext2bdl[i - nBeg].Lba = lba;
ext2bdl[i - nBeg].Length = Ext2Sys->blocksize;
ext2bdl[i - nBeg].Offset = dwBytes;
dwBytes += Ext2Sys->blocksize;
}
}
}
*ext2_bdl = ext2bdl;
return nBlocks;
}
}
fail:
if (ext2bdl)
RtlFreeHeap(RtlGetProcessHeap(), 0, ext2bdl);
// Error
return 0;
}
bool ext2_read_inode(PEXT2_FILESYS Ext2Sys,
ULONG ino,
ULONG offset,
PVOID Buffer,
ULONG size,
PULONG dwReturn)
{
PEXT2_BDL ext2_bdl = NULL;
ULONG blocks, i;
bool bRet = true;
EXT2_INODE ext2_inode;
ULONG dwTotal = 0;
if (!ext2_load_inode(Ext2Sys, ino, &ext2_inode))
{
return false;
}
blocks = ext2_build_bdl(Ext2Sys, &ext2_inode, offset, size, &ext2_bdl);
if (blocks <= 0)
return false;
for(i = 0; i < blocks; i++)
{
bRet = NT_SUCCESS(Ext2ReadDisk(
Ext2Sys,
ext2_bdl[i].Lba,
ext2_bdl[i].Length,
(PUCHAR)Buffer + ext2_bdl[i].Offset
));
if (!bRet)
break;
dwTotal += ext2_bdl[i].Length;
}
*dwReturn = dwTotal;
if (ext2_bdl)
RtlFreeHeap(RtlGetProcessHeap(), 0, ext2_bdl);
return bRet;
}
bool ext2_write_inode (PEXT2_FILESYS Ext2Sys,
ULONG ino,
ULONG offset,
PVOID Buffer,
ULONG size,
PULONG dwReturn )
{
PEXT2_BDL ext2_bdl = NULL;
ULONG blocks, i;
bool bRet = true;
EXT2_INODE inode;
ULONG dwTotal = 0;
ULONG dwBlk = 0;
ULONG TotalBlks;
blocks = (size + offset + Ext2Sys->blocksize - 1) / Ext2Sys->blocksize;
if (!ext2_load_inode(Ext2Sys, ino, &inode))
{
return false;
}
TotalBlks = inode.i_blocks / (Ext2Sys->blocksize / SECTOR_SIZE);
TotalBlks = Ext2DataBlocks(Ext2Sys, TotalBlks);
if (blocks > TotalBlks)
{
for (i=0; i < (blocks - TotalBlks); i++)
{
if (ext2_alloc_block(Ext2Sys, 0, &dwBlk) )
{
ext2_expand_inode(Ext2Sys, &inode, dwBlk);
inode.i_blocks += (Ext2Sys->blocksize/SECTOR_SIZE);
}
}
}
blocks = ext2_build_bdl(Ext2Sys, &inode, offset, size, &ext2_bdl);
if (blocks <= 0)
return false;
for(i = 0; i < blocks; i++)
{
bRet = NT_SUCCESS(Ext2WriteDisk(
Ext2Sys,
ext2_bdl[i].Lba,
ext2_bdl[i].Length,
(PUCHAR)Buffer + ext2_bdl[i].Offset
));
if (!bRet)
{
goto errorout;
}
dwTotal += ext2_bdl[i].Length;
}
*dwReturn = dwTotal;
if (size + offset > inode.i_size)
{
inode.i_size = size + offset;
}
ext2_save_inode(Ext2Sys, ino, &inode);
errorout:
if (ext2_bdl)
RtlFreeHeap(RtlGetProcessHeap(), 0, ext2_bdl);
return bRet;
}
bool
ext2_add_entry( PEXT2_FILESYS Ext2Sys,
ULONG parent, ULONG inode,
int filetype, char *name )
{
PEXT2_DIR_ENTRY2 dir = NULL, newdir = NULL;
EXT2_INODE parent_inode;
ULONG dwRet;
char *buf;
int rec_len;
bool bRet = false;
rec_len = EXT2_DIR_REC_LEN(strlen(name));
if (!ext2_load_inode(Ext2Sys, parent, &parent_inode))
{
return false;
}
buf = (char *)RtlAllocateHeap(RtlGetProcessHeap(), 0, parent_inode.i_size);
if (!ext2_read_inode(Ext2Sys, parent, 0, buf, parent_inode.i_size, &dwRet))
{
return false;
}
dir = (PEXT2_DIR_ENTRY2) buf;
while ((char *)dir < buf + parent_inode.i_size)
{
if ((dir->inode == 0 && dir->rec_len >= rec_len) ||
(dir->rec_len >= dir->name_len + rec_len) )
{
if (dir->inode)
{
newdir = (PEXT2_DIR_ENTRY2) ((PUCHAR)dir + EXT2_DIR_REC_LEN(dir->name_len));
newdir->rec_len = dir->rec_len - EXT2_DIR_REC_LEN(dir->name_len);
dir->rec_len = EXT2_DIR_REC_LEN(dir->name_len);
dir = newdir;
}
dir->file_type = filetype;
dir->inode = inode;
dir->name_len = strlen(name);
memcpy(dir->name, name, strlen(name));
bRet = true;
break;
}
dir = (PEXT2_DIR_ENTRY2) (dir->rec_len + (PUCHAR) dir);
}
if (bRet)
return ext2_write_inode(Ext2Sys, parent, 0, buf, parent_inode.i_size, &dwRet);
return bRet;
}
bool ext2_reserve_inodes(PEXT2_FILESYS fs)
{
ULONG i;
int group;
for (i = EXT2_ROOT_INO + 1; i < EXT2_FIRST_INODE(fs->ext2_sb); i++)
{
ext2_mark_inode_bitmap(fs->inode_map, i);
group = ext2_group_of_ino(fs, i);
fs->group_desc[group].bg_free_inodes_count--;
fs->ext2_sb->s_free_inodes_count--;
}
return true;
}
Reference in a new issue View git blame Copy permalink