generic.c File Reference

#include "ext2fs.h"
#include "linux\ext4.h"

Include dependency graph for generic.c:

Go to the source code of this file.

Macros
#define	MAX_LFS_FILESIZE   0x7fffffffffffffff
#define	ext4_set_bit(n, p)   set_bit((int)(n), (unsigned long *)(p))

Functions
NTSTATUS	Ext2LoadSuper (IN PEXT2_VCB Vcb, IN BOOLEAN bVerify, OUT PEXT2_SUPER_BLOCK *Sb)
BOOLEAN	Ext2SaveSuper (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb)
BOOLEAN	Ext2RefreshSuper (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb)
VOID	Ext2DropGroupBH (IN PEXT2_VCB Vcb)
VOID	Ext2PutGroup (IN PEXT2_VCB Vcb)
BOOLEAN	Ext2LoadGroupBH (IN PEXT2_VCB Vcb)
BOOLEAN	Ext2LoadGroup (IN PEXT2_VCB Vcb)
VOID	Ext2DropBH (IN PEXT2_VCB Vcb)
VOID	Ext2FlushRange (IN PEXT2_VCB Vcb, LARGE_INTEGER s, LARGE_INTEGER e)
NTSTATUS	Ext2FlushVcb (IN PEXT2_VCB Vcb)
BOOLEAN	Ext2SaveGroup (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN ULONG Group)
BOOLEAN	Ext2RefreshGroup (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb)
BOOLEAN	Ext2GetInodeLba (IN PEXT2_VCB Vcb, IN ULONG inode, OUT PLONGLONG offset)
void	Ext2DecodeInode (struct inode *dst, struct ext3_inode *src)
void	Ext2EncodeInode (struct ext3_inode *dst, struct inode *src)
BOOLEAN	Ext2LoadInode (IN PEXT2_VCB Vcb, IN struct inode *Inode)
BOOLEAN	Ext2ClearInode (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN ULONG Inode)
BOOLEAN	Ext2SaveInode (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN struct inode *Inode)
BOOLEAN	Ext2LoadInodeXattr (IN PEXT2_VCB Vcb, IN struct inode *Inode, IN PEXT2_INODE InodeXattr)
BOOLEAN	Ext2SaveInodeXattr (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN struct inode *Inode, IN PEXT2_INODE InodeXattr)
BOOLEAN	Ext2LoadBlock (IN PEXT2_VCB Vcb, IN ULONG Index, IN PVOID Buffer)
BOOLEAN	Ext2SaveBlock (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN ULONG Index, IN PVOID Buf)
BOOLEAN	Ext2LoadBuffer (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN LONGLONG offset, IN ULONG size, IN PVOID buf)
BOOLEAN	Ext2ZeroBuffer (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN LONGLONG offset, IN ULONG size)
BOOLEAN	Ext2SaveBuffer (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN LONGLONG offset, IN ULONG size, IN PVOID buf)
VOID	Ext2UpdateVcbStat (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb)
NTSTATUS	Ext2NewBlock (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN ULONG GroupHint, IN ULONG BlockHint, OUT PULONG Block, IN OUT PULONG Number)
NTSTATUS	Ext2FreeBlock (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN ULONG Block, IN ULONG Number)
NTSTATUS	Ext2NewInode (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN ULONG GroupHint, IN ULONG Type, OUT PULONG Inode)
NTSTATUS	Ext2UpdateGroupDirStat (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN ULONG group)
NTSTATUS	Ext2FreeInode (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN ULONG Inode, IN ULONG Type)
NTSTATUS	Ext2AddEntry (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Dcb, IN struct inode *Inode, IN PUNICODE_STRING FileName, struct dentry **Dentry)
NTSTATUS	Ext2SetFileType (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Dcb, IN PEXT2_MCB Mcb, IN umode_t mode)
NTSTATUS	Ext2RemoveEntry (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Dcb, IN PEXT2_MCB Mcb)
NTSTATUS	Ext2SetParentEntry (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Dcb, IN ULONG OldParent, IN ULONG NewParent)
int	ext3_check_dir_entry (const char *function, struct inode *dir, struct ext3_dir_entry_2 *de, struct buffer_head *bh, unsigned long offset)
struct ext3_dir_entry_2 *	ext3_next_entry (struct ext3_dir_entry_2 *p)
static loff_t	ext4_max_size (int blkbits, int has_huge_files)
loff_t	ext3_max_size (int blkbits, int has_huge_files)
loff_t	ext3_max_bitmap_size (int bits, int has_huge_files)
blkcnt_t	ext3_inode_blocks (struct ext3_inode *raw_inode, struct inode *inode)
int	ext3_inode_blocks_set (struct ext3_inode *raw_inode, struct inode *inode)
ext4_fsblk_t	ext4_block_bitmap (struct super_block *sb, struct ext4_group_desc *bg)
ext4_fsblk_t	ext4_inode_bitmap (struct super_block *sb, struct ext4_group_desc *bg)
ext4_fsblk_t	ext4_inode_table (struct super_block *sb, struct ext4_group_desc *bg)
__u32	ext4_free_blks_count (struct super_block *sb, struct ext4_group_desc *bg)
__u32	ext4_free_inodes_count (struct super_block *sb, struct ext4_group_desc *bg)
__u32	ext4_used_dirs_count (struct super_block *sb, struct ext4_group_desc *bg)
__u32	ext4_itable_unused_count (struct super_block *sb, struct ext4_group_desc *bg)
void	ext4_block_bitmap_set (struct super_block *sb, struct ext4_group_desc *bg, ext4_fsblk_t blk)
void	ext4_inode_bitmap_set (struct super_block *sb, struct ext4_group_desc *bg, ext4_fsblk_t blk)
void	ext4_inode_table_set (struct super_block *sb, struct ext4_group_desc *bg, ext4_fsblk_t blk)
void	ext4_free_blks_set (struct super_block *sb, struct ext4_group_desc *bg, __u32 count)
void	ext4_free_inodes_set (struct super_block *sb, struct ext4_group_desc *bg, __u32 count)
void	ext4_used_dirs_set (struct super_block *sb, struct ext4_group_desc *bg, __u32 count)
void	ext4_itable_unused_set (struct super_block *sb, struct ext4_group_desc *bg, __u32 count)
static __u16	crc16_byte (__u16 crc, const __u8 data)
__u16	crc16 (__u16 crc, __u8 const *buffer, size_t len)
__le16	ext4_group_desc_csum (struct ext3_sb_info *sbi, __u32 block_group, struct ext4_group_desc *gdp)
int	ext4_group_desc_csum_verify (struct ext3_sb_info *sbi, __u32 block_group, struct ext4_group_desc *gdp)
static int	test_root (ext3_group_t a, ext3_group_t b)
static int	ext3_group_sparse (ext3_group_t group)
int	ext3_bg_has_super (struct super_block *sb, ext3_group_t group)
static unsigned long	ext4_bg_num_gdb_meta (struct super_block *sb, ext4_group_t group)
static unsigned long	ext4_bg_num_gdb_nometa (struct super_block *sb, ext4_group_t group)
unsigned long	ext4_bg_num_gdb (struct super_block *sb, ext4_group_t group)
ext3_fsblk_t	descriptor_loc (struct super_block *sb, ext3_fsblk_t logical_sb_block, unsigned int nr)
void	mark_bitmap_end (int start_bit, int end_bit, char *bitmap)
unsigned	ext4_init_inode_bitmap (struct super_block *sb, struct buffer_head *bh, ext4_group_t block_group, struct ext4_group_desc *gdp)
void	ext4_get_group_no_and_offset (struct super_block *sb, ext4_fsblk_t blocknr, ext4_group_t *blockgrpp, ext4_grpblk_t *offsetp)
static int	ext4_block_in_group (struct super_block *sb, ext4_fsblk_t block, ext4_group_t block_group)
static int	ext4_group_used_meta_blocks (struct super_block *sb, ext4_group_t block_group)
unsigned	ext4_init_block_bitmap (struct super_block *sb, struct buffer_head *bh, ext4_group_t block_group, struct ext4_group_desc *gdp)
struct ext4_group_desc *	ext4_get_group_desc (struct super_block *sb, ext4_group_t block_group, struct buffer_head **bh)
ext4_fsblk_t	ext4_count_free_blocks (struct super_block *sb)
unsigned long	ext4_count_free_inodes (struct super_block *sb)
unsigned long	ext4_count_dirs (struct super_block *sb)
int	ext4_check_descriptors (struct super_block *sb)

Variables
PEXT2_GLOBAL	Ext2Global
__u16 const	crc16_table [256]

Macro Definition Documentation

ext4_set_bit

#define ext4_set_bit	(		n,
			p
	)		set_bit((int)(n), (unsigned long *)(p))

Definition at line 2754 of file generic.c.

MAX_LFS_FILESIZE

#define MAX_LFS_FILESIZE   0x7fffffffffffffff

Definition at line 2250 of file generic.c.

Function Documentation

crc16()

__u16 crc16	(	__u16	crc,
		__u8 const *	buffer,
		size_t	len
	)

Definition at line 2612 of file generic.c.

{
    while (len--)
        crc = crc16_byte(crc, *buffer++);
    return crc;
}

Referenced by ext4_group_desc_csum().

crc16_byte()

static __u16 crc16_byte ( __u16  crc, const __u8  data  )

inlinestatic

Definition at line 2607 of file generic.c.

{
    return (crc >> 8) ^ crc16_table[(crc ^ data) & 0xff];
}

Referenced by crc16().

descriptor_loc()

ext3_fsblk_t descriptor_loc	(	struct super_block *	sb,
		ext3_fsblk_t	logical_sb_block,
		unsigned int	nr
	)

Definition at line 2736 of file generic.c.

{
    struct ext3_sb_info *sbi = EXT3_SB(sb);
    ext3_group_t bg, first_meta_bg;
    int has_super = 0;
 
    first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
 
    if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||
            nr < first_meta_bg)
        return logical_sb_block + nr + 1;
    bg = sbi->s_desc_per_block * nr;
    if (ext3_bg_has_super(sb, bg))
        has_super = 1;
    return (has_super + ext3_group_first_block_no(sb, bg));
}

Referenced by Ext2LoadGroup().

Ext2AddEntry()

NTSTATUS Ext2AddEntry	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_FCB	Dcb,
		IN struct inode *	Inode,
		IN PUNICODE_STRING	FileName,
		struct dentry **	Dentry
	)

Definition at line 1879 of file generic.c.

{
    struct dentry          *de = NULL;
 
    NTSTATUS                status = STATUS_UNSUCCESSFUL;
    OEM_STRING              oem;
    int                     rc;
 
    BOOLEAN                 MainResourceAcquired = FALSE;
 
    if (!IsDirectory(Dcb)) {
        DbgBreak();
        return STATUS_NOT_A_DIRECTORY;
    }
 
    ExAcquireResourceExclusiveLite(&Dcb->MainResource, TRUE);
    MainResourceAcquired = TRUE;
 
    _SEH2_TRY {
 
        Ext2ReferXcb(&Dcb->ReferenceCount);
        de = Ext2BuildEntry(Vcb, Dcb->Mcb, FileName);
        if (!de) {
            status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
        de->d_inode = Inode;
 
        rc = ext3_add_entry(IrpContext, de, Inode);
        status = Ext2WinntError(rc);
        if (NT_SUCCESS(status)) {
 
            /* increase dir inode's nlink for .. */
            if (S_ISDIR(Inode->i_mode)) {
                ext3_inc_count(Dcb->Inode);
                ext3_mark_inode_dirty(IrpContext, Dcb->Inode);
            }
 
            /* increase inode nlink reference */
            ext3_inc_count(Inode);
            ext3_mark_inode_dirty(IrpContext, Inode);
 
            if (Dentry) {
                *Dentry = de;
                de = NULL;
            }
        }
 
    } _SEH2_FINALLY {
 
        Ext2DerefXcb(&Dcb->ReferenceCount);
 
        if (MainResourceAcquired)    {
            ExReleaseResourceLite(&Dcb->MainResource);
        }
 
        if (de)
            Ext2FreeEntry(de);
    } _SEH2_END;
 
    return status;
}

Ext2ClearInode()

BOOLEAN Ext2ClearInode	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN ULONG	Inode
	)

Definition at line 530 of file generic.c.

{
    LONGLONG            Offset = 0;
    BOOLEAN             rc;
 
    rc = Ext2GetInodeLba(Vcb, Inode, &Offset);
    if (!rc)  {
        DEBUG(DL_ERR, ( "Ext2SaveInode: failed inode %u.\n", Inode));
        goto errorout;
    }
 
    rc = Ext2ZeroBuffer(IrpContext, Vcb, Offset, Vcb->InodeSize);
 
errorout:
 
    return rc;
}

Referenced by Ext2CreateInode().

Ext2DecodeInode()

void Ext2DecodeInode	(	struct inode *	dst,
		struct ext3_inode *	src
	)

Definition at line 452 of file generic.c.

{
    dst->i_mode = src->i_mode;
    dst->i_flags = src->i_flags;
    dst->i_uid = src->i_uid;
    dst->i_gid = src->i_gid;
    dst->i_nlink = src->i_links_count;
    dst->i_generation = src->i_generation;
    dst->i_size = src->i_size;
    if (S_ISREG(src->i_mode)) {
        dst->i_size |= (loff_t)src->i_size_high << 32;
    }
    dst->i_file_acl = src->i_file_acl_lo;
    dst->i_file_acl |= (ext4_fsblk_t)src->osd2.linux2.l_i_file_acl_high << 32;
    dst->i_atime = src->i_atime;
    dst->i_ctime = src->i_ctime;
    dst->i_mtime = src->i_mtime;
    dst->i_dtime = src->i_dtime;
    dst->i_blocks = ext3_inode_blocks(src, dst);
    memcpy(&dst->i_block[0], &src->i_block[0], sizeof(__u32) * 15);
    if (EXT3_HAS_RO_COMPAT_FEATURE(dst->i_sb,
                                   EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE))
        dst->i_extra_isize = src->i_extra_isize;
    else
        dst->i_extra_isize = 0;
}

Referenced by Ext2LoadInode().

Ext2DropBH()

VOID Ext2DropBH

(

IN PEXT2_VCB

Vcb

)

Definition at line 266 of file generic.c.

{
    struct ext3_sb_info *sbi = &Vcb->sbi;
 
    /* do nothing if Vcb is not initialized yet */
    if (!IsFlagOn(Vcb->Flags, VCB_INITIALIZED))
        return;
 
    _SEH2_TRY {
 
        /* acquire bd lock to avoid bh creation */
        ExAcquireResourceExclusiveLite(&Vcb->bd.bd_bh_lock, TRUE);
 
        SetFlag(Vcb->Flags, VCB_BEING_DROPPED);
        Ext2DropGroupBH(Vcb);
 
        while (!IsListEmpty(&Vcb->bd.bd_bh_free)) {
            struct buffer_head *bh;
            PLIST_ENTRY         l;
            l = RemoveHeadList(&Vcb->bd.bd_bh_free);
            bh = CONTAINING_RECORD(l, struct buffer_head, b_link);
            InitializeListHead(&bh->b_link);
            if (0 == atomic_read(&bh->b_count)) {
                buffer_head_remove(&Vcb->bd, bh);
                free_buffer_head(bh);
            }
        }
 
    } _SEH2_FINALLY {
        ExReleaseResourceLite(&Vcb->bd.bd_bh_lock);
    } _SEH2_END;
 
    ClearFlag(Vcb->Flags, VCB_BEING_DROPPED);
}

Referenced by Ext2DestroyVcb(), Ext2FlushVcb(), and Ext2PurgeVolume().

Ext2DropGroupBH()

VOID Ext2DropGroupBH

(

IN PEXT2_VCB

Vcb

)

Definition at line 132 of file generic.c.

{
    struct ext3_sb_info *sbi = &Vcb->sbi;
    unsigned long i;
 
    if (NULL == Vcb->sbi.s_gd) {
        return;
    }
 
    for (i = 0; i < Vcb->sbi.s_gdb_count; i++) {
        if (Vcb->sbi.s_gd[i].bh) {
            fini_bh(&sbi->s_gd[i].bh);
            Vcb->sbi.s_gd[i].bh = NULL;
        }
    }
}

Referenced by Ext2DropBH(), and Ext2PutGroup().

Ext2EncodeInode()

void Ext2EncodeInode	(	struct ext3_inode *	dst,
		struct inode *	src
	)

Definition at line 479 of file generic.c.

{
    dst->i_mode = src->i_mode;
    dst->i_flags = src->i_flags;
    dst->i_uid = src->i_uid;
    dst->i_gid = src->i_gid;
    dst->i_links_count = src->i_nlink;
    dst->i_generation = src->i_generation;
    dst->i_size = (__u32)src->i_size;
    if (S_ISREG(src->i_mode)) {
        dst->i_size_high = (__u32)(src->i_size >> 32);
    }
    dst->i_file_acl_lo = (__u32)src->i_file_acl;
    dst->osd2.linux2.l_i_file_acl_high |= (__u16)(src->i_file_acl >> 32);
    dst->i_atime = src->i_atime;
    dst->i_ctime = src->i_ctime;
    dst->i_mtime = src->i_mtime;
    dst->i_dtime = src->i_dtime;
    dst->i_extra_isize = src->i_extra_isize;
    ASSERT(src->i_sb);
    ext3_inode_blocks_set(dst, src);
    memcpy(&dst->i_block[0], &src->i_block[0], sizeof(__u32) * 15);
    if (EXT3_HAS_RO_COMPAT_FEATURE(src->i_sb,
                                   EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE))
        dst->i_extra_isize = src->i_extra_isize;
}

Referenced by Ext2LoadInodeXattr(), and Ext2SaveInode().

Ext2FlushRange()

VOID Ext2FlushRange	(	IN PEXT2_VCB	Vcb,
		LARGE_INTEGER	s,
		LARGE_INTEGER	e
	)

Definition at line 303 of file generic.c.

{
    ULONG len;
 
    if (e.QuadPart <= s.QuadPart)
        return;
 
    /* loop per 2G */
    while (s.QuadPart < e.QuadPart) {
        if (e.QuadPart > s.QuadPart + 1024 * 1024 * 1024) {
            len = 1024 * 1024 * 1024;
        } else {
            len = (ULONG) (e.QuadPart - s.QuadPart);
        }
        CcFlushCache(&Vcb->SectionObject, &s, len, NULL);
        s.QuadPart += len;
    }
}

Referenced by Ext2FlushVcb().

Ext2FlushVcb()

NTSTATUS Ext2FlushVcb

(

IN PEXT2_VCB

Vcb

)

Definition at line 323 of file generic.c.

{
    LARGE_INTEGER        s = {0}, o;
    struct ext3_sb_info *sbi = &Vcb->sbi;
    struct rb_node      *node;
    struct buffer_head  *bh;
 
    if (!IsFlagOn(Vcb->Flags, VCB_GD_LOADED)) {
        CcFlushCache(&Vcb->SectionObject, NULL, 0, NULL);
        goto errorout;
    }
 
    ASSERT(ExIsResourceAcquiredExclusiveLite(&Vcb->MainResource));
 
    _SEH2_TRY {
 
        /* acqurie gd block */
        ExAcquireResourceExclusiveLite(&Vcb->sbi.s_gd_lock, TRUE);
 
        /* acquire bd lock to avoid bh creation */
        ExAcquireResourceExclusiveLite(&Vcb->bd.bd_bh_lock, TRUE);
 
        /* drop unused bh */
        Ext2DropBH(Vcb);
 
        /* flush volume with all outstanding bh skipped */
 
        node = rb_first(&Vcb->bd.bd_bh_root);
        while (node) {
 
            bh = container_of(node, struct buffer_head, b_rb_node);
            node = rb_next(node);
 
            o.QuadPart = bh->b_blocknr << BLOCK_BITS;
            ASSERT(o.QuadPart >= s.QuadPart);
 
            if (o.QuadPart == s.QuadPart) {
                s.QuadPart = s.QuadPart + bh->b_size;
                continue;
            }
 
            if (o.QuadPart > s.QuadPart) {
                Ext2FlushRange(Vcb, s, o);
                s.QuadPart = (bh->b_blocknr << BLOCK_BITS) + bh->b_size;
                continue;
            }
        }
 
        o = Vcb->PartitionInformation.PartitionLength;
        Ext2FlushRange(Vcb, s, o);
 
    } _SEH2_FINALLY {
 
        ExReleaseResourceLite(&Vcb->bd.bd_bh_lock);
        ExReleaseResourceLite(&Vcb->sbi.s_gd_lock);
    } _SEH2_END;
 
errorout:
    return STATUS_SUCCESS;
}

Referenced by Ext2FloppyFlush(), and Ext2FlushVolume().

Ext2FreeBlock()

NTSTATUS Ext2FreeBlock	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN ULONG	Block,
		IN ULONG	Number
	)

Definition at line 1217 of file generic.c.

{
    struct super_block     *sb = &Vcb->sb;
    PEXT2_GROUP_DESC        gd;
    struct buffer_head     *gb = NULL;
    ext4_fsblk_t            bitmap_blk;
 
    RTL_BITMAP      BlockBitmap;
    LARGE_INTEGER   Offset;
 
    PBCB            BitmapBcb;
    PVOID           BitmapCache;
 
    ULONG           Group;
    ULONG           Index;
    ULONG           Length;
    ULONG           Count;
 
    NTSTATUS        Status = STATUS_UNSUCCESSFUL;
 
    ExAcquireResourceExclusiveLite(&Vcb->MetaBlock, TRUE);
 
    DEBUG(DL_INF, ("Ext2FreeBlock: Block %xh - %x to be freed.\n",
                   Block, Block + Number));
 
    Group = (Block - EXT2_FIRST_DATA_BLOCK) / BLOCKS_PER_GROUP;
    Index = (Block - EXT2_FIRST_DATA_BLOCK) % BLOCKS_PER_GROUP;
 
Again:
 
    if (gb)
        fini_bh(&gb);
 
    if ( Block < EXT2_FIRST_DATA_BLOCK ||
         Block >= TOTAL_BLOCKS ||
         Group >= Vcb->sbi.s_groups_count) {
 
        DbgBreak();
        Status = STATUS_SUCCESS;
 
    } else  {
 
        gd = ext4_get_group_desc(sb, Group, &gb);
        if (!gd) {
            DbgBreak();
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto errorout;
        }
        bitmap_blk = ext4_block_bitmap(sb, gd);
 
        /* check the block is valid or not */
        if (bitmap_blk >= TOTAL_BLOCKS) {
            DbgBreak();
            Status = STATUS_DISK_CORRUPT_ERROR;
            goto errorout;
        }
 
        /* get bitmap block offset and length */
        Offset.QuadPart = bitmap_blk;
        Offset.QuadPart = Offset.QuadPart << BLOCK_BITS;
 
        if (Group == Vcb->sbi.s_groups_count - 1) {
 
            Length = (ULONG)(TOTAL_BLOCKS % BLOCKS_PER_GROUP);
 
            /* s_blocks_count is integer multiple of s_blocks_per_group */
            if (Length == 0) {
                Length = BLOCKS_PER_GROUP;
            }
 
        } else {
            Length = BLOCKS_PER_GROUP;
        }
 
        /* read and initialize bitmap */
        if (!CcPinRead( Vcb->Volume,
                        &Offset,
                        Vcb->BlockSize,
                        PIN_WAIT,
                        &BitmapBcb,
                        &BitmapCache ) ) {
 
            DEBUG(DL_ERR, ("Ext2FreeBlock: failed to PinLock bitmap block %xh.\n",
                           bitmap_blk));
            Status = STATUS_CANT_WAIT;
            DbgBreak();
            goto errorout;
        }
 
        /* clear usused bits */
        RtlInitializeBitMap(&BlockBitmap, BitmapCache, Length);
        Count = min(Length - Index, Number);
        RtlClearBits(&BlockBitmap, Index, Count);
 
        /* update group description table */
        ext4_free_blks_set(sb, gd, RtlNumberOfClearBits(&BlockBitmap));
 
        /* indict the cache range is dirty */
        CcSetDirtyPinnedData(BitmapBcb, NULL );
        Ext2AddVcbExtent(Vcb, Offset.QuadPart, (LONGLONG)Vcb->BlockSize);
        CcUnpinData(BitmapBcb);
        BitmapBcb = NULL;
        BitmapCache = NULL;
        Ext2SaveGroup(IrpContext, Vcb, Group);
 
        /* remove dirty MCB to prevent Volume's lazy writing. */
        if (Ext2RemoveBlockExtent(Vcb, NULL, Block, Count)) {
        } else {
            DbgBreak();
            Ext2RemoveBlockExtent(Vcb, NULL, Block, Count);
        }
 
        /* save super block (used/unused blocks statics) */
        Ext2UpdateVcbStat(IrpContext, Vcb);
 
        /* try next group to clear all remaining */
        Number -= Count;
        if (Number) {
            Group += 1;
            if (Group < Vcb->sbi.s_groups_count) {
                Index = 0;
                Block += Count;
                goto Again;
            } else {
                DEBUG(DL_ERR, ("Ext2FreeBlock: block number beyonds max group.\n"));
                goto errorout;
            }
        }
    }
 
    Status = STATUS_SUCCESS;
 
errorout:
 
    if (gb)
        fini_bh(&gb);
 
    ExReleaseResourceLite(&Vcb->MetaBlock);
 
    return Status;
}

Referenced by Ext2ExpandLast(), Ext2TruncateBlock(), Ext2TruncateIndirectFast(), and ext4_free_blocks().

Ext2FreeInode()

NTSTATUS Ext2FreeInode	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN ULONG	Inode,
		IN ULONG	Type
	)

Definition at line 1766 of file generic.c.

{
    struct super_block     *sb = &Vcb->sb;
    PEXT2_GROUP_DESC        gd;
    struct buffer_head     *gb = NULL;
    struct buffer_head     *bh = NULL;
    ext4_fsblk_t            bitmap_blk;
 
    RTL_BITMAP      InodeBitmap;
    ULONG           Group;
    ULONG           Length;
    LARGE_INTEGER   Offset;
 
    ULONG           dwIno;
    BOOLEAN         bModified = FALSE;
 
    NTSTATUS        Status = STATUS_UNSUCCESSFUL;
 
    ExAcquireResourceExclusiveLite(&Vcb->MetaInode, TRUE);
 
    Group = (Inode - 1) / INODES_PER_GROUP;
    dwIno = (Inode - 1) % INODES_PER_GROUP;
 
    DEBUG(DL_INF, ( "Ext2FreeInode: Inode: %xh (Group/Off = %xh/%xh)\n",
                    Inode, Group, dwIno));
 
    if (Group >= Vcb->sbi.s_groups_count)  {
        DbgBreak();
        goto errorout;
    }
 
    gd = ext4_get_group_desc(sb, Group, &gb);
    if (!gd) {
        DbgBreak();
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto errorout;
    }
 
    bitmap_blk = ext4_inode_bitmap(sb, gd);
    bh = sb_getblk(sb, bitmap_blk);
    if (!bh) {
        DbgBreak();
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto errorout;
    }
    if (!buffer_uptodate(bh)) {
        int err = bh_submit_read(bh);
        if (err < 0) {
            DbgPrint("bh_submit_read error! err: %d\n", err);
            Status = Ext2WinntError(err);
            goto errorout;
        }
    }
 
    if (Group == Vcb->sbi.s_groups_count - 1) {
 
        Length = INODES_COUNT % INODES_PER_GROUP;
        if (!Length) {
            /* s_inodes_count is integer multiple of s_inodes_per_group */
            Length = INODES_PER_GROUP;
        }
    } else {
        Length = INODES_PER_GROUP;
    }
 
    RtlInitializeBitMap(&InodeBitmap, (PULONG)bh->b_data, Length);
 
    if (RtlCheckBit(&InodeBitmap, dwIno) == 0) {
        DbgBreak();
        Status = STATUS_SUCCESS;
    } else {
        RtlClearBits(&InodeBitmap, dwIno, 1);
        bModified = TRUE;
    }
 
    if (bModified) {
        /* update group free inodes */
        ext4_free_inodes_set(sb, gd,
                             RtlNumberOfClearBits(&InodeBitmap));
 
        /* set inode block dirty and add to vcb dirty range */
        mark_buffer_dirty(bh);
 
        /* update group_desc and super_block */
        if (Type == EXT2_FT_DIR) {
            ext4_used_dirs_set(sb, gd,
                               ext4_used_dirs_count(sb, gd) - 1);
        }
        Ext2SaveGroup(IrpContext, Vcb, Group);
        Ext2UpdateVcbStat(IrpContext, Vcb);
        Status = STATUS_SUCCESS;
    }
 
errorout:
 
    ExReleaseResourceLite(&Vcb->MetaInode);
 
    if (bh)
        fini_bh(&bh);
 
    if (gb)
        fini_bh(&gb);
 
    return Status;
}

Referenced by Ext2CreateInode(), and Ext2DeleteFile().

Ext2GetInodeLba()

BOOLEAN Ext2GetInodeLba	(	IN PEXT2_VCB	Vcb,
		IN ULONG	inode,
		OUT PLONGLONG	offset
	)

Definition at line 418 of file generic.c.

{
    PEXT2_GROUP_DESC gd;
    struct buffer_head *bh = NULL;
    ext4_fsblk_t loc;
    int group;
 
    if (inode < 1 || inode > INODES_COUNT)  {
        DEBUG(DL_ERR, ( "Ext2GetInodeLba: Inode value %xh is invalid.\n",inode));
        *offset = 0;
        return FALSE;
    }
 
    group = (inode - 1) / INODES_PER_GROUP ;
    gd = ext4_get_group_desc(&Vcb->sb, group, &bh);
    if (!bh) {
        *offset = 0;
        DbgBreak();
        return FALSE;
    }
    loc = (LONGLONG)ext4_inode_table(&Vcb->sb, gd);
    loc = loc << BLOCK_BITS;
    loc = loc + ((inode - 1) % INODES_PER_GROUP) * Vcb->InodeSize;
 
    *offset = loc;
    __brelse(bh);
 
    return TRUE;
}

Referenced by Ext2ClearInode(), Ext2LoadInode(), Ext2LoadInodeXattr(), Ext2SaveInode(), and Ext2SaveInodeXattr().

Ext2LoadBlock()

BOOLEAN Ext2LoadBlock	(	IN PEXT2_VCB	Vcb,
		IN ULONG	Index,
		IN PVOID	Buffer
	)

Definition at line 659 of file generic.c.

{
    struct buffer_head *bh = NULL;
    BOOLEAN             rc = 0;
 
    _SEH2_TRY {
 
        bh = sb_getblk(&Vcb->sb, (sector_t)Index);
 
        if (!bh) {
            DEBUG(DL_ERR, ("Ext2Loadblock: can't load block %u\n", Index));
            DbgBreak();
            _SEH2_LEAVE;
        }
 
        if (!buffer_uptodate(bh)) {
            int err = bh_submit_read(bh);
            if (err < 0) {
                DEBUG(DL_ERR, ("Ext2LoadBlock: reading failed %d\n", err));
                _SEH2_LEAVE;
            }
        }
 
        RtlCopyMemory(Buffer, bh->b_data, BLOCK_SIZE);
        rc = TRUE;
 
    } _SEH2_FINALLY {
 
        if (bh)
            fini_bh(&bh);
    } _SEH2_END;
 
    return rc;
}

Ext2LoadBuffer()

BOOLEAN Ext2LoadBuffer	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN LONGLONG	offset,
		IN ULONG	size,
		IN PVOID	buf
	)

Definition at line 733 of file generic.c.

{
    struct buffer_head *bh = NULL;
    BOOLEAN             rc;
 
    _SEH2_TRY {
 
        while (size) {
 
            sector_t    block;
            ULONG       len = 0, delta = 0;
 
            block = (sector_t) (offset >> BLOCK_BITS);
            delta = (ULONG)offset & (BLOCK_SIZE - 1);
            len = BLOCK_SIZE - delta;
            if (size < len)
                len = size;
 
            bh = sb_getblk(&Vcb->sb, block);
            if (!bh) {
                DEBUG(DL_ERR, ("Ext2SaveBuffer: can't load block %I64u\n", block));
                DbgBreak();
                _SEH2_LEAVE;
            }
 
            if (!buffer_uptodate(bh)) {
                int err = bh_submit_read(bh);
                if (err < 0) {
                    DEBUG(DL_ERR, ("Ext2SaveBuffer: bh_submit_read failed: %d\n", err));
                    _SEH2_LEAVE;
                }
            }
 
            _SEH2_TRY {
                RtlCopyMemory(buf, bh->b_data + delta, len);
            } _SEH2_FINALLY {
                fini_bh(&bh);
            } _SEH2_END;
 
            buf = (PUCHAR)buf + len;
            offset = offset + len;
            size = size - len;
        }
 
        rc = TRUE;
 
    } _SEH2_FINALLY {
 
        if (bh)
            fini_bh(&bh);
 
    } _SEH2_END;
 
    return rc;
}

Referenced by Ext2LoadInode(), and Ext2SaveInode().

Ext2LoadGroup()

BOOLEAN Ext2LoadGroup

(

IN PEXT2_VCB

Vcb

)

Definition at line 207 of file generic.c.

{
    struct super_block  *sb = &Vcb->sb;
    struct ext3_sb_info *sbi = &Vcb->sbi;
    ext3_fsblk_t sb_block = 1;
    unsigned long i;
    BOOLEAN rc = FALSE;
 
    _SEH2_TRY {
 
        ExAcquireResourceExclusiveLite(&Vcb->sbi.s_gd_lock, TRUE);
 
        if (NULL == sbi->s_gd) {
            sbi->s_gd = kzalloc(sbi->s_gdb_count * sizeof(struct ext3_gd),
                                        GFP_KERNEL);
        }
        if (sbi->s_gd == NULL) {
            DEBUG(DL_ERR, ("Ext2LoadGroup: not enough memory.\n"));
            _SEH2_LEAVE;
        }
 
        if (BLOCK_SIZE != EXT3_MIN_BLOCK_SIZE) {
            sb_block = EXT4_MIN_BLOCK_SIZE / BLOCK_SIZE;
        }
 
        for (i = 0; i < sbi->s_gdb_count; i++) {
            sbi->s_gd[i].block =  descriptor_loc(sb, sb_block, i);
            if (!sbi->s_gd[i].block) {
                DEBUG(DL_ERR, ("Ext2LoadGroup: can't locate group descriptor %d\n", i));
                _SEH2_LEAVE;
            }
        }
 
        if (!Ext2LoadGroupBH(Vcb)) {
            DEBUG(DL_ERR, ("Ext2LoadGroup: Failed to load group descriptions !\n"));
            _SEH2_LEAVE;
        }
 
        if (!ext4_check_descriptors(sb)) {
            DbgBreak();
            DEBUG(DL_ERR, ("Ext2LoadGroup: group descriptors corrupted !\n"));
            _SEH2_LEAVE;
        }
 
        SetFlag(Vcb->Flags, VCB_GD_LOADED);
        rc = TRUE;
 
    } _SEH2_FINALLY {
 
        if (!rc)
            Ext2PutGroup(Vcb);
 
        ExReleaseResourceLite(&Vcb->sbi.s_gd_lock);
    } _SEH2_END;
 
    return rc;
}

Referenced by Ext2InitializeVcb(), and ext4_get_group_desc().

Ext2LoadGroupBH()

BOOLEAN Ext2LoadGroupBH

(

IN PEXT2_VCB

Vcb

)

Definition at line 170 of file generic.c.

{
    struct super_block  *sb = &Vcb->sb;
    struct ext3_sb_info *sbi = &Vcb->sbi;
    unsigned long i;
    BOOLEAN rc = FALSE;
 
    _SEH2_TRY {
 
        ExAcquireResourceExclusiveLite(&Vcb->sbi.s_gd_lock, TRUE);
        ASSERT (NULL != sbi->s_gd);
 
        for (i = 0; i < sbi->s_gdb_count; i++) {
            ASSERT (sbi->s_gd[i].block);
            if (sbi->s_gd[i].bh)
                continue;
            sbi->s_gd[i].bh = sb_getblk(sb, sbi->s_gd[i].block);
            if (!sbi->s_gd[i].bh) {
                DEBUG(DL_ERR, ("Ext2LoadGroupBH: can't read group descriptor %d\n", i));
                DbgBreak();
                _SEH2_LEAVE;
            }
            sbi->s_gd[i].gd = (struct ext4_group_desc *)sbi->s_gd[i].bh->b_data;
        }
 
        rc = TRUE;
 
    } _SEH2_FINALLY {
 
        ExReleaseResourceLite(&Vcb->sbi.s_gd_lock);
    } _SEH2_END;
 
    return rc;
}

Referenced by Ext2LoadGroup(), and ext4_get_group_desc().

Ext2LoadInode()

BOOLEAN Ext2LoadInode	(	IN PEXT2_VCB	Vcb,
		IN struct inode *	Inode
	)

Definition at line 508 of file generic.c.

{
    struct ext3_inode   ext3i = {0};
    LONGLONG            offset;
 
    if (!Ext2GetInodeLba(Vcb, Inode->i_ino, &offset))  {
        DEBUG(DL_ERR, ("Ext2LoadInode: failed inode %u.\n", Inode->i_ino));
        return FALSE;
    }
 
    if (!Ext2LoadBuffer(NULL, Vcb, offset, sizeof(ext3i), &ext3i)) {
        return FALSE;
    }
 
    Ext2DecodeInode(Inode, &ext3i);
 
    return TRUE;
}

Referenced by Ext2InitializeVcb(), Ext2LoadInternalJournal(), Ext2LookupFile(), Ext2ProcessEntry(), and Ext2RefreshSuper().

Ext2LoadInodeXattr()

BOOLEAN Ext2LoadInodeXattr	(	IN PEXT2_VCB	Vcb,
		IN struct inode *	Inode,
		IN PEXT2_INODE	InodeXattr
	)

Definition at line 590 of file generic.c.

{
    IO_STATUS_BLOCK     IoStatus;
    LONGLONG            Offset;
 
    if (!Ext2GetInodeLba(Vcb, Inode->i_ino, &Offset)) {
        DEBUG(DL_ERR, ("Ext2LoadRawInode: error get inode(%xh)'s addr.\n", Inode->i_ino));
        return FALSE;
    }
 
    if (!CcCopyRead(
        Vcb->Volume,
        (PLARGE_INTEGER)&Offset,
        Vcb->InodeSize,
        PIN_WAIT,
        (PVOID)InodeXattr,
        &IoStatus)) {
        return FALSE;
    }
 
    if (!NT_SUCCESS(IoStatus.Status)) {
        return FALSE;
    }
 
    Ext2EncodeInode(InodeXattr, Inode);
    return TRUE;
}

Referenced by ext4_fs_get_xattr_ref().

Ext2LoadSuper()

NTSTATUS Ext2LoadSuper	(	IN PEXT2_VCB	Vcb,
		IN BOOLEAN	bVerify,
		OUT PEXT2_SUPER_BLOCK *	Sb
	)

Definition at line 29 of file generic.c.

{
    NTSTATUS          Status;
    PEXT2_SUPER_BLOCK Ext2Sb = NULL;
 
    Ext2Sb = (PEXT2_SUPER_BLOCK)
             Ext2AllocatePool(
                 PagedPool,
                 SUPER_BLOCK_SIZE,
                 EXT2_SB_MAGIC
             );
    if (!Ext2Sb) {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto errorout;
    }
 
    Status = Ext2ReadDisk(
                 Vcb,
                 (ULONGLONG) SUPER_BLOCK_OFFSET,
                 SUPER_BLOCK_SIZE,
                 (PVOID) Ext2Sb,
                 bVerify );
 
    if (!NT_SUCCESS(Status)) {
        Ext2FreePool(Ext2Sb, EXT2_SB_MAGIC);
        Ext2Sb = NULL;
    }
 
errorout:
 
    *Sb = Ext2Sb;
    return Status;
}

Referenced by Ext2MountVolume(), and Ext2VerifyVolume().

Ext2NewBlock()

NTSTATUS Ext2NewBlock	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN ULONG	GroupHint,
		IN ULONG	BlockHint,
		OUT PULONG	Block,
		IN OUT PULONG	Number
	)

Definition at line 1008 of file generic.c.

{
    struct super_block      *sb = &Vcb->sb;
    PEXT2_GROUP_DESC        gd;
    struct buffer_head     *gb = NULL;
    struct buffer_head     *bh = NULL;
    ext4_fsblk_t            bitmap_blk;
 
    RTL_BITMAP              BlockBitmap;
 
    ULONG                   Group = 0;
    ULONG                   Index = 0xFFFFFFFF;
    ULONG                   dwHint = 0;
    ULONG                   Count = 0;
    ULONG                   Length = 0;
 
    NTSTATUS                Status = STATUS_DISK_FULL;
 
    *Block = 0;
 
    ExAcquireResourceExclusiveLite(&Vcb->MetaBlock, TRUE);
 
    /* validate the hint group and hint block */
    if (GroupHint >= Vcb->sbi.s_groups_count) {
        DbgBreak();
        GroupHint = Vcb->sbi.s_groups_count - 1;
    }
 
    if (BlockHint != 0) {
        GroupHint = (BlockHint - EXT2_FIRST_DATA_BLOCK) / BLOCKS_PER_GROUP;
        dwHint = (BlockHint - EXT2_FIRST_DATA_BLOCK) % BLOCKS_PER_GROUP;
    }
 
    Group = GroupHint;
 
Again:
 
    if (bh)
        fini_bh(&bh);
 
    if (gb)
        fini_bh(&gb);
 
    gd = ext4_get_group_desc(sb, Group, &gb);
    if (!gd) {
        DbgBreak();
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto errorout;
    }
 
    bitmap_blk = ext4_block_bitmap(sb, gd);
 
    if (gd->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
        bh = sb_getblk_zero(sb, bitmap_blk);
        if (!bh) {
            DbgBreak();
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto errorout;
        }
        gd->bg_checksum = ext4_group_desc_csum(EXT3_SB(sb), Group, gd);
        ext4_init_block_bitmap(sb, bh, Group, gd);
        set_buffer_uptodate(bh);
        gd->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
        Ext2SaveGroup(IrpContext, Vcb, Group);
    } else {
        bh = sb_getblk(sb, bitmap_blk);
        if (!bh) {
            DbgBreak();
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto errorout;
        }
    }
 
    if (!buffer_uptodate(bh)) {
        int err = bh_submit_read(bh);
        if (err < 0) {
            DbgPrint("bh_submit_read error! err: %d\n", err);
            Status = Ext2WinntError(err);
            goto errorout;
        }
    }
 
    if (ext4_free_blks_count(sb, gd)) {
 
        if (Group == Vcb->sbi.s_groups_count - 1) {
 
            Length = (ULONG)(TOTAL_BLOCKS % BLOCKS_PER_GROUP);
 
            /* s_blocks_count is integer multiple of s_blocks_per_group */
            if (Length == 0) {
                Length = BLOCKS_PER_GROUP;
            }
        } else {
            Length = BLOCKS_PER_GROUP;
        }
 
        /* initialize bitmap buffer */
        RtlInitializeBitMap(&BlockBitmap, (PULONG)bh->b_data, Length);
 
        /* try to find a clear bit range */
        Index = RtlFindClearBits(&BlockBitmap, *Number, dwHint);
 
        /* We could not get new block in the prefered group */
        if (Index == 0xFFFFFFFF) {
 
            /* search clear bits from the hint block */
            Count = RtlFindNextForwardRunClear(&BlockBitmap, dwHint, &Index);
            if (dwHint != 0 && Count == 0) {
                /* search clear bits from the very beginning */
                Count = RtlFindNextForwardRunClear(&BlockBitmap, 0, &Index);
            }
 
            if (Count == 0) {
 
                RtlZeroMemory(&BlockBitmap, sizeof(RTL_BITMAP));
 
                /* no blocks found: set bg_free_blocks_count to 0 */
                ext4_free_blks_set(sb, gd, 0);
                Ext2SaveGroup(IrpContext, Vcb, Group);
 
                /* will try next group */
                goto Again;
 
            } else {
 
                /* we got free blocks */
                if (Count <= *Number) {
                    *Number = Count;
                }
            }
        }
 
    } else {
 
        /* try next group */
        dwHint = 0;
        Group = (Group + 1) % Vcb->sbi.s_groups_count;
        if (Group != GroupHint) {
            goto Again;
        }
 
        Index = 0xFFFFFFFF;
    }
 
    if (Index < Length) {
 
        /* mark block bits as allocated */
        RtlSetBits(&BlockBitmap, Index, *Number);
 
        /* set block bitmap dirty in cache */
        mark_buffer_dirty(bh);
 
        /* update group description */
        ext4_free_blks_set(sb, gd, RtlNumberOfClearBits(&BlockBitmap));
        Ext2SaveGroup(IrpContext, Vcb, Group);
 
        /* update Vcb free blocks */
        Ext2UpdateVcbStat(IrpContext, Vcb);
 
        /* validate the new allocated block number */
        *Block = Index + EXT2_FIRST_DATA_BLOCK + Group * BLOCKS_PER_GROUP;
        if (*Block >= TOTAL_BLOCKS || *Block + *Number > TOTAL_BLOCKS) {
            DbgBreak();
            dwHint = 0;
            goto Again;
        }
 
        if (ext4_block_bitmap(sb, gd) == *Block ||
            ext4_inode_bitmap(sb, gd) == *Block ||
            ext4_inode_table(sb,  gd)  == *Block ) {
            DbgBreak();
            dwHint = 0;
            goto Again;
        }
 
        /* Always remove dirty MCB to prevent Volume's lazy writing.
           Metadata blocks will be re-added during modifications.*/
        if (Ext2RemoveBlockExtent(Vcb, NULL, *Block, *Number)) {
        } else {
            DbgBreak();
            Ext2RemoveBlockExtent(Vcb, NULL, *Block, *Number);
        }
 
        DEBUG(DL_INF, ("Ext2NewBlock:  Block %xh - %x allocated.\n",
                       *Block, *Block + *Number));
        Status = STATUS_SUCCESS;
    }
 
errorout:
 
    ExReleaseResourceLite(&Vcb->MetaBlock);
 
    if (bh)
        fini_bh(&bh);
 
    if (gb)
        fini_bh(&gb);
 
    return Status;
}

Referenced by Ext2ExpandLast(), and ext4_new_meta_blocks().

Ext2NewInode()

NTSTATUS Ext2NewInode	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN ULONG	GroupHint,
		IN ULONG	Type,
		OUT PULONG	Inode
	)

Definition at line 1366 of file generic.c.

{
    struct super_block     *sb = &Vcb->sb;
    PEXT2_GROUP_DESC        gd;
    struct buffer_head     *gb = NULL;
    struct buffer_head     *bh = NULL;
    ext4_fsblk_t            bitmap_blk;
 
    RTL_BITMAP      InodeBitmap;
 
    ULONG           Group, i, j;
    ULONG           Average, Length;
 
    ULONG           dwInode;
 
    NTSTATUS        Status = STATUS_DISK_FULL;
 
    *Inode = dwInode = 0XFFFFFFFF;
 
    ExAcquireResourceExclusiveLite(&Vcb->MetaInode, TRUE);
 
    if (GroupHint >= Vcb->sbi.s_groups_count)
        GroupHint = GroupHint % Vcb->sbi.s_groups_count;
 
repeat:
 
    if (bh)
        fini_bh(&bh);
 
    if (gb)
        fini_bh(&gb);
 
    Group = i = 0;
    gd = NULL;
 
    if (Type == EXT2_FT_DIR) {
 
        Average = Vcb->SuperBlock->s_free_inodes_count / Vcb->sbi.s_groups_count;
 
        for (j = 0; j < Vcb->sbi.s_groups_count; j++) {
 
            i = (j + GroupHint) % (Vcb->sbi.s_groups_count);
            gd = ext4_get_group_desc(sb, i, &gb);
            if (!gd) {
                    DbgBreak();
                Status = STATUS_INSUFFICIENT_RESOURCES;
                goto errorout;
            }
 
            if ((gd->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) ||
                (ext4_used_dirs_count(sb, gd) << 8 <
                 ext4_free_inodes_count(sb, gd)) ) {
                Group = i + 1;
                break;
            }
            fini_bh(&gb);
        }
 
        if (!Group) {
 
            PEXT2_GROUP_DESC  desc = NULL;
 
            gd = NULL;
 
            /* get the group with the biggest vacancy */
            for (j = 0; j < Vcb->sbi.s_groups_count; j++) {
 
                struct buffer_head *gt = NULL;
                desc = ext4_get_group_desc(sb, j, &gt);
                if (!desc) {
                    DbgBreak();
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    goto errorout;
                }
 
                /* return the group if it's not initialized yet */
                if (desc->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
                    Group = j + 1;
                    gd = desc;
 
                    if (gb)
                        fini_bh(&gb);
                    gb = gt;
                    gt = NULL;
                    break;
                }
 
                if (!gd) {
                    if (ext4_free_inodes_count(sb, desc) > 0) {
                        Group = j + 1;
                        gd = desc;
                        if (gb)
                            fini_bh(&gb);
                        gb = gt;
                        gt = NULL;
                    }
                } else {
                    if (ext4_free_inodes_count(sb, desc) >
                        ext4_free_inodes_count(sb, gd)) {
                        Group = j + 1;
                        gd = desc;
                        if (gb)
                            fini_bh(&gb);
                        gb = gt;
                        gt = NULL;
                        break;
                    }
                }
                if (gt)
                    fini_bh(&gt);
            }
        }
 
    } else {
 
        /*
         * Try to place the inode in its parent directory (GroupHint)
         */
 
        gd = ext4_get_group_desc(sb, GroupHint, &gb);
        if (!gb) {
            DbgBreak();
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto errorout;
        }
 
        if (gd->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT) ||
            ext4_free_inodes_count(sb, gd)) {
 
            Group = GroupHint + 1;
 
        } else {
 
            /* this group is 100% cocucpied */
            fini_bh(&gb);
 
            i = GroupHint;
 
            /*
             * Use a quadratic hash to find a group with a free inode
             */
 
            for (j = 1; j < Vcb->sbi.s_groups_count; j <<= 1) {
 
 
                i = (i + j) % Vcb->sbi.s_groups_count;
                gd = ext4_get_group_desc(sb, i, &gb);
                if (!gd) {
                    DbgBreak();
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    goto errorout;
                }
 
                if (gd->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT) ||
                    ext4_free_inodes_count(sb, gd)) {
                    Group = i + 1;
                    break;
                }
 
                fini_bh(&gb);
            }
        }
 
        if (!Group) {
            /*
             * That failed: try linear search for a free inode
             */
            i = GroupHint;
            for (j = 2; j < Vcb->sbi.s_groups_count; j++) {
 
                i = (i + 1) % Vcb->sbi.s_groups_count;
                gd = ext4_get_group_desc(sb, i, &gb);
                if (!gd) {
                    DbgBreak();
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    goto errorout;
                }
 
                if (gd->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT) ||
                    ext4_free_inodes_count(sb, gd)) {
                    Group = i + 1;
                    break;
                }
 
                fini_bh(&gb);
            }
        }
    }
 
    if (gd == NULL || Group == 0) {
        goto errorout;
    }
 
    /* finally we got the group, but is it valid ? */
    if (Group > Vcb->sbi.s_groups_count) {
        DbgBreak();
        goto errorout;
    }
 
    /* valid group number starts from 1, not 0 */
    Group -= 1;
 
    ASSERT(gd);
    bitmap_blk = ext4_inode_bitmap(sb, gd);
    /* check the block is valid or not */
    if (bitmap_blk == 0 || bitmap_blk >= TOTAL_BLOCKS) {
        DbgBreak();
        Status = STATUS_DISK_CORRUPT_ERROR;
        goto errorout;
    }
 
    if (gd->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
        bh = sb_getblk_zero(sb, bitmap_blk);
        if (!bh) {
            DbgBreak();
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto errorout;
        }
        gd->bg_checksum = ext4_group_desc_csum(EXT3_SB(sb), Group, gd);
        ext4_init_inode_bitmap(sb, bh, Group, gd);
        set_buffer_uptodate(bh);
        gd->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT);
        Ext2SaveGroup(IrpContext, Vcb, Group);
    } else {
        bh = sb_getblk(sb, bitmap_blk);
        if (!bh) {
            DbgBreak();
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto errorout;
        }
    }
 
    if (!buffer_uptodate(bh)) {
        int err = bh_submit_read(bh);
        if (err < 0) {
            DbgPrint("bh_submit_read error! err: %d\n", err);
            Status = Ext2WinntError(err);
            goto errorout;
        }
    }
 
    if (Vcb->sbi.s_groups_count == 1) {
        Length = INODES_COUNT;
    } else {
        if (Group + 1 == Vcb->sbi.s_groups_count) {
            Length = INODES_COUNT % INODES_PER_GROUP;
            if (!Length) {
                /* INODES_COUNT is integer multiple of INODES_PER_GROUP */
                Length = INODES_PER_GROUP;
            }
        } else  {
            Length = INODES_PER_GROUP;
        }
    }
 
    RtlInitializeBitMap(&InodeBitmap, (PULONG)bh->b_data, Length);
    dwInode = RtlFindClearBits(&InodeBitmap, 1, 0);
 
    if (dwInode == 0xFFFFFFFF || dwInode >= Length) {
 
        RtlZeroMemory(&InodeBitmap, sizeof(RTL_BITMAP));
        if (ext4_free_inodes_count(sb, gd) > 0) {
            ext4_free_inodes_set(sb, gd, 0);
            Ext2SaveGroup(IrpContext, Vcb, Group);
        }
        goto repeat;
 
    } else {
 
        __u32 count = 0;
 
        /* update unused inodes count */
        count = ext4_free_inodes_count(sb, gd) - 1;
        ext4_free_inodes_set(sb, gd, count);
 
        RtlSetBits(&InodeBitmap, dwInode, 1);
 
        /* set block bitmap dirty in cache */
        mark_buffer_dirty(bh);
 
        /* If we didn't allocate from within the initialized part of the inode
         * table then we need to initialize up to this inode. */
        if (EXT3_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
 
            __u32 free;
 
            if (gd->bg_flags & cpu_to_le16(EXT4_BG_INODE_UNINIT)) {
                gd->bg_flags &= cpu_to_le16(~EXT4_BG_INODE_UNINIT);
                /* When marking the block group with
                 * ~EXT4_BG_INODE_UNINIT we don't want to depend
                 * on the value of bg_itable_unused even though
                 * mke2fs could have initialized the same for us.
                 * Instead we calculated the value below
                 */
 
                free = 0;
            } else {
                free = EXT3_INODES_PER_GROUP(sb) - ext4_itable_unused_count(sb, gd);
            }
 
            /*
             * Check the relative inode number against the last used
             * relative inode number in this group. if it is greater
             * we need to  update the bg_itable_unused count
             *
             */
            if (dwInode + 1 > free) {
                ext4_itable_unused_set(sb, gd,
                                       (EXT3_INODES_PER_GROUP(sb) - 1 - dwInode));
            }
 
            /* We may have to initialize the block bitmap if it isn't already */
            if (gd->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
 
                struct buffer_head *block_bitmap_bh = NULL;
 
                /* recheck and clear flag under lock if we still need to */
                block_bitmap_bh = sb_getblk_zero(sb, ext4_block_bitmap(sb, gd));
                if (block_bitmap_bh) {
                    gd->bg_checksum = ext4_group_desc_csum(EXT3_SB(sb), Group, gd);
                    free = ext4_init_block_bitmap(sb, block_bitmap_bh, Group, gd);
                    set_buffer_uptodate(block_bitmap_bh);
                    brelse(block_bitmap_bh);
                    gd->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
                    ext4_free_blks_set(sb, gd, free);
                    Ext2SaveGroup(IrpContext, Vcb, Group);
                }
            }
        }
 
        *Inode = dwInode + 1 + Group * INODES_PER_GROUP;
 
        /* update group_desc / super_block */
        if (Type == EXT2_FT_DIR) {
            ext4_used_dirs_set(sb, gd, ext4_used_dirs_count(sb, gd) + 1);
        }
        Ext2SaveGroup(IrpContext, Vcb, Group);
        Ext2UpdateVcbStat(IrpContext, Vcb);
        Status = STATUS_SUCCESS;
    }
 
errorout:
 
    ExReleaseResourceLite(&Vcb->MetaInode);
 
    if (bh)
        fini_bh(&bh);
 
    if (gb)
        fini_bh(&gb);
 
 
    return Status;
}

Referenced by Ext2CreateInode().

Ext2PutGroup()

VOID Ext2PutGroup

(

IN PEXT2_VCB

Vcb

)

Definition at line 150 of file generic.c.

{
    struct ext3_sb_info *sbi = &Vcb->sbi;
    unsigned long i;
 
 
    if (NULL == Vcb->sbi.s_gd) {
        return;
    }
 
    Ext2DropGroupBH(Vcb);
 
    kfree(Vcb->sbi.s_gd);
    Vcb->sbi.s_gd = NULL;
 
    ClearFlag(Vcb->Flags, VCB_GD_LOADED);
}

Referenced by Ext2InitializeVcb(), and Ext2LoadGroup().

Ext2RefreshGroup()

BOOLEAN Ext2RefreshGroup	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb
	)

Definition at line 409 of file generic.c.

{
    return TRUE;
}

Referenced by Ext2RecoverJournal().

Ext2RefreshSuper()

BOOLEAN Ext2RefreshSuper	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb
	)

Definition at line 92 of file generic.c.

{
    LONGLONG        offset;
    IO_STATUS_BLOCK iosb;
 
    offset = (LONGLONG) SUPER_BLOCK_OFFSET;
    if (!CcCopyRead(
                Vcb->Volume,
                (PLARGE_INTEGER)&offset,
                SUPER_BLOCK_SIZE,
                TRUE,
                (PVOID)Vcb->SuperBlock,
                &iosb )) {
        return FALSE;
    }
 
    if (!NT_SUCCESS(iosb.Status)) {
        return FALSE;
    }
 
    /* reload root inode */
    if (Vcb->McbTree) {
 
        if (!Ext2LoadInode(Vcb, &Vcb->McbTree->Inode))
            return FALSE;
 
        /* initializeroot node */
        Vcb->McbTree->CreationTime = Ext2NtTime(Vcb->McbTree->Inode.i_ctime);
        Vcb->McbTree->LastAccessTime = Ext2NtTime(Vcb->McbTree->Inode.i_atime);
        Vcb->McbTree->LastWriteTime = Ext2NtTime(Vcb->McbTree->Inode.i_mtime);
        Vcb->McbTree->ChangeTime = Ext2NtTime(Vcb->McbTree->Inode.i_mtime);
    }
 
    return TRUE;
}

Referenced by Ext2RecoverJournal().

Ext2RemoveEntry()

NTSTATUS Ext2RemoveEntry	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_FCB	Dcb,
		IN PEXT2_MCB	Mcb
	)

Definition at line 2021 of file generic.c.

{
    struct inode *dir = Dcb->Inode;
    struct buffer_head *bh = NULL;
    struct ext3_dir_entry_2 *de;
    struct inode *inode;
    int rc = -ENOENT;
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    BOOLEAN  MainResourceAcquired = FALSE;
 
    if (!IsDirectory(Dcb)) {
        return STATUS_NOT_A_DIRECTORY;
    }
 
    ExAcquireResourceExclusiveLite(&Dcb->MainResource, TRUE);
    MainResourceAcquired = TRUE;
 
    _SEH2_TRY {
 
        Ext2ReferXcb(&Dcb->ReferenceCount);
 
        bh = ext3_find_entry(IrpContext, Mcb->de, &de);
        if (!bh)
            _SEH2_LEAVE;
 
        inode = &Mcb->Inode;
        if (le32_to_cpu(de->inode) != inode->i_ino)
            _SEH2_LEAVE;
 
        if (!inode->i_nlink) {
            ext3_warning (inode->i_sb, "ext3_unlink",
                          "Deleting nonexistent file (%lu), %d",
                          inode->i_ino, inode->i_nlink);
            inode->i_nlink = 1;
        }
        rc = ext3_delete_entry(IrpContext, dir, de, bh);
        if (rc) {
            Status = Ext2WinntError(rc);
            _SEH2_LEAVE;
        }
        /*
                if (!inode->i_nlink)
                    ext3_orphan_add(handle, inode);
        */
        inode->i_ctime = dir->i_ctime = dir->i_mtime = ext3_current_time(dir);
        ext3_dec_count(inode);
        ext3_mark_inode_dirty(IrpContext, inode);
 
        /* decrease dir inode's nlink for .. */
        if (S_ISDIR(inode->i_mode)) {
            ext3_update_dx_flag(dir);
            ext3_dec_count(dir);
            ext3_mark_inode_dirty(IrpContext, dir);
        }
 
        Status = STATUS_SUCCESS;
 
    } _SEH2_FINALLY {
 
        Ext2DerefXcb(&Dcb->ReferenceCount);
 
        if (MainResourceAcquired)
            ExReleaseResourceLite(&Dcb->MainResource);
 
        if (bh)
            brelse(bh);
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DeleteFile(), and Ext2SetRenameInfo().

Ext2SaveBlock()

BOOLEAN Ext2SaveBlock	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN ULONG	Index,
		IN PVOID	Buf
	)

Definition at line 698 of file generic.c.

{
    struct buffer_head *bh = NULL;
    BOOLEAN             rc = 0;
 
    _SEH2_TRY {
 
        bh = sb_getblk_zero(&Vcb->sb, (sector_t)Index);
 
        if (!bh) {
            DEBUG(DL_ERR, ("Ext2Saveblock: can't load block %u\n", Index));
            DbgBreak();
            _SEH2_LEAVE;
        }
 
        if (!buffer_uptodate(bh)) {
        }
 
        RtlCopyMemory(bh->b_data, Buf, BLOCK_SIZE);
        mark_buffer_dirty(bh);
        rc = TRUE;
 
    } _SEH2_FINALLY {
 
        if (bh)
            fini_bh(&bh);
    } _SEH2_END;
 
    return rc;
}

Referenced by Ext2ExpandBlock(), and Ext2ExpandLast().

Ext2SaveBuffer()

BOOLEAN Ext2SaveBuffer	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN LONGLONG	offset,
		IN ULONG	size,
		IN PVOID	buf
	)

Definition at line 928 of file generic.c.

{
    struct buffer_head *bh = NULL;
    BOOLEAN             rc = 0;
 
    __try {
 
        while (size) {
 
            sector_t    block;
            ULONG       len = 0, delta = 0;
 
            block = (sector_t) (offset >> BLOCK_BITS);
            delta = (ULONG)offset & (BLOCK_SIZE - 1);
            len = BLOCK_SIZE - delta;
            if (size < len)
                len = size;
 
            if (delta == 0 && len >= BLOCK_SIZE) {
                bh = sb_getblk_zero(&Vcb->sb, block);
            } else {
                bh = sb_getblk(&Vcb->sb, block);
            }
 
            if (!bh) {
                DEBUG(DL_ERR, ("Ext2SaveBuffer: can't load block %I64u\n", block));
                DbgBreak();
                __leave;
            }
 
            if (!buffer_uptodate(bh)) {
                int err = bh_submit_read(bh);
                if (err < 0) {
                    DEBUG(DL_ERR, ("Ext2SaveBuffer: bh_submit_read failed: %d\n", err));
                    __leave;
                }
            }
 
            __try {
                RtlCopyMemory(bh->b_data + delta, buf, len);
                mark_buffer_dirty(bh);
            } __finally {
                fini_bh(&bh);
            }
 
            buf = (PUCHAR)buf + len;
            offset = offset + len;
            size = size - len;
        }
 
        rc = TRUE;
 
    } __finally {
 
        if (bh)
            fini_bh(&bh);
 
    }
 
    return rc;
}

Referenced by Ext2SaveInode(), Ext2SaveInodeXattr(), Ext2SaveSuper(), and Ext2WriteInode().

Ext2SaveGroup()

BOOLEAN Ext2SaveGroup	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN ULONG	Group
	)

Definition at line 386 of file generic.c.

{
    struct ext4_group_desc *gd;
    struct buffer_head     *gb = NULL;
    unsigned long i;
 
    gd = ext4_get_group_desc(&Vcb->sb, Group, &gb);
    if (!gd)
        return 0;
 
    gd->bg_checksum = ext4_group_desc_csum(&Vcb->sbi, Group, gd);
    mark_buffer_dirty(gb);
    fini_bh(&gb);
 
    return TRUE;
}

Referenced by Ext2FreeBlock(), Ext2FreeInode(), Ext2NewBlock(), Ext2NewInode(), and Ext2UpdateGroupDirStat().

Ext2SaveInode()

BOOLEAN Ext2SaveInode	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN struct inode *	Inode
	)

Definition at line 552 of file generic.c.

{
    struct ext3_inode   ext3i = {0};
 
    LONGLONG            Offset = 0;
    ULONG               InodeSize = sizeof(ext3i);
    BOOLEAN             rc = 0;
 
    DEBUG(DL_INF, ( "Ext2SaveInode: Saving Inode %xh: Mode=%xh Size=%xh\n",
                    Inode->i_ino, Inode->i_mode, Inode->i_size));
    rc = Ext2GetInodeLba(Vcb,  Inode->i_ino, &Offset);
    if (!rc)  {
        DEBUG(DL_ERR, ( "Ext2SaveInode: failed inode %u.\n", Inode->i_ino));
        goto errorout;
    }
 
    rc = Ext2LoadBuffer(NULL, Vcb, Offset, InodeSize, &ext3i);
    if (!rc) {
        DEBUG(DL_ERR, ( "Ext2SaveInode: failed reading inode %u.\n", Inode->i_ino));
        goto errorout;;
    }
 
    Ext2EncodeInode(&ext3i, Inode);
    if (InodeSize > Vcb->InodeSize)
        InodeSize = Vcb->InodeSize;
    rc = Ext2SaveBuffer(IrpContext, Vcb, Offset, InodeSize, &ext3i);
 
    if (rc && IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK)) {
        Ext2StartFloppyFlushDpc(Vcb, NULL, NULL);
    }
 
errorout:
    return rc;
}

Referenced by Ext2Cleanup(), Ext2CreateInode(), Ext2DeleteFile(), Ext2DoExtentExpand(), Ext2ExpandExtent(), Ext2ExpandIndirect(), Ext2FlushFile(), Ext2GetBlock(), Ext2MapExtent(), Ext2MapIndirect(), Ext2SetFileInformation(), Ext2SetReparsePoint(), Ext2SupersedeOrOverWriteFile(), Ext2TruncateExtent(), Ext2TruncateIndirect(), Ext2TruncateSymlink(), Ext2WriteFile(), Ext2WriteSymlink(), ext3_append(), ext3_mark_inode_dirty(), and ext4_fs_put_xattr_ref().

Ext2SaveInodeXattr()

BOOLEAN Ext2SaveInodeXattr	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN struct inode *	Inode,
		IN PEXT2_INODE	InodeXattr
	)

Definition at line 621 of file generic.c.

{
    IO_STATUS_BLOCK     IoStatus;
    LONGLONG            Offset = 0;
    ULONG               InodeSize = Vcb->InodeSize;
    BOOLEAN             rc = 0;
 
    /* There is no way to put EA information in such a small inode */
    if (InodeSize == EXT2_GOOD_OLD_INODE_SIZE)
        return FALSE;
 
    DEBUG(DL_INF, ("Ext2SaveInodeXattr: Saving Inode %xh: Mode=%xh Size=%xh\n",
        Inode->i_ino, Inode->i_mode, Inode->i_size));
    rc = Ext2GetInodeLba(Vcb, Inode->i_ino, &Offset);
    if (!rc) {
        DEBUG(DL_ERR, ("Ext2SaveInodeXattr: error get inode(%xh)'s addr.\n", Inode->i_ino));
        goto errorout;
    }
 
    rc = Ext2SaveBuffer(IrpContext,
                                    Vcb,
                                    Offset + EXT2_GOOD_OLD_INODE_SIZE + Inode->i_extra_isize,
                                    InodeSize - EXT2_GOOD_OLD_INODE_SIZE - Inode->i_extra_isize,
                                    (char *)InodeXattr + EXT2_GOOD_OLD_INODE_SIZE + Inode->i_extra_isize);
 
    if (rc && IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK)) {
        Ext2StartFloppyFlushDpc(Vcb, NULL, NULL);
    }
 
errorout:
    return rc;
}

Referenced by ext4_fs_put_xattr_ref().

Ext2SaveSuper()

BOOLEAN Ext2SaveSuper	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb
	)

Definition at line 67 of file generic.c.

{
    LONGLONG    offset;
    BOOLEAN     rc;
 
    offset = (LONGLONG) SUPER_BLOCK_OFFSET;
    rc = Ext2SaveBuffer( IrpContext,
                         Vcb,
                         offset,
                         SUPER_BLOCK_SIZE,
                         Vcb->SuperBlock
                       );
 
    if (IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK)) {
        Ext2StartFloppyFlushDpc(Vcb, NULL, NULL);
    }
 
    return rc;
}

Referenced by Ext2RecoverJournal(), Ext2SetFileInformation(), Ext2SetVolumeInformation(), Ext2ShutDown(), Ext2UpdateVcbStat(), Ext2WriteFile(), and ext3_inode_blocks_set().

Ext2SetFileType()

NTSTATUS Ext2SetFileType	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_FCB	Dcb,
		IN PEXT2_MCB	Mcb,
		IN umode_t	mode
	)

Definition at line 1951 of file generic.c.

{
    struct inode *dir = Dcb->Inode;
    struct buffer_head *bh = NULL;
    struct ext3_dir_entry_2 *de;
    struct inode *inode;
    NTSTATUS Status = STATUS_UNSUCCESSFUL;
    BOOLEAN  MainResourceAcquired = FALSE;
 
    if (!EXT3_HAS_INCOMPAT_FEATURE(dir->i_sb, EXT3_FEATURE_INCOMPAT_FILETYPE)) {
        return STATUS_SUCCESS;
    }
 
    if (!IsDirectory(Dcb)) {
        return STATUS_NOT_A_DIRECTORY;
    }
 
    ExAcquireResourceExclusiveLite(&Dcb->MainResource, TRUE);
    MainResourceAcquired = TRUE;
 
    _SEH2_TRY {
 
        Ext2ReferXcb(&Dcb->ReferenceCount);
 
        bh = ext3_find_entry(IrpContext, Mcb->de, &de);
        if (!bh)
            _SEH2_LEAVE;
 
        inode = &Mcb->Inode;
        if (le32_to_cpu(de->inode) != inode->i_ino)
            _SEH2_LEAVE;
 
        ext3_set_de_type(inode->i_sb, de, mode);
        mark_buffer_dirty(bh);
 
        if (S_ISDIR(inode->i_mode) == S_ISDIR(mode)) {
        } else if (S_ISDIR(inode->i_mode)) {
            ext3_dec_count(dir);
        } else if (S_ISDIR(mode)) {
            ext3_inc_count(dir);
        }
        dir->i_ctime = dir->i_mtime = ext3_current_time(dir);
        ext3_mark_inode_dirty(IrpContext, dir);
 
        inode->i_mode = mode;
        ext3_mark_inode_dirty(IrpContext, inode);
 
        Status = STATUS_SUCCESS;
 
    } _SEH2_FINALLY {
 
        Ext2DerefXcb(&Dcb->ReferenceCount);
 
        if (MainResourceAcquired)
            ExReleaseResourceLite(&Dcb->MainResource);
 
        if (bh)
            brelse(bh);
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2SetReparsePoint().

Ext2SetParentEntry()

NTSTATUS Ext2SetParentEntry	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_FCB	Dcb,
		IN ULONG	OldParent,
		IN ULONG	NewParent
	)

Definition at line 2098 of file generic.c.

{
    NTSTATUS                Status = STATUS_UNSUCCESSFUL;
 
    PEXT2_DIR_ENTRY2        pSelf   = NULL;
    PEXT2_DIR_ENTRY2        pParent = NULL;
 
    ULONG                   dwBytes = 0;
 
    BOOLEAN                 MainResourceAcquired = FALSE;
 
    ULONG                   Offset = 0;
 
    if (!IsDirectory(Dcb)) {
        return STATUS_NOT_A_DIRECTORY;
    }
 
    if (OldParent == NewParent) {
        return STATUS_SUCCESS;
    }
 
    MainResourceAcquired =
        ExAcquireResourceExclusiveLite(&Dcb->MainResource, TRUE);
 
    _SEH2_TRY {
 
        Ext2ReferXcb(&Dcb->ReferenceCount);
 
        pSelf = (PEXT2_DIR_ENTRY2)
                Ext2AllocatePool(
                    PagedPool,
                    EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2),
                    EXT2_DENTRY_MAGIC
                );
        if (!pSelf) {
            DEBUG(DL_ERR, ( "Ex2SetParentEntry: failed to allocate pSelf.\n"));
            Status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
 
        dwBytes = 0;
 
        //
        // Reading the DCB contents
        //
 
        Status = Ext2ReadInode(
                     IrpContext,
                     Vcb,
                     Dcb->Mcb,
                     (ULONGLONG)Offset,
                     (PVOID)pSelf,
                     EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2),
                     FALSE,
                     &dwBytes );
 
        if (!NT_SUCCESS(Status)) {
            DEBUG(DL_ERR, ( "Ext2SetParentEntry: failed to read directory.\n"));
            _SEH2_LEAVE;
        }
 
        ASSERT(dwBytes == EXT2_DIR_REC_LEN(1) + EXT2_DIR_REC_LEN(2));
 
        pParent = (PEXT2_DIR_ENTRY2)((PUCHAR)pSelf + pSelf->rec_len);
 
        if (pSelf->name_len == 1 && pSelf->name[0] == '.' &&
                pParent->name_len == 2 && pParent->name[0] == '.' &&
                pParent->name[1] == '.') {
 
            if (pParent->inode != OldParent) {
                DbgBreak();
            }
            pParent->inode = NewParent;
 
            Status = Ext2WriteInode(
                         IrpContext,
                         Vcb,
                         Dcb->Mcb,
                         (ULONGLONG)Offset,
                         pSelf,
                         dwBytes,
                         FALSE,
                         &dwBytes );
        } else {
            DbgBreak();
        }
 
    } _SEH2_FINALLY {
 
 
        if (Ext2DerefXcb(&Dcb->ReferenceCount) == 0) {
            DEBUG(DL_ERR, ( "Ext2SetParentEntry: Dcb reference goes to ZERO.\n"));
        }
 
        if (MainResourceAcquired)    {
            ExReleaseResourceLite(&Dcb->MainResource);
        }
 
        if (pSelf) {
            Ext2FreePool(pSelf, EXT2_DENTRY_MAGIC);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2SetRenameInfo().

Ext2UpdateGroupDirStat()

NTSTATUS Ext2UpdateGroupDirStat	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN ULONG	group
	)

Definition at line 1728 of file generic.c.

{
    struct super_block     *sb = &Vcb->sb;
    PEXT2_GROUP_DESC        gd;
    struct buffer_head     *gb = NULL;
    NTSTATUS                status;
 
    ExAcquireResourceExclusiveLite(&Vcb->MetaInode, TRUE);
 
    /* get group desc */
    gd = ext4_get_group_desc(sb, group, &gb);
    if (!gd) {
        status = STATUS_INSUFFICIENT_RESOURCES;
        goto errorout;
    }
 
    /* update group_desc and super_block */
    ext4_used_dirs_set(sb, gd, ext4_used_dirs_count(sb, gd) - 1);
    Ext2SaveGroup(IrpContext, Vcb, group);
    Ext2UpdateVcbStat(IrpContext, Vcb);
    status = STATUS_SUCCESS;
 
errorout:
 
    ExReleaseResourceLite(&Vcb->MetaInode);
 
    if (gb)
        fini_bh(&gb);
 
    return status;
}

Referenced by Ext2SetReparsePoint().

Ext2UpdateVcbStat()

VOID Ext2UpdateVcbStat	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb
	)

Definition at line 997 of file generic.c.

{
    Vcb->SuperBlock->s_free_inodes_count = ext4_count_free_inodes(&Vcb->sb);
    ext3_free_blocks_count_set(SUPER_BLOCK, ext4_count_free_blocks(&Vcb->sb));
    Ext2SaveSuper(IrpContext, Vcb);
}

Referenced by Ext2FreeBlock(), Ext2FreeInode(), Ext2NewBlock(), Ext2NewInode(), and Ext2UpdateGroupDirStat().

Ext2ZeroBuffer()

BOOLEAN Ext2ZeroBuffer	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN LONGLONG	offset,
		IN ULONG	size
	)

Definition at line 795 of file generic.c.

{
    struct buffer_head *bh = NULL;
    BOOLEAN             rc = 0;
 
    _SEH2_TRY {
 
        while (size) {
 
            sector_t    block;
            ULONG       len = 0, delta = 0;
 
            block = (sector_t) (offset >> BLOCK_BITS);
            delta = (ULONG)offset & (BLOCK_SIZE - 1);
            len = BLOCK_SIZE - delta;
            if (size < len)
                len = size;
 
            if (delta == 0 && len >= BLOCK_SIZE) {
                bh = sb_getblk_zero(&Vcb->sb, block);
            } else {
                bh = sb_getblk(&Vcb->sb, block);
            }
 
            if (!bh) {
                DEBUG(DL_ERR, ("Ext2SaveBuffer: can't load block %I64u\n", block));
                DbgBreak();
                _SEH2_LEAVE;
            }
 
            if (!buffer_uptodate(bh)) {
                int err = bh_submit_read(bh);
                if (err < 0) {
                    DEBUG(DL_ERR, ("Ext2SaveBuffer: bh_submit_read failed: %d\n", err));
                    _SEH2_LEAVE;
                }
            }
 
            _SEH2_TRY {
                if (delta == 0 && len >= BLOCK_SIZE) {
                    /* bh (cache) was already cleaned as zero */
                } else {
                    RtlZeroMemory(bh->b_data + delta, len);
                }
                mark_buffer_dirty(bh);
            } _SEH2_FINALLY {
                fini_bh(&bh);
            } _SEH2_END;
 
            offset = offset + len;
            size = size - len;
        }
 
        rc = TRUE;
 
    } _SEH2_FINALLY {
 
        if (bh)
            fini_bh(&bh);
 
    } _SEH2_END;
 
    return rc;
}

Referenced by Ext2ClearInode().

ext3_bg_has_super()

int ext3_bg_has_super	(	struct super_block *	sb,
		ext3_group_t	group
	)

ext4_bg_has_super - number of blocks used by the superblock in group @sb: superblock for filesystem @group: group number to check

Return the number of blocks used by the superblock (primary or backup) in this group. Currently this will be only 0 or 1.

Definition at line 2686 of file generic.c.

{
    if (EXT3_HAS_RO_COMPAT_FEATURE(sb,
                                   EXT3_FEATURE_RO_COMPAT_SPARSE_SUPER) &&
            !ext3_group_sparse(group))
        return 0;
    return 1;
}

Referenced by descriptor_loc(), ext4_bg_num_gdb_nometa(), and ext4_init_block_bitmap().

ext3_check_dir_entry()

int ext3_check_dir_entry	(	const char *	function,
		struct inode *	dir,
		struct ext3_dir_entry_2 *	de,
		struct buffer_head *	bh,
		unsigned long	offset
	)

Definition at line 2209 of file generic.c.

{
    const char * error_msg = NULL;
    const int rlen = ext3_rec_len_from_disk(de->rec_len);
 
    if (rlen < EXT3_DIR_REC_LEN(1))
        error_msg = "rec_len is smaller than minimal";
    else if (rlen % 4 != 0)
        error_msg = "rec_len % 4 != 0";
    else if (rlen < EXT3_DIR_REC_LEN(de->name_len))
        error_msg = "rec_len is too small for name_len";
    else if ((char *) de + rlen > bh->b_data + dir->i_sb->s_blocksize)
        error_msg = "directory entry across blocks";
    else if (le32_to_cpu(de->inode) >
             le32_to_cpu(EXT3_SB(dir->i_sb)->s_es->s_inodes_count))
        error_msg = "inode out of bounds";
 
    if (error_msg != NULL) {
        DEBUG(DL_ERR, ("%s: bad entry in directory %u: %s - "
                       "offset=%u, inode=%u, rec_len=%d, name_len=%d\n",
                       function, dir->i_ino, error_msg, offset,
                       (unsigned long) le32_to_cpu(de->inode),
                       rlen, de->name_len));
    }
    return error_msg == NULL ? 1 : 0;
}

Referenced by add_dirent_to_buf(), ext3_delete_entry(), ext3_is_dir_empty(), and search_dirblock().

ext3_group_sparse()

static int ext3_group_sparse ( ext3_group_t  group )

static

Definition at line 2668 of file generic.c.

{
    if (group <= 1)
        return 1;
    if (!(group & 1))
        return 0;
    return (test_root(group, 7) || test_root(group, 5) ||
            test_root(group, 3));
}

Referenced by ext3_bg_has_super().

ext3_inode_blocks()

blkcnt_t ext3_inode_blocks	(	struct ext3_inode *	raw_inode,
		struct inode *	inode
	)

Definition at line 2395 of file generic.c.

{
    blkcnt_t i_blocks ;
    struct super_block *sb = inode->i_sb;
    PEXT2_VCB Vcb = (PEXT2_VCB)sb->s_priv;
 
    if (EXT3_HAS_RO_COMPAT_FEATURE(sb,
                                   EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
        /* we are using combined 48 bit field */
        i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
                   le32_to_cpu(raw_inode->i_blocks);
        if (inode->i_flags & EXT4_HUGE_FILE_FL) {
            /* i_blocks represent file system block size */
            return i_blocks  << (BLOCK_BITS - 9);
        } else {
            return i_blocks;
        }
    } else {
        return le32_to_cpu(raw_inode->i_blocks);
    }
}

Referenced by Ext2DecodeInode().

ext3_inode_blocks_set()

int ext3_inode_blocks_set	(	struct ext3_inode *	raw_inode,
		struct inode *	inode
	)

Definition at line 2418 of file generic.c.

{
    u64 i_blocks = inode->i_blocks;
    struct super_block *sb = inode->i_sb;
    PEXT2_VCB Vcb = (PEXT2_VCB)sb->s_priv;
 
    if (i_blocks < 0x100000000) {
        /*
         * i_blocks can be represnted in a 32 bit variable
         * as multiple of 512 bytes
         */
        raw_inode->i_blocks = cpu_to_le32(i_blocks);
        raw_inode->i_blocks_high = 0;
        inode->i_flags &= ~EXT4_HUGE_FILE_FL;
        return 0;
    }
 
    if (!EXT3_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
        EXT3_SET_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE);
        Ext2SaveSuper(NULL, Vcb);
    }
 
    if (i_blocks <= 0xffffffffffff) {
        /*
         * i_blocks can be represented in a 48 bit variable
         * as multiple of 512 bytes
         */
        raw_inode->i_blocks = (__u32)cpu_to_le32(i_blocks);
        raw_inode->i_blocks_high = (__u16)cpu_to_le16(i_blocks >> 32);
        inode->i_flags &= ~EXT4_HUGE_FILE_FL;
    } else {
        inode->i_flags |= EXT4_HUGE_FILE_FL;
        /* i_block is stored in file system block size */
        i_blocks = i_blocks >> (BLOCK_BITS - 9);
        raw_inode->i_blocks  = (__u32)cpu_to_le32(i_blocks);
        raw_inode->i_blocks_high = (__u16)cpu_to_le16(i_blocks >> 32);
    }
    return 0;
}

Referenced by Ext2EncodeInode().

ext3_max_bitmap_size()

loff_t ext3_max_bitmap_size	(	int	bits,
		int	has_huge_files
	)

Definition at line 2337 of file generic.c.

{
    loff_t res = EXT3_NDIR_BLOCKS;
    int meta_blocks;
    loff_t upper_limit;
    /* This is calculated to be the largest file size for a
     * dense, bitmapped file such that the total number of
     * sectors in the file, including data and all indirect blocks,
     * does not exceed 2^48 -1
     * __u32 i_blocks_lo and _u16 i_blocks_high representing the
     * total number of  512 bytes blocks of the file
     */
 
    if (!has_huge_files) {
        /*
         * !has_huge_files or CONFIG_LBD is not enabled
         * implies the inode i_block represent total blocks in
         * 512 bytes 32 == size of vfs inode i_blocks * 8
         */
        upper_limit = ((loff_t)1 << 32) - 1;
 
        /* total blocks in file system block size */
        upper_limit >>= (bits - 9);
 
    } else {
        /*
         * We use 48 bit ext4_inode i_blocks
         * With EXT4_HUGE_FILE_FL set the i_blocks
         * represent total number of blocks in
         * file system block size
         */
        upper_limit = ((loff_t)1 << 48) - 1;
 
    }
 
    /* indirect blocks */
    meta_blocks = 1;
    /* double indirect blocks */
    meta_blocks += 1 + ((loff_t)1 << (bits-2));
    /* tripple indirect blocks */
    meta_blocks += 1 + ((loff_t)1 << (bits-2)) + ((loff_t)1 << (2*(bits-2)));
 
    upper_limit -= meta_blocks;
    upper_limit <<= bits;
 
    res += (loff_t)1 << (bits-2);
    res += (loff_t)1 << (2*(bits-2));
    res += (loff_t)1 << (3*(bits-2));
    res <<= bits;
    if (res > upper_limit)
        res = upper_limit;
 
    if (res > MAX_LFS_FILESIZE)
        res = MAX_LFS_FILESIZE;
 
    return res;
}

Referenced by Ext2InitializeVcb().

ext3_max_size()

loff_t ext3_max_size	(	int	blkbits,
		int	has_huge_files
	)

Definition at line 2301 of file generic.c.

{
    loff_t res;
    loff_t upper_limit = MAX_LFS_FILESIZE;
 
    /* small i_blocks in vfs inode? */
    if (!has_huge_files) {
        /*
         * CONFIG_LBD is not enabled implies the inode
         * i_block represent total blocks in 512 bytes
         * 32 == size of vfs inode i_blocks * 8
         */
        upper_limit = ((loff_t)1 << 32) - 1;
 
        /* total blocks in file system block size */
        upper_limit >>= (blkbits - 9);
        upper_limit <<= blkbits;
    }
 
    /* 32-bit extent-start container, ee_block */
    res = (loff_t)1 << 32;
    res <<= blkbits;
    res -= 1;
 
    /* Sanity check against vm- & vfs- imposed limits */
    if (res > upper_limit)
        res = upper_limit;
 
    return res;
}

Referenced by Ext2InitializeVcb().

ext3_next_entry()

struct ext3_dir_entry_2 * ext3_next_entry

(

struct ext3_dir_entry_2 *

p

)

Definition at line 2244 of file generic.c.

{
    return (struct ext3_dir_entry_2 *)((char *)p +
                                       ext3_rec_len_from_disk(p->rec_len));
}

Referenced by ext3_delete_entry(), and ext3_is_dir_empty().

ext4_bg_num_gdb()

unsigned long ext4_bg_num_gdb	(	struct super_block *	sb,
		ext4_group_t	group
	)

ext4_bg_num_gdb - number of blocks used by the group table in group @sb: superblock for filesystem @group: group number to check

Return the number of blocks used by the group descriptor table (primary or backup) in this group. In the future there may be a different number of descriptor blocks in each group.

Definition at line 2722 of file generic.c.

{
    unsigned long first_meta_bg =
        le32_to_cpu(EXT3_SB(sb)->s_es->s_first_meta_bg);
    unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
 
    if (!EXT3_HAS_INCOMPAT_FEATURE(sb,EXT4_FEATURE_INCOMPAT_META_BG) ||
            metagroup < first_meta_bg)
        return ext4_bg_num_gdb_nometa(sb, group);
 
    return ext4_bg_num_gdb_meta(sb,group);
 
}

Referenced by ext4_init_block_bitmap().

ext4_bg_num_gdb_meta()

static unsigned long ext4_bg_num_gdb_meta ( struct super_block *  sb, ext4_group_t  group  )

static

Definition at line 2695 of file generic.c.

{
    unsigned long metagroup = group / EXT4_DESC_PER_BLOCK(sb);
    ext4_group_t first = metagroup * EXT4_DESC_PER_BLOCK(sb);
    ext4_group_t last = first + EXT4_DESC_PER_BLOCK(sb) - 1;
 
    if (group == first || group == first + 1 || group == last)
        return 1;
    return 0;
}

Referenced by ext4_bg_num_gdb().

ext4_bg_num_gdb_nometa()

static unsigned long ext4_bg_num_gdb_nometa ( struct super_block *  sb, ext4_group_t  group  )

static

Definition at line 2707 of file generic.c.

{
    return ext3_bg_has_super(sb, group) ? EXT3_SB(sb)->s_gdb_count : 0;
}

Referenced by ext4_bg_num_gdb().

ext4_block_bitmap()

ext4_fsblk_t ext4_block_bitmap	(	struct super_block *	sb,
		struct ext4_group_desc *	bg
	)

Definition at line 2459 of file generic.c.

{
    return le32_to_cpu(bg->bg_block_bitmap) |
           (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
            (ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
}

Referenced by Ext2CheckBitmapConsistency(), Ext2CheckSetBlock(), Ext2FreeBlock(), Ext2NewBlock(), Ext2NewInode(), ext4_check_descriptors(), ext4_group_used_meta_blocks(), and ext4_init_block_bitmap().

ext4_block_bitmap_set()

void ext4_block_bitmap_set	(	struct super_block *	sb,
		struct ext4_group_desc *	bg,
		ext4_fsblk_t	blk
	)

Definition at line 2515 of file generic.c.

{
    bg->bg_block_bitmap = cpu_to_le32((u32)blk);
    if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
        bg->bg_block_bitmap_hi = cpu_to_le32(blk >> 32);
}

ext4_block_in_group()

static int ext4_block_in_group ( struct super_block *  sb, ext4_fsblk_t  block, ext4_group_t  block_group  )

static

Definition at line 2832 of file generic.c.

{
    ext4_group_t actual_group;
    ext4_get_group_no_and_offset(sb, block, &actual_group, NULL);
    if (actual_group == block_group)
        return 1;
    return 0;
}

Referenced by ext4_group_used_meta_blocks(), and ext4_init_block_bitmap().

ext4_check_descriptors()

int ext4_check_descriptors

(

struct super_block *

sb

)

Definition at line 3091 of file generic.c.

{
    PEXT2_VCB            Vcb = sb->s_priv;
    struct ext3_sb_info *sbi = EXT3_SB(sb);
    ext4_fsblk_t first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
    ext4_fsblk_t last_block;
    ext4_fsblk_t block_bitmap;
    ext4_fsblk_t inode_bitmap;
    ext4_fsblk_t inode_table;
    int flexbg_flag = 0;
    ext4_group_t i;
 
    if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
        flexbg_flag = 1;
 
    DEBUG(DL_INF, ("Checking group descriptors"));
 
    for (i = 0; i < sbi->s_groups_count; i++) {
 
        struct buffer_head *bh = NULL;
        struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, &bh);
 
        if (!bh)
            continue;
 
        if (i == sbi->s_groups_count - 1 || flexbg_flag)
            last_block = ext3_blocks_count(sbi->s_es) - 1;
        else
            last_block = first_block +
                         (EXT3_BLOCKS_PER_GROUP(sb) - 1);
 
        block_bitmap = ext4_block_bitmap(sb, gdp);
        if (block_bitmap < first_block || block_bitmap > last_block) {
            printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
                   "Block bitmap for group %u not in group "
                   "(block %llu)!\n", i, block_bitmap);
            __brelse(bh);
            return 0;
        }
        inode_bitmap = ext4_inode_bitmap(sb, gdp);
        if (inode_bitmap < first_block || inode_bitmap > last_block) {
            printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
                   "Inode bitmap for group %u not in group "
                   "(block %llu)!\n", i, inode_bitmap);
            __brelse(bh);
            return 0;
        }
        inode_table = ext4_inode_table(sb, gdp);
        if (inode_table < first_block ||
                inode_table + sbi->s_itb_per_group - 1 > last_block) {
            printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
                   "Inode table for group %u not in group "
                   "(block %llu)!\n", i, inode_table);
            __brelse(bh);
            return 0;
        }
 
        if (!ext4_group_desc_csum_verify(sbi, i, gdp)) {
            printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
                   "Checksum for group %u failed (%u!=%u)\n",
                   i, le16_to_cpu(ext4_group_desc_csum(sbi, i,
                                                       gdp)),
                   le16_to_cpu(gdp->bg_checksum));
            if (!IsVcbReadOnly(Vcb)) {
                __brelse(bh);
                return 0;
            }
        }
 
        if (!flexbg_flag)
            first_block += EXT4_BLOCKS_PER_GROUP(sb);
 
        __brelse(bh);
    }
 
    ext3_free_blocks_count_set(sbi->s_es, ext4_count_free_blocks(sb));
    sbi->s_es->s_free_inodes_count = cpu_to_le32(ext4_count_free_inodes(sb));
    return 1;
}

Referenced by Ext2LoadGroup().

ext4_count_dirs()

unsigned long ext4_count_dirs

(

struct super_block *

sb

)

Definition at line 3073 of file generic.c.

{
    struct ext4_group_desc *gdp;
    struct buffer_head *bh = NULL;
    unsigned long count = 0;
    ext4_group_t i;
 
    for (i = 0; i < EXT3_SB(sb)->s_groups_count; i++) {
        gdp = ext4_get_group_desc(sb, i, &bh);
        if (!bh)
            continue;
        count += ext4_used_dirs_count(sb, gdp);
        fini_bh(&bh);
    }
    return count;
}

ext4_count_free_blocks()

ext4_fsblk_t ext4_count_free_blocks

(

struct super_block *

sb

)

ext4_count_free_blocks() – count filesystem free blocks @sb: superblock

Adds up the number of free blocks from each block group.

Definition at line 3033 of file generic.c.

{
    ext4_fsblk_t desc_count;
    struct ext4_group_desc *gdp;
    struct buffer_head *bh = NULL;
    ext4_group_t i;
    ext4_group_t ngroups = EXT3_SB(sb)->s_groups_count;
 
    desc_count = 0;
    smp_rmb();
    for (i = 0; i < ngroups; i++) {
        gdp = ext4_get_group_desc(sb, i, &bh);
        if (!bh)
            continue;
        desc_count += ext4_free_blks_count(sb, gdp);
        fini_bh(&bh);
    }
 
    return desc_count;
}

Referenced by Ext2UpdateVcbStat(), and ext4_check_descriptors().

ext4_count_free_inodes()

unsigned long ext4_count_free_inodes

(

struct super_block *

sb

)

Definition at line 3054 of file generic.c.

{
    unsigned long desc_count;
    struct ext4_group_desc *gdp;
    struct buffer_head *bh = NULL;
    ext4_group_t i;
 
    desc_count = 0;
    for (i = 0; i < EXT3_SB(sb)->s_groups_count; i++) {
        gdp = ext4_get_group_desc(sb, i, &bh);
        if (!bh)
            continue;
        desc_count += ext4_free_inodes_count(sb, gdp);
        fini_bh(&bh);
    }
    return desc_count;
}

Referenced by Ext2UpdateVcbStat(), and ext4_check_descriptors().

ext4_free_blks_count()

__u32 ext4_free_blks_count	(	struct super_block *	sb,
		struct ext4_group_desc *	bg
	)

Definition at line 2483 of file generic.c.

{
    return le16_to_cpu(bg->bg_free_blocks_count) |
           (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
            (__u32)le16_to_cpu(bg->bg_free_blocks_count_hi) << 16 : 0);
}

Referenced by Ext2NewBlock(), and ext4_count_free_blocks().

ext4_free_blks_set()

void ext4_free_blks_set	(	struct super_block *	sb,
		struct ext4_group_desc *	bg,
		__u32	count
	)

Definition at line 2539 of file generic.c.

{
    bg->bg_free_blocks_count = cpu_to_le16((__u16)count);
    if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
        bg->bg_free_blocks_count_hi = cpu_to_le16(count >> 16);
}

Referenced by Ext2FreeBlock(), Ext2NewBlock(), Ext2NewInode(), ext4_init_block_bitmap(), and ext4_init_inode_bitmap().

ext4_free_inodes_count()

__u32 ext4_free_inodes_count	(	struct super_block *	sb,
		struct ext4_group_desc *	bg
	)

Definition at line 2491 of file generic.c.

{
    return le16_to_cpu(bg->bg_free_inodes_count) |
           (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
            (__u32)le16_to_cpu(bg->bg_free_inodes_count_hi) << 16 : 0);
}

Referenced by Ext2NewInode(), and ext4_count_free_inodes().

ext4_free_inodes_set()

void ext4_free_inodes_set	(	struct super_block *	sb,
		struct ext4_group_desc *	bg,
		__u32	count
	)

Definition at line 2547 of file generic.c.

{
    bg->bg_free_inodes_count = cpu_to_le16((__u16)count);
    if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
        bg->bg_free_inodes_count_hi = cpu_to_le16(count >> 16);
}

Referenced by Ext2FreeInode(), Ext2NewInode(), ext4_init_block_bitmap(), and ext4_init_inode_bitmap().

ext4_get_group_desc()

struct ext4_group_desc * ext4_get_group_desc	(	struct super_block *	sb,
		ext4_group_t	block_group,
		struct buffer_head **	bh
	)

ext4_get_group_desc() – load group descriptor from disk @sb: super block @block_group: given block group @bh: pointer to the buffer head to store the block group descriptor

Definition at line 2976 of file generic.c.

{
    struct ext4_group_desc *desc = NULL;
    struct ext3_sb_info *sbi = EXT3_SB(sb);
    PEXT2_VCB vcb = sb->s_priv;
    ext4_group_t group;
    ext4_group_t offset;
 
    if (bh)
        *bh = NULL;
 
    if (block_group >= sbi->s_groups_count) {
        ext4_error(sb, "ext4_get_group_desc",
                   "block_group >= groups_count - "
                   "block_group = %u, groups_count = %u",
                   block_group, sbi->s_groups_count);
 
        return NULL;
    }
 
    _SEH2_TRY {
 
        group = block_group >> EXT4_DESC_PER_BLOCK_BITS(sb);
        offset = block_group & (EXT4_DESC_PER_BLOCK(sb) - 1);
 
        if (!sbi->s_gd) {
            if (!Ext2LoadGroup(vcb)) {
                _SEH2_LEAVE;
            }
        } else if ( !sbi->s_gd[group].block ||
                    !sbi->s_gd[group].bh) {
            if (!Ext2LoadGroupBH(vcb)) {
                _SEH2_LEAVE;
            }
        }
 
        desc = (struct ext4_group_desc *)((PCHAR)sbi->s_gd[group].gd +
                                          offset * EXT4_DESC_SIZE(sb));
        if (bh) {
            atomic_inc(&sbi->s_gd[group].bh->b_count);
            *bh = sbi->s_gd[group].bh;
        }
    } _SEH2_FINALLY {
        /* do cleanup */
    } _SEH2_END;
 
    return desc;
}

Referenced by Ext2CheckBitmapConsistency(), Ext2CheckSetBlock(), Ext2FreeBlock(), Ext2FreeInode(), Ext2GetInodeLba(), Ext2NewBlock(), Ext2NewInode(), Ext2SaveGroup(), Ext2UpdateGroupDirStat(), ext4_check_descriptors(), ext4_count_dirs(), ext4_count_free_blocks(), ext4_count_free_inodes(), and ext4_group_used_meta_blocks().

ext4_get_group_no_and_offset()

void ext4_get_group_no_and_offset	(	struct super_block *	sb,
		ext4_fsblk_t	blocknr,
		ext4_group_t *	blockgrpp,
		ext4_grpblk_t *	offsetp
	)

Definition at line 2817 of file generic.c.

{
    struct ext3_super_block *es = EXT3_SB(sb)->s_es;
    ext4_grpblk_t offset;
 
    blocknr = blocknr - le32_to_cpu(es->s_first_data_block);
    offset = do_div(blocknr, EXT4_BLOCKS_PER_GROUP(sb));
    if (offsetp)
        *offsetp = offset;
    if (blockgrpp)
        *blockgrpp = (ext4_grpblk_t)blocknr;
 
}

Referenced by ext4_block_in_group().

ext4_group_desc_csum()

__le16 ext4_group_desc_csum	(	struct ext3_sb_info *	sbi,
		__u32	block_group,
		struct ext4_group_desc *	gdp
	)

Definition at line 2619 of file generic.c.

{
    int offset;
    __u16 crc = 0;
    __le32 le_group = cpu_to_le32(block_group);
 
    /* old crc16 code */
    if (!(sbi->s_es->s_feature_ro_compat &
          cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)))
        return 0;
 
    offset = offsetof(struct ext4_group_desc, bg_checksum);
 
    crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
    crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
    crc = crc16(crc, (__u8 *)gdp, offset);
    offset += sizeof(gdp->bg_checksum); /* skip checksum */
    /* for checksum of struct ext4_group_desc do the rest...*/
    if ((sbi->s_es->s_feature_incompat &
         cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) &&
        offset < le16_to_cpu(sbi->s_es->s_desc_size))
        crc = crc16(crc, (__u8 *)gdp + offset,
                le16_to_cpu(sbi->s_es->s_desc_size) -
                offset);
 
    return cpu_to_le16(crc);
}

Referenced by Ext2NewBlock(), Ext2NewInode(), Ext2SaveGroup(), ext4_check_descriptors(), and ext4_group_desc_csum_verify().

ext4_group_desc_csum_verify()

int ext4_group_desc_csum_verify	(	struct ext3_sb_info *	sbi,
		__u32	block_group,
		struct ext4_group_desc *	gdp
	)

Definition at line 2648 of file generic.c.

{
    if ((sbi->s_es->s_feature_ro_compat & cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) &&
        (gdp->bg_checksum != ext4_group_desc_csum(sbi, block_group, gdp)))
        return 0;
 
    return 1;
}

Referenced by ext4_check_descriptors(), ext4_init_block_bitmap(), and ext4_init_inode_bitmap().

ext4_group_used_meta_blocks()

static int ext4_group_used_meta_blocks ( struct super_block *  sb, ext4_group_t  block_group  )

static

Definition at line 2842 of file generic.c.

{
    ext4_fsblk_t tmp;
    struct ext3_sb_info *sbi = EXT3_SB(sb);
    /* block bitmap, inode bitmap, and inode table blocks */
    int used_blocks = sbi->s_itb_per_group + 2;
 
    if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
        struct ext4_group_desc *gdp;
        struct buffer_head *bh = NULL;
 
        gdp = ext4_get_group_desc(sb, block_group, &bh);
        if (!ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp),
                                 block_group))
            used_blocks--;
 
        if (!ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp),
                                 block_group))
            used_blocks--;
 
        tmp = ext4_inode_table(sb, gdp);
        for (; tmp < ext4_inode_table(sb, gdp) +
                sbi->s_itb_per_group; tmp++) {
            if (!ext4_block_in_group(sb, tmp, block_group))
                used_blocks -= 1;
        }
        if (bh)
            fini_bh(&bh);
    }
    return used_blocks;
}

Referenced by ext4_init_block_bitmap().

ext4_init_block_bitmap()

unsigned ext4_init_block_bitmap	(	struct super_block *	sb,
		struct buffer_head *	bh,
		ext4_group_t	block_group,
		struct ext4_group_desc *	gdp
	)

Definition at line 2877 of file generic.c.

{
    int bit, bit_max;
    unsigned free_blocks, group_blocks;
    struct ext3_sb_info *sbi = EXT3_SB(sb);
 
    if (bh) {
        mark_buffer_dirty(bh);
        /* If checksum is bad mark all blocks used to prevent allocation
         * essentially implementing a per-group read-only flag. */
        if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
            ext4_error(sb, __FUNCTION__,
                       "Checksum bad for group %u", block_group);
            ext4_free_blks_set(sb, gdp, 0);
            ext4_free_inodes_set(sb, gdp, 0);
            ext4_itable_unused_set(sb, gdp, 0);
            memset(bh->b_data, 0xff, sb->s_blocksize);
            return 0;
        }
        memset(bh->b_data, 0, sb->s_blocksize);
    }
 
    /* Check for superblock and gdt backups in this group */
    bit_max = ext3_bg_has_super(sb, block_group);
 
    if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||
            block_group < le32_to_cpu(sbi->s_es->s_first_meta_bg) *
            sbi->s_desc_per_block) {
        if (bit_max) {
            bit_max += ext4_bg_num_gdb(sb, block_group);
            bit_max +=
                le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks);
        }
    } else { /* For META_BG_BLOCK_GROUPS */
        bit_max += ext4_bg_num_gdb(sb, block_group);
    }
 
    if (block_group == sbi->s_groups_count - 1) {
        /*
         * Even though mke2fs always initialize first and last group
         * if some other tool enabled the EXT4_BG_BLOCK_UNINIT we need
         * to make sure we calculate the right free blocks
         */
        group_blocks = (unsigned int)(ext3_blocks_count(sbi->s_es) -
                                      le32_to_cpu(sbi->s_es->s_first_data_block) -
                                      (EXT4_BLOCKS_PER_GROUP(sb) * (sbi->s_groups_count - 1)));
    } else {
        group_blocks = EXT4_BLOCKS_PER_GROUP(sb);
    }
 
    free_blocks = group_blocks - bit_max;
 
    if (bh) {
        ext4_fsblk_t start, tmp;
        int flex_bg = 0;
 
        for (bit = 0; bit < bit_max; bit++)
            ext4_set_bit(bit, bh->b_data);
 
        start = ext3_group_first_block_no(sb, block_group);
 
        if (EXT3_HAS_INCOMPAT_FEATURE(sb,
                                      EXT4_FEATURE_INCOMPAT_FLEX_BG))
            flex_bg = 1;
 
        /* Set bits for block and inode bitmaps, and inode table */
        tmp = ext4_block_bitmap(sb, gdp);
        if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
            ext4_set_bit(tmp - start, bh->b_data);
 
        tmp = ext4_inode_bitmap(sb, gdp);
        if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
            ext4_set_bit(tmp - start, bh->b_data);
 
        tmp = ext4_inode_table(sb, gdp);
        for (; tmp < ext4_inode_table(sb, gdp) +
                sbi->s_itb_per_group; tmp++) {
            if (!flex_bg ||
                    ext4_block_in_group(sb, tmp, block_group))
                ext4_set_bit(tmp - start, bh->b_data);
        }
        /*
         * Also if the number of blocks within the group is
         * less than the blocksize * 8 ( which is the size
         * of bitmap ), set rest of the block bitmap to 1
         */
        mark_bitmap_end(group_blocks, sb->s_blocksize * 8, bh->b_data);
    }
    return free_blocks - ext4_group_used_meta_blocks(sb, block_group);
}

Referenced by Ext2NewBlock(), and Ext2NewInode().

ext4_init_inode_bitmap()

unsigned ext4_init_inode_bitmap	(	struct super_block *	sb,
		struct buffer_head *	bh,
		ext4_group_t	block_group,
		struct ext4_group_desc *	gdp
	)

Definition at line 2786 of file generic.c.

{
    struct ext3_sb_info *sbi = EXT3_SB(sb);
 
    mark_buffer_dirty(bh);
 
    /* If checksum is bad mark all blocks and inodes use to prevent
     * allocation, essentially implementing a per-group read-only flag. */
    if (!ext4_group_desc_csum_verify(sbi, block_group, gdp)) {
        ext4_error(sb, __FUNCTION__, "Checksum bad for group %u",
                   block_group);
        ext4_free_blks_set(sb, gdp, 0);
        ext4_free_inodes_set(sb, gdp, 0);
        ext4_itable_unused_set(sb, gdp, 0);
        memset(bh->b_data, 0xff, sb->s_blocksize);
        return 0;
    }
 
    memset(bh->b_data, 0, (EXT4_INODES_PER_GROUP(sb) + 7) / 8);
    mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), sb->s_blocksize * 8,
                    bh->b_data);
    ext4_itable_unused_set(sb, gdp, EXT4_INODES_PER_GROUP(sb));
 
    return EXT4_INODES_PER_GROUP(sb);
}

Referenced by Ext2NewInode().

ext4_inode_bitmap()

ext4_fsblk_t ext4_inode_bitmap	(	struct super_block *	sb,
		struct ext4_group_desc *	bg
	)

Definition at line 2467 of file generic.c.

{
    return le32_to_cpu(bg->bg_inode_bitmap) |
           (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
            (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
}

Referenced by Ext2CheckBitmapConsistency(), Ext2FreeInode(), Ext2NewBlock(), Ext2NewInode(), ext4_check_descriptors(), ext4_group_used_meta_blocks(), and ext4_init_block_bitmap().

ext4_inode_bitmap_set()

void ext4_inode_bitmap_set	(	struct super_block *	sb,
		struct ext4_group_desc *	bg,
		ext4_fsblk_t	blk
	)

Definition at line 2523 of file generic.c.

{
    bg->bg_inode_bitmap  = cpu_to_le32((u32)blk);
    if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
        bg->bg_inode_bitmap_hi = cpu_to_le32(blk >> 32);
}

ext4_inode_table()

ext4_fsblk_t ext4_inode_table	(	struct super_block *	sb,
		struct ext4_group_desc *	bg
	)

Definition at line 2475 of file generic.c.

{
    return le32_to_cpu(bg->bg_inode_table) |
           (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
            (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
}

Referenced by Ext2CheckBitmapConsistency(), Ext2GetInodeLba(), Ext2NewBlock(), ext4_check_descriptors(), ext4_group_used_meta_blocks(), and ext4_init_block_bitmap().

ext4_inode_table_set()

void ext4_inode_table_set	(	struct super_block *	sb,
		struct ext4_group_desc *	bg,
		ext4_fsblk_t	blk
	)

Definition at line 2531 of file generic.c.

{
    bg->bg_inode_table = cpu_to_le32((u32)blk);
    if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
        bg->bg_inode_table_hi = cpu_to_le32(blk >> 32);
}

ext4_itable_unused_count()

__u32 ext4_itable_unused_count	(	struct super_block *	sb,
		struct ext4_group_desc *	bg
	)

Definition at line 2507 of file generic.c.

{
    return le16_to_cpu(bg->bg_itable_unused) |
           (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
            (__u32)le16_to_cpu(bg->bg_itable_unused_hi) << 16 : 0);
}

Referenced by Ext2NewInode().

ext4_itable_unused_set()

void ext4_itable_unused_set	(	struct super_block *	sb,
		struct ext4_group_desc *	bg,
		__u32	count
	)

Definition at line 2563 of file generic.c.

{
    bg->bg_itable_unused = cpu_to_le16((__u16)count);
    if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
        bg->bg_itable_unused_hi = cpu_to_le16(count >> 16);
}

Referenced by Ext2NewInode(), ext4_init_block_bitmap(), and ext4_init_inode_bitmap().

ext4_max_size()

static loff_t ext4_max_size ( int  blkbits, int  has_huge_files  )

static

Definition at line 2261 of file generic.c.

{
    loff_t res;
    loff_t upper_limit = MAX_LFS_FILESIZE;
 
    /* small i_blocks in vfs inode? */
    if (!has_huge_files || sizeof(blkcnt_t) < sizeof(u64)) {
        /*
         * CONFIG_LBD is not enabled implies the inode
         * i_block represent total blocks in 512 bytes
         * 32 == size of vfs inode i_blocks * 8
         */
        upper_limit = (1LL << 32) - 1;
 
        /* total blocks in file system block size */
        upper_limit >>= (blkbits - 9);
        upper_limit <<= blkbits;
    }
 
    /* 32-bit extent-start container, ee_block */
    res = 1LL << 32;
    res <<= blkbits;
    res -= 1;
 
    /* Sanity check against vm- & vfs- imposed limits */
    if (res > upper_limit)
        res = upper_limit;
 
    return res;
}

ext4_used_dirs_count()

__u32 ext4_used_dirs_count	(	struct super_block *	sb,
		struct ext4_group_desc *	bg
	)

Definition at line 2499 of file generic.c.

{
    return le16_to_cpu(bg->bg_used_dirs_count) |
           (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
            (__u32)le16_to_cpu(bg->bg_used_dirs_count_hi) << 16 : 0);
}

Referenced by Ext2FreeInode(), Ext2NewInode(), Ext2UpdateGroupDirStat(), and ext4_count_dirs().

ext4_used_dirs_set()

void ext4_used_dirs_set	(	struct super_block *	sb,
		struct ext4_group_desc *	bg,
		__u32	count
	)

Definition at line 2555 of file generic.c.

{
    bg->bg_used_dirs_count = cpu_to_le16((__u16)count);
    if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
        bg->bg_used_dirs_count_hi = cpu_to_le16(count >> 16);
}

Referenced by Ext2FreeInode(), Ext2NewInode(), and Ext2UpdateGroupDirStat().

mark_bitmap_end()

void mark_bitmap_end	(	int	start_bit,
		int	end_bit,
		char *	bitmap
	)

Definition at line 2771 of file generic.c.

{
    int i;
 
    if (start_bit >= end_bit)
        return;
 
    DEBUG(DL_INF, ("mark end bits +%d through +%d used\n", start_bit, end_bit));
    for (i = start_bit; (unsigned)i < ((start_bit + 7) & ~7UL); i++)
        ext4_set_bit(i, bitmap);
    if (i < end_bit)
        memset(bitmap + (i >> 3), 0xff, (end_bit - i) >> 3);
}

Referenced by ext4_init_block_bitmap(), and ext4_init_inode_bitmap().

test_root()

static int test_root ( ext3_group_t  a, ext3_group_t  b  )

inlinestatic

Definition at line 2659 of file generic.c.

{
    ext3_group_t num = b;
 
    while (a > num)
        num *= b;
    return num == a;
}

Referenced by ext3_group_sparse().

Variable Documentation

crc16_table

__u16 const crc16_table[256]

CRC table for the CRC-16. The poly is 0x8005 (x16 + x15 + x2 + 1)

Definition at line 2572 of file generic.c.

Referenced by crc16_byte().

Ext2Global

PEXT2_GLOBAL Ext2Global

extern

Definition at line 16 of file init.c.