Memory.c File Reference

#include "Mke2fs.h"
#include <debug.h>

Include dependency graph for Memory.c:

Go to the source code of this file.

Functions
int	ext2_group_of_ino (PEXT2_FILESYS fs, ULONG ino)
int	ext2_group_of_blk (PEXT2_FILESYS fs, ULONG blk)
void	ext2_inode_alloc_stats2 (PEXT2_FILESYS fs, ULONG ino, int inuse, int isdir)
void	ext2_inode_alloc_stats (PEXT2_FILESYS fs, ULONG ino, int inuse)
void	ext2_block_alloc_stats (PEXT2_FILESYS fs, ULONG blk, int inuse)
bool	ext2_allocate_tables (PEXT2_FILESYS Ext2Sys)
bool	ext2_allocate_group_table (PEXT2_FILESYS fs, ULONG group, PEXT2_BLOCK_BITMAP bmap)
bool	ext2_get_free_blocks (PEXT2_FILESYS fs, ULONG start, ULONG finish, int num, PEXT2_BLOCK_BITMAP map, ULONG *ret)
bool	write_inode_tables (PEXT2_FILESYS fs)
bool	ext2_new_block (PEXT2_FILESYS fs, ULONG goal, PEXT2_BLOCK_BITMAP map, ULONG *ret)
bool	ext2_alloc_block (PEXT2_FILESYS fs, ULONG goal, ULONG *ret)
bool	ext2_new_dir_block (PEXT2_FILESYS fs, ULONG dir_ino, ULONG parent_ino, char **block)
bool	ext2_write_block (PEXT2_FILESYS fs, ULONG block, void *inbuf)
bool	ext2_read_block (PEXT2_FILESYS fs, ULONG block, void *inbuf)

Variables
char *	device_name

Function Documentation

ext2_alloc_block()

bool ext2_alloc_block	(	PEXT2_FILESYS	fs,
		ULONG	goal,
		ULONG *	ret
	)

Definition at line 293 of file Memory.c.

{
    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;
}

Referenced by create_lost_and_found(), ext2_expand_block(), ext2_expand_inode(), and ext2_write_inode().

ext2_allocate_group_table()

bool ext2_allocate_group_table	(	PEXT2_FILESYS	fs,
		ULONG	group,
		PEXT2_BLOCK_BITMAP	bmap
	)

Definition at line 92 of file Memory.c.

{
    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;
}

Referenced by ext2_allocate_tables().

ext2_allocate_tables()

bool ext2_allocate_tables

(

PEXT2_FILESYS

Ext2Sys

)

Definition at line 75 of file Memory.c.

{
    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;
}

Referenced by Ext2Format().

ext2_block_alloc_stats()

void ext2_block_alloc_stats	(	PEXT2_FILESYS	fs,
		ULONG	blk,
		int	inuse
	)

Definition at line 61 of file Memory.c.

{
    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;
}

Referenced by ext2_alloc_block(), and ext2_mkdir().

ext2_get_free_blocks()

bool ext2_get_free_blocks	(	PEXT2_FILESYS	fs,
		ULONG	start,
		ULONG	finish,
		int	num,
		PEXT2_BLOCK_BITMAP	map,
		ULONG *	ret
	)

Definition at line 182 of file Memory.c.

{
    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;
}

Referenced by ext2_allocate_group_table().

ext2_group_of_blk()

int ext2_group_of_blk	(	PEXT2_FILESYS	fs,
		ULONG	blk
	)

Definition at line 31 of file Memory.c.

{
    return (blk - fs->ext2_sb->s_first_data_block) /
        fs->ext2_sb->s_blocks_per_group;
}

Referenced by ext2_block_alloc_stats().

ext2_group_of_ino()

int ext2_group_of_ino	(	PEXT2_FILESYS	fs,
		ULONG	ino
	)

Definition at line 23 of file Memory.c.

{
    return (ino - 1) / fs->ext2_sb->s_inodes_per_group;
}

Referenced by ext2_inode_alloc_stats2(), and ext2_reserve_inodes().

ext2_inode_alloc_stats()

void ext2_inode_alloc_stats	(	PEXT2_FILESYS	fs,
		ULONG	ino,
		int	inuse
	)

Definition at line 56 of file Memory.c.

{
    ext2_inode_alloc_stats2(fs, ino, inuse, 0);
}

ext2_inode_alloc_stats2()

void ext2_inode_alloc_stats2	(	PEXT2_FILESYS	fs,
		ULONG	ino,
		int	inuse,
		int	isdir
	)

Definition at line 37 of file Memory.c.

{
    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;
}

Referenced by ext2_inode_alloc_stats(), and ext2_mkdir().

ext2_new_block()

bool ext2_new_block	(	PEXT2_FILESYS	fs,
		ULONG	goal,
		PEXT2_BLOCK_BITMAP	map,
		ULONG *	ret
	)

Definition at line 254 of file Memory.c.

{
    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;
}

Referenced by ext2_alloc_block(), and ext2_mkdir().

ext2_new_dir_block()

bool ext2_new_dir_block	(	PEXT2_FILESYS	fs,
		ULONG	dir_ino,
		ULONG	parent_ino,
		char **	block
	)

Definition at line 349 of file Memory.c.

{
    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;
}

Referenced by ext2_mkdir().

ext2_read_block()

bool ext2_read_block	(	PEXT2_FILESYS	fs,
		ULONG	block,
		void *	inbuf
	)

Definition at line 406 of file Memory.c.

{
    bool    retval = false;
 
    retval = NT_SUCCESS(Ext2ReadDisk(
                fs,
                ((ULONGLONG)block * fs->blocksize),
                fs->blocksize, (unsigned char *)inbuf));
 
    return retval;
}

Referenced by ext2_expand_block(), and ext2_get_block().

ext2_write_block()

bool ext2_write_block	(	PEXT2_FILESYS	fs,
		ULONG	block,
		void *	inbuf
	)

Definition at line 394 of file Memory.c.

{
    bool    retval = false;
 
    retval = NT_SUCCESS(Ext2WriteDisk(
                fs,
                ((ULONGLONG)block * fs->blocksize),
                fs->blocksize, (unsigned char *)inbuf));
 
    return retval;
}

Referenced by create_lost_and_found(), ext2_expand_block(), and ext2_mkdir().

write_inode_tables()

bool write_inode_tables

(

PEXT2_FILESYS

fs

)

Definition at line 221 of file Memory.c.

{
    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;
}

Referenced by Ext2Format().

Variable Documentation

device_name

char* device_name

extern