Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-09 16:20:37 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/lib/fslib/ext2lib/Memory.c
Amine Khaldi c424146e2c Create a branch for cmake bringup. 
svn path=/branches/cmake-bringup/; revision=48236
2010-07-24 18:52:44 +00:00

416 lines
9.1 KiB
C
Raw Blame History

/*
* PROJECT: Mke2fs
* FILE: Memory.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 *************************************************************/
/*
* Return the group # of an inode number
*/
int ext2_group_of_ino(PEXT2_FILESYS fs, ULONG ino)
{
return (ino - 1) / fs->ext2_sb->s_inodes_per_group;
}
/*
* Return the group # of a block
*/
int ext2_group_of_blk(PEXT2_FILESYS fs, ULONG blk)
{
return (blk - fs->ext2_sb->s_first_data_block) /
fs->ext2_sb->s_blocks_per_group;
}
void ext2_inode_alloc_stats2(PEXT2_FILESYS fs, ULONG ino,
int inuse, int isdir)
{
int group = ext2_group_of_ino(fs, ino);
if (inuse > 0)
ext2_mark_inode_bitmap(fs->inode_map, ino);
else
ext2_unmark_inode_bitmap(fs->inode_map, ino);
fs->group_desc[group].bg_free_inodes_count -= inuse;
if (isdir)
fs->group_desc[group].bg_used_dirs_count += inuse;
fs->ext2_sb->s_free_inodes_count -= inuse;
}
void ext2_inode_alloc_stats(PEXT2_FILESYS fs, ULONG ino, int inuse)
{
ext2_inode_alloc_stats2(fs, ino, inuse, 0);
}
void ext2_block_alloc_stats(PEXT2_FILESYS fs, ULONG blk, int inuse)
{
int group = ext2_group_of_blk(fs, blk);
if (inuse > 0)
ext2_mark_block_bitmap(fs->block_map, blk);
else
ext2_unmark_block_bitmap(fs->block_map, blk);
fs->group_desc[group].bg_free_blocks_count -= inuse;
fs->ext2_sb->s_free_blocks_count -= inuse;
}
bool ext2_allocate_tables(PEXT2_FILESYS Ext2Sys)
{
bool retval;
ULONG i;
for (i = 0; i < Ext2Sys->group_desc_count; i++)
{
retval = ext2_allocate_group_table(Ext2Sys, i, Ext2Sys->block_map);
if (!retval)
return retval;
}
return true;
}
bool ext2_allocate_group_table(PEXT2_FILESYS fs, ULONG group,
PEXT2_BLOCK_BITMAP bmap)
{
bool retval;
ULONG group_blk, start_blk, last_blk, new_blk, blk, j;
group_blk = fs->ext2_sb->s_first_data_block +
(group * fs->ext2_sb->s_blocks_per_group);
last_blk = group_blk + fs->ext2_sb->s_blocks_per_group;
if (last_blk >= fs->ext2_sb->s_blocks_count)
last_blk = fs->ext2_sb->s_blocks_count - 1;
start_blk = group_blk + 3 + fs->desc_blocks;
if (start_blk > last_blk)
start_blk = group_blk;
if (!bmap)
bmap = fs->block_map;
/*
* Allocate the inode table
*/
if (!fs->group_desc[group].bg_inode_table)
{
retval = ext2_get_free_blocks(fs, start_blk, last_blk,
fs->inode_blocks_per_group,
bmap, &new_blk);
if (!retval)
return retval;
for (j=0, blk = new_blk;
j < fs->inode_blocks_per_group;
j++, blk++)
ext2_mark_block_bitmap(bmap, blk);
fs->group_desc[group].bg_inode_table = new_blk;
}
/*
* Allocate the block and inode bitmaps, if necessary
*/
if (fs->stride)
{
start_blk += fs->inode_blocks_per_group;
start_blk += ((fs->stride * group) %
(last_blk - start_blk));
if (start_blk > last_blk)
/* should never happen */
start_blk = group_blk;
}
else
{
start_blk = group_blk;
}
if (!fs->group_desc[group].bg_block_bitmap)
{
retval = ext2_get_free_blocks(fs, start_blk, last_blk,
1, bmap, &new_blk);
if (!retval)
retval = ext2_get_free_blocks(fs, group_blk,
last_blk, 1, bmap, &new_blk);
if (!retval)
return retval;
ext2_mark_block_bitmap(bmap, new_blk);
fs->group_desc[group].bg_block_bitmap = new_blk;
}
if (!fs->group_desc[group].bg_inode_bitmap)
{
retval = ext2_get_free_blocks(fs, start_blk, last_blk,
1, bmap, &new_blk);
if (!retval)
retval = ext2_get_free_blocks(fs, group_blk,
last_blk, 1, bmap, &new_blk);
if (!retval)
return retval;
ext2_mark_block_bitmap(bmap, new_blk);
fs->group_desc[group].bg_inode_bitmap = new_blk;
}
return true;
}
bool ext2_get_free_blocks(PEXT2_FILESYS fs, ULONG start, ULONG finish,
int num, PEXT2_BLOCK_BITMAP map, ULONG *ret)
{
ULONG b = start;
if (!map)
map = fs->block_map;
if (!map)
return false;
if (!b)
b = fs->ext2_sb->s_first_data_block;
if (!finish)
finish = start;
if (!num)
num = 1;
do
{
if (b+num-1 > fs->ext2_sb->s_blocks_count)
b = fs->ext2_sb->s_first_data_block;
if (ext2_test_block_bitmap_range(map, b, num))
{
*ret = b;
return true;
}
b++;
} while (b != finish);
return false;
}
bool write_inode_tables(PEXT2_FILESYS fs)
{
bool retval;
ULONG blk, num;
int i;
for (i = 0; (ULONG)i < fs->group_desc_count; i++)
{
blk = fs->group_desc[i].bg_inode_table;
num = fs->inode_blocks_per_group;
retval = zero_blocks(fs, blk, num, &blk, &num);
if (!retval)
{
DPRINT1("\nMke2fs: Could not write %lu blocks "
"in inode table starting at %lu.\n",
num, blk);
zero_blocks(0, 0, 0, 0, 0);
return false;
}
}
zero_blocks(0, 0, 0, 0, 0);
return true;
}
/*
* Stupid algorithm --- we now just search forward starting from the
* goal. Should put in a smarter one someday....
*/
bool ext2_new_block(PEXT2_FILESYS fs, ULONG goal,
PEXT2_BLOCK_BITMAP map, ULONG *ret)
{
ULONG i;
if (!map)
map = fs->block_map;
if (!map)
return false;
if (!goal || (goal >= fs->ext2_sb->s_blocks_count))
goal = fs->ext2_sb->s_first_data_block;
i = goal;
do
{
if (!ext2_test_block_bitmap(map, i))
{
*ret = i;
return true;
}
i++;
if (i >= fs->ext2_sb->s_blocks_count)
i = fs->ext2_sb->s_first_data_block;
} while (i != goal);
return false;
}
/*
* This function zeros out the allocated block, and updates all of the
* appropriate filesystem records.
*/
bool ext2_alloc_block(PEXT2_FILESYS fs, ULONG goal, ULONG *ret)
{
bool retval;
ULONG block;
char *buf = NULL;
buf = (char *)RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, fs->blocksize);
if (!buf)
return false;
if (!fs->block_map)
{
retval = ext2_read_block_bitmap(fs);
if (!retval)
goto fail;
}
retval = ext2_new_block(fs, goal, 0, &block);
if (!retval)
goto fail;
retval = NT_SUCCESS(Ext2WriteDisk(
fs,
((LONGLONG)block * fs->blocksize),
fs->blocksize, (unsigned char *)buf));
if (!retval)
{
goto fail;
}
ext2_block_alloc_stats(fs, block, +1);
*ret = block;
if (buf)
{
RtlFreeHeap(RtlGetProcessHeap(), 0, buf);
}
return true;
fail:
if (buf)
{
RtlFreeHeap(RtlGetProcessHeap(), 0, buf);
}
return false;
}
/*
* Create new directory block
*/
bool ext2_new_dir_block(PEXT2_FILESYS fs, ULONG dir_ino,
ULONG parent_ino, char **block)
{
PEXT2_DIR_ENTRY dir = NULL;
char *buf;
int rec_len;
int filetype = 0;
buf = (char *)RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, fs->blocksize);
if (!buf)
return false;
dir = (PEXT2_DIR_ENTRY) buf;
dir->rec_len = fs->blocksize;
if (dir_ino)
{
if (fs->ext2_sb->s_feature_incompat &
EXT2_FEATURE_INCOMPAT_FILETYPE)
filetype = EXT2_FT_DIR << 8;
/*
* Set up entry for '.'
*/
dir->inode = dir_ino;
dir->name_len = 1 | filetype;
dir->name[0] = '.';
rec_len = dir->rec_len - EXT2_DIR_REC_LEN(1);
dir->rec_len = EXT2_DIR_REC_LEN(1);
/*
* Set up entry for '..'
*/
dir = (struct ext2_dir_entry *) (buf + dir->rec_len);
dir->rec_len = rec_len;
dir->inode = parent_ino;
dir->name_len = 2 | filetype;
dir->name[0] = '.';
dir->name[1] = '.';
}
*block = buf;
return true;
}
bool ext2_write_block(PEXT2_FILESYS fs, ULONG block, void *inbuf)
{
bool retval = false;
retval = NT_SUCCESS(Ext2WriteDisk(
fs,
((ULONGLONG)block * fs->blocksize),
fs->blocksize, (unsigned char *)inbuf));
return retval;
}
bool ext2_read_block(PEXT2_FILESYS fs, ULONG block, void *inbuf)
{
bool retval = false;
retval = NT_SUCCESS(Ext2ReadDisk(
fs,
((ULONGLONG)block * fs->blocksize),
fs->blocksize, (unsigned char *)inbuf));
return retval;
}
Reference in a new issue View git blame Copy permalink