Bitmap.c File Reference

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

Include dependency graph for Bitmap.c:

Go to the source code of this file.

Functions
bool	ext2_set_bit (int nr, void *addr)
bool	ext2_clear_bit (int nr, void *addr)
bool	ext2_test_bit (int nr, void *addr)
bool	ext2_mark_bitmap (PEXT2_BITMAP bitmap, ULONG bitno)
bool	ext2_unmark_bitmap (PEXT2_BITMAP bitmap, ULONG bitno)
bool	ext2_test_block_bitmap (PEXT2_BLOCK_BITMAP bitmap, ULONG block)
bool	ext2_test_block_bitmap_range (PEXT2_BLOCK_BITMAP bitmap, ULONG block, int num)
bool	ext2_test_inode_bitmap (PEXT2_BLOCK_BITMAP bitmap, ULONG inode)
bool	ext2_allocate_block_bitmap (PEXT2_FILESYS Ext2Sys)
bool	ext2_allocate_inode_bitmap (PEXT2_FILESYS Ext2Sys)
void	ext2_free_generic_bitmap (PEXT2_GENERIC_BITMAP bitmap)
void	ext2_free_inode_bitmap (PEXT2_FILESYS Ext2Sys)
void	ext2_free_block_bitmap (PEXT2_FILESYS Ext2Sys)
bool	ext2_write_inode_bitmap (PEXT2_FILESYS fs)
bool	ext2_write_block_bitmap (PEXT2_FILESYS fs)
bool	ext2_write_bitmaps (PEXT2_FILESYS fs)
bool	read_bitmaps (PEXT2_FILESYS fs, int do_inode, int do_block)
bool	ext2_read_inode_bitmap (PEXT2_FILESYS fs)
bool	ext2_read_block_bitmap (PEXT2_FILESYS fs)
bool	ext2_read_bitmaps (PEXT2_FILESYS fs)

Function Documentation

ext2_allocate_block_bitmap()

bool ext2_allocate_block_bitmap

(

PEXT2_FILESYS

Ext2Sys

)

Definition at line 100 of file Bitmap.c.

{
    ULONG   size = 0;
 
    PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
    Ext2Sys->block_map = (PEXT2_BLOCK_BITMAP)
        RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(EXT2_BLOCK_BITMAP));
 
    if (!Ext2Sys->block_map)
    {
        DPRINT1("Mke2fs: error allocating block bitmap...\n");
        return false;
    }
 
    memset(Ext2Sys->block_map, 0, sizeof(EXT2_BLOCK_BITMAP));
 
    Ext2Sys->block_map->start = pExt2Sb->s_first_data_block;
    Ext2Sys->block_map->end = pExt2Sb->s_blocks_count-1;
    Ext2Sys->block_map->real_end = (EXT2_BLOCKS_PER_GROUP(pExt2Sb)
        * Ext2Sys->group_desc_count) -1 + Ext2Sys->block_map->start;
 
    size = (((Ext2Sys->block_map->real_end - Ext2Sys->block_map->start) / 8) + 1);
 
    Ext2Sys->block_map->bitmap =
        (char *)RtlAllocateHeap(RtlGetProcessHeap(), 0, size);
 
    if (!Ext2Sys->block_map->bitmap)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Ext2Sys->block_map);
        Ext2Sys->block_map = NULL;
        DPRINT1("Mke2fs: error allocating block bitmap...\n");
        return false;
    }
 
    memset(Ext2Sys->block_map->bitmap, 0, size);
 
    return true;
}

Referenced by ext2_initialize_sb(), and read_bitmaps().

ext2_allocate_inode_bitmap()

bool ext2_allocate_inode_bitmap

(

PEXT2_FILESYS

Ext2Sys

)

Definition at line 140 of file Bitmap.c.

{
    ULONG   size = 0;
 
    PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
 
    Ext2Sys->inode_map = (PEXT2_INODE_BITMAP)
        RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(EXT2_INODE_BITMAP));
 
    if (!Ext2Sys->inode_map)
    {
        DPRINT1("Mke2fs: error allocating inode bitmap...\n");
        return false;
    }
 
    memset(Ext2Sys->inode_map, 0, sizeof(EXT2_INODE_BITMAP));
 
    Ext2Sys->inode_map->start = 1;
    Ext2Sys->inode_map->end = pExt2Sb->s_inodes_count;
    Ext2Sys->inode_map->real_end = (EXT2_INODES_PER_GROUP(pExt2Sb)
        * Ext2Sys->group_desc_count);
 
    size = (((Ext2Sys->inode_map->real_end - Ext2Sys->inode_map->start) / 8) + 1);
 
    Ext2Sys->inode_map->bitmap =
        (char *)RtlAllocateHeap(RtlGetProcessHeap(), 0, size);
 
    if (!Ext2Sys->inode_map->bitmap)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, Ext2Sys->inode_map);
        Ext2Sys->inode_map = NULL;
        DPRINT1("Mke2fs: error allocating block bitmap...\n");
        return false;
    }
 
    memset(Ext2Sys->inode_map->bitmap, 0, size);
 
    return true;
}

Referenced by ext2_initialize_sb(), and read_bitmaps().

ext2_clear_bit()

bool ext2_clear_bit	(	int	nr,
		void *	addr
	)

Definition at line 30 of file Bitmap.c.

{
    int     mask;
    unsigned char   *ADDR = (unsigned char *) addr;
 
    ADDR += nr >> 3;
    mask = 1 << (nr & 0x07);
    *ADDR &= ~mask;
    return true;
}

Referenced by ext2_unmark_bitmap().

ext2_free_block_bitmap()

void ext2_free_block_bitmap

(

PEXT2_FILESYS

Ext2Sys

)

Definition at line 205 of file Bitmap.c.

{
    PEXT2_BLOCK_BITMAP bitmap = Ext2Sys->block_map;
    if (!bitmap)
        return;
 
    ext2_free_generic_bitmap(bitmap);
 
    Ext2Sys->block_map = NULL;
}

Referenced by ext2_initialize_sb(), Ext2Format(), and read_bitmaps().

ext2_free_generic_bitmap()

void ext2_free_generic_bitmap

(

PEXT2_GENERIC_BITMAP

bitmap

)

Definition at line 180 of file Bitmap.c.

{
    if (!bitmap)
        return;
 
    if (bitmap->bitmap)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, bitmap->bitmap);
        bitmap->bitmap = 0;
    }
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, bitmap);
}

Referenced by ext2_free_block_bitmap(), and ext2_free_inode_bitmap().

ext2_free_inode_bitmap()

void ext2_free_inode_bitmap

(

PEXT2_FILESYS

Ext2Sys

)

Definition at line 194 of file Bitmap.c.

{
    PEXT2_INODE_BITMAP bitmap = Ext2Sys->inode_map;
    if (!bitmap)
        return;
 
    ext2_free_generic_bitmap(bitmap);
 
    Ext2Sys->inode_map = NULL;
}

Referenced by ext2_initialize_sb(), Ext2Format(), and read_bitmaps().

ext2_mark_bitmap()

bool ext2_mark_bitmap	(	PEXT2_BITMAP	bitmap,
		ULONG	bitno
	)

Definition at line 52 of file Bitmap.c.

{
    if ((bitno < bitmap->start) || (bitno > bitmap->end))
    {
        return false;
    }
 
    return ext2_set_bit(bitno - bitmap->start, bitmap->bitmap);
}

Referenced by ext2_initialize_sb().

ext2_read_bitmaps()

bool ext2_read_bitmaps

(

PEXT2_FILESYS

fs

)

Definition at line 492 of file Bitmap.c.

{
 
    if (fs->inode_map && fs->block_map)
        return 0;
 
    return read_bitmaps(fs, !fs->inode_map, !fs->block_map);
}

ext2_read_block_bitmap()

bool ext2_read_block_bitmap

(

PEXT2_FILESYS

fs

)

Definition at line 487 of file Bitmap.c.

{
    return read_bitmaps(fs, 0, 1);
}

Referenced by ext2_alloc_block().

ext2_read_inode_bitmap()

bool ext2_read_inode_bitmap

(

PEXT2_FILESYS

fs

)

Definition at line 482 of file Bitmap.c.

{
    return read_bitmaps(fs, 1, 0);
}

ext2_set_bit()

bool ext2_set_bit	(	int	nr,
		void *	addr
	)

Definition at line 18 of file Bitmap.c.

{
    int     mask;
    unsigned char *ADDR = (unsigned char *) addr;
 
    ADDR += nr >> 3;
    mask = 1 << (nr & 0x07);
    *ADDR |= mask;
 
    return true;
}

Referenced by ext2_mark_bitmap(), and ext2_write_block_bitmap().

ext2_test_bit()

bool ext2_test_bit	(	int	nr,
		void *	addr
	)

Definition at line 41 of file Bitmap.c.

{
    int         mask;
    const unsigned char *ADDR = (const unsigned char *) addr;
 
    ADDR += nr >> 3;
    mask = 1 << (nr & 0x07);
 
    return ((mask & *ADDR) != 0);
}

Referenced by ext2_test_block_bitmap(), and ext2_test_inode_bitmap().

ext2_test_block_bitmap()

bool ext2_test_block_bitmap	(	PEXT2_BLOCK_BITMAP	bitmap,
		ULONG	block
	)

Definition at line 73 of file Bitmap.c.

{
    return ext2_test_bit(block - bitmap->start, bitmap->bitmap);
}

Referenced by ext2_new_block(), and ext2_test_block_bitmap_range().

ext2_test_block_bitmap_range()

bool ext2_test_block_bitmap_range	(	PEXT2_BLOCK_BITMAP	bitmap,
		ULONG	block,
		int	num
	)

Definition at line 80 of file Bitmap.c.

{
    int i;
 
    for (i=0; i < num; i++)
    {
        if (ext2_test_block_bitmap(bitmap, block+i))
            return false;
    }
    return true;
}

Referenced by ext2_get_free_blocks().

ext2_test_inode_bitmap()

bool ext2_test_inode_bitmap	(	PEXT2_BLOCK_BITMAP	bitmap,
		ULONG	inode
	)

Definition at line 93 of file Bitmap.c.

{
    return ext2_test_bit(inode - bitmap->start, bitmap->bitmap);
}

Referenced by ext2_new_inode().

ext2_unmark_bitmap()

bool ext2_unmark_bitmap	(	PEXT2_BITMAP	bitmap,
		ULONG	bitno
	)

Definition at line 62 of file Bitmap.c.

{
    if ((bitno < bitmap->start) || (bitno > bitmap->end))
    {
        return false;
    }
 
    return ext2_clear_bit(bitno - bitmap->start, bitmap->bitmap);
}

ext2_write_bitmaps()

bool ext2_write_bitmaps

(

PEXT2_FILESYS

fs

)

Definition at line 342 of file Bitmap.c.

{
    bool    retval;
 
    if (fs->block_map) // && ext2fs_test_bb_dirty(fs))
    {
        retval = ext2_write_block_bitmap(fs);
        if (!retval)
            return retval;
    }
 
    if (fs->inode_map) // && ext2fs_test_ib_dirty(fs))
    {
        retval = ext2_write_inode_bitmap(fs);
        if (!retval)
            return retval;
    }
 
    return true;
}

Referenced by ext2_flush().

ext2_write_block_bitmap()

bool ext2_write_block_bitmap

(

PEXT2_FILESYS

fs

)

Definition at line 270 of file Bitmap.c.

{
    ULONG   i;
    int     j;
    int     nbytes;
    int     nbits;
    bool    retval;
    char    *block_bitmap = fs->block_map->bitmap;
    char    *bitmap_block = NULL;
    ULONG   blk;
 
    if (!block_bitmap)
        return false;
 
    nbytes = EXT2_BLOCKS_PER_GROUP(fs->ext2_sb) / 8;
 
    bitmap_block = (char *)RtlAllocateHeap(RtlGetProcessHeap(), 0, fs->blocksize);
    if (!bitmap_block)
        return false;
 
    memset(bitmap_block, 0xff, fs->blocksize);
 
    for (i = 0; i < fs->group_desc_count; i++)
    {
        memcpy(bitmap_block, block_bitmap, nbytes);
 
        if (i == fs->group_desc_count - 1)
        {
            /* Force bitmap padding for the last group */
            nbits = (int) ((fs->ext2_sb->s_blocks_count
                    - fs->ext2_sb->s_first_data_block)
                       % EXT2_BLOCKS_PER_GROUP(fs->ext2_sb));
 
            if (nbits)
            {
                for (j = nbits; j < fs->blocksize * 8; j++)
                {
                    ext2_set_bit(j, bitmap_block);
                }
            }
        }
 
        blk = fs->group_desc[i].bg_block_bitmap;
 
        if (blk)
        {
#ifdef EXT2_BIG_ENDIAN_BITMAPS
            if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
                  (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)))
                ext2_swap_bitmap(fs, bitmap_block, nbytes);
#endif
            retval = NT_SUCCESS(Ext2WriteDisk(
                        fs,
                        ((ULONGLONG)blk * fs->blocksize),
                        fs->blocksize,
                        (unsigned char *)bitmap_block));
 
            if (!retval)
            {
                RtlFreeHeap(RtlGetProcessHeap(), 0, bitmap_block);
                return false;
            }
        }
 
        block_bitmap += nbytes;
    }
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, bitmap_block);
 
    return true;
}

Referenced by ext2_write_bitmaps().

ext2_write_inode_bitmap()

bool ext2_write_inode_bitmap

(

PEXT2_FILESYS

fs

)

Definition at line 216 of file Bitmap.c.

{
    ULONG   i;
    ULONG   nbytes;
    bool    retval;
    char    *inode_bitmap = fs->inode_map->bitmap;
    char    *bitmap_block = NULL;
    ULONG   blk;
 
    if (!inode_bitmap)
        return false;
 
    nbytes = (size_t) ((EXT2_INODES_PER_GROUP(fs->ext2_sb)+7) / 8);
 
    bitmap_block = (char *)RtlAllocateHeap(RtlGetProcessHeap(), 0, fs->blocksize);
    if (!bitmap_block) return false;
 
    memset(bitmap_block, 0xff, fs->blocksize);
 
    for (i = 0; i < fs->group_desc_count; i++)
    {
        memcpy(bitmap_block, inode_bitmap, nbytes);
        blk = fs->group_desc[i].bg_inode_bitmap;
 
        if (blk)
        {
/*
#ifdef EXT2_BIG_ENDIAN_BITMAPS
            if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
                  (fs->flags & EXT2_FLAG_SWAP_BYTES_WRITE)))
                ext2_swap_bitmap(fs, bitmap_block, nbytes);
#endif
*/
            retval = NT_SUCCESS(Ext2WriteDisk(
                    fs,
                    ((ULONGLONG)blk * fs->blocksize),
                    fs->blocksize,
                    (unsigned char *)bitmap_block));
 
            if (!retval)
            {
                RtlFreeHeap(RtlGetProcessHeap(), 0, bitmap_block);
                return false;
            }
        }
 
        inode_bitmap += nbytes;
    }
 
    RtlFreeHeap(RtlGetProcessHeap(), 0, bitmap_block);
 
    return true;
}

Referenced by ext2_write_bitmaps().

read_bitmaps()

bool read_bitmaps	(	PEXT2_FILESYS	fs,
		int	do_inode,
		int	do_block
	)

Definition at line 364 of file Bitmap.c.

{
    ULONG i;
    char *block_bitmap = 0, *inode_bitmap = 0;
    bool retval = false;
    ULONG block_nbytes = EXT2_BLOCKS_PER_GROUP(fs->ext2_sb) / 8;
    ULONG inode_nbytes = EXT2_INODES_PER_GROUP(fs->ext2_sb) / 8;
    ULONG blk;
 
//  fs->write_bitmaps = ext2_write_bitmaps;
 
    if (do_block)
    {
        if (fs->block_map)
            ext2_free_block_bitmap(fs);
 
        retval = ext2_allocate_block_bitmap(fs);
 
        if (!retval)
            goto cleanup;
 
        block_bitmap = fs->block_map->bitmap;
    }
 
    if (do_inode)
    {
        if (fs->inode_map)
            ext2_free_inode_bitmap(fs);
 
        retval = ext2_allocate_inode_bitmap(fs);
        if (!retval)
            goto cleanup;
 
        inode_bitmap = fs->inode_map->bitmap;
    }
 
    for (i = 0; i < fs->group_desc_count; i++)
    {
        if (block_bitmap)
        {
            blk = fs->group_desc[i].bg_block_bitmap;
 
            if (blk)
            {
                retval = NT_SUCCESS(Ext2ReadDisk(
                            fs,
                            ((ULONGLONG)blk * fs->blocksize),
                            block_nbytes,
                            (unsigned char *) block_bitmap));
 
                if (!retval)
                {
                    goto cleanup;
                }
 
#ifdef EXT2_BIG_ENDIAN_BITMAPS
                if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
                      (fs->flags & EXT2_FLAG_SWAP_BYTES_READ)))
                    ext2_swap_bitmap(fs, block_bitmap, block_nbytes);
#endif
            }
            else
            {
                memset(block_bitmap, 0, block_nbytes);
            }
 
            block_bitmap += block_nbytes;
        }
 
        if (inode_bitmap)
        {
            blk = fs->group_desc[i].bg_inode_bitmap;
            if (blk)
            {
                retval = NT_SUCCESS(Ext2ReadDisk(
                    fs, ((LONGLONG)blk * fs->blocksize),
                    inode_nbytes,
                    (unsigned char *)inode_bitmap));
 
                if (!retval)
                {
                    goto cleanup;
                }
 
#ifdef EXT2_BIG_ENDIAN_BITMAPS
                if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
                      (fs->flags & EXT2_FLAG_SWAP_BYTES_READ)))
                    ext2_swap_bitmap(fs, inode_bitmap, inode_nbytes);
#endif
            }
            else
            {
                memset(inode_bitmap, 0, inode_nbytes);
            }
 
            inode_bitmap += inode_nbytes;
        }
    }
 
    return true;
 
cleanup:
 
    if (do_block)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, fs->block_map);
        fs->block_map = NULL;
    }
 
    if (do_inode)
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, fs->inode_map);
        fs->inode_map = 0;
    }
 
    return false;
}

Referenced by ext2_read_bitmaps(), ext2_read_block_bitmap(), and ext2_read_inode_bitmap().