#include <ndk/kefuncs.h>
#include <ndk/rtlfuncs.h>
#include "ext2_fs.h"

Include dependency graph for Mke2fs.h:

This graph shows which files directly or indirectly include this file:

Classes
struct	_GUID

struct	_ext2fs_bitmap

struct	ext2_struct_badblocks_list

struct	_ext2_filesys

struct	_EXT2_BDL

Macros
#define	NTOS_MODE_USER

#define	SECTOR_SIZE (Ext2Sys->DiskGeometry.BytesPerSector)

#define	GUID_DEFINED

#define	UUID_DEFINED

#define	uuid_t UUID

#define	bool BOOLEAN

#define	true TRUE

#define	false FALSE

#define	EXT2_CHECK_MAGIC(struct, code) if ((struct)->magic != (code)) return (code)

#define	EXT2_SF_CHK_BADBLOCKS 0x0001

#define	EXT2_SF_BAD_INODE_BLK 0x0002

#define	EXT2_SF_BAD_EXTRA_BYTES 0x0004

#define	EXT2_SF_SKIP_MISSING_ITABLE 0x0008

#define	EXT2_MF_MOUNTED 1

#define	EXT2_MF_ISROOT 2

#define	EXT2_MF_READONLY 4

#define	EXT2_MF_SWAP 8

#define	LINUX_S_IFMT 00170000

#define	LINUX_S_IFSOCK 0140000

#define	LINUX_S_IFLNK 0120000

#define	LINUX_S_IFREG 0100000

#define	LINUX_S_IFBLK 0060000

#define	LINUX_S_IFDIR 0040000

#define	LINUX_S_IFCHR 0020000

#define	LINUX_S_IFIFO 0010000

#define	LINUX_S_ISUID 0004000

#define	LINUX_S_ISGID 0002000

#define	LINUX_S_ISVTX 0001000

#define	LINUX_S_IRWXU 00700

#define	LINUX_S_IRUSR 00400

#define	LINUX_S_IWUSR 00200

#define	LINUX_S_IXUSR 00100

#define	LINUX_S_IRWXG 00070

#define	LINUX_S_IRGRP 00040

#define	LINUX_S_IWGRP 00020

#define	LINUX_S_IXGRP 00010

#define	LINUX_S_IRWXO 00007

#define	LINUX_S_IROTH 00004

#define	LINUX_S_IWOTH 00002

#define	LINUX_S_IXOTH 00001

#define	LINUX_S_ISLNK(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFLNK)

#define	LINUX_S_ISREG(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFREG)

#define	LINUX_S_ISDIR(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFDIR)

#define	LINUX_S_ISCHR(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFCHR)

#define	LINUX_S_ISBLK(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFBLK)

#define	LINUX_S_ISFIFO(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFIFO)

#define	LINUX_S_ISSOCK(m) (((m) & LINUX_S_IFMT) == LINUX_S_IFSOCK)

#define	EXT2_FIRST_INODE(s) EXT2_FIRST_INO(s)

#define	SUPERBLOCK_OFFSET 1024

#define	SUPERBLOCK_SIZE 1024

#define	ext2_mark_block_bitmap ext2_mark_bitmap

#define	ext2_mark_inode_bitmap ext2_mark_bitmap

#define	ext2_unmark_block_bitmap ext2_unmark_bitmap

#define	ext2_unmark_inode_bitmap ext2_unmark_bitmap

Typedefs
typedef struct _GUID	GUID

typedef GUID	UUID

typedef struct _ext2fs_bitmap	EXT2_BITMAP

typedef struct _ext2fs_bitmap *	PEXT2_BITMAP

typedef EXT2_BITMAP	EXT2_GENERIC_BITMAP

typedef EXT2_BITMAP *	PEXT2_GENERIC_BITMAP

typedef EXT2_BITMAP	EXT2_INODE_BITMAP

typedef EXT2_BITMAP *	PEXT2_INODE_BITMAP

typedef EXT2_BITMAP	EXT2_BLOCK_BITMAP

typedef EXT2_BITMAP *	PEXT2_BLOCK_BITMAP

typedef struct ext2_acl_entry	EXT2_ACL_ENTRY

typedef struct ext2_acl_entry *	PEXT2_ACL_ENTRY

typedef struct ext2_acl_header	EXT2_ACL_HEADER

typedef struct ext2_acl_header *	PEXT2_ACL_HEADER

typedef struct ext2_dir_entry	EXT2_DIR_ENTRY

typedef struct ext2_dir_entry *	PEXT2_DIR_ENTRY

typedef struct ext2_dir_entry_2	EXT2_DIR_ENTRY2

typedef struct ext2_dir_entry_2 *	PEXT2_DIR_ENTRY2

typedef struct ext2_dx_countlimit	EXT2_DX_CL

typedef struct ext2_dx_countlimit *	PEXT2_DX_CL

typedef struct ext2_dx_entry	EXT2_DX_ENTRY

typedef struct ext2_dx_entry *	PEXT2_DX_ENTRY

typedef struct ext2_dx_root_info	EXT2_DX_RI

typedef struct ext2_dx_root_info *	PEXT2_DX_RI

typedef struct ext2_inode	EXT2_INODE

typedef struct ext2_inode *	PEXT2_INODE

typedef struct ext2_group_desc	EXT2_GROUP_DESC

typedef struct ext2_group_desc *	PEXT2_GROUP_DESC

typedef struct ext2_super_block	EXT2_SUPER_BLOCK

typedef struct ext2_super_block *	PEXT2_SUPER_BLOCK

typedef struct ext2_struct_badblocks_list	EXT2_BADBLK_LIST

typedef struct ext2_struct_badblocks_list *	PEXT2_BADBLK_LIST

typedef struct _ext2_filesys	EXT2_FILESYS

typedef struct _ext2_filesys *	PEXT2_FILESYS

typedef struct _EXT2_BDL	EXT2_BDL

typedef struct _EXT2_BDL *	PEXT2_BDL

Functions
bool	create_bad_block_inode (PEXT2_FILESYS fs, PEXT2_BADBLK_LIST bb_list)

bool	ext2_set_bit (int nr, void *addr)

bool	ext2_clear_bit (int nr, void *addr)

bool	ext2_test_bit (int nr, void *addr)

bool	ext2_mark_bitmap (PEXT2_BITMAP bitmap, ULONG bitno)

bool	ext2_unmark_bitmap (PEXT2_BITMAP bitmap, ULONG bitno)

bool	ext2_test_block_bitmap (PEXT2_BLOCK_BITMAP bitmap, ULONG block)

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

bool	ext2_test_inode_bitmap (PEXT2_BLOCK_BITMAP bitmap, ULONG inode)

bool	ext2_allocate_block_bitmap (PEXT2_FILESYS pExt2Sys)

bool	ext2_allocate_inode_bitmap (PEXT2_FILESYS pExt2Sys)

void	ext2_free_inode_bitmap (PEXT2_FILESYS pExt2Sys)

void	ext2_free_block_bitmap (PEXT2_FILESYS pExt2Sys)

bool	ext2_write_block_bitmap (PEXT2_FILESYS fs)

bool	ext2_write_inode_bitmap (PEXT2_FILESYS fs)

bool	ext2_write_bitmaps (PEXT2_FILESYS fs)

bool	ext2_read_inode_bitmap (PEXT2_FILESYS fs)

bool	ext2_read_block_bitmap (PEXT2_FILESYS fs)

bool	ext2_read_bitmaps (PEXT2_FILESYS fs)

NTSTATUS	Ext2OpenDevice (PEXT2_FILESYS Ext2Sys, PUNICODE_STRING DeviceName)

NTSTATUS	Ext2CloseDevice (PEXT2_FILESYS Ext2Sys)

NTSTATUS	Ext2ReadDisk (PEXT2_FILESYS Ext2Sys, ULONGLONG Offset, ULONG Length, PVOID Buffer)

NTSTATUS	Ext2WriteDisk (PEXT2_FILESYS Ext2Sys, ULONGLONG Offset, ULONG Length, PVOID Buffer)

NTSTATUS	Ext2GetMediaInfo (PEXT2_FILESYS Ext2Sys)

NTSTATUS	Ext2LockVolume (PEXT2_FILESYS Ext2Sys)

NTSTATUS	Ext2UnLockVolume (PEXT2_FILESYS Ext2Sys)

NTSTATUS	Ext2DisMountVolume (PEXT2_FILESYS Ext2Sys)

bool	ext2_allocate_group_desc (PEXT2_FILESYS pExt2Sys)

void	ext2_free_group_desc (PEXT2_FILESYS pExt2Sys)

bool	ext2_bg_has_super (PEXT2_SUPER_BLOCK pExt2Sb, int group_block)

bool	ext2_get_inode_lba (PEXT2_FILESYS pExt2Sys, ULONG no, LONGLONG *offset)

bool	ext2_load_inode (PEXT2_FILESYS pExt2Sys, ULONG no, PEXT2_INODE pInode)

bool	ext2_save_inode (PEXT2_FILESYS pExt2Sys, ULONG no, PEXT2_INODE pInode)

bool	ext2_new_inode (PEXT2_FILESYS fs, ULONG dir, int mode, PEXT2_INODE_BITMAP map, ULONG *ret)

bool	ext2_expand_inode (PEXT2_FILESYS pExt2Sys, PEXT2_INODE, ULONG newBlk)

bool	ext2_read_inode (PEXT2_FILESYS pExt2Sys, ULONG ino, ULONG offset, PVOID Buffer, ULONG size, PULONG dwReturn)

bool	ext2_write_inode (PEXT2_FILESYS pExt2Sys, ULONG ino, ULONG offset, PVOID Buffer, ULONG size, PULONG dwReturn)

bool	ext2_add_entry (PEXT2_FILESYS pExt2Sys, ULONG parent, ULONG inode, int filetype, char *name)

bool	ext2_reserve_inodes (PEXT2_FILESYS fs)

int	ext2_group_of_ino (PEXT2_FILESYS fs, ULONG ino)

int	ext2_group_of_blk (PEXT2_FILESYS fs, ULONG blk)

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

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

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

bool	ext2_allocate_tables (PEXT2_FILESYS pExt2Sys)

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

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

bool	write_inode_tables (PEXT2_FILESYS fs)

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

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

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

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

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

bool	parase_cmd (int argc, char *argv[], PEXT2_FILESYS pExt2Sys)

bool	zero_blocks (PEXT2_FILESYS fs, ULONG blk, ULONG num, ULONG ret_blk, ULONG ret_count)

ULONG	Ext2DataBlocks (PEXT2_FILESYS Ext2Sys, ULONG TotalBlocks)

ULONG	Ext2TotalBlocks (PEXT2_FILESYS Ext2Sys, ULONG DataBlocks)

void	ext2_print_super (PEXT2_SUPER_BLOCK pExt2Sb)

bool	ext2_initialize_sb (PEXT2_FILESYS pExt2Sys)

LONGLONG	ext2_nt_time (ULONG i_time)

ULONG	ext2_unix_time (LONGLONG n_time)

void	uuid_generate (__u8 *uuid)

Macro Definition Documentation

◆ bool

#define bool BOOLEAN

Definition at line 43 of file Mke2fs.h.

◆ EXT2_CHECK_MAGIC

#define EXT2_CHECK_MAGIC	(	struct,
		code
	)	if ((struct)->magic != (code)) return (code)

Definition at line 55 of file Mke2fs.h.

◆ EXT2_FIRST_INODE

#define EXT2_FIRST_INODE ( s ) EXT2_FIRST_INO(s)

Definition at line 116 of file Mke2fs.h.

◆ ext2_mark_block_bitmap

#define ext2_mark_block_bitmap ext2_mark_bitmap

Definition at line 215 of file Mke2fs.h.

◆ ext2_mark_inode_bitmap

#define ext2_mark_inode_bitmap ext2_mark_bitmap

Definition at line 216 of file Mke2fs.h.

◆ EXT2_MF_ISROOT

#define EXT2_MF_ISROOT 2

Definition at line 70 of file Mke2fs.h.

◆ EXT2_MF_MOUNTED

#define EXT2_MF_MOUNTED 1

Definition at line 69 of file Mke2fs.h.

◆ EXT2_MF_READONLY

#define EXT2_MF_READONLY 4

Definition at line 71 of file Mke2fs.h.

◆ EXT2_MF_SWAP

#define EXT2_MF_SWAP 8

Definition at line 72 of file Mke2fs.h.

◆ EXT2_SF_BAD_EXTRA_BYTES

#define EXT2_SF_BAD_EXTRA_BYTES 0x0004

Definition at line 63 of file Mke2fs.h.

◆ EXT2_SF_BAD_INODE_BLK

#define EXT2_SF_BAD_INODE_BLK 0x0002

Definition at line 62 of file Mke2fs.h.

◆ EXT2_SF_CHK_BADBLOCKS

#define EXT2_SF_CHK_BADBLOCKS 0x0001

Definition at line 61 of file Mke2fs.h.

◆ EXT2_SF_SKIP_MISSING_ITABLE

#define EXT2_SF_SKIP_MISSING_ITABLE 0x0008

Definition at line 64 of file Mke2fs.h.

◆ ext2_unmark_block_bitmap

#define ext2_unmark_block_bitmap ext2_unmark_bitmap

Definition at line 217 of file Mke2fs.h.

◆ ext2_unmark_inode_bitmap

#define ext2_unmark_inode_bitmap ext2_unmark_bitmap

Definition at line 218 of file Mke2fs.h.

◆ false

#define false FALSE

Definition at line 51 of file Mke2fs.h.

◆ GUID_DEFINED

#define GUID_DEFINED

Definition at line 24 of file Mke2fs.h.

◆ LINUX_S_IFBLK

#define LINUX_S_IFBLK 0060000

Definition at line 84 of file Mke2fs.h.

◆ LINUX_S_IFCHR

#define LINUX_S_IFCHR 0020000

Definition at line 86 of file Mke2fs.h.

◆ LINUX_S_IFDIR

#define LINUX_S_IFDIR 0040000

Definition at line 85 of file Mke2fs.h.

◆ LINUX_S_IFIFO

#define LINUX_S_IFIFO 0010000

Definition at line 87 of file Mke2fs.h.

◆ LINUX_S_IFLNK

#define LINUX_S_IFLNK 0120000

Definition at line 82 of file Mke2fs.h.

◆ LINUX_S_IFMT

#define LINUX_S_IFMT 00170000

Definition at line 80 of file Mke2fs.h.

◆ LINUX_S_IFREG

#define LINUX_S_IFREG 0100000

Definition at line 83 of file Mke2fs.h.

◆ LINUX_S_IFSOCK

#define LINUX_S_IFSOCK 0140000

Definition at line 81 of file Mke2fs.h.

◆ LINUX_S_IRGRP

#define LINUX_S_IRGRP 00040

Definition at line 98 of file Mke2fs.h.

◆ LINUX_S_IROTH

#define LINUX_S_IROTH 00004

Definition at line 103 of file Mke2fs.h.

◆ LINUX_S_IRUSR

#define LINUX_S_IRUSR 00400

Definition at line 93 of file Mke2fs.h.

◆ LINUX_S_IRWXG

#define LINUX_S_IRWXG 00070

Definition at line 97 of file Mke2fs.h.

◆ LINUX_S_IRWXO

#define LINUX_S_IRWXO 00007

Definition at line 102 of file Mke2fs.h.

◆ LINUX_S_IRWXU

#define LINUX_S_IRWXU 00700

Definition at line 92 of file Mke2fs.h.

◆ LINUX_S_ISBLK

#define LINUX_S_ISBLK ( m ) (((m) & LINUX_S_IFMT) == LINUX_S_IFBLK)

Definition at line 111 of file Mke2fs.h.

◆ LINUX_S_ISCHR

#define LINUX_S_ISCHR ( m ) (((m) & LINUX_S_IFMT) == LINUX_S_IFCHR)

Definition at line 110 of file Mke2fs.h.

◆ LINUX_S_ISDIR

#define LINUX_S_ISDIR ( m ) (((m) & LINUX_S_IFMT) == LINUX_S_IFDIR)

Definition at line 109 of file Mke2fs.h.

◆ LINUX_S_ISFIFO

#define LINUX_S_ISFIFO ( m ) (((m) & LINUX_S_IFMT) == LINUX_S_IFIFO)

Definition at line 112 of file Mke2fs.h.

◆ LINUX_S_ISGID

#define LINUX_S_ISGID 0002000

Definition at line 89 of file Mke2fs.h.

◆ LINUX_S_ISLNK

#define LINUX_S_ISLNK ( m ) (((m) & LINUX_S_IFMT) == LINUX_S_IFLNK)

Definition at line 107 of file Mke2fs.h.

◆ LINUX_S_ISREG

#define LINUX_S_ISREG ( m ) (((m) & LINUX_S_IFMT) == LINUX_S_IFREG)

Definition at line 108 of file Mke2fs.h.

◆ LINUX_S_ISSOCK

#define LINUX_S_ISSOCK ( m ) (((m) & LINUX_S_IFMT) == LINUX_S_IFSOCK)

Definition at line 113 of file Mke2fs.h.

◆ LINUX_S_ISUID

#define LINUX_S_ISUID 0004000

Definition at line 88 of file Mke2fs.h.

◆ LINUX_S_ISVTX

#define LINUX_S_ISVTX 0001000

Definition at line 90 of file Mke2fs.h.

◆ LINUX_S_IWGRP

#define LINUX_S_IWGRP 00020

Definition at line 99 of file Mke2fs.h.

◆ LINUX_S_IWOTH

#define LINUX_S_IWOTH 00002

Definition at line 104 of file Mke2fs.h.

◆ LINUX_S_IWUSR

#define LINUX_S_IWUSR 00200

Definition at line 94 of file Mke2fs.h.

◆ LINUX_S_IXGRP

#define LINUX_S_IXGRP 00010

Definition at line 100 of file Mke2fs.h.

◆ LINUX_S_IXOTH

#define LINUX_S_IXOTH 00001

Definition at line 105 of file Mke2fs.h.

◆ LINUX_S_IXUSR

#define LINUX_S_IXUSR 00100

Definition at line 95 of file Mke2fs.h.

◆ NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 13 of file Mke2fs.h.

◆ SECTOR_SIZE

#define SECTOR_SIZE (Ext2Sys->DiskGeometry.BytesPerSector)

Definition at line 21 of file Mke2fs.h.

◆ SUPERBLOCK_OFFSET

#define SUPERBLOCK_OFFSET 1024

Definition at line 204 of file Mke2fs.h.

◆ SUPERBLOCK_SIZE

#define SUPERBLOCK_SIZE 1024

Definition at line 205 of file Mke2fs.h.

◆ true

#define true TRUE

Definition at line 47 of file Mke2fs.h.

◆ UUID_DEFINED

#define UUID_DEFINED

Definition at line 35 of file Mke2fs.h.

◆ uuid_t

#define uuid_t UUID

Definition at line 38 of file Mke2fs.h.

Typedef Documentation

◆ EXT2_ACL_ENTRY

typedef struct ext2_acl_entry EXT2_ACL_ENTRY

Definition at line 128 of file Mke2fs.h.

◆ EXT2_ACL_HEADER

typedef struct ext2_acl_header EXT2_ACL_HEADER

Definition at line 129 of file Mke2fs.h.

◆ EXT2_BADBLK_LIST

typedef struct ext2_struct_badblocks_list EXT2_BADBLK_LIST

Definition at line 149 of file Mke2fs.h.

◆ EXT2_BDL

typedef struct _EXT2_BDL EXT2_BDL

◆ EXT2_BITMAP

typedef struct _ext2fs_bitmap EXT2_BITMAP

◆ EXT2_BLOCK_BITMAP

typedef EXT2_BITMAP EXT2_BLOCK_BITMAP

Definition at line 126 of file Mke2fs.h.

◆ EXT2_DIR_ENTRY

typedef struct ext2_dir_entry EXT2_DIR_ENTRY

Definition at line 130 of file Mke2fs.h.

◆ EXT2_DIR_ENTRY2

typedef struct ext2_dir_entry_2 EXT2_DIR_ENTRY2

Definition at line 131 of file Mke2fs.h.

◆ EXT2_DX_CL

typedef struct ext2_dx_countlimit EXT2_DX_CL

Definition at line 132 of file Mke2fs.h.

◆ EXT2_DX_ENTRY

typedef struct ext2_dx_entry EXT2_DX_ENTRY

Definition at line 133 of file Mke2fs.h.

◆ EXT2_DX_RI

typedef struct ext2_dx_root_info EXT2_DX_RI

Definition at line 134 of file Mke2fs.h.

◆ EXT2_FILESYS

typedef struct _ext2_filesys EXT2_FILESYS

◆ EXT2_GENERIC_BITMAP

typedef EXT2_BITMAP EXT2_GENERIC_BITMAP

Definition at line 124 of file Mke2fs.h.

◆ EXT2_GROUP_DESC

typedef struct ext2_group_desc EXT2_GROUP_DESC

Definition at line 136 of file Mke2fs.h.

◆ EXT2_INODE

typedef struct ext2_inode EXT2_INODE

Definition at line 135 of file Mke2fs.h.

◆ EXT2_INODE_BITMAP

typedef EXT2_BITMAP EXT2_INODE_BITMAP

Definition at line 125 of file Mke2fs.h.

◆ EXT2_SUPER_BLOCK

typedef struct ext2_super_block EXT2_SUPER_BLOCK

Definition at line 137 of file Mke2fs.h.

◆ GUID

typedef struct _GUID GUID

◆ PEXT2_ACL_ENTRY

typedef struct ext2_acl_entry * PEXT2_ACL_ENTRY

Definition at line 128 of file Mke2fs.h.

◆ PEXT2_ACL_HEADER

typedef struct ext2_acl_header * PEXT2_ACL_HEADER

Definition at line 129 of file Mke2fs.h.

◆ PEXT2_BADBLK_LIST

typedef struct ext2_struct_badblocks_list * PEXT2_BADBLK_LIST

Definition at line 149 of file Mke2fs.h.

◆ PEXT2_BDL

typedef struct _EXT2_BDL * PEXT2_BDL

◆ PEXT2_BITMAP

typedef struct _ext2fs_bitmap * PEXT2_BITMAP

◆ PEXT2_BLOCK_BITMAP

typedef EXT2_BITMAP * PEXT2_BLOCK_BITMAP

Definition at line 126 of file Mke2fs.h.

◆ PEXT2_DIR_ENTRY

typedef struct ext2_dir_entry * PEXT2_DIR_ENTRY

Definition at line 130 of file Mke2fs.h.

◆ PEXT2_DIR_ENTRY2

typedef struct ext2_dir_entry_2 * PEXT2_DIR_ENTRY2

Definition at line 131 of file Mke2fs.h.

◆ PEXT2_DX_CL

typedef struct ext2_dx_countlimit * PEXT2_DX_CL

Definition at line 132 of file Mke2fs.h.

◆ PEXT2_DX_ENTRY

typedef struct ext2_dx_entry * PEXT2_DX_ENTRY

Definition at line 133 of file Mke2fs.h.

◆ PEXT2_DX_RI

typedef struct ext2_dx_root_info * PEXT2_DX_RI

Definition at line 134 of file Mke2fs.h.

◆ PEXT2_FILESYS

typedef struct _ext2_filesys * PEXT2_FILESYS

◆ PEXT2_GENERIC_BITMAP

typedef EXT2_BITMAP * PEXT2_GENERIC_BITMAP

Definition at line 124 of file Mke2fs.h.

◆ PEXT2_GROUP_DESC

typedef struct ext2_group_desc * PEXT2_GROUP_DESC

Definition at line 136 of file Mke2fs.h.

◆ PEXT2_INODE

typedef struct ext2_inode * PEXT2_INODE

Definition at line 135 of file Mke2fs.h.

◆ PEXT2_INODE_BITMAP

typedef EXT2_BITMAP * PEXT2_INODE_BITMAP

Definition at line 125 of file Mke2fs.h.

◆ PEXT2_SUPER_BLOCK

typedef struct ext2_super_block * PEXT2_SUPER_BLOCK

Definition at line 137 of file Mke2fs.h.

◆ UUID

typedef GUID UUID

Definition at line 36 of file Mke2fs.h.

Function Documentation

◆ create_bad_block_inode()

bool create_bad_block_inode	(	PEXT2_FILESYS	fs,
		PEXT2_BADBLK_LIST	bb_list
	)

Definition at line 16 of file Badblock.c.

 {
     bool            retval;
     EXT2_INODE      inode;
     LARGE_INTEGER   SysTime;
 
     NtQuerySystemTime(&SysTime);
 
     ext2_mark_inode_bitmap(Ext2Sys->inode_map, EXT2_BAD_INO);
 
     Ext2Sys->group_desc[0].bg_free_inodes_count--;
     Ext2Sys->ext2_sb->s_free_inodes_count--;
 
     memset(&inode, 0, sizeof(EXT2_INODE));
     inode.i_mode = (USHORT)((0777 & ~Ext2Sys->umask));
     inode.i_uid = inode.i_gid = 0;
     inode.i_blocks = 0;
     inode.i_block[0] = 0;
     inode.i_links_count = 2;
     RtlTimeToSecondsSince1970(&SysTime, &inode.i_mtime);
     inode.i_ctime = inode.i_atime = inode.i_mtime;
     inode.i_size = 0;
 
     retval = ext2_save_inode(Ext2Sys, EXT2_BAD_INO, &inode);
 
     return retval;
 }

Referenced by Ext2Format().

◆ ext2_add_entry()

bool ext2_add_entry	(	PEXT2_FILESYS	pExt2Sys,
		ULONG	parent,
		ULONG	inode,
		int	filetype,
		char *	name
	)

Definition at line 619 of file Inode.c.

 {
     PEXT2_DIR_ENTRY2  dir = NULL, newdir = NULL;
     EXT2_INODE      parent_inode;
     ULONG       dwRet;
     char        *buf;
     int         rec_len;
     bool        bRet = false;
 
     rec_len = EXT2_DIR_REC_LEN(strlen(name));
 
     if (!ext2_load_inode(Ext2Sys, parent, &parent_inode))
     {
         return false;
     }
 
     buf = (char *)RtlAllocateHeap(RtlGetProcessHeap(), 0, parent_inode.i_size);
 
     if (!ext2_read_inode(Ext2Sys, parent, 0, buf, parent_inode.i_size, &dwRet))
     {
         return false;
     }
 
     dir = (PEXT2_DIR_ENTRY2) buf;
 
     while ((char *)dir < buf + parent_inode.i_size)
     {
         if ((dir->inode == 0 && dir->rec_len >= rec_len) ||
                (dir->rec_len >= dir->name_len + rec_len) )
         {
             if (dir->inode)
             {
                 newdir = (PEXT2_DIR_ENTRY2) ((PUCHAR)dir + EXT2_DIR_REC_LEN(dir->name_len));
                 newdir->rec_len = dir->rec_len - EXT2_DIR_REC_LEN(dir->name_len);
 
                 dir->rec_len = EXT2_DIR_REC_LEN(dir->name_len);
 
                 dir = newdir;
             }
 
             dir->file_type = filetype;
             dir->inode = inode;
             dir->name_len = strlen(name);
             memcpy(dir->name, name, strlen(name));
 
             bRet = true;
             break;
         }
 
         dir = (PEXT2_DIR_ENTRY2) (dir->rec_len + (PUCHAR) dir);
     }
 
 
     if (bRet)
         return ext2_write_inode(Ext2Sys, parent, 0, buf, parent_inode.i_size, &dwRet);
 
     return bRet;
 }

Referenced by ext2_mkdir().

◆ ext2_alloc_block()

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

Definition at line 293 of file Memory.c.

 {
     bool        retval;
     ULONG       block;
     char        *buf = NULL;
 
     buf = (char *)RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, fs->blocksize);
     if (!buf)
         return false;
 
     if (!fs->block_map)
     {
         retval = ext2_read_block_bitmap(fs);
         if (!retval)
             goto fail;
     }
 
     retval = ext2_new_block(fs, goal, 0, &block);
 
     if (!retval)
         goto fail;
 
     retval = NT_SUCCESS(Ext2WriteDisk(
                 fs,
                 ((LONGLONG)block * fs->blocksize),
                 fs->blocksize, (unsigned char *)buf));
 
     if (!retval)
     {
         goto fail;
     }
 
     ext2_block_alloc_stats(fs, block, +1);
     *ret = block;
 
     if (buf)
     {
         RtlFreeHeap(RtlGetProcessHeap(), 0, buf);
     }
 
     return true;
 
 fail:
 
     if (buf)
     {
         RtlFreeHeap(RtlGetProcessHeap(), 0, buf);
     }
 
     return false;
 }

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

◆ ext2_allocate_block_bitmap()

bool ext2_allocate_block_bitmap ( PEXT2_FILESYS pExt2Sys )

Definition at line 100 of file Bitmap.c.

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

Referenced by ext2_initialize_sb(), and read_bitmaps().

◆ ext2_allocate_group_desc()

bool ext2_allocate_group_desc ( PEXT2_FILESYS pExt2Sys )

Definition at line 43 of file Group.c.

 {
     ULONG size;
 
     size = Ext2Sys->desc_blocks * Ext2Sys->blocksize;
 
     Ext2Sys->group_desc =
         (PEXT2_GROUP_DESC)RtlAllocateHeap(RtlGetProcessHeap(), 0, size);
 
     if (Ext2Sys->group_desc)
     {
         memset(Ext2Sys->group_desc, 0, size);
         return true;
     }
 
     return false;
 }

Referenced by ext2_initialize_sb().

◆ ext2_allocate_group_table()

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

Definition at line 92 of file Memory.c.

 {
     bool    retval;
     ULONG   group_blk, start_blk, last_blk, new_blk, blk, j;
 
     group_blk = fs->ext2_sb->s_first_data_block +
         (group * fs->ext2_sb->s_blocks_per_group);
 
     last_blk = group_blk + fs->ext2_sb->s_blocks_per_group;
     if (last_blk >= fs->ext2_sb->s_blocks_count)
         last_blk = fs->ext2_sb->s_blocks_count - 1;
 
     start_blk = group_blk + 3 + fs->desc_blocks;
     if (start_blk > last_blk)
         start_blk = group_blk;
 
     if (!bmap)
         bmap = fs->block_map;
 
     /*
      * Allocate the inode table
      */
     if (!fs->group_desc[group].bg_inode_table)
     {
         retval = ext2_get_free_blocks(fs, start_blk, last_blk,
                         fs->inode_blocks_per_group,
                         bmap, &new_blk);
         if (!retval)
             return retval;
 
         for (j=0, blk = new_blk;
              j < fs->inode_blocks_per_group;
              j++, blk++)
             ext2_mark_block_bitmap(bmap, blk);
 
         fs->group_desc[group].bg_inode_table = new_blk;
     }
 
     /*
      * Allocate the block and inode bitmaps, if necessary
      */
     if (fs->stride)
     {
         start_blk += fs->inode_blocks_per_group;
         start_blk += ((fs->stride * group) %
                   (last_blk - start_blk));
         if (start_blk > last_blk)
             /* should never happen */
             start_blk = group_blk;
     }
     else
     {
         start_blk = group_blk;
     }
 
     if (!fs->group_desc[group].bg_block_bitmap)
     {
         retval = ext2_get_free_blocks(fs, start_blk, last_blk,
                         1, bmap, &new_blk);
 
         if (!retval)
             retval = ext2_get_free_blocks(fs, group_blk,
                     last_blk, 1, bmap, &new_blk);
 
         if (!retval)
             return retval;
 
         ext2_mark_block_bitmap(bmap, new_blk);
         fs->group_desc[group].bg_block_bitmap = new_blk;
     }
 
     if (!fs->group_desc[group].bg_inode_bitmap)
     {
         retval = ext2_get_free_blocks(fs, start_blk, last_blk,
                         1, bmap, &new_blk);
         if (!retval)
             retval = ext2_get_free_blocks(fs, group_blk,
                     last_blk, 1, bmap, &new_blk);
         if (!retval)
             return retval;
 
         ext2_mark_block_bitmap(bmap, new_blk);
         fs->group_desc[group].bg_inode_bitmap = new_blk;
     }
 
     return true;
 }

Referenced by ext2_allocate_tables().

◆ ext2_allocate_inode_bitmap()

bool ext2_allocate_inode_bitmap ( PEXT2_FILESYS pExt2Sys )

Definition at line 140 of file Bitmap.c.

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

Referenced by ext2_initialize_sb(), and read_bitmaps().

◆ ext2_allocate_tables()

bool ext2_allocate_tables ( PEXT2_FILESYS pExt2Sys )

Definition at line 75 of file Memory.c.

 {
     bool    retval;
     ULONG   i;
 
     for (i = 0; i < Ext2Sys->group_desc_count; i++)
     {
         retval = ext2_allocate_group_table(Ext2Sys, i, Ext2Sys->block_map);
 
         if (!retval)
             return retval;
     }
 
     return true;
 }

Referenced by Ext2Format().

◆ ext2_bg_has_super()

bool ext2_bg_has_super	(	PEXT2_SUPER_BLOCK	pExt2Sb,
		int	group_block
	)

Definition at line 30 of file Group.c.

 {
     if (!(pExt2Sb->s_feature_ro_compat & EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER))
         return true;
 
     if (test_root(group_block, 3) || (test_root(group_block, 5)) ||
         test_root(group_block, 7))
         return true;
 
     return false;
 }

Referenced by ext2_flush(), and ext2_initialize_sb().

◆ ext2_block_alloc_stats()

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

Definition at line 61 of file Memory.c.

 {
     int group = ext2_group_of_blk(fs, blk);
 
     if (inuse > 0)
         ext2_mark_block_bitmap(fs->block_map, blk);
     else
         ext2_unmark_block_bitmap(fs->block_map, blk);
 
     fs->group_desc[group].bg_free_blocks_count -= inuse;
     fs->ext2_sb->s_free_blocks_count -= inuse;
 }

Referenced by ext2_alloc_block(), and ext2_mkdir().

◆ ext2_clear_bit()

bool ext2_clear_bit	(	int	nr,
		void *	addr
	)

Definition at line 30 of file Bitmap.c.

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

Referenced by ext2_unmark_bitmap().

◆ ext2_expand_inode()

bool ext2_expand_inode	(	PEXT2_FILESYS	pExt2Sys,
		PEXT2_INODE	,
		ULONG	newBlk
	)

Definition at line 212 of file Inode.c.

 {
     ULONG dwSizes[4] = {12, 1, 1, 1};
     ULONG Index = 0;
     ULONG dwTotal = 0;
     ULONG dwBlk = 0, dwNewBlk = 0, Offset = 0;
     PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
     int   i = 0;
     bool  bRet = true;
     ULONG TotalBlocks;
 
     TotalBlocks = Inode->i_blocks / (Ext2Sys->blocksize / SECTOR_SIZE);
     Index = Ext2DataBlocks(Ext2Sys, TotalBlocks);
 
     for (i = 0; i < 4; i++)
     {
         dwSizes[i] = dwSizes[i] << ((10 + pExt2Sb->s_log_block_size - 2) * i);
         dwTotal += dwSizes[i];
     }
 
     if (Index >= dwTotal)
     {
         DPRINT1("Mke2fs: ext2_expand_inode: beyond the maxinum size of an inode.\n");
         return false;
     }
 
     for (i = 0; i < 4; i++)
     {
         if (Index < dwSizes[i])
         {
             if (i == 0)
             {
                 Inode->i_block[Index] = newBlk;
             }
             else
             {
                 dwBlk = Inode->i_block[(i + 12 - 1)];
 
                 if (dwBlk == 0)
                 {
                     if (ext2_alloc_block(Ext2Sys, 0, &dwBlk))
                     {
                         Inode->i_block[(i + 12 - 1)] = dwBlk;
 
                         Inode->i_blocks += (Ext2Sys->blocksize / SECTOR_SIZE);
                     }
                     else
                     {
                         break;
                     }
                 }
 
                 dwNewBlk = 0;
                 bRet = ext2_expand_block(
                              Ext2Sys,
                              Inode,
                              dwBlk,
                              Index,
                              i,
                              newBlk,
                              &dwNewBlk,
                              &Offset   );
             }
 
             break;
         }
 
         Index -= dwSizes[i];
     }
 
     return bRet;
 }

Referenced by create_lost_and_found(), and ext2_write_inode().

◆ ext2_free_block_bitmap()

void ext2_free_block_bitmap ( PEXT2_FILESYS pExt2Sys )

Definition at line 205 of file Bitmap.c.

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

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

◆ ext2_free_group_desc()

void ext2_free_group_desc ( PEXT2_FILESYS pExt2Sys )

Definition at line 61 of file Group.c.

 {
     if (Ext2Sys->group_desc)
     {
         RtlFreeHeap(RtlGetProcessHeap(), 0, Ext2Sys->group_desc);
         Ext2Sys->group_desc = NULL;
     }
 }

Referenced by ext2_initialize_sb(), and Ext2Format().

◆ ext2_free_inode_bitmap()

void ext2_free_inode_bitmap ( PEXT2_FILESYS pExt2Sys )

Definition at line 194 of file Bitmap.c.

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

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

◆ ext2_get_free_blocks()

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

Definition at line 182 of file Memory.c.

 {
     ULONG   b = start;
 
     if (!map)
         map = fs->block_map;
 
     if (!map)
         return false;
 
     if (!b)
         b = fs->ext2_sb->s_first_data_block;
 
     if (!finish)
         finish = start;
 
     if (!num)
         num = 1;
 
     do
     {
         if (b+num-1 > fs->ext2_sb->s_blocks_count)
             b = fs->ext2_sb->s_first_data_block;
 
         if (ext2_test_block_bitmap_range(map, b, num))
         {
             *ret = b;
             return true;
         }
 
         b++;
 
     } while (b != finish);
 
     return false;
 }

Referenced by ext2_allocate_group_table().

◆ ext2_get_inode_lba()

bool ext2_get_inode_lba	(	PEXT2_FILESYS	pExt2Sys,
		ULONG	no,
		LONGLONG *	offset
	)

Definition at line 20 of file Inode.c.

 {
     LONGLONG loc = 0;
     PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
 
     if (no < 1 || no > pExt2Sb->s_inodes_count)
     {
         DPRINT1("Mke2fs: Inode value %lu was out of range in load_inode.(1-%ld)\n",
             no, pExt2Sb->s_inodes_count);
         *offset = 0;
         return false;
     }
 
     loc = (LONGLONG)(Ext2Sys->blocksize) * Ext2Sys->group_desc[(no - 1) / pExt2Sb->s_inodes_per_group].bg_inode_table +
         ((no - 1) % pExt2Sb->s_inodes_per_group) * sizeof(EXT2_INODE);
 
     *offset = loc;
 
     return true;
 }

Referenced by ext2_load_inode(), and ext2_save_inode().

◆ ext2_group_of_blk()

int ext2_group_of_blk	(	PEXT2_FILESYS	fs,
		ULONG	blk
	)

Definition at line 31 of file Memory.c.

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

Referenced by ext2_block_alloc_stats().

◆ ext2_group_of_ino()

int ext2_group_of_ino	(	PEXT2_FILESYS	fs,
		ULONG	ino
	)

Definition at line 23 of file Memory.c.

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

Referenced by ext2_inode_alloc_stats2(), and ext2_reserve_inodes().

◆ ext2_initialize_sb()

bool ext2_initialize_sb ( PEXT2_FILESYS pExt2Sys )

Definition at line 74 of file Super.c.

 {
     int frags_per_block = 0;
     ULONG overhead      = 0;
     ULONG rem           = 0;
     ULONG   i = 0;
     ULONG   group_block = 0;
     ULONG   numblocks = 0;
     PEXT2_SUPER_BLOCK pExt2Sb = Ext2Sys->ext2_sb;
     LARGE_INTEGER   SysTime;
 
     NtQuerySystemTime(&SysTime);
 
     Ext2Sys->blocksize = EXT2_BLOCK_SIZE(pExt2Sb);
     Ext2Sys->fragsize = EXT2_FRAG_SIZE(pExt2Sb);
     frags_per_block = Ext2Sys->blocksize / Ext2Sys->fragsize;
 
     pExt2Sb->s_magic = EXT2_SUPER_MAGIC;
     pExt2Sb->s_state = EXT2_VALID_FS;
 
     pExt2Sb->s_first_data_block =  (pExt2Sb->s_log_block_size) ? 0 : 1;
     pExt2Sb->s_max_mnt_count = EXT2_DFL_MAX_MNT_COUNT;
 
     pExt2Sb->s_errors = EXT2_ERRORS_DEFAULT;
 
     pExt2Sb->s_checkinterval = EXT2_DFL_CHECKINTERVAL;
 
     if (!pExt2Sb->s_rev_level)
         pExt2Sb->s_rev_level = EXT2_GOOD_OLD_REV;
 
     if (pExt2Sb->s_rev_level >= EXT2_DYNAMIC_REV)
     {
         set_field(s_first_ino, EXT2_GOOD_OLD_FIRST_INO);
         set_field(s_inode_size, EXT2_GOOD_OLD_INODE_SIZE);
     }
 
     RtlTimeToSecondsSince1970(&SysTime, &pExt2Sb->s_wtime);
     pExt2Sb->s_lastcheck = pExt2Sb->s_mtime = pExt2Sb->s_wtime;
 
     if (!pExt2Sb->s_blocks_per_group)
         pExt2Sb->s_blocks_per_group = Ext2Sys->blocksize * 8;
 
     pExt2Sb->s_frags_per_group = pExt2Sb->s_blocks_per_group *  frags_per_block;
     pExt2Sb->s_creator_os = EXT2_OS_WINNT;
 
     if (pExt2Sb->s_r_blocks_count >= pExt2Sb->s_blocks_count)
     {
         goto cleanup;
     }
 
     /*
      * If we're creating an external journal device, we don't need
      * to bother with the rest.
      */
     if (pExt2Sb->s_feature_incompat &
         EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)
     {
         Ext2Sys->group_desc_count = 0;
         // ext2fs_mark_super_dirty(fs);
         return true;
     }
 
 retry:
 
     Ext2Sys->group_desc_count = (pExt2Sb->s_blocks_count - pExt2Sb->s_first_data_block
         + EXT2_BLOCKS_PER_GROUP(pExt2Sb) - 1) / EXT2_BLOCKS_PER_GROUP(pExt2Sb);
 
     if (Ext2Sys->group_desc_count == 0)
         return false;
 
     Ext2Sys->desc_blocks = (Ext2Sys->group_desc_count +  EXT2_DESC_PER_BLOCK(pExt2Sb)
         - 1) / EXT2_DESC_PER_BLOCK(pExt2Sb);
 
     if (!pExt2Sb->s_inodes_count)
         pExt2Sb->s_inodes_count = pExt2Sb->s_blocks_count / ( inode_ratio /Ext2Sys->blocksize);
 
     /*
      * Make sure we have at least EXT2_FIRST_INO + 1 inodes, so
      * that we have enough inodes for the filesystem(!)
      */
     if (pExt2Sb->s_inodes_count < EXT2_FIRST_INODE(pExt2Sb)+1)
         pExt2Sb->s_inodes_count = EXT2_FIRST_INODE(pExt2Sb)+1;
 
     /*
      * There should be at least as many inodes as the user
      * requested.  Figure out how many inodes per group that
      * should be.  But make sure that we don't allocate more than
      * one bitmap's worth of inodes
      */
     pExt2Sb->s_inodes_per_group = (pExt2Sb->s_inodes_count + Ext2Sys->group_desc_count - 1)
         /Ext2Sys->group_desc_count;
 
     if (pExt2Sb->s_inodes_per_group > (ULONG)(Ext2Sys->blocksize*8))
         pExt2Sb->s_inodes_per_group = Ext2Sys->blocksize*8;
 
     /*
      * Make sure the number of inodes per group completely fills
      * the inode table blocks in the descriptor.  If not, add some
      * additional inodes/group.  Waste not, want not...
      */
     Ext2Sys->inode_blocks_per_group = (((pExt2Sb->s_inodes_per_group * EXT2_INODE_SIZE(pExt2Sb))
         + EXT2_BLOCK_SIZE(pExt2Sb) - 1) / EXT2_BLOCK_SIZE(pExt2Sb));
 
     pExt2Sb->s_inodes_per_group = ((Ext2Sys->inode_blocks_per_group * EXT2_BLOCK_SIZE(pExt2Sb))
         / EXT2_INODE_SIZE(pExt2Sb));
 
     /*
      * Finally, make sure the number of inodes per group is a
      * multiple of 8.  This is needed to simplify the bitmap
      * splicing code.
      */
     pExt2Sb->s_inodes_per_group &= ~7;
     Ext2Sys->inode_blocks_per_group = (((pExt2Sb->s_inodes_per_group * EXT2_INODE_SIZE(pExt2Sb))
         + EXT2_BLOCK_SIZE(pExt2Sb) - 1) / EXT2_BLOCK_SIZE(pExt2Sb));
 
     /*
      * adjust inode count to reflect the adjusted inodes_per_group
      */
     pExt2Sb->s_inodes_count = pExt2Sb->s_inodes_per_group * Ext2Sys->group_desc_count;
     pExt2Sb->s_free_inodes_count = pExt2Sb->s_inodes_count;
 
     /*
      * Overhead is the number of bookkeeping blocks per group.  It
      * includes the superblock backup, the group descriptor
      * backups, the inode bitmap, the block bitmap, and the inode
      * table.
      *
      * XXX Not all block groups need the descriptor blocks, but
      * being clever is tricky...
      */
     overhead = (3 + Ext2Sys->desc_blocks + Ext2Sys->inode_blocks_per_group);
 
     /*
      * See if the last group is big enough to support the
      * necessary data structures.  If not, we need to get rid of
      * it.
      */
     rem = ((pExt2Sb->s_blocks_count - pExt2Sb->s_first_data_block) %
              pExt2Sb->s_blocks_per_group);
 
     if ((Ext2Sys->group_desc_count == 1) && rem && (rem < overhead))
         return false;
 
     if (rem && (rem < overhead+50))
     {
         pExt2Sb->s_blocks_count -= rem;
         goto retry;
     }
 
     /*
      * At this point we know how big the filesystem will be.  So we can do
      * any and all allocations that depend on the block count.
      */
 
     // Allocate block bitmap
     if(!ext2_allocate_block_bitmap(Ext2Sys))
     {
         goto cleanup;
     }
 
     // Allocate inode bitmap
     if(!ext2_allocate_inode_bitmap(Ext2Sys))
     {
         goto cleanup;
     }
 
     // Allocate gourp desc
     if(!ext2_allocate_group_desc(Ext2Sys))
     {
         goto cleanup;
     }
 
     /*
      * Reserve the superblock and group descriptors for each
      * group, and fill in the correct group statistics for group.
      * Note that although the block bitmap, inode bitmap, and
      * inode table have not been allocated (and in fact won't be
      * by this routine), they are accounted for nevertheless.
      */
     group_block = pExt2Sb->s_first_data_block;
     numblocks = 0;
 
     pExt2Sb->s_free_blocks_count = 0;
 
     for (i = 0; i < Ext2Sys->group_desc_count; i++)
     {
         if (i == Ext2Sys->group_desc_count-1)
         {
             numblocks = (pExt2Sb->s_blocks_count - pExt2Sb->s_first_data_block)
                 % pExt2Sb->s_blocks_per_group;
 
             if (!numblocks)
                 numblocks = pExt2Sb->s_blocks_per_group;
         }
         else
         {
             numblocks = pExt2Sb->s_blocks_per_group;
         }
 
         if (ext2_bg_has_super(pExt2Sb, i))
         {
             ULONG j;
 
             for (j=0; j < Ext2Sys->desc_blocks+1; j++)
                 ext2_mark_bitmap(Ext2Sys->block_map, group_block + j);
 
             numblocks -= 1 + Ext2Sys->desc_blocks;
         }
 
         numblocks -= 2 + Ext2Sys->inode_blocks_per_group;
 
         pExt2Sb->s_free_blocks_count += numblocks;
         Ext2Sys->group_desc[i].bg_free_blocks_count = (__u16)numblocks;
         Ext2Sys->group_desc[i].bg_free_inodes_count = (__u16)pExt2Sb->s_inodes_per_group;
         Ext2Sys->group_desc[i].bg_used_dirs_count = 0;
 
         group_block += pExt2Sb->s_blocks_per_group;
     }
 
     return true;
 
 cleanup:
 
     ext2_free_group_desc(Ext2Sys);
     ext2_free_block_bitmap(Ext2Sys);
     ext2_free_inode_bitmap(Ext2Sys);
 
     return false;
 }

Referenced by Ext2Format().

◆ ext2_inode_alloc_stats()

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

Definition at line 56 of file Memory.c.

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

◆ ext2_inode_alloc_stats2()

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

Definition at line 37 of file Memory.c.

 {
     int group = ext2_group_of_ino(fs, ino);
 
     if (inuse > 0)
         ext2_mark_inode_bitmap(fs->inode_map, ino);
     else
         ext2_unmark_inode_bitmap(fs->inode_map, ino);
 
     fs->group_desc[group].bg_free_inodes_count -= inuse;
 
     if (isdir)
         fs->group_desc[group].bg_used_dirs_count += inuse;
 
     fs->ext2_sb->s_free_inodes_count -= inuse;
 }

Referenced by ext2_inode_alloc_stats(), and ext2_mkdir().

◆ ext2_load_inode()

bool ext2_load_inode	(	PEXT2_FILESYS	pExt2Sys,
		ULONG	no,
		PEXT2_INODE	pInode
	)

Definition at line 41 of file Inode.c.

 {
     LONGLONG Offset;
     bool  bRet = false;
 
     if (ext2_get_inode_lba(Ext2Sys, no, &Offset))
     {
         bRet = NT_SUCCESS(Ext2ReadDisk(
                     Ext2Sys,
                     Offset,
                     sizeof(EXT2_INODE),
                     (unsigned char *)pInode));
     }
 
     return bRet;
 }

Referenced by ext2_add_entry(), ext2_mkdir(), ext2_read_inode(), and ext2_write_inode().

◆ ext2_mark_bitmap()

bool ext2_mark_bitmap	(	PEXT2_BITMAP	bitmap,
		ULONG	bitno
	)

Definition at line 52 of file Bitmap.c.

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

Referenced by ext2_initialize_sb().

◆ ext2_new_block()

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

Definition at line 254 of file Memory.c.

 {
     ULONG   i;
 
     if (!map)
         map = fs->block_map;
 
     if (!map)
         return false;
 
     if (!goal || (goal >= fs->ext2_sb->s_blocks_count))
         goal = fs->ext2_sb->s_first_data_block;
 
     i = goal;
 
     do
     {
         if (!ext2_test_block_bitmap(map, i))
         {
             *ret = i;
             return true;
         }
 
         i++;
 
         if (i >= fs->ext2_sb->s_blocks_count)
             i = fs->ext2_sb->s_first_data_block;
 
     } while (i != goal);
 
     return false;
 }

Referenced by ext2_alloc_block(), and ext2_mkdir().

◆ ext2_new_dir_block()

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

Definition at line 349 of file Memory.c.

 {
     PEXT2_DIR_ENTRY dir = NULL;
     char        *buf;
     int         rec_len;
     int         filetype = 0;
 
     buf = (char *)RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, fs->blocksize);
     if (!buf)
         return false;
 
     dir = (PEXT2_DIR_ENTRY) buf;
     dir->rec_len = fs->blocksize;
 
     if (dir_ino)
     {
         if (fs->ext2_sb->s_feature_incompat &
             EXT2_FEATURE_INCOMPAT_FILETYPE)
             filetype = EXT2_FT_DIR << 8;
         /*
          * Set up entry for '.'
          */
         dir->inode = dir_ino;
         dir->name_len = 1 | filetype;
         dir->name[0] = '.';
         rec_len = dir->rec_len - EXT2_DIR_REC_LEN(1);
         dir->rec_len = EXT2_DIR_REC_LEN(1);
 
         /*
          * Set up entry for '..'
          */
         dir = (struct ext2_dir_entry *) (buf + dir->rec_len);
         dir->rec_len = rec_len;
         dir->inode = parent_ino;
         dir->name_len = 2 | filetype;
         dir->name[0] = '.';
         dir->name[1] = '.';
     }
 
     *block = buf;
 
     return true;
 }

Referenced by ext2_mkdir().

◆ ext2_new_inode()

bool ext2_new_inode	(	PEXT2_FILESYS	fs,
		ULONG	dir,
		int	mode,
		PEXT2_INODE_BITMAP	map,
		ULONG *	ret
	)

Definition at line 84 of file Inode.c.

 {
     ULONG   dir_group = 0;
     ULONG   i;
     ULONG   start_inode;
 
     if (!map)
         map = fs->inode_map;
 
     if (!map)
         return false;
 
     if (dir > 0)
         dir_group = (dir - 1) / EXT2_INODES_PER_GROUP(fs->ext2_sb);
 
     start_inode = (dir_group * EXT2_INODES_PER_GROUP(fs->ext2_sb)) + 1;
 
     if (start_inode < EXT2_FIRST_INODE(fs->ext2_sb))
         start_inode = EXT2_FIRST_INODE(fs->ext2_sb);
 
     i = start_inode;
 
     do
     {
         if (!ext2_test_inode_bitmap(map, i))
             break;
 
         i++;
 
         if (i > fs->ext2_sb->s_inodes_count)
             i = EXT2_FIRST_INODE(fs->ext2_sb);
 
     } while (i != start_inode);
 
     if (ext2_test_inode_bitmap(map, i))
         return false;
 
     *ret = i;
 
     return true;
 }

Referenced by ext2_mkdir().

◆ ext2_nt_time()

LONGLONG ext2_nt_time ( ULONG i_time )

◆ ext2_print_super()

void ext2_print_super ( PEXT2_SUPER_BLOCK pExt2Sb )

Definition at line 20 of file Super.c.

 {
     int i;
 
     DPRINT("\nExt2 Super Block Details ...\n\n");
     DPRINT("     Inode Count: %lu\n", pExt2Sb->s_inodes_count);
     DPRINT("     Block Count: %lu\n", pExt2Sb->s_blocks_count);
     DPRINT("     Reserved Block Count: %lu\n", pExt2Sb->s_r_blocks_count);
     DPRINT("     Free Blocks: %lu\n", pExt2Sb->s_free_blocks_count);
     DPRINT("     Free Inodes: %lu\n", pExt2Sb->s_free_inodes_count);
     DPRINT("     First Data Block: %lu\n", pExt2Sb->s_first_data_block);
     DPRINT("     Log Block Size: %lu\n", pExt2Sb->s_log_block_size);
     DPRINT("     Log Frag Size: %ld\n", pExt2Sb->s_log_frag_size);
     DPRINT("     Blocks per Group: %lu\n", pExt2Sb->s_blocks_per_group);
     DPRINT("     Fragments per Group: %lu\n", pExt2Sb->s_frags_per_group);
     DPRINT("     Inodes per Group: %lu\n", pExt2Sb->s_inodes_per_group);
 //    DPRINT("     Mount Time: %s", ctime((time_t *) & (pExt2Sb->s_mtime)));
 //    DPRINT("     Write Time: %s", ctime((time_t *) & (pExt2Sb->s_wtime)));
     DPRINT("     Mount Count: %u\n", pExt2Sb->s_mnt_count);
     DPRINT("     Max Mount Count: %d\n", pExt2Sb->s_max_mnt_count);
     DPRINT("     Magic Number: %X  (%s)\n", pExt2Sb->s_magic,
         pExt2Sb->s_magic == EXT2_SUPER_MAGIC ? "OK" : "BAD");
     DPRINT("     File System State: %X\n", pExt2Sb->s_state);
     DPRINT("     Error Behaviour: %X\n", pExt2Sb->s_errors);
     DPRINT("     Minor rev: %u\n", pExt2Sb->s_minor_rev_level);
 //    DPRINT("     Last Check: %s", ctime((time_t *) & (pExt2Sb->s_lastcheck)));
     DPRINT("     Check Interval: %lu\n", pExt2Sb->s_checkinterval);
     DPRINT("     Creator OS: %lu\n", pExt2Sb->s_creator_os);
     DPRINT("     Revision Level: %lu\n", pExt2Sb->s_rev_level);
     DPRINT("     Reserved Block Default UID: %u\n", pExt2Sb->s_def_resuid);
     DPRINT("     Reserved Block Default GID: %u\n", pExt2Sb->s_def_resgid);
     DPRINT("     uuid = ");
     for (i=0; i < 16; i++)
         DbgPrint("%x ", pExt2Sb->s_uuid[i]);
     DbgPrint("\n");
 
     DPRINT("     volume label name: ");
     for (i=0; i < 16; i++)
     {
         if (pExt2Sb->s_volume_name[i] == 0)
             break;
         DbgPrint("%c", pExt2Sb->s_volume_name[i]);
     }
     DbgPrint("\n");
 
     DPRINT("\n\n");
 }

Referenced by Ext2Format().

◆ ext2_read_bitmaps()

bool ext2_read_bitmaps ( PEXT2_FILESYS fs )

Definition at line 492 of file Bitmap.c.

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

◆ ext2_read_block()

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

Definition at line 406 of file Memory.c.

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

Referenced by ext2_expand_block(), and ext2_get_block().

◆ ext2_read_block_bitmap()

bool ext2_read_block_bitmap ( PEXT2_FILESYS fs )

Definition at line 487 of file Bitmap.c.

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

Referenced by ext2_alloc_block().

◆ ext2_read_inode()

bool ext2_read_inode	(	PEXT2_FILESYS	pExt2Sys,
		ULONG	ino,
		ULONG	offset,
		PVOID	Buffer,
		ULONG	size,
		PULONG	dwReturn
	)

Definition at line 494 of file Inode.c.

 {
     PEXT2_BDL   ext2_bdl = NULL;
     ULONG       blocks, i;
     bool        bRet = true;
     EXT2_INODE  ext2_inode;
     ULONG       dwTotal = 0;
 
     if (!ext2_load_inode(Ext2Sys, ino, &ext2_inode))
     {
         return false;
     }
 
     blocks = ext2_build_bdl(Ext2Sys, &ext2_inode, offset, size, &ext2_bdl);
 
     if (blocks <= 0)
         return  false;
 
 
     for(i = 0; i < blocks; i++)
     {
         bRet = NT_SUCCESS(Ext2ReadDisk(
                 Ext2Sys,
                 ext2_bdl[i].Lba,
                 ext2_bdl[i].Length,
                 (PUCHAR)Buffer + ext2_bdl[i].Offset
                ));
 
         if (!bRet)
             break;
         dwTotal += ext2_bdl[i].Length;
     }
 
     *dwReturn = dwTotal;
 
     if (ext2_bdl)
         RtlFreeHeap(RtlGetProcessHeap(), 0, ext2_bdl);
 
     return bRet;
 }

Referenced by ext2_add_entry().

◆ ext2_read_inode_bitmap()

bool ext2_read_inode_bitmap ( PEXT2_FILESYS fs )

Definition at line 482 of file Bitmap.c.

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

◆ ext2_reserve_inodes()

bool ext2_reserve_inodes ( PEXT2_FILESYS fs )

Definition at line 681 of file Inode.c.

 {
     ULONG   i;
     int     group;
 
     for (i = EXT2_ROOT_INO + 1; i < EXT2_FIRST_INODE(fs->ext2_sb); i++)
     {
         ext2_mark_inode_bitmap(fs->inode_map, i);
         group = ext2_group_of_ino(fs, i);
         fs->group_desc[group].bg_free_inodes_count--;
         fs->ext2_sb->s_free_inodes_count--;
     }
 
     return true;
 }

Referenced by Ext2Format().

◆ ext2_save_inode()

bool ext2_save_inode	(	PEXT2_FILESYS	pExt2Sys,
		ULONG	no,
		PEXT2_INODE	pInode
	)

Definition at line 59 of file Inode.c.

 {
     LONGLONG offset;
     bool  bRet = false;
 
     if (ext2_get_inode_lba(Ext2Sys, no, &offset))
     {
         bRet = NT_SUCCESS(Ext2WriteDisk(
                         Ext2Sys,
                         offset,
                         sizeof(EXT2_INODE),
                         (unsigned char *)pInode));
     }
 
     return bRet;
 }

Referenced by create_bad_block_inode(), create_lost_and_found(), create_root_dir(), ext2_mkdir(), and ext2_write_inode().

◆ ext2_set_bit()

bool ext2_set_bit	(	int	nr,
		void *	addr
	)

Definition at line 18 of file Bitmap.c.

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

Referenced by ext2_mark_bitmap(), and ext2_write_block_bitmap().

◆ ext2_test_bit()

bool ext2_test_bit	(	int	nr,
		void *	addr
	)

Definition at line 41 of file Bitmap.c.

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

Referenced by ext2_test_block_bitmap(), and ext2_test_inode_bitmap().

◆ ext2_test_block_bitmap()

bool ext2_test_block_bitmap	(	PEXT2_BLOCK_BITMAP	bitmap,
		ULONG	block
	)

Definition at line 73 of file Bitmap.c.

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

Referenced by ext2_new_block(), and ext2_test_block_bitmap_range().

◆ ext2_test_block_bitmap_range()

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

Definition at line 80 of file Bitmap.c.

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

Referenced by ext2_get_free_blocks().

◆ ext2_test_inode_bitmap()

bool ext2_test_inode_bitmap	(	PEXT2_BLOCK_BITMAP	bitmap,
		ULONG	inode
	)

Definition at line 93 of file Bitmap.c.

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

Referenced by ext2_new_inode().

◆ ext2_unix_time()

ULONG ext2_unix_time ( LONGLONG n_time )

◆ ext2_unmark_bitmap()

bool ext2_unmark_bitmap	(	PEXT2_BITMAP	bitmap,
		ULONG	bitno
	)

Definition at line 62 of file Bitmap.c.

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

◆ ext2_write_bitmaps()

bool ext2_write_bitmaps ( PEXT2_FILESYS fs )

Definition at line 342 of file Bitmap.c.

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

Referenced by ext2_flush().

◆ ext2_write_block()

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

Definition at line 394 of file Memory.c.

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

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

◆ ext2_write_block_bitmap()

bool ext2_write_block_bitmap ( PEXT2_FILESYS fs )

Definition at line 270 of file Bitmap.c.

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

Referenced by ext2_write_bitmaps().

◆ ext2_write_inode()

bool ext2_write_inode	(	PEXT2_FILESYS	pExt2Sys,
		ULONG	ino,
		ULONG	offset,
		PVOID	Buffer,
		ULONG	size,
		PULONG	dwReturn
	)

Definition at line 541 of file Inode.c.

 {
     PEXT2_BDL   ext2_bdl = NULL;
     ULONG       blocks, i;
     bool        bRet = true;
     EXT2_INODE  inode;
     ULONG       dwTotal = 0;
     ULONG       dwBlk = 0;
     ULONG       TotalBlks;
 
     blocks =  (size + offset + Ext2Sys->blocksize - 1) / Ext2Sys->blocksize;
 
     if (!ext2_load_inode(Ext2Sys, ino, &inode))
     {
         return false;
     }
 
     TotalBlks = inode.i_blocks / (Ext2Sys->blocksize / SECTOR_SIZE);
     TotalBlks = Ext2DataBlocks(Ext2Sys, TotalBlks);
 
     if (blocks > TotalBlks)
     {
         for (i=0; i < (blocks - TotalBlks);  i++)
         {
             if (ext2_alloc_block(Ext2Sys, 0, &dwBlk) )
             {
                 ext2_expand_inode(Ext2Sys, &inode, dwBlk);
                 inode.i_blocks += (Ext2Sys->blocksize/SECTOR_SIZE);
             }
         }
     }
 
     blocks = ext2_build_bdl(Ext2Sys, &inode, offset, size, &ext2_bdl);
 
     if (blocks <= 0)
         return  false;
 
     for(i = 0; i < blocks; i++)
     {
         bRet = NT_SUCCESS(Ext2WriteDisk(
                 Ext2Sys,
                 ext2_bdl[i].Lba,
                 ext2_bdl[i].Length,
                 (PUCHAR)Buffer + ext2_bdl[i].Offset
                ));
 
         if (!bRet)
         {
             goto errorout;
         }
 
         dwTotal += ext2_bdl[i].Length;
     }
 
     *dwReturn = dwTotal;
 
     if (size + offset > inode.i_size)
     {
         inode.i_size = size + offset;
     }
 
     ext2_save_inode(Ext2Sys, ino, &inode);
 
 
 errorout:
 
     if (ext2_bdl)
         RtlFreeHeap(RtlGetProcessHeap(), 0, ext2_bdl);
 
     return bRet;
 }

Referenced by ext2_add_entry().

◆ ext2_write_inode_bitmap()

bool ext2_write_inode_bitmap ( PEXT2_FILESYS fs )

Definition at line 216 of file Bitmap.c.

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

Referenced by ext2_write_bitmaps().

◆ Ext2CloseDevice()

NTSTATUS Ext2CloseDevice ( PEXT2_FILESYS Ext2Sys )

Definition at line 1342 of file Disk.c.

 {
     NTSTATUS Status = STATUS_SUCCESS;
 
     if(Ext2Sys->MediaHandle)
     {
         Status = NtClose(Ext2Sys->MediaHandle);
     }
 
     return Status;
 }

Referenced by Ext2Format().

◆ Ext2DataBlocks()

ULONG Ext2DataBlocks	(	PEXT2_FILESYS	Ext2Sys,
		ULONG	TotalBlocks
	)

Definition at line 698 of file Mke2fs.c.

 {
     ULONG   dwData[4] = {1, 1, 1, 1};
     ULONG   dwMeta[4] = {0, 0, 0, 0};
     ULONG   DataBlocks = 0;
     ULONG   i, j;
 
     if (TotalBlocks <= EXT2_NDIR_BLOCKS)
     {
         return TotalBlocks;
     }
 
     TotalBlocks -= EXT2_NDIR_BLOCKS;
 
     for (i = 0; i < 4; i++)
     {
         dwData[i] = dwData[i] << ((BLOCK_BITS - 2) * i);
 
         if (i > 0)
         {
             dwMeta[i] = 1 + (dwMeta[i - 1] << (BLOCK_BITS - 2));
         }
     }
 
     for( i=1; (i < 4) && (TotalBlocks > 0); i++)
     {
         if (TotalBlocks >= (dwData[i] + dwMeta[i]))
         {
             TotalBlocks -= (dwData[i] + dwMeta[i]);
             DataBlocks  += dwData[i];
         }
         else
         {
             ULONG   dwDivide = 0;
             ULONG   dwRemain = 0;
 
             for (j=i; (j > 0) && (TotalBlocks > 0); j--)
             {
                 dwDivide = (TotalBlocks - 1) / (dwData[j-1] + dwMeta[j-1]);
                 dwRemain = (TotalBlocks - 1) % (dwData[j-1] + dwMeta[j-1]);
 
                 DataBlocks += (dwDivide * dwData[j-1]);
                 TotalBlocks = dwRemain;
             }
         }
     }
 
     return (DataBlocks + EXT2_NDIR_BLOCKS);
 }

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

◆ Ext2DisMountVolume()

NTSTATUS Ext2DisMountVolume ( PEXT2_FILESYS Ext2Sys )

Definition at line 1260 of file Disk.c.

 {
     NTSTATUS Status;
     IO_STATUS_BLOCK IoSb;
 
     Status = NtFsControlFile( Ext2Sys->MediaHandle,
                               NULL, NULL, NULL, &IoSb,
                               FSCTL_DISMOUNT_VOLUME,
                               NULL, 0, NULL, 0 );
 
     if (!NT_SUCCESS(Status))
     {
         DPRINT1("Mke2fs: Error when dismounting volume ...\n");
         goto errorout;
     }
 
 errorout:
 
     return Status;
 }

Referenced by Ext2Format().

◆ Ext2GetMediaInfo()

NTSTATUS Ext2GetMediaInfo ( PEXT2_FILESYS Ext2Sys )

Definition at line 1162 of file Disk.c.

 {
     NTSTATUS Status;
     IO_STATUS_BLOCK IoSb;
 
     Status = NtDeviceIoControlFile( Ext2Sys->MediaHandle,
                                 NULL, NULL, NULL, &IoSb,
                                 IOCTL_DISK_GET_DRIVE_GEOMETRY,
                                 &(Ext2Sys->DiskGeometry), sizeof(DISK_GEOMETRY),
                                 &(Ext2Sys->DiskGeometry), sizeof(DISK_GEOMETRY));
 
 
     if (!NT_SUCCESS(Status))
     {
         goto errorout;
     }
 
     Status = NtDeviceIoControlFile( Ext2Sys->MediaHandle,
                                 NULL, NULL, NULL, &IoSb,
                                 IOCTL_DISK_GET_PARTITION_INFO,
                                 &(Ext2Sys->PartInfo), sizeof(PARTITION_INFORMATION),
                                 &(Ext2Sys->PartInfo), sizeof(PARTITION_INFORMATION));
 
     if (!NT_SUCCESS(Status))
     {
         goto errorout;
     }
 
 errorout:
 
     return Status;
 }

Referenced by Ext2Format().

◆ Ext2LockVolume()

NTSTATUS Ext2LockVolume ( PEXT2_FILESYS Ext2Sys )

Definition at line 1212 of file Disk.c.

 {
     NTSTATUS Status;
     IO_STATUS_BLOCK IoSb;
 
     Status = NtFsControlFile( Ext2Sys->MediaHandle,
                               NULL, NULL, NULL, &IoSb,
                               FSCTL_LOCK_VOLUME,
                               NULL, 0, NULL, 0 );
 
     if (!NT_SUCCESS(Status))
     {
         DPRINT1("Mke2fs: Error when locking volume: Status = %lxh %s...\n",
                 Status, Ext2StatusToString(Status));
 
         goto errorout;
     }
 
 errorout:
 
     return Status;
 }

◆ Ext2OpenDevice()

NTSTATUS Ext2OpenDevice	(	PEXT2_FILESYS	Ext2Sys,
		PUNICODE_STRING	DeviceName
	)

Definition at line 1282 of file Disk.c.

 {
     NTSTATUS Status;
     OBJECT_ATTRIBUTES ObjectAttributes;
     HANDLE FileHandle;
     IO_STATUS_BLOCK Iosb;
 
     //
     // Setup the name in an object attributes structure.
     // Note that we create a name that is case INsensitive
     //
     InitializeObjectAttributes(&ObjectAttributes,           // ptr to structure
                                DeviceName,                  // ptr to file spec
                                OBJ_CASE_INSENSITIVE,        // attributes
                                NULL,                        // root directory handle
                                NULL );                      // ptr to security descriptor
 
     //
     // Do the create.  In this particular case, we'll have the I/O Manager
     // make our write requests syncrhonous for our convenience.
     //
     Status = NtCreateFile(&FileHandle,                      // returned file handle
                           (GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE),    // desired access
                           &ObjectAttributes,                // ptr to object attributes
                           &Iosb,                            // ptr to I/O status block
                           0,                                // allocation size
                           FILE_ATTRIBUTE_NORMAL,            // file attributes
                           FILE_SHARE_WRITE | FILE_SHARE_READ, // share access
                           FILE_OPEN  /*FILE_SUPERSEDE*/,    // create disposition
                           FILE_SYNCHRONOUS_IO_NONALERT, // create options
                           NULL,                             // ptr to extended attributes
                           0);                               // length of ea buffer
 
     //
     // Check the system service status
     //
     if( !NT_SUCCESS(Status) )
     {
         DPRINT1("Mke2fs: Create system service failed status = 0x%lx\n", Status);
         return Status;
     }
 
 
     //
     // Check the returned status too...
     //
     if(!NT_SUCCESS(Iosb.Status) )
     {
         DPRINT1("Mke2fs: Create failed with status = 0x%lx\n",Iosb.Status);
         return Status;
     }
 
     Ext2Sys->MediaHandle = FileHandle;
 
     return Status;
 }

Referenced by Ext2Format().

◆ Ext2ReadDisk()

NTSTATUS Ext2ReadDisk	(	PEXT2_FILESYS	Ext2Sys,
		ULONGLONG	Offset,
		ULONG	Length,
		PVOID	Buffer
	)

Definition at line 964 of file Disk.c.

 {
     LARGE_INTEGER   Address;
     NTSTATUS        Status;
     ULONG           AlignedLength;
 
     IO_STATUS_BLOCK IoStatus;
 
     PVOID           NonPagedBuffer = NULL;
 
     ASSERT(Buffer != NULL);
 
 #if 0
     if (Ext2Sys->bFile)
     {
         Address.QuadPart = Offset;
 
         Status = NtReadFile(  Ext2Sys->MediaHandle,
                               NULL,
                               NULL,
                               NULL,
                               &IoStatus,
                               Buffer,
                               Length,
                               &Address,
                               NULL );
     }
     else
 #endif
     {
         Address.QuadPart = Offset & (~((ULONGLONG)SECTOR_SIZE - 1));
 
         AlignedLength = (Length + SECTOR_SIZE - 1)&(~(SECTOR_SIZE - 1));
 
         AlignedLength += ((ULONG)(Offset - Address.QuadPart) + SECTOR_SIZE - 1)
                          & (~(SECTOR_SIZE - 1));
 
         NonPagedBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, AlignedLength);
         if (!NonPagedBuffer)
         {
             Status = STATUS_INSUFFICIENT_RESOURCES;
             goto errorout;
         }
 
         Status = NtReadFile( Ext2Sys->MediaHandle,
                              NULL,
                              NULL,
                              NULL,
                              &IoStatus,
                              NonPagedBuffer,
                              AlignedLength,
                              &Address,
                              NULL );
 
         if (!NT_SUCCESS(Status))
         {
             goto errorout;
         }
 
         RtlCopyMemory( Buffer,
                        (PUCHAR)NonPagedBuffer + (ULONG)(Offset - Address.QuadPart),
                        Length );
     }
 
 errorout:
 
     if (NonPagedBuffer)
         RtlFreeHeap(RtlGetProcessHeap(), 0, NonPagedBuffer);
 
     return Status;
 }

◆ Ext2TotalBlocks()

ULONG Ext2TotalBlocks	(	PEXT2_FILESYS	Ext2Sys,
		ULONG	DataBlocks
	)

Definition at line 750 of file Mke2fs.c.

 {
     ULONG   dwData[4] = {1, 1, 1, 1};
     ULONG   dwMeta[4] = {0, 0, 0, 0};
     ULONG   TotalBlocks = 0;
     ULONG   i, j;
 
     if (DataBlocks <= EXT2_NDIR_BLOCKS)
     {
         return DataBlocks;
     }
 
     DataBlocks -= EXT2_NDIR_BLOCKS;
 
     for (i = 0; i < 4; i++)
     {
         dwData[i] = dwData[i] << ((BLOCK_BITS - 2) * i);
 
         if (i > 0)
         {
             dwMeta[i] = 1 + (dwMeta[i - 1] << (BLOCK_BITS - 2));
         }
     }
 
     for( i=1; (i < 4) && (DataBlocks > 0); i++)
     {
         if (DataBlocks >= dwData[i])
         {
             DataBlocks  -= dwData[i];
             TotalBlocks += (dwData[i] + dwMeta[i]);
         }
         else
         {
             ULONG   dwDivide = 0;
             ULONG   dwRemain = 0;
 
             for (j=i; (j > 0) && (DataBlocks > 0); j--)
             {
                 dwDivide = (DataBlocks) / (dwData[j-1]);
                 dwRemain = (DataBlocks) % (dwData[j-1]);
 
                 TotalBlocks += (dwDivide * (dwData[j-1] + dwMeta[j-1]) + 1);
                 DataBlocks = dwRemain;
             }
         }
     }
 
     return (TotalBlocks + EXT2_NDIR_BLOCKS);
 }

Referenced by create_lost_and_found().

◆ Ext2UnLockVolume()

NTSTATUS Ext2UnLockVolume ( PEXT2_FILESYS Ext2Sys )

Definition at line 1237 of file Disk.c.

 {
     NTSTATUS Status;
     IO_STATUS_BLOCK IoSb;
 
     Status = NtFsControlFile( Ext2Sys->MediaHandle,
                               NULL, NULL, NULL, &IoSb,
                               FSCTL_UNLOCK_VOLUME,
                               NULL, 0, NULL, 0 );
 
     if (!NT_SUCCESS(Status))
     {
         DPRINT1("Mke2fs: Error when unlocking volume ...\n");
         goto errorout;
     }
 
 errorout:
 
     return Status;
 }

Referenced by Ext2Format().

◆ Ext2WriteDisk()

NTSTATUS Ext2WriteDisk	(	PEXT2_FILESYS	Ext2Sys,
		ULONGLONG	Offset,
		ULONG	Length,
		PVOID	Buffer
	)

Definition at line 1059 of file Disk.c.

 {
     LARGE_INTEGER   Address;
     NTSTATUS        Status;
     ULONG           AlignedLength;
 
     IO_STATUS_BLOCK IoStatus;
 
     PVOID           NonPagedBuffer = NULL;
 
     ASSERT(Buffer != NULL);
 
 #if 0
     if (Ext2Sys->bFile)
     {
         Address.QuadPart = Offset;
 
         Status = NtWriteFile( Ext2Sys->MediaHandle,
                               NULL,
                               NULL,
                               NULL,
                               &IoStatus,
                               Buffer,
                               Length,
                               &Address,
                               NULL );
     }
     else
 #endif
     {
         Address.QuadPart = Offset & (~((ULONGLONG)SECTOR_SIZE - 1));
 
         AlignedLength = (Length + SECTOR_SIZE - 1)&(~(SECTOR_SIZE - 1));
 
         AlignedLength += ((ULONG)(Offset - Address.QuadPart) + SECTOR_SIZE - 1)
                          & (~(SECTOR_SIZE - 1));
 
         NonPagedBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, AlignedLength);
         if (!NonPagedBuffer)
         {
             Status = STATUS_INSUFFICIENT_RESOURCES;
             goto errorout;
         }
 
         if ((AlignedLength != Length) || (Address.QuadPart != (LONGLONG)Offset))
         {
             Status = NtReadFile( Ext2Sys->MediaHandle,
                                  NULL,
                                  NULL,
                                  NULL,
                                  &IoStatus,
                                  NonPagedBuffer,
                                  AlignedLength,
                                  &Address,
                                  NULL );
 
             if (!NT_SUCCESS(Status))
             {
                 goto errorout;
             }
         }
 
         RtlCopyMemory( (PUCHAR)NonPagedBuffer + (ULONG)(Offset - Address.QuadPart),
                        Buffer, Length );
 
         Status = NtWriteFile( Ext2Sys->MediaHandle,
                               NULL,
                               NULL,
                               NULL,
                               &IoStatus,
                               NonPagedBuffer,
                               AlignedLength,
                               &Address,
                               NULL );
     }
 
 errorout:
 
     if (NonPagedBuffer)
         RtlFreeHeap(RtlGetProcessHeap(), 0, NonPagedBuffer);
 
     return Status;
 }

Referenced by create_journal_dev(), ext2_alloc_block(), ext2_flush(), ext2_save_inode(), ext2_write_block(), ext2_write_block_bitmap(), ext2_write_inode(), ext2_write_inode_bitmap(), write_primary_superblock(), zap_sector(), and zero_blocks().

◆ parase_cmd()

bool parase_cmd	(	int	argc,
		char *	argv[],
		PEXT2_FILESYS	pExt2Sys
	)

◆ uuid_generate()

void uuid_generate ( __u8 * uuid )

Definition at line 17 of file Uuid.c.

 {
 #if 0
     UuidCreate((UUID *) uuid);
 #else
     RtlZeroMemory(uuid, 16);
 #endif
 }

Referenced by Ext2Format().

◆ write_inode_tables()

bool write_inode_tables ( PEXT2_FILESYS fs )

Definition at line 221 of file Memory.c.

 {
     bool    retval;
     ULONG   blk, num;
     int     i;
 
     for (i = 0; (ULONG)i < fs->group_desc_count; i++)
     {
         blk = fs->group_desc[i].bg_inode_table;
         num = fs->inode_blocks_per_group;
 
         retval = zero_blocks(fs, blk, num, &blk, &num);
         if (!retval)
         {
             DPRINT1("\nMke2fs: Could not write %lu blocks "
                 "in inode table starting at %lu.\n",
                 num, blk);
 
             zero_blocks(0, 0, 0, 0, 0);
             return false;
         }
     }
 
     zero_blocks(0, 0, 0, 0, 0);
 
     return true;
 }

Referenced by Ext2Format().

◆ zero_blocks()

bool zero_blocks	(	PEXT2_FILESYS	fs,
		ULONG	blk,
		ULONG	num,
		ULONG *	ret_blk,
		ULONG *	ret_count
	)

Definition at line 122 of file Mke2fs.c.

 {
     ULONG       j, count;
     static unsigned char        *buf;
     bool        retval;
 
     /* If fs is null, clean up the static buffer and return */
     if (!fs)
     {
         if (buf)
         {
             RtlFreeHeap(RtlGetProcessHeap(), 0, buf);
             buf = 0;
         }
         return true;
     }
 
 #define STRIDE_LENGTH 8
 
     /* Allocate the zeroizing buffer if necessary */
     if (!buf)
     {
         buf = (unsigned char *)
             RtlAllocateHeap(RtlGetProcessHeap(), 0, fs->blocksize * STRIDE_LENGTH);
         if (!buf)
         {
             DPRINT1("Mke2fs: while allocating zeroizing buffer");
             if (ret_blk)
                 *ret_blk = blk;
             return false;
         }
         memset(buf, 0, fs->blocksize * STRIDE_LENGTH);
     }
 
     /* OK, do the write loop */
     for (j=0; j < num; j += STRIDE_LENGTH, blk += STRIDE_LENGTH)
     {
         if (num-j > STRIDE_LENGTH)
             count = STRIDE_LENGTH;
         else
             count = num - j;
 
         retval = NT_SUCCESS(Ext2WriteDisk(
                         fs,
                         ((ULONGLONG)blk * fs->blocksize),
                         count * fs->blocksize,
                         buf));
 
         if (!retval)
         {
             if (ret_count)
                 *ret_count = count;
 
             if (ret_blk)
                 *ret_blk = blk;
 
             return retval;
         }
     }
 
     return true;
 }

Referenced by create_journal_dev(), Ext2Format(), and write_inode_tables().

Classes

Macros

Typedefs

Functions

Macro Definition Documentation

◆ bool

◆ EXT2_CHECK_MAGIC

◆ EXT2_FIRST_INODE

◆ ext2_mark_block_bitmap

◆ ext2_mark_inode_bitmap

◆ EXT2_MF_ISROOT

◆ EXT2_MF_MOUNTED

◆ EXT2_MF_READONLY

◆ EXT2_MF_SWAP

◆ EXT2_SF_BAD_EXTRA_BYTES

◆ EXT2_SF_BAD_INODE_BLK

◆ EXT2_SF_CHK_BADBLOCKS

◆ EXT2_SF_SKIP_MISSING_ITABLE

◆ ext2_unmark_block_bitmap

◆ ext2_unmark_inode_bitmap

◆ false

◆ GUID_DEFINED

◆ LINUX_S_IFBLK

◆ LINUX_S_IFCHR

◆ LINUX_S_IFDIR

◆ LINUX_S_IFIFO

◆ LINUX_S_IFLNK

◆ LINUX_S_IFMT

◆ LINUX_S_IFREG

◆ LINUX_S_IFSOCK

◆ LINUX_S_IRGRP

◆ LINUX_S_IROTH

◆ LINUX_S_IRUSR

◆ LINUX_S_IRWXG

◆ LINUX_S_IRWXO

◆ LINUX_S_IRWXU

◆ LINUX_S_ISBLK

◆ LINUX_S_ISCHR

◆ LINUX_S_ISDIR

◆ LINUX_S_ISFIFO

◆ LINUX_S_ISGID

◆ LINUX_S_ISLNK

◆ LINUX_S_ISREG

◆ LINUX_S_ISSOCK

◆ LINUX_S_ISUID

◆ LINUX_S_ISVTX

◆ LINUX_S_IWGRP

◆ LINUX_S_IWOTH

◆ LINUX_S_IWUSR

◆ LINUX_S_IXGRP

◆ LINUX_S_IXOTH

◆ LINUX_S_IXUSR

◆ NTOS_MODE_USER

◆ SECTOR_SIZE

◆ SUPERBLOCK_OFFSET

◆ SUPERBLOCK_SIZE

◆ true

◆ UUID_DEFINED

◆ uuid_t

Typedef Documentation

◆ EXT2_ACL_ENTRY

◆ EXT2_ACL_HEADER

◆ EXT2_BADBLK_LIST

◆ EXT2_BDL

◆ EXT2_BITMAP

◆ EXT2_BLOCK_BITMAP

◆ EXT2_DIR_ENTRY

◆ EXT2_DIR_ENTRY2

◆ EXT2_DX_CL

◆ EXT2_DX_ENTRY

◆ EXT2_DX_RI

◆ EXT2_FILESYS

◆ EXT2_GENERIC_BITMAP

◆ EXT2_GROUP_DESC

◆ EXT2_INODE

◆ EXT2_INODE_BITMAP

◆ EXT2_SUPER_BLOCK

◆ GUID

◆ PEXT2_ACL_ENTRY

◆ PEXT2_ACL_HEADER