#include <linux/module.h>
#include <ntdddisk.h>
#include <stdio.h>
#include <time.h>
#include <string.h>
#include <linux/ext2_fs.h>
#include <linux/ext3_fs.h>
#include <linux/ext3_fs_i.h>
#include <linux/ext4.h>
#include "common.h"

Include dependency graph for ext2fs.h:

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

Go to the source code of this file.

Classes
struct	_EXT2_IDENTIFIER

struct	_EXT2_REAPER

struct	_EXT2_GLOBAL

struct	_EXT2_FCBVCB

struct	_EXT2_VCB

struct	_EXT2_FCB

struct	_EXT2_MCB

struct	_EXT2_CCB

struct	ext2_icb

struct	_EXT2_ALLOC_HEADER

struct	_FCB_LIST_ENTRY

struct	_EXT2_EXTENT

struct	_EXT2_FILLDIR_CONTEXT

struct	_EXT2_RW_CONTEXT

Macros
#define	EXT2_DEBUG 0

#define	EXT_DEBUG_BREAKPOINT FALSE

#define	DbgBreak()

#define	EXT2FSD_VERSION "0.69"

#define	EXT2_UNLOAD FALSE

#define	EXT2_PRE_ALLOCATION_SUPPORT TRUE

#define	EXT2_MAX_NESTED_LINKS (8)

#define	EXT2_LINKLEN_IN_INODE (60)

#define	EXT2_BLOCK_TYPES (0x04)

#define	MAXIMUM_RECORD_LENGTH (0x10000)

#define	SECTOR_BITS (Vcb->SectorBits)

#define	SECTOR_SIZE (Vcb->DiskGeometry.BytesPerSector)

#define	DEFAULT_SECTOR_SIZE (0x200)

#define	SUPER_BLOCK_OFFSET (0x400)

#define	SUPER_BLOCK_SIZE (0x400)

#define	READ_AHEAD_GRANULARITY (0x10000)

#define	SUPER_BLOCK (Vcb->SuperBlock)

#define	INODE_SIZE (Vcb->InodeSize)

#define	BLOCK_SIZE (Vcb->BlockSize)

#define	BLOCK_BITS (SUPER_BLOCK->s_log_block_size + 10)

#define	GROUP_DESC_SIZE (Vcb->sbi.s_desc_size)

#define	INODES_COUNT (Vcb->SuperBlock->s_inodes_count)

#define	INODES_PER_GROUP (SUPER_BLOCK->s_inodes_per_group)

#define	BLOCKS_PER_GROUP (SUPER_BLOCK->s_blocks_per_group)

#define	TOTAL_BLOCKS (ext3_blocks_count(SUPER_BLOCK))

#define	EXT2_FIRST_DATA_BLOCK (SUPER_BLOCK->s_first_data_block)

#define	CEILING_ALIGNED(T, A, B) (((A) + (B) - 1) & (~((T)(B) - 1)))

#define	COCKLOFT_ALIGNED(T, A, B) (((A) + (B)) & (~((T)(B) - 1)))

#define	CL_ASSERT(cond) do {switch('x') {case (cond): case 0: break;}} while (0)

#define	DRIVER_NAME "Ext2Fsd"

#define	DEVICE_NAME L"\\Ext2Fsd"

#define	CDROM_NAME L"\\Ext2CdFsd"

#define	PARAMETERS_KEY L"\\Parameters"

#define	VOLUMES_KEY L"\\Volumes"

#define	READING_ONLY L"Readonly"

#define	WRITING_SUPPORT L"WritingSupport"

#define	CHECKING_BITMAP L"CheckingBitmap"

#define	EXT3_FORCEWRITING L"Ext3ForceWriting"

#define	CODEPAGE_NAME L"CodePage"

#define	HIDING_PREFIX L"HidingPrefix"

#define	HIDING_SUFFIX L"HidingSuffix"

#define	AUTO_MOUNT L"AutoMount"

#define	MOUNT_POINT L"MountPoint"

#define	UID L"uid"

#define	GID L"gid"

#define	EUID L"euid"

#define	EGID L"egid"

#define	DOS_DEVICE_NAME L"\\DosDevices\\Ext2Fsd"

#define	IsFlagOn(a, b) ((BOOLEAN)(FlagOn(a,b) == b))

#define	FlagOn(_F, _SF) ((_F) & (_SF))

#define	BooleanFlagOn(F, SF) ((BOOLEAN)(((F) & (SF)) != 0))

#define	SetFlag(_F, _SF) ((_F) \|= (_SF))

#define	ClearFlag(_F, _SF) ((_F) &= ~(_SF))

#define	min(a, b) (((a) < (b)) ? (a) : (b))

#define	max(a, b) (((a) > (b)) ? (a) : (b))

#define	SetLongFlag(_F, _SF) InterlockedOr(&(_F), (ULONG)(_SF))

#define	ClearLongFlag(_F, _SF) InterlockedAnd(&(_F), ~((ULONG)(_SF)))

#define	Ext2RaiseStatus(IRPCONTEXT, STATUS)

#define	Ext2NormalizeAndRaiseStatus(IRPCONTEXT, STATUS)

#define	FILE_WRITE_TO_END_OF_FILE 0xffffffff

#define	IsWritingToEof(Pos)

#define	IsDirectory(Fcb) IsMcbDirectory((Fcb)->Mcb)

#define	IsSpecialFile(Fcb) IsMcbSpecialFile((Fcb)->Mcb)

#define	IsSymLink(Fcb) IsMcbSymLink((Fcb)->Mcb)

#define	IsInodeSymLink(I) S_ISLNK((I)->i_mode)

#define	IsRoot(Fcb) IsMcbRoot((Fcb)->Mcb)

#define	TAG_VPB ' bpV'

#define	VPB_SIZE sizeof(VPB)

#define	EXT2_DATA_MAGIC 'BD2E'

#define	EXT2_INAME_MAGIC 'NI2E'

#define	EXT2_FNAME_MAGIC 'NF2E'

#define	EXT2_VNAME_MAGIC 'NV2E'

#define	EXT2_DENTRY_MAGIC 'ED2E'

#define	EXT2_DIRSP_MAGIC 'SD2E'

#define	EXT2_SB_MAGIC 'BS2E'

#define	EXT2_GD_MAGIC 'DG2E'

#define	EXT2_FLIST_MAGIC 'LF2E'

#define	EXT2_PARAM_MAGIC 'PP2E'

#define	EXT2_RWC_MAGIC 'WR2E'

#define	EXT2_FILE_SYSTEM (FILE_SYSTEM)

#define	EXT2_BUGCHK_BLOCK (0x00010000)

#define	EXT2_BUGCHK_CLEANUP (0x00020000)

#define	EXT2_BUGCHK_CLOSE (0x00030000)

#define	EXT2_BUGCHK_CMCB (0x00040000)

#define	EXT2_BUGCHK_CREATE (0x00050000)

#define	EXT2_BUGCHK_DEBUG (0x00060000)

#define	EXT2_BUGCHK_DEVCTL (0x00070000)

#define	EXT2_BUGCHK_DIRCTL (0x00080000)

#define	EXT2_BUGCHK_DISPATCH (0x00090000)

#define	EXT2_BUGCHK_EXCEPT (0x000A0000)

#define	EXT2_BUGCHK_EXT2 (0x000B0000)

#define	EXT2_BUGCHK_FASTIO (0x000C0000)

#define	EXT2_BUGCHK_FILEINFO (0x000D0000)

#define	EXT2_BUGCHK_FLUSH (0x000E0000)

#define	EXT2_BUGCHK_FSCTL (0x000F0000)

#define	EXT2_BUGCHK_INIT (0x00100000)

#define	EXT2_BUGCHK_LOCK (0x0011000)

#define	EXT2_BUGCHK_MEMORY (0x0012000)

#define	EXT2_BUGCHK_MISC (0x0013000)

#define	EXT2_BUGCHK_READ (0x00140000)

#define	EXT2_BUGCHK_SHUTDOWN (0x00150000)

#define	EXT2_BUGCHK_VOLINFO (0x00160000)

#define	EXT2_BUGCHK_WRITE (0x00170000)

#define	EXT2_BUGCHK_LAST (0x00170000)

#define	Ext2BugCheck(A, B, C, D) { KeBugCheckEx(EXT2_FILE_SYSTEM, A \| __LINE__, B, C, D ); }

#define	EXT2_SUPER_MAGIC 0xEF53

#define	EXT2_MIN_BLOCK 1024

#define	EXT2_MIN_FRAG 1024

#define	EXT2_MAX_USER_BLKSIZE 65536

#define	S_IFMT 0x0F000 /* 017 0000 */

#define	S_IFSOCK 0x0C000 /* 014 0000 */

#define	S_IFLNK 0x0A000 /* 012 0000 */

#define	S_IFREG 0x08000 /* 010 0000 */

#define	S_IFBLK 0x06000 /* 006 0000 */

#define	S_IFDIR 0x04000 /* 004 0000 */

#define	S_IFCHR 0x02000 /* 002 0000 */

#define	S_IFIFO 0x01000 /* 001 0000 */

#define	S_ISUID 0x00800 /* 000 4000 */

#define	S_ISGID 0x00400 /* 000 2000 */

#define	S_ISVTX 0x00200 /* 000 1000 */

#define	S_ISREG(m) (((m) & S_IFMT) == S_IFREG)

#define	S_ISSOCK(m) (((m) & S_IFMT) == S_IFSOCK)

#define	S_ISLNK(m) (((m) & S_IFMT) == S_IFLNK)

#define	S_ISFIL(m) (((m) & S_IFMT) == S_IFFIL)

#define	S_ISBLK(m) (((m) & S_IFMT) == S_IFBLK)

#define	S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)

#define	S_ISCHR(m) (((m) & S_IFMT) == S_IFCHR)

#define	S_ISFIFO(m) (((m) & S_IFMT) == S_IFIFO)

#define	S_IPERMISSION_MASK 0x1FF /* */

#define	S_IRWXU 0x1C0 /* 0 0700 */

#define	S_IRWNU 0x180 /* 0 0600 */

#define	S_IRUSR 0x100 /* 0 0400 */

#define	S_IWUSR 0x080 /* 0 0200 */

#define	S_IXUSR 0x040 /* 0 0100 */

#define	S_IRWXG 0x038 /* 0 0070 */

#define	S_IRWNG 0x030 /* 0 0060 */

#define	S_IRGRP 0x020 /* 0 0040 */

#define	S_IWGRP 0x010 /* 0 0020 */

#define	S_IXGRP 0x008 /* 0 0010 */

#define	S_IRWXO 0x007 /* 0 0007 */

#define	S_IRWNO 0x006 /* 0 0006 */

#define	S_IROTH 0x004 /* 0 0004 */

#define	S_IWOTH 0x002 /* 0 0002 */

#define	S_IXOTH 0x001 /* 0 0001 */

#define	S_IRWXUGO (S_IRWXU\|S_IRWXG\|S_IRWXO)

#define	S_IALLUGO (S_ISUID\|S_ISGID\|S_ISVTX\|S_IRWXUGO)

#define	S_IRUGO (S_IRUSR\|S_IRGRP\|S_IROTH)

#define	S_IWUGO (S_IWUSR\|S_IWGRP\|S_IWOTH)

#define	S_IXUGO (S_IXUSR\|S_IXGRP\|S_IXOTH)

#define	S_IFATTR (S_IRWNU\|S_IRWNG\|S_IRWNO)

#define	S_ISREADABLE(m) (((m) & S_IPERMISSION_MASK) == (S_IRUSR \| S_IRGRP \| S_IROTH))

#define	S_ISWRITABLE(m) (((m) & S_IPERMISSION_MASK) == (S_IWUSR \| S_IWGRP \| S_IWOTH))

#define	Ext2SetReadable(m) do {(m) = (m) \| (S_IRUSR \| S_IRGRP \| S_IROTH);} while(0)

#define	Ext2SetWritable(m) do {(m) = (m) \| (S_IWUSR \| S_IWGRP \| S_IWOTH);} while(0)

#define	Ext2SetOwnerWritable(m) do {(m) \|= S_IWUSR;} while(0)

#define	Ext2SetOwnerReadOnly(m) do {(m) &= ~S_IWUSR;} while(0)

#define	Ext2IsOwnerWritable(m) (((m) & S_IWUSR) == S_IWUSR)

#define	Ext2IsOwnerReadable(m) (((m) & S_IRUSR) == S_IRUSR)

#define	Ext2IsOwnerReadOnly(m) (!(Ext2IsOwnerWritable(m)) && Ext2IsOwnerReadable(m))

#define	Ext2IsGroupWritable(m) (((m) & S_IWGRP) == S_IWGRP)

#define	Ext2IsGroupReadable(m) (((m) & S_IRGRP) == S_IRGRP)

#define	Ext2IsGroupReadOnly(m) (!(Ext2IsGroupWritable(m)) && Ext2IsGroupReadable(m))

#define	Ext2IsOtherWritable(m) (((m) & S_IWOTH) == S_IWOTH)

#define	Ext2IsOtherReadable(m) (((m) & S_IROTH) == S_IROTH)

#define	Ext2IsOtherReadOnly(m) (!(Ext2IsOtherWritable(m)) && Ext2IsOtherReadable(m))

#define	Ext2SetReadOnly(m) do {(m) &= ~(S_IWUSR \| S_IWGRP \| S_IWOTH);} while(0)

#define	Ext2FileCanRead (0x1)

#define	Ext2FileCanWrite (0x2)

#define	Ext2FileCanExecute (0x4)

#define	NodeType(Ptr) (((EXT2_IDENTIFIER_TYPE )(Ptr)))

#define	EXT2_REAPER_FLAG_STOP (1 << 0)

#define	EXT2_UNLOAD_PENDING 0x00000001

#define	EXT2_SUPPORT_WRITING 0x00000002

#define	EXT3_FORCE_WRITING 0x00000004

#define	EXT2_CHECKING_BITMAP 0x00000008

#define	EXT2_AUTO_MOUNT 0x00000010

#define	INC_MEM_COUNT(_i, _p, _s) do { ASSERT(_p); Ext2TraceMemory(TRUE, (int) (_i), (PVOID)(_p), (LONG)(_s)); } while(0)

#define	DEC_MEM_COUNT(_i, _p, _s) do { ASSERT(_p); Ext2TraceMemory(FALSE, (int) (_i), (PVOID)(_p), (LONG)(_s)); } while(0)

#define	INC_IRP_COUNT(IrpContext) Ext2TraceIrpContext(TRUE, (IrpContext))

#define	DEC_IRP_COUNT(IrpContext) Ext2TraceIrpContext(FALSE, (IrpContext))

#define	IsExt2FsDevice(DO)

#define	VCB_INITIALIZED 0x00000001

#define	VCB_VOLUME_LOCKED 0x00000002

#define	VCB_MOUNTED 0x00000004

#define	VCB_DISMOUNT_PENDING 0x00000008

#define	VCB_NEW_VPB 0x00000010

#define	VCB_BEING_CLOSED 0x00000020

#define	VCB_USER_IDS 0x00000040 /* uid/gid specified by user */

#define	VCB_USER_EIDS 0x00000080 /* euid/egid specified by user */

#define	VCB_GD_LOADED 0x00000100 /* group desc loaded */

#define	VCB_BEING_DROPPED 0x00002000

#define	VCB_FORCE_WRITING 0x00004000

#define	VCB_DEVICE_REMOVED 0x00008000

#define	VCB_JOURNAL_RECOVER 0x00080000

#define	VCB_ARRIVAL_NOTIFIED 0x00800000

#define	VCB_RO_COMPAT_READ_ONLY 0x01000000

#define	VCB_READ_ONLY 0x08000000

#define	VCB_WRITE_PROTECTED 0x10000000

#define	VCB_FLOPPY_DISK 0x20000000

#define	VCB_REMOVAL_PREVENTED 0x40000000

#define	VCB_REMOVABLE_MEDIA 0x80000000

#define	IsVcbInited(Vcb) (IsFlagOn((Vcb)->Flags, VCB_INITIALIZED))

#define	IsMounted(Vcb) (IsFlagOn((Vcb)->Flags, VCB_MOUNTED))

#define	IsDispending(Vcb) (IsFlagOn((Vcb)->Flags, VCB_DISMOUNT_PENDING))

#define	IsVcbReadOnly(Vcb)

#define	IsExt3ForceWrite() (IsFlagOn(Ext2Global->Flags, EXT3_FORCE_WRITING))

#define	IsVcbForceWrite(Vcb) (IsFlagOn((Vcb)->Flags, VCB_FORCE_WRITING))

#define	CanIWrite(Vcb) (IsExt3ForceWrite() \|\| (!IsVcbReadOnly(Vcb) && IsVcbForceWrite(Vcb)))

#define	IsLazyWriter(Fcb) ((Fcb)->LazyWriterThread == PsGetCurrentThread())

#define	FCB_FROM_POOL 0x00000001

#define	FCB_PAGE_FILE 0x00000002

#define	FCB_FILE_MODIFIED 0x00000020

#define	FCB_ALLOC_IN_CREATE 0x00000080

#define	FCB_ALLOC_IN_WRITE 0x00000100

#define	FCB_ALLOC_IN_SETINFO 0x00000200

#define	FCB_DELETE_PENDING 0x80000000

#define	MCB_FROM_POOL 0x00000001

#define	MCB_VCB_LINK 0x00000002

#define	MCB_ENTRY_TREE 0x00000004

#define	MCB_FILE_DELETED 0x00000008

#define	MCB_ZONE_INITED 0x20000000

#define	MCB_TYPE_SPECIAL 0x40000000 /* unresolved symlink + device node */

#define	MCB_TYPE_SYMLINK 0x80000000

#define	IsMcbUsed(Mcb) ((Mcb)->Refercount > 0)

#define	IsMcbSymLink(Mcb) IsFlagOn((Mcb)->Flags, MCB_TYPE_SYMLINK)

#define	IsZoneInited(Mcb) IsFlagOn((Mcb)->Flags, MCB_ZONE_INITED)

#define	IsMcbSpecialFile(Mcb) IsFlagOn((Mcb)->Flags, MCB_TYPE_SPECIAL)

#define	IsMcbRoot(Mcb) ((Mcb)->Inode.i_ino == EXT2_ROOT_INO)

#define	IsMcbReadonly(Mcb) IsFlagOn((Mcb)->FileAttr, FILE_ATTRIBUTE_READONLY)

#define	IsMcbDirectory(Mcb) IsFlagOn((Mcb)->FileAttr, FILE_ATTRIBUTE_DIRECTORY)

#define	IsFileDeleted(Mcb) IsFlagOn((Mcb)->Flags, MCB_FILE_DELETED)

#define	IsLinkInvalid(Mcb) (IsMcbSymLink(Mcb) && IsFileDeleted(Mcb->Target))

#define	Ext2ReferXcb(_C) InterlockedIncrement(_C)

#define	Ext2DerefXcb(_C) DEC_OBJ_CNT(_C)

#define	Ext2ReferMcb(Mcb) Ext2ReferXcb(&Mcb->Refercount)

#define	Ext2DerefMcb(Mcb) Ext2DerefXcb(&Mcb->Refercount)

#define	CCB_FROM_POOL 0x00000001

#define	CCB_VOLUME_DASD_PURGE 0x00000002

#define	CCB_LAST_WRITE_UPDATED 0x00000004

#define	CCB_OPEN_REPARSE_POINT 0x00000008

#define	CCB_DELETE_ON_CLOSE 0x00000010

#define	CCB_ALLOW_EXTENDED_DASD_IO 0x80000000

#define	IRP_CONTEXT_FLAG_FROM_POOL (0x00000001)

#define	IRP_CONTEXT_FLAG_WAIT (0x00000002)

#define	IRP_CONTEXT_FLAG_WRITE_THROUGH (0x00000004)

#define	IRP_CONTEXT_FLAG_FLOPPY (0x00000008)

#define	IRP_CONTEXT_FLAG_DISABLE_POPUPS (0x00000020)

#define	IRP_CONTEXT_FLAG_DEFERRED (0x00000040)

#define	IRP_CONTEXT_FLAG_VERIFY_READ (0x00000080)

#define	IRP_CONTEXT_STACK_IO_CONTEXT (0x00000100)

#define	IRP_CONTEXT_FLAG_REQUEUED (0x00000200)

#define	IRP_CONTEXT_FLAG_USER_IO (0x00000400)

#define	IRP_CONTEXT_FLAG_DELAY_CLOSE (0x00000800)

#define	IRP_CONTEXT_FLAG_FILE_BUSY (0x00001000)

#define	Ext2CanIWait() (!IrpContext \|\| IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT))

#define	FSCTL_GET_RETRIEVAL_POINTER_BASE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 141, METHOD_BUFFERED, FILE_ANY_ACCESS)

#define	FILE_SUPPORTS_EXTENDED_ATTRIBUTES 0x00800000

#define	CanExt2Wait(IRP) IoIsOperationSynchronous(Irp)

#define	EXT2_LOOKUP_FLAG_MASK (0xFF00000)

#define	EXT2_LOOKUP_NOT_FOLLOW (0x8000000)

#define	DL_NVR 0

#define	DL_VIT 0x00000001

#define	DL_ERR 0x00000002

#define	DL_DBG 0x00000004

#define	DL_INF 0x00000008

#define	DL_FUN 0x00000010

#define	DL_LOW 0x00000020

#define	DL_REN 0x00000040 /* renaming operation */

#define	DL_RES 0x00000080 /* entry reference managment */

#define	DL_BLK 0x00000100 /* data block allocation / free */

#define	DL_CP 0x00000200 /* code pages (create, querydir) */

#define	DL_EXT 0x00000400 /* mcb extents */

#define	DL_MAP 0x00000800 /* retrieval points */

#define	DL_JNL 0x00001000 /* dump journal operations */

#define	DL_HTI 0x00002000 /* htree index */

#define	DL_WRN 0x00004000 /* warning */

#define	DL_BH 0x00008000 /* buffer head */

#define	DL_PNP 0x00010000 /* pnp */

#define	DL_IO 0x00020000 /* file i/o */

#define	DL_DEFAULT (DL_ERR\|DL_VIT)

#define	DEBUG(_DL, arg) do {if ((_DL) & DL_ERR) DbgPrint arg;} while(0)

#define	Ext2CompleteRequest(Irp, bPrint, PriorityBoost) IoCompleteRequest(Irp, PriorityBoost)

#define	Ext2GetCurrentProcessName()

#define	ext3_error ext3_warning

#define	ext4_error ext3_error

#define	EXT2_RW_CONTEXT_WRITE 1

Typedefs
typedef struct ext3_super_block	EXT2_SUPER_BLOCK

typedef struct ext3_super_block *	PEXT2_SUPER_BLOCK

typedef struct ext3_inode	EXT2_INODE

typedef struct ext3_inode *	PEXT2_INODE

typedef struct ext4_group_desc	EXT2_GROUP_DESC

typedef struct ext4_group_desc *	PEXT2_GROUP_DESC

typedef struct ext3_dir_entry	EXT2_DIR_ENTRY

typedef struct ext3_dir_entry *	PEXT2_DIR_ENTRY

typedef struct ext3_dir_entry_2	EXT2_DIR_ENTRY2

typedef struct ext3_dir_entry_2 *	PEXT2_DIR_ENTRY2

typedef IO_STACK_LOCATION	EXTENDED_IO_STACK_LOCATION

typedef IO_STACK_LOCATION *	PEXTENDED_IO_STACK_LOCATION

typedef enum _EXT2_IDENTIFIER_TYPE	EXT2_IDENTIFIER_TYPE

typedef struct _EXT2_IDENTIFIER	EXT2_IDENTIFIER

typedef struct _EXT2_IDENTIFIER *	PEXT2_IDENTIFIER

typedef struct _EXT2_MCB	EXT2_MCB

typedef struct _EXT2_MCB *	PEXT2_MCB

typedef PVOID	PBCB

typedef VOID(*	EXT2_REAPER_RELEASE) (PVOID)

typedef struct _EXT2_REAPER	EXT2_REAPER

typedef struct _EXT2_REAPER *	PEXT2_REAPER

typedef struct _EXT2_GLOBAL	EXT2_GLOBAL

typedef struct _EXT2_GLOBAL *	PEXT2_GLOBAL

typedef struct _EXT2_FCBVCB	EXT2_FCBVCB

typedef struct _EXT2_FCBVCB *	PEXT2_FCBVCB

typedef struct _EXT2_VCB	EXT2_VCB

typedef struct _EXT2_VCB *	PEXT2_VCB

typedef struct _EXT2_FCB	EXT2_FCB

typedef struct _EXT2_FCB *	PEXT2_FCB

typedef struct _EXT2_CCB	EXT2_CCB

typedef struct _EXT2_CCB *	PEXT2_CCB

typedef struct ext2_icb	EXT2_IRP_CONTEXT

typedef struct ext2_icb *	PEXT2_IRP_CONTEXT

typedef struct _EXT2_ALLOC_HEADER	EXT2_ALLOC_HEADER

typedef struct _EXT2_ALLOC_HEADER *	PEXT2_ALLOC_HEADER

typedef struct _FCB_LIST_ENTRY	FCB_LIST_ENTRY

typedef struct _FCB_LIST_ENTRY *	PFCB_LIST_ENTRY

typedef struct _EXT2_EXTENT	EXT2_EXTENT

typedef struct _EXT2_EXTENT *	PEXT2_EXTENT

typedef struct _EXT2_FILLDIR_CONTEXT	EXT2_FILLDIR_CONTEXT

typedef struct _EXT2_FILLDIR_CONTEXT *	PEXT2_FILLDIR_CONTEXT

typedef int(*	filldir_t) (void , const char , int, unsigned long, __u32, unsigned)

typedef struct _EXT2_RW_CONTEXT	EXT2_RW_CONTEXT

typedef struct _EXT2_RW_CONTEXT *	PEXT2_RW_CONTEXT

Enumerations
enum	_EXT2_IDENTIFIER_TYPE { EXT2FGD = 0xE2FD0001 , EXT2VCB = 0xE2FD0002 , EXT2FCB = 0xE2FD0003 , EXT2CCB = 0xE2FD0004 , EXT2ICX = 0xE2FD0005 , EXT2FSD = 0xE2FD0006 , EXT2MCB = 0xE2FD0007 }

Functions
__inline ULONG	DEC_OBJ_CNT (PULONG _C)

__inline VOID	Ext2TraceMemory (BOOLEAN _n, int _i, PVOID _p, LONG _s)

__inline VOID	Ext2TraceIrpContext (BOOLEAN _n, PEXT2_IRP_CONTEXT IrpContext)

int	Ext2CheckInodeAccess (PEXT2_VCB Vcb, struct inode *in, int attempt)

int	Ext2CheckFileAccess (PEXT2_VCB Vcb, PEXT2_MCB Mcb, int attempt)

PMDL	Ext2CreateMdl (IN PVOID Buffer, IN ULONG Length, IN LOCK_OPERATION Operation)

VOID	Ext2DestroyMdl (IN PMDL Mdl)

NTSTATUS	Ext2LockUserBuffer (IN PIRP Irp, IN ULONG Length, IN LOCK_OPERATION Operation)

PVOID	Ext2GetUserBuffer (IN PIRP Irp)

NTSTATUS	Ext2ReadWriteBlocks (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_EXTENT Extent, IN ULONG Length)

NTSTATUS	Ext2ReadSync (IN PEXT2_VCB Vcb, IN ULONGLONG Offset, IN ULONG Length, OUT PVOID Buffer, IN BOOLEAN bVerify)

NTSTATUS	Ext2ReadDisk (IN PEXT2_VCB Vcb, IN ULONGLONG Offset, IN ULONG Size, IN PVOID Buffer, IN BOOLEAN bVerify)

NTSTATUS	Ext2DiskIoControl (IN PDEVICE_OBJECT DeviceOjbect, IN ULONG IoctlCode, IN PVOID InputBuffer, IN ULONG InputBufferSize, IN OUT PVOID OutputBuffer, IN OUT PULONG OutputBufferSize)

VOID	Ext2MediaEjectControl (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN BOOLEAN bPrevent)

NTSTATUS	Ext2DiskShutDown (PEXT2_VCB Vcb)

NTSTATUS	Ext2Cleanup (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2Close (IN PEXT2_IRP_CONTEXT IrpContext)

VOID	Ext2QueueCloseRequest (IN PEXT2_IRP_CONTEXT IrpContext)

VOID	Ext2DeQueueCloseRequest (IN PVOID Context)

BOOLEAN	Ext2AcquireForLazyWrite (IN PVOID Context, IN BOOLEAN Wait)

VOID	Ext2ReleaseFromLazyWrite (IN PVOID Context)

BOOLEAN	Ext2AcquireForReadAhead (IN PVOID Context, IN BOOLEAN Wait)

VOID	Ext2ReleaseFromReadAhead (IN PVOID Context)

BOOLEAN	Ext2NoOpAcquire (IN PVOID Fcb, IN BOOLEAN Wait)

VOID	Ext2NoOpRelease (IN PVOID Fcb)

BOOLEAN	Ext2IsNameValid (PUNICODE_STRING FileName)

NTSTATUS	Ext2FollowLink (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Parent, IN PEXT2_MCB Mcb, IN ULONG Linkdep)

NTSTATUS	Ext2ScanDir (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Parent, IN PUNICODE_STRING FileName, OUT PULONG Inode, struct dentry **dentry)

BOOLEAN	Ext2IsSpecialSystemFile (IN PUNICODE_STRING FileName, IN BOOLEAN bDirectory)

NTSTATUS	Ext2LookupFile (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PUNICODE_STRING FullName, IN PEXT2_MCB Parent, OUT PEXT2_MCB *Ext2Mcb, IN ULONG Linkdep)

NTSTATUS	Ext2CreateFile (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, OUT PBOOLEAN OpPostIrp)

NTSTATUS	Ext2CreateVolume (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb)

NTSTATUS	Ext2Create (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2CreateInode (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB pParentFcb, IN ULONG Type, IN ULONG FileAttr, IN PUNICODE_STRING FileName)

NTSTATUS	Ext2SupersedeOrOverWriteFile (IN PEXT2_IRP_CONTEXT IrpContext, IN PFILE_OBJECT FileObject, IN PEXT2_VCB Vcb, IN PEXT2_FCB Fcb, IN PLARGE_INTEGER AllocationSize, IN ULONG Disposition)

VOID __cdecl	Ext2Printf (PCHAR DebugMessage,...)

ULONG	Ext2GetProcessNameOffset (VOID)

VOID	Ext2DbgPrintCall (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

VOID	Ext2DbgPrintComplete (IN PIRP Irp, IN BOOLEAN bPrint)

PUCHAR	Ext2NtStatusToString (IN NTSTATUS Status)

PVOID	Ext2AllocatePool (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes, IN ULONG Tag)

VOID	Ext2FreePool (IN PVOID P, IN ULONG Tag)

NTSTATUS	Ext2ProcessGlobalProperty (IN PDEVICE_OBJECT DeviceObject, IN PEXT2_VOLUME_PROPERTY3 Property, IN ULONG Length)

NTSTATUS	Ext2ProcessVolumeProperty (IN PEXT2_VCB Vcb, IN PEXT2_VOLUME_PROPERTY3 Property, IN ULONG Length)

NTSTATUS	Ext2ProcessUserProperty (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VOLUME_PROPERTY3 Property, IN ULONG Length)

NTSTATUS	Ex2ProcessUserPerfStat (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_QUERY_PERFSTAT QueryPerf, IN ULONG Length)

NTSTATUS	Ex2ProcessMountPoint (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_MOUNT_POINT MountPoint, IN ULONG Length)

NTSTATUS	Ext2DeviceControlNormal (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2PrepareToUnload (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2DeviceControl (IN PEXT2_IRP_CONTEXT IrpContext)

ULONG	Ext2GetInfoLength (IN FILE_INFORMATION_CLASS FileInformationClass)

NTSTATUS	Ext2ProcessEntry (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Dcb, IN FILE_INFORMATION_CLASS FileInformationClass, IN ULONG in, IN PVOID Buffer, IN ULONG UsedLength, IN ULONG Length, IN ULONG FileIndex, IN PUNICODE_STRING pName, OUT PULONG EntrySize, IN BOOLEAN Single)

BOOLEAN	Ext2IsWearingCloak (IN PEXT2_VCB Vcb, IN POEM_STRING OeName)

NTSTATUS	Ext2QueryDirectory (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2NotifyChangeDirectory (IN PEXT2_IRP_CONTEXT IrpContext)

VOID	Ext2NotifyReportChange (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Filter, IN ULONG Action)

NTSTATUS	Ext2DirectoryControl (IN PEXT2_IRP_CONTEXT IrpContext)

BOOLEAN	Ext2IsDirectoryEmpty (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb)

VOID	Ext2OplockComplete (IN PVOID Context, IN PIRP Irp)

VOID	Ext2LockIrp (IN PVOID Context, IN PIRP Irp)

NTSTATUS	Ext2QueueRequest (IN PEXT2_IRP_CONTEXT IrpContext)

VOID	Ext2DeQueueRequest (IN PVOID Context)

NTSTATUS	Ext2DispatchRequest (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2BuildRequest (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

NTSTATUS	Ext2QueryEa (IN PEXT2_IRP_CONTEXT IrpContext)

BOOLEAN	Ext2IsEaNameValid (IN OEM_STRING Name)

NTSTATUS	Ext2SetEa (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2ExceptionFilter (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXCEPTION_POINTERS ExceptionPointer)

NTSTATUS	Ext2ExceptionHandler (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2MapExtent (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Index, IN BOOLEAN Alloc, OUT PULONG Block, OUT PULONG Number)

NTSTATUS	Ext2ExpandExtent (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_MCB Mcb, ULONG Start, ULONG End, PLARGE_INTEGER Size)

NTSTATUS	Ext2TruncateExtent (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_MCB Mcb, PLARGE_INTEGER Size)

static ext3_fsblk_t	ext3_blocks_count (struct ext3_super_block *es)

static ext3_fsblk_t	ext3_r_blocks_count (struct ext3_super_block *es)

static ext3_fsblk_t	ext3_free_blocks_count (struct ext3_super_block *es)

static void	ext3_blocks_count_set (struct ext3_super_block *es, ext3_fsblk_t blk)

static void	ext3_free_blocks_count_set (struct ext3_super_block *es, ext3_fsblk_t blk)

static void	ext3_r_blocks_count_set (struct ext3_super_block *es, ext3_fsblk_t blk)

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)

int	ext3_bg_has_super (struct super_block *sb, ext3_group_t group)

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

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

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)

int	ext4_check_descriptors (struct super_block *sb)

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)

BOOLEAN	Ext2LoadGroupBH (IN PEXT2_VCB Vcb)

BOOLEAN	Ext2LoadGroup (IN PEXT2_VCB Vcb)

VOID	Ext2DropGroupBH (IN PEXT2_VCB Vcb)

VOID	Ext2PutGroup (IN PEXT2_VCB Vcb)

VOID	Ext2DropBH (IN PEXT2_VCB Vcb)

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)

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 dwBlk, IN PVOID Buffer)

BOOLEAN	Ext2SaveBlock (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN ULONG dwBlk, 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)

NTSTATUS	Ext2GetBlock (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Base, IN ULONG Layer, IN ULONG Start, IN ULONG SizeArray, IN PULONG BlockArray, IN BOOLEAN bAlloc, IN OUT PULONG Hint, OUT PULONG Block, OUT PULONG Number)

NTSTATUS	Ext2BlockMap (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Index, IN BOOLEAN bAlloc, OUT PULONG pBlock, OUT PULONG Number)

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, OUT 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)

NTSTATUS	Ext2TruncateBlock (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Base, IN ULONG Start, IN ULONG Layer, IN ULONG SizeArray, IN PULONG BlockArray, IN PULONG Extra)

struct ext3_dir_entry_2 *	ext3_next_entry (struct ext3_dir_entry_2 *p)

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

loff_t	ext3_max_size (int blkbits, int has_huge_files)

loff_t	ext3_max_bitmap_size (int bits, int has_huge_files)

__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)

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

FAST_IO_POSSIBLE	Ext2IsFastIoPossible (IN PEXT2_FCB Fcb)

BOOLEAN	Ext2FastIoCheckIfPossible (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, IN BOOLEAN CheckForReadOperation, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

BOOLEAN	Ext2FastIoRead (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

BOOLEAN	Ext2FastIoWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

BOOLEAN	Ext2FastIoQueryBasicInfo (IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, OUT PFILE_BASIC_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

BOOLEAN	Ext2FastIoQueryStandardInfo (IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, OUT PFILE_STANDARD_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

BOOLEAN	Ext2FastIoLock (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS Process, IN ULONG Key, IN BOOLEAN FailImmediately, IN BOOLEAN ExclusiveLock, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

BOOLEAN	Ext2FastIoUnlockSingle (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN PLARGE_INTEGER Length, IN PEPROCESS Process, IN ULONG Key, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

BOOLEAN	Ext2FastIoUnlockAll (IN PFILE_OBJECT FileObject, IN PEPROCESS Process, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

BOOLEAN	Ext2FastIoUnlockAllByKey (IN PFILE_OBJECT FileObject, IN PEPROCESS Process, IN ULONG Key, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

BOOLEAN	Ext2FastIoQueryNetworkOpenInfo (IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, OUT PFILE_NETWORK_OPEN_INFORMATION Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)

VOID	Ext2AcquireForCreateSection (IN PFILE_OBJECT FileObject)

VOID	Ext2ReleaseForCreateSection (IN PFILE_OBJECT FileObject)

NTSTATUS	Ext2AcquireFileForModWrite (IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER EndingOffset, OUT PERESOURCE *ResourceToRelease, IN PDEVICE_OBJECT DeviceObject)

NTSTATUS	Ext2ReleaseFileForModWrite (IN PFILE_OBJECT FileObject, IN PERESOURCE ResourceToRelease, IN PDEVICE_OBJECT DeviceObject)

NTSTATUS	Ext2AcquireFileForCcFlush (IN PFILE_OBJECT FileObject, IN PDEVICE_OBJECT DeviceObject)

NTSTATUS	Ext2ReleaseFileForCcFlush (IN PFILE_OBJECT FileObject, IN PDEVICE_OBJECT DeviceObject)

NTSTATUS	Ext2PreAcquireForCreateSection (IN PFS_FILTER_CALLBACK_DATA cd, OUT PVOID *cc)

NTSTATUS	Ext2QueryFileInformation (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2SetFileInformation (IN PEXT2_IRP_CONTEXT IrpContext)

ULONG	Ext2TotalBlocks (PEXT2_VCB Vcb, PLARGE_INTEGER Size, PULONG pMeta)

NTSTATUS	Ext2ExpandFile (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_MCB Mcb, PLARGE_INTEGER Size)

NTSTATUS	Ext2TruncateFile (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_MCB Mcb, PLARGE_INTEGER AllocationSize)

NTSTATUS	Ext2IsFileRemovable (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Fcb, IN PEXT2_CCB Ccb)

NTSTATUS	Ext2SetDispositionInfo (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_FCB Fcb, PEXT2_CCB Ccb, BOOLEAN bDelete)

NTSTATUS	Ext2SetRenameInfo (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_FCB Fcb, PEXT2_CCB Ccb)

NTSTATUS	Ext2SetLinkInfo (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_FCB Fcb, PEXT2_CCB Ccb)

ULONG	Ext2InodeType (PEXT2_MCB Mcb)

NTSTATUS	Ext2DeleteFile (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_FCB Fcb, PEXT2_MCB Mcb)

NTSTATUS	Ext2FlushFiles (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN BOOLEAN bShutDown)

NTSTATUS	Ext2FlushVolume (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN BOOLEAN bShutDown)

NTSTATUS	Ext2FlushFile (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_FCB Fcb, IN PEXT2_CCB Ccb)

NTSTATUS	Ext2Flush (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2ReadSymlink (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN PVOID Buffer, IN ULONG Size, OUT PULONG BytesRead)

NTSTATUS	Ext2WriteSymlink (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN PVOID Buffer, IN ULONG Size, OUT PULONG BytesWritten)

NTSTATUS	Ext2TruncateSymlink (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_MCB Mcb, ULONG Size)

VOID	Ext2SetVpbFlag (IN PVPB Vpb, IN USHORT Flag)

VOID	Ext2ClearVpbFlag (IN PVPB Vpb, IN USHORT Flag)

BOOLEAN	Ext2CheckDismount (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN BOOLEAN bForce)

NTSTATUS	Ext2PurgeVolume (IN PEXT2_VCB Vcb, IN BOOLEAN FlushBeforePurge)

NTSTATUS	Ext2PurgeFile (IN PEXT2_FCB Fcb, IN BOOLEAN FlushBeforePurge)

BOOLEAN	Ext2IsHandleCountZero (IN PEXT2_VCB Vcb)

NTSTATUS	Ext2LockVcb (IN PEXT2_VCB Vcb, IN PFILE_OBJECT FileObject)

NTSTATUS	Ext2LockVolume (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2UnlockVcb (IN PEXT2_VCB Vcb, IN PFILE_OBJECT FileObject)

NTSTATUS	Ext2UnlockVolume (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2AllowExtendedDasdIo (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2OplockRequest (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2QueryExtentMappings (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_FCB Fcb, IN PLARGE_INTEGER RequestVbn, OUT PLARGE_INTEGER *pMappedRuns)

NTSTATUS	Ext2QueryRetrievalPointers (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2GetRetrievalPointers (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2GetRetrievalPointerBase (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2UserFsRequest (IN PEXT2_IRP_CONTEXT IrpContext)

BOOLEAN	Ext2IsMediaWriteProtected (IN PEXT2_IRP_CONTEXT IrpContext, IN PDEVICE_OBJECT TargetDevice)

NTSTATUS	Ext2MountVolume (IN PEXT2_IRP_CONTEXT IrpContext)

VOID	Ext2VerifyVcb (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb)

NTSTATUS	Ext2VerifyVolume (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2IsVolumeMounted (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2DismountVolume (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2FileSystemControl (IN PEXT2_IRP_CONTEXT IrpContext)

struct buffer_head *	ext3_append (struct ext2_icb icb, struct inode inode, ext3_lblk_t block, int err)

void	ext3_set_de_type (struct super_block sb, struct ext3_dir_entry_2 de, umode_t mode)

__u32	ext3_current_time (struct inode *in)

void	ext3_warning (struct super_block sb, const char function, char *fmt,...)

void	ext3_update_dx_flag (struct inode *inode)

int	ext3_mark_inode_dirty (struct ext2_icb icb, struct inode in)

void	ext3_inc_count (struct inode *inode)

void	ext3_dec_count (struct inode *inode)

struct buffer_head *	ext3_find_entry (struct ext2_icb icb, struct dentry dentry, struct ext3_dir_entry_2 **res_dir)

struct buffer_head *	ext3_dx_find_entry (struct ext2_icb , struct dentry dentry, struct ext3_dir_entry_2 *res_dir, int err)

int	ext3_dx_readdir (struct file filp, filldir_t filldir, void context)

struct buffer_head *	ext3_bread (struct ext2_icb icb, struct inode inode, unsigned long block, int *err)

int	add_dirent_to_buf (struct ext2_icb icb, struct dentry dentry, struct inode inode, struct ext3_dir_entry_2 de, struct buffer_head *bh)

struct ext3_dir_entry_2 *	do_split (struct ext2_icb icb, struct inode dir, struct buffer_head *bh, struct dx_frame frame, struct dx_hash_info hinfo, int error)

int	ext3_add_entry (struct ext2_icb icb, struct dentry dentry, struct inode *inode)

int	ext3_delete_entry (struct ext2_icb icb, struct inode dir, struct ext3_dir_entry_2 de_del, struct buffer_head bh)

int	ext3_is_dir_empty (struct ext2_icb icb, struct inode inode)

NTSTATUS	Ext2QueryGlobalParameters (IN PUNICODE_STRING RegistryPath)

BOOLEAN	Ext2QueryRegistrySettings (IN PUNICODE_STRING RegistryPath)

VOID	DriverUnload (IN PDRIVER_OBJECT DriverObject)

NTSTATUS	Ext2MapIndirect (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Index, IN BOOLEAN bAlloc, OUT PULONG pBlock, OUT PULONG Number)

NTSTATUS	Ext2ExpandIndirect (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_MCB Mcb, ULONG Start, ULONG End, PLARGE_INTEGER Size)

NTSTATUS	Ext2TruncateIndirect (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_MCB Mcb, PLARGE_INTEGER Size)

int	ext2_init_linux ()

void	ext2_destroy_linux ()

NTSTATUS	Ext2LockControl (IN PEXT2_IRP_CONTEXT IrpContext)

VOID	Ext2FcbReaperThread (PVOID Context)

VOID	Ext2McbReaperThread (PVOID Context)

VOID	Ext2bhReaperThread (PVOID Context)

PEXT2_IRP_CONTEXT	Ext2AllocateIrpContext (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)

VOID	Ext2FreeIrpContext (IN PEXT2_IRP_CONTEXT IrpContext)

PEXT2_FCB	Ext2AllocateFcb (IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb)

VOID	Ext2UnlinkFcb (IN PEXT2_FCB Fcb)

VOID	Ext2FreeFcb (IN PEXT2_FCB Fcb)

VOID	Ext2ReleaseFcb (IN PEXT2_FCB Fcb)

VOID	Ext2InsertFcb (PEXT2_VCB Vcb, PEXT2_FCB Fcb)

PEXT2_CCB	Ext2AllocateCcb (ULONG Flags, PEXT2_MCB SymLink)

VOID	Ext2FreeMcb (IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb)

VOID	Ext2FreeCcb (IN PEXT2_VCB Vcb, IN PEXT2_CCB Ccb)

PEXT2_INODE	Ext2AllocateInode (PEXT2_VCB Vcb)

VOID	Ext2DestroyInode (IN PEXT2_VCB Vcb, IN PEXT2_INODE inode)

struct dentry *	Ext2AllocateEntry ()

VOID	Ext2FreeEntry (IN struct dentry *de)

struct dentry *	Ext2BuildEntry (PEXT2_VCB Vcb, PEXT2_MCB Dcb, PUNICODE_STRING FileName)

PEXT2_EXTENT	Ext2AllocateExtent ()

VOID	Ext2FreeExtent (IN PEXT2_EXTENT Extent)

ULONG	Ext2CountExtents (IN PEXT2_EXTENT Chain)

VOID	Ext2JointExtents (IN PEXT2_EXTENT Chain, IN PEXT2_EXTENT Extent)

VOID	Ext2DestroyExtentChain (IN PEXT2_EXTENT Chain)

NTSTATUS	Ext2BuildExtents (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONGLONG Offset, IN ULONG Size, IN BOOLEAN bAlloc, OUT PEXT2_EXTENT *Chain)

BOOLEAN	Ext2ListExtents (PLARGE_MCB Extents)

VOID	Ext2CheckExtent (PLARGE_MCB Zone, LONGLONG Vbn, LONGLONG Lbn, LONGLONG Length, BOOLEAN bAdded)

VOID	Ext2ClearAllExtents (PLARGE_MCB Zone)

BOOLEAN	Ext2AddVcbExtent (IN PEXT2_VCB Vcb, IN LONGLONG Vbn, IN LONGLONG Length)

BOOLEAN	Ext2RemoveVcbExtent (IN PEXT2_VCB Vcb, IN LONGLONG Vbn, IN LONGLONG Length)

BOOLEAN	Ext2LookupVcbExtent (IN PEXT2_VCB Vcb, IN LONGLONG Vbn, OUT PLONGLONG Lbn, OUT PLONGLONG Length)

BOOLEAN	Ext2AddMcbExtent (IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN LONGLONG Vbn, IN LONGLONG Lbn, IN LONGLONG Length)

BOOLEAN	Ext2RemoveMcbExtent (IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN LONGLONG Vbn, IN LONGLONG Length)

BOOLEAN	Ext2LookupMcbExtent (IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN LONGLONG Vbn, OUT PLONGLONG Lbn, OUT PLONGLONG Length)

BOOLEAN	Ext2AddMcbMetaExts (IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Block, IN ULONG Length)

BOOLEAN	Ext2RemoveMcbMetaExts (IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Block, IN ULONG Length)

BOOLEAN	Ext2AddBlockExtent (IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Start, IN ULONG Block, IN ULONG Number)

BOOLEAN	Ext2LookupBlockExtent (IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Start, IN PULONG Block, IN PULONG Mapped)

BOOLEAN	Ext2RemoveBlockExtent (IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONG Start, IN ULONG Number)

NTSTATUS	Ext2InitializeZone (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb)

BOOLEAN	Ext2BuildName (IN OUT PUNICODE_STRING Target, IN PUNICODE_STRING File, IN PUNICODE_STRING Parent)

PEXT2_MCB	Ext2AllocateMcb (IN PEXT2_VCB Vcb, IN PUNICODE_STRING FileName, IN PUNICODE_STRING Parent, IN ULONG FileAttr)

PEXT2_MCB	Ext2SearchMcb (PEXT2_VCB Vcb, PEXT2_MCB Parent, PUNICODE_STRING FileName)

PEXT2_MCB	Ext2SearchMcbWithoutLock (PEXT2_MCB Parent, PUNICODE_STRING FileName)

VOID	Ext2InsertMcb (PEXT2_VCB Vcb, PEXT2_MCB Parent, PEXT2_MCB Child)

BOOLEAN	Ext2RemoveMcb (PEXT2_VCB Vcb, PEXT2_MCB Mcb)

VOID	Ext2CleanupAllMcbs (PEXT2_VCB Vcb)

BOOLEAN	Ext2CheckSetBlock (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, LONGLONG Block)

BOOLEAN	Ext2CheckBitmapConsistency (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb)

VOID	Ext2InsertVcb (PEXT2_VCB Vcb)

VOID	Ext2RemoveVcb (PEXT2_VCB Vcb)

NTSTATUS	Ext2InitializeLabel (IN PEXT2_VCB Vcb, IN PEXT2_SUPER_BLOCK Sb)

NTSTATUS	Ext2InitializeVcb (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb, PEXT2_SUPER_BLOCK Ext2Sb, PDEVICE_OBJECT TargetDevice, PDEVICE_OBJECT VolumeDevice, PVPB Vpb)

VOID	Ext2TearDownStream (IN PEXT2_VCB Vcb)

VOID	Ext2DestroyVcb (IN PEXT2_VCB Vcb)

NTSTATUS	Ext2CompleteIrpContext (IN PEXT2_IRP_CONTEXT IrpContext, IN NTSTATUS Status)

VOID	Ext2SyncUninitializeCacheMap (IN PFILE_OBJECT FileObject)

VOID	Ext2LinkTailMcb (PEXT2_VCB Vcb, PEXT2_MCB Mcb)

VOID	Ext2LinkHeadMcb (PEXT2_VCB Vcb, PEXT2_MCB Mcb)

VOID	Ext2UnlinkMcb (PEXT2_VCB Vcb, PEXT2_MCB Mcb)

PEXT2_MCB	Ext2FirstUnusedMcb (PEXT2_VCB Vcb, BOOLEAN Wait, ULONG Number)

VOID	Ext2ReaperThread (PVOID Context)

NTSTATUS	Ext2StartReaper (PEXT2_REAPER, EXT2_REAPER_RELEASE)

VOID	Ext2StopReaper (PEXT2_REAPER Reaper)

ULONG	Ext2Log2 (ULONG Value)

LARGE_INTEGER	Ext2NtTime (IN ULONG i_time)

ULONG	Ext2LinuxTime (IN LARGE_INTEGER SysTime)

ULONG	Ext2OEMToUnicodeSize (IN PEXT2_VCB Vcb, IN PANSI_STRING Oem)

NTSTATUS	Ext2OEMToUnicode (IN PEXT2_VCB Vcb, IN OUT PUNICODE_STRING Oem, IN POEM_STRING Unicode)

ULONG	Ext2UnicodeToOEMSize (IN PEXT2_VCB Vcb, IN PUNICODE_STRING Unicode)

NTSTATUS	Ext2UnicodeToOEM (IN PEXT2_VCB Vcb, IN OUT POEM_STRING Oem, IN PUNICODE_STRING Unicode)

VOID	Ext2Sleep (ULONG ms)

int	Ext2LinuxError (NTSTATUS Status)

NTSTATUS	Ext2WinntError (int rc)

BOOLEAN	Ext2IsDot (PUNICODE_STRING name)

BOOLEAN	Ext2IsDotDot (PUNICODE_STRING name)

int	Ext2LoadAllNls ()

VOID	Ext2UnloadAllNls ()

NTSTATUS	Ext2Pnp (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2PnpQueryRemove (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb)

NTSTATUS	Ext2PnpRemove (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb)

NTSTATUS	Ext2PnpCancelRemove (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb)

NTSTATUS	Ext2PnpSurpriseRemove (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb)

NTSTATUS	Ext2ReadInode (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONGLONG Offset, IN PVOID Buffer, IN ULONG Size, IN BOOLEAN bDirectIo, OUT PULONG dwReturn)

NTSTATUS	Ext2Read (IN PEXT2_IRP_CONTEXT IrpContext)

PEXT2_MCB	Ext2LoadInternalJournal (PEXT2_VCB Vcb, ULONG jNo)

INT	Ext2CheckJournal (PEXT2_VCB Vcb, PULONG jNo)

INT	Ext2RecoverJournal (PEXT2_IRP_CONTEXT IrpContext, PEXT2_VCB Vcb)

NTSTATUS	Ext2ShutDown (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2QueryVolumeInformation (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2SetVolumeInformation (IN PEXT2_IRP_CONTEXT IrpContext)

NTSTATUS	Ext2WriteInode (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PEXT2_MCB Mcb, IN ULONGLONG Offset, IN PVOID Buffer, IN ULONG Size, IN BOOLEAN bDirectIo, OUT PULONG dwReturn)

VOID	Ext2StartFloppyFlushDpc (PEXT2_VCB Vcb, PEXT2_FCB Fcb, PFILE_OBJECT FileObject)

BOOLEAN	Ext2ZeroData (IN PEXT2_IRP_CONTEXT IrpContext, IN PEXT2_VCB Vcb, IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER Start, IN PLARGE_INTEGER End)

NTSTATUS	Ext2Write (IN PEXT2_IRP_CONTEXT IrpContext)

Variables
PEXT2_GLOBAL	Ext2Global

ULONG	ProcessNameOffset

Macro Definition Documentation

◆ AUTO_MOUNT

#define AUTO_MOUNT L"AutoMount"

Definition at line 152 of file ext2fs.h.

◆ BLOCK_BITS

#define BLOCK_BITS (SUPER_BLOCK->s_log_block_size + 10)

Definition at line 94 of file ext2fs.h.

◆ BLOCK_SIZE

#define BLOCK_SIZE (Vcb->BlockSize)

Definition at line 93 of file ext2fs.h.

◆ BLOCKS_PER_GROUP

#define BLOCKS_PER_GROUP (SUPER_BLOCK->s_blocks_per_group)

Definition at line 100 of file ext2fs.h.

◆ BooleanFlagOn

#define BooleanFlagOn	(	F,
		SF
	)	((BOOLEAN)(((F) & (SF)) != 0))

Definition at line 183 of file ext2fs.h.

◆ CanExt2Wait

#define CanExt2Wait ( IRP ) IoIsOperationSynchronous(Irp)

Definition at line 1146 of file ext2fs.h.

◆ CanIWrite

#define CanIWrite ( Vcb ) (IsExt3ForceWrite() || (!IsVcbReadOnly(Vcb) && IsVcbForceWrite(Vcb)))

Definition at line 821 of file ext2fs.h.

◆ CCB_ALLOW_EXTENDED_DASD_IO

#define CCB_ALLOW_EXTENDED_DASD_IO 0x80000000

Definition at line 1037 of file ext2fs.h.

◆ CCB_DELETE_ON_CLOSE

#define CCB_DELETE_ON_CLOSE 0x00000010

Definition at line 1035 of file ext2fs.h.

◆ CCB_FROM_POOL

#define CCB_FROM_POOL 0x00000001

Definition at line 1031 of file ext2fs.h.

◆ CCB_LAST_WRITE_UPDATED

#define CCB_LAST_WRITE_UPDATED 0x00000004

Definition at line 1033 of file ext2fs.h.

◆ CCB_OPEN_REPARSE_POINT

#define CCB_OPEN_REPARSE_POINT 0x00000008

Definition at line 1034 of file ext2fs.h.

◆ CCB_VOLUME_DASD_PURGE

#define CCB_VOLUME_DASD_PURGE 0x00000002

Definition at line 1032 of file ext2fs.h.

◆ CDROM_NAME

#define CDROM_NAME L"\\Ext2CdFsd"

Definition at line 138 of file ext2fs.h.

◆ CEILING_ALIGNED

#define CEILING_ALIGNED	(	T,
		A,
		B
	)	(((A) + (B) - 1) & (~((T)(B) - 1)))

Definition at line 111 of file ext2fs.h.

◆ CHECKING_BITMAP

#define CHECKING_BITMAP L"CheckingBitmap"

Definition at line 147 of file ext2fs.h.

◆ CL_ASSERT

#define CL_ASSERT ( cond ) do {switch('x') {case (cond): case 0: break;}} while (0)

Definition at line 132 of file ext2fs.h.

◆ ClearFlag

#define ClearFlag	(	_F,
		_SF
	)	((_F) &= ~(_SF))

Definition at line 191 of file ext2fs.h.

◆ ClearLongFlag

#define ClearLongFlag	(	_F,
		_SF
	)	InterlockedAnd(&(_F), ~((ULONG)(_SF)))

Definition at line 259 of file ext2fs.h.

◆ COCKLOFT_ALIGNED

#define COCKLOFT_ALIGNED	(	T,
		A,
		B
	)	(((A) + (B)) & (~((T)(B) - 1)))

Definition at line 112 of file ext2fs.h.

◆ CODEPAGE_NAME

#define CODEPAGE_NAME L"CodePage"

Definition at line 149 of file ext2fs.h.

◆ DbgBreak

#define DbgBreak ( )

Definition at line 46 of file ext2fs.h.

◆ DEBUG

#define DEBUG	(	_DL,
		arg
	)	do {if ((_DL) & DL_ERR) DbgPrint arg;} while(0)

Definition at line 1473 of file ext2fs.h.

◆ DEC_IRP_COUNT

#define DEC_IRP_COUNT ( IrpContext ) Ext2TraceIrpContext(FALSE, (IrpContext))

Definition at line 610 of file ext2fs.h.

◆ DEC_MEM_COUNT

#define DEC_MEM_COUNT	(	_i,
		_p,
		_s
	)	do { ASSERT(_p); Ext2TraceMemory(FALSE, (int) (_i), (PVOID)(_p), (LONG)(_s)); } while(0)

Definition at line 608 of file ext2fs.h.

◆ DEFAULT_SECTOR_SIZE

#define DEFAULT_SECTOR_SIZE (0x200)

Definition at line 83 of file ext2fs.h.

◆ DEVICE_NAME

#define DEVICE_NAME L"\\Ext2Fsd"

Definition at line 137 of file ext2fs.h.

◆ DL_BH

#define DL_BH 0x00008000 /* buffer head */

Definition at line 1448 of file ext2fs.h.

◆ DL_BLK

#define DL_BLK 0x00000100 /* data block allocation / free */

Definition at line 1441 of file ext2fs.h.

◆ DL_CP

#define DL_CP 0x00000200 /* code pages (create, querydir) */

Definition at line 1442 of file ext2fs.h.

◆ DL_DBG

#define DL_DBG 0x00000004

Definition at line 1435 of file ext2fs.h.

◆ DL_DEFAULT

#define DL_DEFAULT (DL_ERR|DL_VIT)

Definition at line 1452 of file ext2fs.h.

◆ DL_ERR

#define DL_ERR 0x00000002

Definition at line 1434 of file ext2fs.h.

◆ DL_EXT

#define DL_EXT 0x00000400 /* mcb extents */

Definition at line 1443 of file ext2fs.h.

◆ DL_FUN

#define DL_FUN 0x00000010

Definition at line 1437 of file ext2fs.h.

◆ DL_HTI

#define DL_HTI 0x00002000 /* htree index */

Definition at line 1446 of file ext2fs.h.

◆ DL_INF

#define DL_INF 0x00000008

Definition at line 1436 of file ext2fs.h.

◆ DL_IO

#define DL_IO 0x00020000 /* file i/o */

Definition at line 1450 of file ext2fs.h.

◆ DL_JNL

#define DL_JNL 0x00001000 /* dump journal operations */

Definition at line 1445 of file ext2fs.h.

◆ DL_LOW

#define DL_LOW 0x00000020

Definition at line 1438 of file ext2fs.h.

◆ DL_MAP

#define DL_MAP 0x00000800 /* retrieval points */

Definition at line 1444 of file ext2fs.h.

◆ DL_NVR

#define DL_NVR 0

Definition at line 1432 of file ext2fs.h.

◆ DL_PNP

#define DL_PNP 0x00010000 /* pnp */

Definition at line 1449 of file ext2fs.h.

◆ DL_REN

#define DL_REN 0x00000040 /* renaming operation */

Definition at line 1439 of file ext2fs.h.

◆ DL_RES

#define DL_RES 0x00000080 /* entry reference managment */

Definition at line 1440 of file ext2fs.h.

◆ DL_VIT

#define DL_VIT 0x00000001

Definition at line 1433 of file ext2fs.h.

◆ DL_WRN

#define DL_WRN 0x00004000 /* warning */

Definition at line 1447 of file ext2fs.h.

◆ DOS_DEVICE_NAME

#define DOS_DEVICE_NAME L"\\DosDevices\\Ext2Fsd"

Definition at line 159 of file ext2fs.h.

◆ DRIVER_NAME

#define DRIVER_NAME "Ext2Fsd"

Definition at line 136 of file ext2fs.h.

◆ EGID

#define EGID L"egid"

Definition at line 157 of file ext2fs.h.

◆ EUID

#define EUID L"euid"

Definition at line 156 of file ext2fs.h.

◆ EXT2_AUTO_MOUNT

#define EXT2_AUTO_MOUNT 0x00000010

Definition at line 594 of file ext2fs.h.

◆ EXT2_BLOCK_TYPES

#define EXT2_BLOCK_TYPES (0x04)

Definition at line 77 of file ext2fs.h.

◆ EXT2_BUGCHK_BLOCK

#define EXT2_BUGCHK_BLOCK (0x00010000)

Definition at line 314 of file ext2fs.h.

◆ EXT2_BUGCHK_CLEANUP

#define EXT2_BUGCHK_CLEANUP (0x00020000)

Definition at line 315 of file ext2fs.h.

◆ EXT2_BUGCHK_CLOSE

#define EXT2_BUGCHK_CLOSE (0x00030000)

Definition at line 316 of file ext2fs.h.

◆ EXT2_BUGCHK_CMCB

#define EXT2_BUGCHK_CMCB (0x00040000)

Definition at line 317 of file ext2fs.h.

◆ EXT2_BUGCHK_CREATE

#define EXT2_BUGCHK_CREATE (0x00050000)

Definition at line 318 of file ext2fs.h.

◆ EXT2_BUGCHK_DEBUG

#define EXT2_BUGCHK_DEBUG (0x00060000)

Definition at line 319 of file ext2fs.h.

◆ EXT2_BUGCHK_DEVCTL

#define EXT2_BUGCHK_DEVCTL (0x00070000)

Definition at line 320 of file ext2fs.h.

◆ EXT2_BUGCHK_DIRCTL

#define EXT2_BUGCHK_DIRCTL (0x00080000)

Definition at line 321 of file ext2fs.h.

◆ EXT2_BUGCHK_DISPATCH

#define EXT2_BUGCHK_DISPATCH (0x00090000)

Definition at line 322 of file ext2fs.h.

◆ EXT2_BUGCHK_EXCEPT

#define EXT2_BUGCHK_EXCEPT (0x000A0000)

Definition at line 323 of file ext2fs.h.

◆ EXT2_BUGCHK_EXT2

#define EXT2_BUGCHK_EXT2 (0x000B0000)

Definition at line 324 of file ext2fs.h.

◆ EXT2_BUGCHK_FASTIO

#define EXT2_BUGCHK_FASTIO (0x000C0000)

Definition at line 325 of file ext2fs.h.

◆ EXT2_BUGCHK_FILEINFO

#define EXT2_BUGCHK_FILEINFO (0x000D0000)

Definition at line 326 of file ext2fs.h.

◆ EXT2_BUGCHK_FLUSH

#define EXT2_BUGCHK_FLUSH (0x000E0000)

Definition at line 327 of file ext2fs.h.

◆ EXT2_BUGCHK_FSCTL

#define EXT2_BUGCHK_FSCTL (0x000F0000)

Definition at line 328 of file ext2fs.h.

◆ EXT2_BUGCHK_INIT

#define EXT2_BUGCHK_INIT (0x00100000)

Definition at line 329 of file ext2fs.h.

◆ EXT2_BUGCHK_LAST

#define EXT2_BUGCHK_LAST (0x00170000)

Definition at line 338 of file ext2fs.h.

◆ EXT2_BUGCHK_LOCK

#define EXT2_BUGCHK_LOCK (0x0011000)

Definition at line 330 of file ext2fs.h.

◆ EXT2_BUGCHK_MEMORY

#define EXT2_BUGCHK_MEMORY (0x0012000)

Definition at line 331 of file ext2fs.h.

◆ EXT2_BUGCHK_MISC

#define EXT2_BUGCHK_MISC (0x0013000)

Definition at line 332 of file ext2fs.h.

◆ EXT2_BUGCHK_READ

#define EXT2_BUGCHK_READ (0x00140000)

Definition at line 333 of file ext2fs.h.

◆ EXT2_BUGCHK_SHUTDOWN

#define EXT2_BUGCHK_SHUTDOWN (0x00150000)

Definition at line 334 of file ext2fs.h.

◆ EXT2_BUGCHK_VOLINFO

#define EXT2_BUGCHK_VOLINFO (0x00160000)

Definition at line 335 of file ext2fs.h.

◆ EXT2_BUGCHK_WRITE

#define EXT2_BUGCHK_WRITE (0x00170000)

Definition at line 336 of file ext2fs.h.

◆ EXT2_CHECKING_BITMAP

#define EXT2_CHECKING_BITMAP 0x00000008

Definition at line 593 of file ext2fs.h.

◆ EXT2_DATA_MAGIC

#define EXT2_DATA_MAGIC 'BD2E'

Definition at line 296 of file ext2fs.h.

◆ EXT2_DEBUG

#define EXT2_DEBUG 0

Definition at line 34 of file ext2fs.h.

◆ EXT2_DENTRY_MAGIC

#define EXT2_DENTRY_MAGIC 'ED2E'

Definition at line 300 of file ext2fs.h.

◆ EXT2_DIRSP_MAGIC

#define EXT2_DIRSP_MAGIC 'SD2E'

Definition at line 301 of file ext2fs.h.

◆ EXT2_FILE_SYSTEM

#define EXT2_FILE_SYSTEM (FILE_SYSTEM)

Definition at line 312 of file ext2fs.h.

◆ EXT2_FIRST_DATA_BLOCK

#define EXT2_FIRST_DATA_BLOCK (SUPER_BLOCK->s_first_data_block)

Definition at line 103 of file ext2fs.h.

◆ EXT2_FLIST_MAGIC

#define EXT2_FLIST_MAGIC 'LF2E'

Definition at line 304 of file ext2fs.h.

◆ EXT2_FNAME_MAGIC

#define EXT2_FNAME_MAGIC 'NF2E'

Definition at line 298 of file ext2fs.h.

◆ EXT2_GD_MAGIC

#define EXT2_GD_MAGIC 'DG2E'

Definition at line 303 of file ext2fs.h.

◆ EXT2_INAME_MAGIC

#define EXT2_INAME_MAGIC 'NI2E'

Definition at line 297 of file ext2fs.h.

◆ EXT2_LINKLEN_IN_INODE

#define EXT2_LINKLEN_IN_INODE (60)

Definition at line 76 of file ext2fs.h.

◆ EXT2_LOOKUP_FLAG_MASK

#define EXT2_LOOKUP_FLAG_MASK (0xFF00000)

Definition at line 1379 of file ext2fs.h.

◆ EXT2_LOOKUP_NOT_FOLLOW

#define EXT2_LOOKUP_NOT_FOLLOW (0x8000000)

Definition at line 1380 of file ext2fs.h.

◆ EXT2_MAX_NESTED_LINKS

#define EXT2_MAX_NESTED_LINKS (8)

Definition at line 75 of file ext2fs.h.

◆ EXT2_MAX_USER_BLKSIZE

#define EXT2_MAX_USER_BLKSIZE 65536

Definition at line 353 of file ext2fs.h.

◆ EXT2_MIN_BLOCK

#define EXT2_MIN_BLOCK 1024

Definition at line 351 of file ext2fs.h.

◆ EXT2_MIN_FRAG

#define EXT2_MIN_FRAG 1024

Definition at line 352 of file ext2fs.h.

◆ EXT2_PARAM_MAGIC

#define EXT2_PARAM_MAGIC 'PP2E'

Definition at line 305 of file ext2fs.h.

◆ EXT2_PRE_ALLOCATION_SUPPORT

#define EXT2_PRE_ALLOCATION_SUPPORT TRUE

Definition at line 69 of file ext2fs.h.

◆ EXT2_REAPER_FLAG_STOP

#define EXT2_REAPER_FLAG_STOP (1 << 0)

Definition at line 511 of file ext2fs.h.

◆ EXT2_RW_CONTEXT_WRITE

#define EXT2_RW_CONTEXT_WRITE 1

Definition at line 3215 of file ext2fs.h.

◆ EXT2_RWC_MAGIC

#define EXT2_RWC_MAGIC 'WR2E'

Definition at line 306 of file ext2fs.h.

◆ EXT2_SB_MAGIC

#define EXT2_SB_MAGIC 'BS2E'

Definition at line 302 of file ext2fs.h.

◆ EXT2_SUPER_MAGIC

#define EXT2_SUPER_MAGIC 0xEF53

Definition at line 349 of file ext2fs.h.

◆ EXT2_SUPPORT_WRITING

#define EXT2_SUPPORT_WRITING 0x00000002

Definition at line 591 of file ext2fs.h.

◆ EXT2_UNLOAD

#define EXT2_UNLOAD FALSE

Definition at line 65 of file ext2fs.h.

◆ EXT2_UNLOAD_PENDING

#define EXT2_UNLOAD_PENDING 0x00000001

Definition at line 590 of file ext2fs.h.

◆ EXT2_VNAME_MAGIC

#define EXT2_VNAME_MAGIC 'NV2E'

Definition at line 299 of file ext2fs.h.

◆ Ext2BugCheck

#define Ext2BugCheck	(	A,
		B,
		C,
		D
	)	{ KeBugCheckEx(EXT2_FILE_SYSTEM, A \| __LINE__, B, C, D ); }

Definition at line 340 of file ext2fs.h.

◆ Ext2CanIWait

#define Ext2CanIWait ( ) (!IrpContext || IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT))

Definition at line 1100 of file ext2fs.h.

◆ Ext2CompleteRequest

#define Ext2CompleteRequest	(	Irp,
		bPrint,
		PriorityBoost
	)	IoCompleteRequest(Irp, PriorityBoost)

Definition at line 1475 of file ext2fs.h.

◆ Ext2DerefMcb

#define Ext2DerefMcb ( Mcb ) Ext2DerefXcb(&Mcb->Refercount)

Definition at line 996 of file ext2fs.h.

◆ Ext2DerefXcb

#define Ext2DerefXcb ( _C ) DEC_OBJ_CNT(_C)

Definition at line 977 of file ext2fs.h.

◆ Ext2FileCanExecute

#define Ext2FileCanExecute (0x4)

Definition at line 433 of file ext2fs.h.

◆ Ext2FileCanRead

#define Ext2FileCanRead (0x1)

Definition at line 431 of file ext2fs.h.

◆ Ext2FileCanWrite

#define Ext2FileCanWrite (0x2)

Definition at line 432 of file ext2fs.h.

◆ EXT2FSD_VERSION

#define EXT2FSD_VERSION "0.69"

Definition at line 51 of file ext2fs.h.

◆ Ext2GetCurrentProcessName

#define Ext2GetCurrentProcessName ( )

Value:

    ( \
    (PUCHAR) PsGetCurrentProcess() + ProcessNameOffset \
)

Definition at line 1489 of file ext2fs.h.

◆ Ext2IsGroupReadable

#define Ext2IsGroupReadable ( m ) (((m) & S_IRGRP) == S_IRGRP)

Definition at line 421 of file ext2fs.h.

◆ Ext2IsGroupReadOnly

#define Ext2IsGroupReadOnly ( m ) (!(Ext2IsGroupWritable(m)) && Ext2IsGroupReadable(m))

Definition at line 422 of file ext2fs.h.

◆ Ext2IsGroupWritable

#define Ext2IsGroupWritable ( m ) (((m) & S_IWGRP) == S_IWGRP)

Definition at line 420 of file ext2fs.h.

◆ Ext2IsOtherReadable

#define Ext2IsOtherReadable ( m ) (((m) & S_IROTH) == S_IROTH)

Definition at line 425 of file ext2fs.h.

◆ Ext2IsOtherReadOnly

#define Ext2IsOtherReadOnly ( m ) (!(Ext2IsOtherWritable(m)) && Ext2IsOtherReadable(m))

Definition at line 426 of file ext2fs.h.

◆ Ext2IsOtherWritable

#define Ext2IsOtherWritable ( m ) (((m) & S_IWOTH) == S_IWOTH)

Definition at line 424 of file ext2fs.h.

◆ Ext2IsOwnerReadable

#define Ext2IsOwnerReadable ( m ) (((m) & S_IRUSR) == S_IRUSR)

Definition at line 417 of file ext2fs.h.

◆ Ext2IsOwnerReadOnly

#define Ext2IsOwnerReadOnly ( m ) (!(Ext2IsOwnerWritable(m)) && Ext2IsOwnerReadable(m))

Definition at line 418 of file ext2fs.h.

◆ Ext2IsOwnerWritable

#define Ext2IsOwnerWritable ( m ) (((m) & S_IWUSR) == S_IWUSR)

Definition at line 416 of file ext2fs.h.

◆ Ext2NormalizeAndRaiseStatus

#define Ext2NormalizeAndRaiseStatus	(	IRPCONTEXT,
		STATUS
	)

Value:

    {                        \
    (IRPCONTEXT)->ExceptionCode = STATUS;                                       \
    if ((STATUS) == STATUS_VERIFY_REQUIRED) { ExRaiseStatus((STATUS)); }        \
    ExRaiseStatus(FsRtlNormalizeNtstatus((STATUS),STATUS_UNEXPECTED_IO_ERROR)); \
}

Definition at line 268 of file ext2fs.h.

◆ Ext2RaiseStatus

#define Ext2RaiseStatus	(	IRPCONTEXT,
		STATUS
	)

Value:

    {  \
    (IRPCONTEXT)->ExceptionCode = (STATUS); \
    ExRaiseStatus((STATUS));                \
}

Definition at line 263 of file ext2fs.h.

◆ Ext2ReferMcb

#define Ext2ReferMcb ( Mcb ) Ext2ReferXcb(&Mcb->Refercount)

Definition at line 995 of file ext2fs.h.

◆ Ext2ReferXcb

#define Ext2ReferXcb ( _C ) InterlockedIncrement(_C)

Definition at line 976 of file ext2fs.h.

◆ Ext2SetOwnerReadOnly

#define Ext2SetOwnerReadOnly ( m ) do {(m) &= ~S_IWUSR;} while(0)

Definition at line 414 of file ext2fs.h.

◆ Ext2SetOwnerWritable

#define Ext2SetOwnerWritable ( m ) do {(m) |= S_IWUSR;} while(0)

Definition at line 413 of file ext2fs.h.

◆ Ext2SetReadable

#define Ext2SetReadable ( m ) do {(m) = (m) | (S_IRUSR | S_IRGRP | S_IROTH);} while(0)

Definition at line 410 of file ext2fs.h.

◆ Ext2SetReadOnly

#define Ext2SetReadOnly ( m ) do {(m) &= ~(S_IWUSR | S_IWGRP | S_IWOTH);} while(0)

Definition at line 428 of file ext2fs.h.

◆ Ext2SetWritable

#define Ext2SetWritable ( m ) do {(m) = (m) | (S_IWUSR | S_IWGRP | S_IWOTH);} while(0)

Definition at line 411 of file ext2fs.h.

◆ ext3_error

#define ext3_error ext3_warning

Definition at line 2593 of file ext2fs.h.

◆ EXT3_FORCE_WRITING

#define EXT3_FORCE_WRITING 0x00000004

Definition at line 592 of file ext2fs.h.

◆ EXT3_FORCEWRITING

#define EXT3_FORCEWRITING L"Ext3ForceWriting"

Definition at line 148 of file ext2fs.h.

◆ ext4_error

#define ext4_error ext3_error

Definition at line 2594 of file ext2fs.h.

◆ EXT_DEBUG_BREAKPOINT

#define EXT_DEBUG_BREAKPOINT FALSE

Definition at line 37 of file ext2fs.h.

◆ FCB_ALLOC_IN_CREATE

#define FCB_ALLOC_IN_CREATE 0x00000080

Definition at line 884 of file ext2fs.h.

◆ FCB_ALLOC_IN_SETINFO

#define FCB_ALLOC_IN_SETINFO 0x00000200

Definition at line 886 of file ext2fs.h.

◆ FCB_ALLOC_IN_WRITE

#define FCB_ALLOC_IN_WRITE 0x00000100

Definition at line 885 of file ext2fs.h.

◆ FCB_DELETE_PENDING

#define FCB_DELETE_PENDING 0x80000000

Definition at line 888 of file ext2fs.h.

◆ FCB_FILE_MODIFIED

#define FCB_FILE_MODIFIED 0x00000020

Definition at line 882 of file ext2fs.h.

◆ FCB_FROM_POOL

#define FCB_FROM_POOL 0x00000001

Definition at line 880 of file ext2fs.h.

◆ FCB_PAGE_FILE

#define FCB_PAGE_FILE 0x00000002

Definition at line 881 of file ext2fs.h.

◆ FILE_SUPPORTS_EXTENDED_ATTRIBUTES

#define FILE_SUPPORTS_EXTENDED_ATTRIBUTES 0x00800000

Definition at line 1136 of file ext2fs.h.

◆ FILE_WRITE_TO_END_OF_FILE

#define FILE_WRITE_TO_END_OF_FILE 0xffffffff

Definition at line 278 of file ext2fs.h.

◆ FlagOn

#define FlagOn	(	_F,
		_SF
	)	((_F) & (_SF))

Definition at line 179 of file ext2fs.h.

◆ FSCTL_GET_RETRIEVAL_POINTER_BASE

#define FSCTL_GET_RETRIEVAL_POINTER_BASE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 141, METHOD_BUFFERED, FILE_ANY_ACCESS)

Definition at line 1132 of file ext2fs.h.

◆ GID

#define GID L"gid"

Definition at line 155 of file ext2fs.h.

◆ GROUP_DESC_SIZE

#define GROUP_DESC_SIZE (Vcb->sbi.s_desc_size)

Definition at line 95 of file ext2fs.h.

◆ HIDING_PREFIX

#define HIDING_PREFIX L"HidingPrefix"

Definition at line 150 of file ext2fs.h.

◆ HIDING_SUFFIX

#define HIDING_SUFFIX L"HidingSuffix"

Definition at line 151 of file ext2fs.h.

◆ INC_IRP_COUNT

#define INC_IRP_COUNT ( IrpContext ) Ext2TraceIrpContext(TRUE, (IrpContext))

Definition at line 609 of file ext2fs.h.

◆ INC_MEM_COUNT

#define INC_MEM_COUNT	(	_i,
		_p,
		_s
	)	do { ASSERT(_p); Ext2TraceMemory(TRUE, (int) (_i), (PVOID)(_p), (LONG)(_s)); } while(0)

Definition at line 607 of file ext2fs.h.

◆ INODE_SIZE

#define INODE_SIZE (Vcb->InodeSize)

Definition at line 92 of file ext2fs.h.

◆ INODES_COUNT

#define INODES_COUNT (Vcb->SuperBlock->s_inodes_count)

Definition at line 97 of file ext2fs.h.

◆ INODES_PER_GROUP

#define INODES_PER_GROUP (SUPER_BLOCK->s_inodes_per_group)

Definition at line 99 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_DEFERRED

#define IRP_CONTEXT_FLAG_DEFERRED (0x00000040)

Definition at line 1091 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_DELAY_CLOSE

#define IRP_CONTEXT_FLAG_DELAY_CLOSE (0x00000800)

Definition at line 1096 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_DISABLE_POPUPS

#define IRP_CONTEXT_FLAG_DISABLE_POPUPS (0x00000020)

Definition at line 1090 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_FILE_BUSY

#define IRP_CONTEXT_FLAG_FILE_BUSY (0x00001000)

Definition at line 1097 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_FLOPPY

#define IRP_CONTEXT_FLAG_FLOPPY (0x00000008)

Definition at line 1089 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_FROM_POOL

#define IRP_CONTEXT_FLAG_FROM_POOL (0x00000001)

Definition at line 1086 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_REQUEUED

#define IRP_CONTEXT_FLAG_REQUEUED (0x00000200)

Definition at line 1094 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_USER_IO

#define IRP_CONTEXT_FLAG_USER_IO (0x00000400)

Definition at line 1095 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_VERIFY_READ

#define IRP_CONTEXT_FLAG_VERIFY_READ (0x00000080)

Definition at line 1092 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_WAIT

#define IRP_CONTEXT_FLAG_WAIT (0x00000002)

Definition at line 1087 of file ext2fs.h.

◆ IRP_CONTEXT_FLAG_WRITE_THROUGH

#define IRP_CONTEXT_FLAG_WRITE_THROUGH (0x00000004)

Definition at line 1088 of file ext2fs.h.

◆ IRP_CONTEXT_STACK_IO_CONTEXT

#define IRP_CONTEXT_STACK_IO_CONTEXT (0x00000100)

Definition at line 1093 of file ext2fs.h.

◆ IsDirectory

#define IsDirectory ( Fcb ) IsMcbDirectory((Fcb)->Mcb)

Definition at line 283 of file ext2fs.h.

◆ IsDispending

#define IsDispending ( Vcb ) (IsFlagOn((Vcb)->Flags, VCB_DISMOUNT_PENDING))

Definition at line 813 of file ext2fs.h.

◆ IsExt2FsDevice

#define IsExt2FsDevice ( DO )

Value:

((DO == Ext2Global->DiskdevObject) || \

(DO == Ext2Global->CdromdevObject) )

Ext2Global

PEXT2_GLOBAL Ext2Global

Definition: init.c:16

DO

#define DO

Definition: ftp_var.h:15

_EXT2_GLOBAL::DiskdevObject

PDEVICE_OBJECT DiskdevObject

Definition: ext2fs.h:539

_EXT2_GLOBAL::CdromdevObject

PDEVICE_OBJECT CdromdevObject

Definition: ext2fs.h:542

Definition at line 616 of file ext2fs.h.

◆ IsExt3ForceWrite

#define IsExt3ForceWrite ( ) (IsFlagOn(Ext2Global->Flags, EXT3_FORCE_WRITING))

Definition at line 819 of file ext2fs.h.

◆ IsFileDeleted

#define IsFileDeleted ( Mcb ) IsFlagOn((Mcb)->Flags, MCB_FILE_DELETED)

Definition at line 968 of file ext2fs.h.

◆ IsFlagOn

#define IsFlagOn	(	a,
		b
	)	((BOOLEAN)(FlagOn(a,b) == b))

Definition at line 177 of file ext2fs.h.

◆ IsInodeSymLink

#define IsInodeSymLink ( I ) S_ISLNK((I)->i_mode)

Definition at line 286 of file ext2fs.h.

◆ IsLazyWriter

#define IsLazyWriter ( Fcb ) ((Fcb)->LazyWriterThread == PsGetCurrentThread())

Definition at line 822 of file ext2fs.h.

◆ IsLinkInvalid

#define IsLinkInvalid ( Mcb ) (IsMcbSymLink(Mcb) && IsFileDeleted(Mcb->Target))

Definition at line 970 of file ext2fs.h.

◆ IsMcbDirectory

#define IsMcbDirectory ( Mcb ) IsFlagOn((Mcb)->FileAttr, FILE_ATTRIBUTE_DIRECTORY)

Definition at line 967 of file ext2fs.h.

◆ IsMcbReadonly

#define IsMcbReadonly ( Mcb ) IsFlagOn((Mcb)->FileAttr, FILE_ATTRIBUTE_READONLY)

Definition at line 966 of file ext2fs.h.

◆ IsMcbRoot

#define IsMcbRoot ( Mcb ) ((Mcb)->Inode.i_ino == EXT2_ROOT_INO)

Definition at line 965 of file ext2fs.h.

◆ IsMcbSpecialFile

#define IsMcbSpecialFile ( Mcb ) IsFlagOn((Mcb)->Flags, MCB_TYPE_SPECIAL)

Definition at line 964 of file ext2fs.h.

◆ IsMcbSymLink

#define IsMcbSymLink ( Mcb ) IsFlagOn((Mcb)->Flags, MCB_TYPE_SYMLINK)

Definition at line 962 of file ext2fs.h.

◆ IsMcbUsed

#define IsMcbUsed ( Mcb ) ((Mcb)->Refercount > 0)

Definition at line 961 of file ext2fs.h.

◆ IsMounted

#define IsMounted ( Vcb ) (IsFlagOn((Vcb)->Flags, VCB_MOUNTED))

Definition at line 812 of file ext2fs.h.

◆ IsRoot

#define IsRoot ( Fcb ) IsMcbRoot((Fcb)->Mcb)

Definition at line 287 of file ext2fs.h.

◆ IsSpecialFile

#define IsSpecialFile ( Fcb ) IsMcbSpecialFile((Fcb)->Mcb)

Definition at line 284 of file ext2fs.h.

◆ IsSymLink

#define IsSymLink ( Fcb ) IsMcbSymLink((Fcb)->Mcb)

Definition at line 285 of file ext2fs.h.

◆ IsVcbForceWrite

#define IsVcbForceWrite ( Vcb ) (IsFlagOn((Vcb)->Flags, VCB_FORCE_WRITING))

Definition at line 820 of file ext2fs.h.

◆ IsVcbInited

#define IsVcbInited ( Vcb ) (IsFlagOn((Vcb)->Flags, VCB_INITIALIZED))

Definition at line 811 of file ext2fs.h.

◆ IsVcbReadOnly

#define IsVcbReadOnly ( Vcb )

Value:

                            (IsFlagOn((Vcb)->Flags, VCB_READ_ONLY) ||    \
                            IsFlagOn((Vcb)->Flags, VCB_RO_COMPAT_READ_ONLY) ||    \
                            IsFlagOn((Vcb)->Flags, VCB_WRITE_PROTECTED))

Definition at line 814 of file ext2fs.h.

◆ IsWritingToEof

#define IsWritingToEof ( Pos )

Value:

(((Pos).LowPart == FILE_WRITE_TO_END_OF_FILE) && \

((Pos).HighPart == -1 ))

Pos

ush Pos

Definition: deflate.h:92

FILE_WRITE_TO_END_OF_FILE

#define FILE_WRITE_TO_END_OF_FILE

Definition: ext2fs.h:278

Definition at line 280 of file ext2fs.h.

◆ IsZoneInited

#define IsZoneInited ( Mcb ) IsFlagOn((Mcb)->Flags, MCB_ZONE_INITED)

Definition at line 963 of file ext2fs.h.

◆ max

#define max	(	a,
		b
	)	(((a) > (b)) ? (a) : (b))

Definition at line 199 of file ext2fs.h.

◆ MAXIMUM_RECORD_LENGTH

#define MAXIMUM_RECORD_LENGTH (0x10000)

Definition at line 79 of file ext2fs.h.

◆ MCB_ENTRY_TREE

#define MCB_ENTRY_TREE 0x00000004

Definition at line 954 of file ext2fs.h.

◆ MCB_FILE_DELETED

#define MCB_FILE_DELETED 0x00000008

Definition at line 955 of file ext2fs.h.

◆ MCB_FROM_POOL

#define MCB_FROM_POOL 0x00000001

Definition at line 952 of file ext2fs.h.

◆ MCB_TYPE_SPECIAL

#define MCB_TYPE_SPECIAL 0x40000000 /* unresolved symlink + device node */

Definition at line 958 of file ext2fs.h.

◆ MCB_TYPE_SYMLINK

#define MCB_TYPE_SYMLINK 0x80000000

Definition at line 959 of file ext2fs.h.

◆ MCB_VCB_LINK

#define MCB_VCB_LINK 0x00000002

Definition at line 953 of file ext2fs.h.

◆ MCB_ZONE_INITED

#define MCB_ZONE_INITED 0x20000000

Definition at line 957 of file ext2fs.h.

◆ min

#define min	(	a,
		b
	)	(((a) < (b)) ? (a) : (b))

Definition at line 195 of file ext2fs.h.

◆ MOUNT_POINT

#define MOUNT_POINT L"MountPoint"

Definition at line 153 of file ext2fs.h.

◆ NodeType

#define NodeType ( Ptr ) (*((EXT2_IDENTIFIER_TYPE *)(Ptr)))

Definition at line 482 of file ext2fs.h.

◆ PARAMETERS_KEY

#define PARAMETERS_KEY L"\\Parameters"

Definition at line 142 of file ext2fs.h.

◆ READ_AHEAD_GRANULARITY

#define READ_AHEAD_GRANULARITY (0x10000)

Definition at line 88 of file ext2fs.h.

◆ READING_ONLY

#define READING_ONLY L"Readonly"

Definition at line 145 of file ext2fs.h.

◆ S_IALLUGO

#define S_IALLUGO (S_ISUID|S_ISGID|S_ISVTX|S_IRWXUGO)

Definition at line 401 of file ext2fs.h.

◆ S_IFATTR

#define S_IFATTR (S_IRWNU|S_IRWNG|S_IRWNO)

Definition at line 405 of file ext2fs.h.

◆ S_IFBLK

#define S_IFBLK 0x06000 /* 006 0000 */

Definition at line 362 of file ext2fs.h.

◆ S_IFCHR

#define S_IFCHR 0x02000 /* 002 0000 */

Definition at line 364 of file ext2fs.h.

◆ S_IFDIR

#define S_IFDIR 0x04000 /* 004 0000 */

Definition at line 363 of file ext2fs.h.

◆ S_IFIFO

#define S_IFIFO 0x01000 /* 001 0000 */

Definition at line 365 of file ext2fs.h.

◆ S_IFLNK

#define S_IFLNK 0x0A000 /* 012 0000 */

Definition at line 360 of file ext2fs.h.

◆ S_IFMT

#define S_IFMT 0x0F000 /* 017 0000 */

Definition at line 358 of file ext2fs.h.

◆ S_IFREG

#define S_IFREG 0x08000 /* 010 0000 */

Definition at line 361 of file ext2fs.h.

◆ S_IFSOCK

#define S_IFSOCK 0x0C000 /* 014 0000 */

Definition at line 359 of file ext2fs.h.

◆ S_IPERMISSION_MASK

#define S_IPERMISSION_MASK 0x1FF /* */

Definition at line 380 of file ext2fs.h.

◆ S_IRGRP

#define S_IRGRP 0x020 /* 0 0040 */

Definition at line 390 of file ext2fs.h.

◆ S_IROTH

#define S_IROTH 0x004 /* 0 0004 */

Definition at line 396 of file ext2fs.h.

◆ S_IRUGO

#define S_IRUGO (S_IRUSR|S_IRGRP|S_IROTH)

Definition at line 402 of file ext2fs.h.

◆ S_IRUSR

#define S_IRUSR 0x100 /* 0 0400 */

Definition at line 384 of file ext2fs.h.

◆ S_IRWNG

#define S_IRWNG 0x030 /* 0 0060 */

Definition at line 389 of file ext2fs.h.

◆ S_IRWNO

#define S_IRWNO 0x006 /* 0 0006 */

Definition at line 395 of file ext2fs.h.

◆ S_IRWNU

#define S_IRWNU 0x180 /* 0 0600 */

Definition at line 383 of file ext2fs.h.

◆ S_IRWXG

#define S_IRWXG 0x038 /* 0 0070 */

Definition at line 388 of file ext2fs.h.

◆ S_IRWXO

#define S_IRWXO 0x007 /* 0 0007 */

Definition at line 394 of file ext2fs.h.

◆ S_IRWXU

#define S_IRWXU 0x1C0 /* 0 0700 */

Definition at line 382 of file ext2fs.h.

◆ S_IRWXUGO

#define S_IRWXUGO (S_IRWXU|S_IRWXG|S_IRWXO)

Definition at line 400 of file ext2fs.h.

◆ S_ISBLK

#define S_ISBLK ( m ) (((m) & S_IFMT) == S_IFBLK)

Definition at line 375 of file ext2fs.h.

◆ S_ISCHR

#define S_ISCHR ( m ) (((m) & S_IFMT) == S_IFCHR)

Definition at line 377 of file ext2fs.h.

◆ S_ISDIR

#define S_ISDIR ( m ) (((m) & S_IFMT) == S_IFDIR)

Definition at line 376 of file ext2fs.h.

◆ S_ISFIFO

#define S_ISFIFO ( m ) (((m) & S_IFMT) == S_IFIFO)

Definition at line 378 of file ext2fs.h.

◆ S_ISFIL

#define S_ISFIL ( m ) (((m) & S_IFMT) == S_IFFIL)

Definition at line 374 of file ext2fs.h.

◆ S_ISGID

#define S_ISGID 0x00400 /* 000 2000 */

Definition at line 368 of file ext2fs.h.

◆ S_ISLNK

#define S_ISLNK ( m ) (((m) & S_IFMT) == S_IFLNK)

Definition at line 373 of file ext2fs.h.

◆ S_ISREADABLE

#define S_ISREADABLE ( m ) (((m) & S_IPERMISSION_MASK) == (S_IRUSR | S_IRGRP | S_IROTH))

Definition at line 407 of file ext2fs.h.

◆ S_ISREG

#define S_ISREG ( m ) (((m) & S_IFMT) == S_IFREG)

Definition at line 371 of file ext2fs.h.

◆ S_ISSOCK

#define S_ISSOCK ( m ) (((m) & S_IFMT) == S_IFSOCK)

Definition at line 372 of file ext2fs.h.

◆ S_ISUID

#define S_ISUID 0x00800 /* 000 4000 */

Definition at line 367 of file ext2fs.h.

◆ S_ISVTX

#define S_ISVTX 0x00200 /* 000 1000 */

Definition at line 369 of file ext2fs.h.

◆ S_ISWRITABLE

#define S_ISWRITABLE ( m ) (((m) & S_IPERMISSION_MASK) == (S_IWUSR | S_IWGRP | S_IWOTH))

Definition at line 408 of file ext2fs.h.

◆ S_IWGRP

#define S_IWGRP 0x010 /* 0 0020 */

Definition at line 391 of file ext2fs.h.

◆ S_IWOTH

#define S_IWOTH 0x002 /* 0 0002 */

Definition at line 397 of file ext2fs.h.

◆ S_IWUGO

#define S_IWUGO (S_IWUSR|S_IWGRP|S_IWOTH)

Definition at line 403 of file ext2fs.h.

◆ S_IWUSR

#define S_IWUSR 0x080 /* 0 0200 */

Definition at line 385 of file ext2fs.h.

◆ S_IXGRP

#define S_IXGRP 0x008 /* 0 0010 */

Definition at line 392 of file ext2fs.h.

◆ S_IXOTH

#define S_IXOTH 0x001 /* 0 0001 */

Definition at line 398 of file ext2fs.h.

◆ S_IXUGO

#define S_IXUGO (S_IXUSR|S_IXGRP|S_IXOTH)

Definition at line 404 of file ext2fs.h.

◆ S_IXUSR

#define S_IXUSR 0x040 /* 0 0100 */

Definition at line 386 of file ext2fs.h.

◆ SECTOR_BITS

#define SECTOR_BITS (Vcb->SectorBits)

Definition at line 81 of file ext2fs.h.

◆ SECTOR_SIZE

#define SECTOR_SIZE (Vcb->DiskGeometry.BytesPerSector)

Definition at line 82 of file ext2fs.h.

◆ SetFlag

#define SetFlag	(	_F,
		_SF
	)	((_F) \|= (_SF))

Definition at line 187 of file ext2fs.h.

◆ SetLongFlag

#define SetLongFlag	(	_F,
		_SF
	)	InterlockedOr(&(_F), (ULONG)(_SF))

Definition at line 258 of file ext2fs.h.

◆ SUPER_BLOCK

#define SUPER_BLOCK (Vcb->SuperBlock)

Definition at line 90 of file ext2fs.h.

◆ SUPER_BLOCK_OFFSET

#define SUPER_BLOCK_OFFSET (0x400)

Definition at line 85 of file ext2fs.h.

◆ SUPER_BLOCK_SIZE

#define SUPER_BLOCK_SIZE (0x400)

Definition at line 86 of file ext2fs.h.

◆ TAG_VPB

#define TAG_VPB ' bpV'

Definition at line 293 of file ext2fs.h.

◆ TOTAL_BLOCKS

#define TOTAL_BLOCKS (ext3_blocks_count(SUPER_BLOCK))

Definition at line 101 of file ext2fs.h.

◆ UID

#define UID L"uid"

Definition at line 154 of file ext2fs.h.

◆ VCB_ARRIVAL_NOTIFIED

#define VCB_ARRIVAL_NOTIFIED 0x00800000

Definition at line 802 of file ext2fs.h.

◆ VCB_BEING_CLOSED

#define VCB_BEING_CLOSED 0x00000020

Definition at line 793 of file ext2fs.h.

◆ VCB_BEING_DROPPED

#define VCB_BEING_DROPPED 0x00002000

Definition at line 798 of file ext2fs.h.

◆ VCB_DEVICE_REMOVED

#define VCB_DEVICE_REMOVED 0x00008000

Definition at line 800 of file ext2fs.h.

◆ VCB_DISMOUNT_PENDING

#define VCB_DISMOUNT_PENDING 0x00000008

Definition at line 791 of file ext2fs.h.

◆ VCB_FLOPPY_DISK

#define VCB_FLOPPY_DISK 0x20000000

Definition at line 806 of file ext2fs.h.

◆ VCB_FORCE_WRITING

#define VCB_FORCE_WRITING 0x00004000

Definition at line 799 of file ext2fs.h.

◆ VCB_GD_LOADED

#define VCB_GD_LOADED 0x00000100 /* group desc loaded */

Definition at line 796 of file ext2fs.h.

◆ VCB_INITIALIZED

#define VCB_INITIALIZED 0x00000001

Definition at line 788 of file ext2fs.h.

◆ VCB_JOURNAL_RECOVER

#define VCB_JOURNAL_RECOVER 0x00080000

Definition at line 801 of file ext2fs.h.

◆ VCB_MOUNTED

#define VCB_MOUNTED 0x00000004

Definition at line 790 of file ext2fs.h.

◆ VCB_NEW_VPB

#define VCB_NEW_VPB 0x00000010

Definition at line 792 of file ext2fs.h.

◆ VCB_READ_ONLY

#define VCB_READ_ONLY 0x08000000

Definition at line 804 of file ext2fs.h.

◆ VCB_REMOVABLE_MEDIA

#define VCB_REMOVABLE_MEDIA 0x80000000

Definition at line 808 of file ext2fs.h.

◆ VCB_REMOVAL_PREVENTED

#define VCB_REMOVAL_PREVENTED 0x40000000

Definition at line 807 of file ext2fs.h.

◆ VCB_RO_COMPAT_READ_ONLY

#define VCB_RO_COMPAT_READ_ONLY 0x01000000

Definition at line 803 of file ext2fs.h.

◆ VCB_USER_EIDS

#define VCB_USER_EIDS 0x00000080 /* euid/egid specified by user */

Definition at line 795 of file ext2fs.h.

◆ VCB_USER_IDS

#define VCB_USER_IDS 0x00000040 /* uid/gid specified by user */

Definition at line 794 of file ext2fs.h.

◆ VCB_VOLUME_LOCKED

#define VCB_VOLUME_LOCKED 0x00000002

Definition at line 789 of file ext2fs.h.

◆ VCB_WRITE_PROTECTED

#define VCB_WRITE_PROTECTED 0x10000000

Definition at line 805 of file ext2fs.h.

◆ VOLUMES_KEY

#define VOLUMES_KEY L"\\Volumes"

Definition at line 143 of file ext2fs.h.

◆ VPB_SIZE

#define VPB_SIZE sizeof(VPB)

Definition at line 294 of file ext2fs.h.

◆ WRITING_SUPPORT

#define WRITING_SUPPORT L"WritingSupport"

Definition at line 146 of file ext2fs.h.

Typedef Documentation

◆ EXT2_ALLOC_HEADER

typedef struct _EXT2_ALLOC_HEADER EXT2_ALLOC_HEADER

◆ EXT2_CCB

typedef struct _EXT2_CCB EXT2_CCB

◆ EXT2_DIR_ENTRY

typedef struct ext3_dir_entry EXT2_DIR_ENTRY

Definition at line 108 of file ext2fs.h.

◆ EXT2_DIR_ENTRY2

typedef struct ext3_dir_entry_2 EXT2_DIR_ENTRY2

Definition at line 109 of file ext2fs.h.

◆ EXT2_EXTENT

typedef struct _EXT2_EXTENT EXT2_EXTENT

◆ EXT2_FCB

typedef struct _EXT2_FCB EXT2_FCB

◆ EXT2_FCBVCB

typedef struct _EXT2_FCBVCB EXT2_FCBVCB

◆ EXT2_FILLDIR_CONTEXT

typedef struct _EXT2_FILLDIR_CONTEXT EXT2_FILLDIR_CONTEXT

◆ EXT2_GLOBAL

typedef struct _EXT2_GLOBAL EXT2_GLOBAL

◆ EXT2_GROUP_DESC

typedef struct ext4_group_desc EXT2_GROUP_DESC

Definition at line 107 of file ext2fs.h.

◆ EXT2_IDENTIFIER

typedef struct _EXT2_IDENTIFIER EXT2_IDENTIFIER

◆ EXT2_IDENTIFIER_TYPE

typedef enum _EXT2_IDENTIFIER_TYPE EXT2_IDENTIFIER_TYPE

◆ EXT2_INODE

typedef struct ext3_inode EXT2_INODE

Definition at line 106 of file ext2fs.h.

◆ EXT2_IRP_CONTEXT

typedef struct ext2_icb EXT2_IRP_CONTEXT

◆ EXT2_MCB

typedef struct _EXT2_MCB EXT2_MCB

Definition at line 484 of file ext2fs.h.

◆ EXT2_REAPER

typedef struct _EXT2_REAPER EXT2_REAPER

◆ EXT2_REAPER_RELEASE

typedef VOID(* EXT2_REAPER_RELEASE) (PVOID)

Definition at line 500 of file ext2fs.h.

◆ EXT2_RW_CONTEXT

typedef struct _EXT2_RW_CONTEXT EXT2_RW_CONTEXT

◆ EXT2_SUPER_BLOCK

typedef struct ext3_super_block EXT2_SUPER_BLOCK

Definition at line 105 of file ext2fs.h.

◆ EXT2_VCB

typedef struct _EXT2_VCB EXT2_VCB

◆ EXTENDED_IO_STACK_LOCATION

typedef IO_STACK_LOCATION EXTENDED_IO_STACK_LOCATION

Definition at line 174 of file ext2fs.h.

◆ FCB_LIST_ENTRY

typedef struct _FCB_LIST_ENTRY FCB_LIST_ENTRY

◆ filldir_t

typedef int(* filldir_t) (void *, const char *, int, unsigned long, __u32, unsigned)

Definition at line 2609 of file ext2fs.h.

◆ PBCB

typedef PVOID PBCB

Definition at line 487 of file ext2fs.h.

◆ PEXT2_ALLOC_HEADER

typedef struct _EXT2_ALLOC_HEADER * PEXT2_ALLOC_HEADER

◆ PEXT2_CCB

typedef struct _EXT2_CCB * PEXT2_CCB

◆ PEXT2_DIR_ENTRY

typedef struct ext3_dir_entry * PEXT2_DIR_ENTRY

Definition at line 108 of file ext2fs.h.

◆ PEXT2_DIR_ENTRY2

typedef struct ext3_dir_entry_2 * PEXT2_DIR_ENTRY2

Definition at line 109 of file ext2fs.h.

◆ PEXT2_EXTENT

typedef struct _EXT2_EXTENT * PEXT2_EXTENT

◆ PEXT2_FCB

typedef struct _EXT2_FCB * PEXT2_FCB

◆ PEXT2_FCBVCB

typedef struct _EXT2_FCBVCB * PEXT2_FCBVCB

◆ PEXT2_FILLDIR_CONTEXT

typedef struct _EXT2_FILLDIR_CONTEXT * PEXT2_FILLDIR_CONTEXT

◆ PEXT2_GLOBAL

typedef struct _EXT2_GLOBAL * PEXT2_GLOBAL

◆ PEXT2_GROUP_DESC

typedef struct ext4_group_desc * PEXT2_GROUP_DESC

Definition at line 107 of file ext2fs.h.

◆ PEXT2_IDENTIFIER

typedef struct _EXT2_IDENTIFIER * PEXT2_IDENTIFIER

◆ PEXT2_INODE

typedef struct ext3_inode * PEXT2_INODE

Definition at line 106 of file ext2fs.h.

◆ PEXT2_IRP_CONTEXT

typedef struct ext2_icb * PEXT2_IRP_CONTEXT

◆ PEXT2_MCB

typedef struct _EXT2_MCB * PEXT2_MCB

Definition at line 484 of file ext2fs.h.

◆ PEXT2_REAPER

typedef struct _EXT2_REAPER * PEXT2_REAPER

◆ PEXT2_RW_CONTEXT

typedef struct _EXT2_RW_CONTEXT * PEXT2_RW_CONTEXT

◆ PEXT2_SUPER_BLOCK

typedef struct ext3_super_block * PEXT2_SUPER_BLOCK

Definition at line 105 of file ext2fs.h.

◆ PEXT2_VCB

typedef struct _EXT2_VCB * PEXT2_VCB

◆ PEXTENDED_IO_STACK_LOCATION

typedef IO_STACK_LOCATION * PEXTENDED_IO_STACK_LOCATION

Definition at line 174 of file ext2fs.h.

◆ PFCB_LIST_ENTRY

typedef struct _FCB_LIST_ENTRY * PFCB_LIST_ENTRY

Enumeration Type Documentation

◆ _EXT2_IDENTIFIER_TYPE

enum _EXT2_IDENTIFIER_TYPE

Enumerator
EXT2FGD
EXT2VCB
EXT2FCB
EXT2CCB
EXT2ICX
EXT2FSD
EXT2MCB

Definition at line 451 of file ext2fs.h.

                                   {
#ifdef _MSC_VER
    EXT2FGD  = ':DGF',
    EXT2VCB  = ':BCV',
    EXT2FCB  = ':BCF',
    EXT2CCB  = ':BCC',
    EXT2ICX  = ':XCI',
    EXT2FSD  = ':DSF',
    EXT2MCB  = ':BCM'
#else
    EXT2FGD  = 0xE2FD0001,
    EXT2VCB  = 0xE2FD0002,
    EXT2FCB  = 0xE2FD0003,
    EXT2CCB  = 0xE2FD0004,
    EXT2ICX  = 0xE2FD0005,
    EXT2FSD  = 0xE2FD0006,
    EXT2MCB  = 0xE2FD0007
#endif
} EXT2_IDENTIFIER_TYPE;

Function Documentation

◆ add_dirent_to_buf()

int add_dirent_to_buf	(	struct ext2_icb *	icb,
		struct dentry *	dentry,
		struct inode *	inode,
		struct ext3_dir_entry_2 *	de,
		struct buffer_head *	bh
	)

Definition at line 386 of file htree.c.

{
    struct inode *dir = dentry->d_parent->d_inode;
    const char  *name = dentry->d_name.name;
    int     namelen = dentry->d_name.len;
    unsigned int    offset = 0;
    unsigned short  reclen;
    int     nlen, rlen, err;
    char        *top;
 
    reclen = EXT3_DIR_REC_LEN(namelen);
    if (!de) {
        de = (struct ext3_dir_entry_2 *)bh->b_data;
        top = bh->b_data + dir->i_sb->s_blocksize - reclen;
        while ((char *) de <= top) {
            if (!ext3_check_dir_entry("ext3_add_entry", dir, de,
                                      bh, offset)) {
                __brelse(bh);
                return -EIO;
            }
            if (ext3_match(namelen, name, de)) {
                __brelse(bh);
                return -EEXIST;
            }
            nlen = EXT3_DIR_REC_LEN(de->name_len);
            rlen = ext3_rec_len_from_disk(de->rec_len);
            if ((de->inode? rlen - nlen: rlen) >= reclen)
                break;
            de = (struct ext3_dir_entry_2 *)((char *)de + rlen);
            offset += rlen;
        }
        if ((char *) de > top)
            return -ENOSPC;
    }
 
    /* By now the buffer is marked for journaling */
    nlen = EXT3_DIR_REC_LEN(de->name_len);
    rlen = ext3_rec_len_from_disk(de->rec_len);
    if (de->inode) {
        struct ext3_dir_entry_2 *de1 = (struct ext3_dir_entry_2 *)((char *)de + nlen);
        de1->rec_len = ext3_rec_len_to_disk(rlen - nlen);
        de->rec_len = ext3_rec_len_to_disk(nlen);
        de = de1;
    }
    de->file_type = EXT3_FT_UNKNOWN;
    if (inode) {
        de->inode = cpu_to_le32(inode->i_ino);
        ext3_set_de_type(dir->i_sb, de, inode->i_mode);
    } else
        de->inode = 0;
    de->name_len = (__u8)namelen;
    memcpy(de->name, name, namelen);
 
    /*
     * XXX shouldn't update any times until successful
     * completion of syscall, but too many callers depend
     * on this.
     *
     * XXX similarly, too many callers depend on
     * ext4_new_inode() setting the times, but error
     * recovery deletes the inode, so the worst that can
     * happen is that the times are slightly out of date
     * and/or different from the directory change time.
     */
    dir->i_mtime = dir->i_ctime = ext3_current_time(dir);
    ext3_update_dx_flag(dir);
    dir->i_version++;
    ext3_mark_inode_dirty(icb, dir);
    set_buffer_dirty(bh);
    __brelse(bh);
    return 0;
}

Referenced by ext3_add_entry().

◆ DEC_OBJ_CNT()

__inline ULONG DEC_OBJ_CNT ( PULONG _C )

Definition at line 982 of file ext2fs.h.

                                      {
    if (*_C <= 0) {
        DbgBreak();
    }
    return InterlockedDecrement(_C);
}

◆ 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().

◆ do_split()

struct ext3_dir_entry_2 * do_split	(	struct ext2_icb *	icb,
		struct inode *	dir,
		struct buffer_head **	bh,
		struct dx_frame *	frame,
		struct dx_hash_info *	hinfo,
		int *	error
	)

◆ DriverUnload()

VOID DriverUnload ( IN PDRIVER_OBJECT DriverObject )

Definition at line 15 of file green.c.

{
    // nothing to do here yet
}

◆ Ex2ProcessMountPoint()

NTSTATUS Ex2ProcessMountPoint	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_MOUNT_POINT	MountPoint,
		IN ULONG	Length
	)

Definition at line 723 of file devctl.c.

{
    UNICODE_STRING  Link;
    UNICODE_STRING  Target;
    WCHAR           Buffer[] = L"\\DosDevices\\Global\\Z:";
    NTSTATUS        status = STATUS_SUCCESS;
 
    PDEVICE_OBJECT  DeviceObject = NULL;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
        if (!IsExt2FsDevice(DeviceObject)) {
            status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        if (Length != sizeof(EXT2_MOUNT_POINT) ||
            MountPoint->Magic != EXT2_APP_MOUNTPOINT_MAGIC) {
            status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        RtlInitUnicodeString(&Link, Buffer);
        Buffer[12] = MountPoint->Link[0];
 
        switch (MountPoint->Command) {
 
        case APP_CMD_ADD_DOS_SYMLINK:
            RtlInitUnicodeString(&Target, &MountPoint->Name[0]);
            status = IoCreateSymbolicLink(&Link, &Target);
            break;
 
        case APP_CMD_DEL_DOS_SYMLINK:
            status = IoDeleteSymbolicLink(&Link);
            break;
 
        default:
            status = STATUS_INVALID_PARAMETER;
        }
 
    } _SEH2_FINALLY {
 
        if (!IrpContext->ExceptionInProgress) {
            Ext2CompleteIrpContext(IrpContext, status);
        }
    } _SEH2_END;
 
    return status;
}

Referenced by Ext2DeviceControl().

◆ Ex2ProcessUserPerfStat()

NTSTATUS Ex2ProcessUserPerfStat	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_QUERY_PERFSTAT	QueryPerf,
		IN ULONG	Length
	)

Definition at line 640 of file devctl.c.

{
 
#ifndef __REACTOS__
    PEXT2_VCB   Vcb = NULL;
#endif
    PDEVICE_OBJECT  DeviceObject = NULL;
 
    BOOLEAN     GlobalDataResourceAcquired = FALSE;
    NTSTATUS    Status = STATUS_SUCCESS;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
        if (IsExt2FsDevice(DeviceObject)) {
 
            if (QueryPerf->Magic != EXT2_QUERY_PERFSTAT_MAGIC) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            if (QueryPerf->Command != IOCTL_APP_QUERY_PERFSTAT) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            if (Length != EXT2_QUERY_PERFSTAT_SZV1 &&
                Length != EXT2_QUERY_PERFSTAT_SZV2) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            ExAcquireResourceSharedLite(&Ext2Global->Resource, TRUE);
            GlobalDataResourceAcquired = TRUE;
 
            if (Length == EXT2_QUERY_PERFSTAT_SZV2) {
                QueryPerf->Flags = EXT2_QUERY_PERFSTAT_VER2;
                QueryPerf->PerfStatV2 = Ext2Global->PerfStat;
            } else {
                memcpy(&QueryPerf->PerfStatV1.Irps[0], &Ext2Global->PerfStat.Irps[0],
                       FIELD_OFFSET(EXT2_PERF_STATISTICS_V1, Unit));
                memcpy(&QueryPerf->PerfStatV1.Unit, &Ext2Global->PerfStat.Unit,
                       sizeof(EXT2_STAT_ARRAY_V1));
                memcpy(&QueryPerf->PerfStatV1.Current, &Ext2Global->PerfStat.Current,
                       sizeof(EXT2_STAT_ARRAY_V1));
                memcpy(&QueryPerf->PerfStatV1.Size, &Ext2Global->PerfStat.Size,
                       sizeof(EXT2_STAT_ARRAY_V1));
                memcpy(&QueryPerf->PerfStatV1.Total, &Ext2Global->PerfStat.Total,
                       sizeof(EXT2_STAT_ARRAY_V1));
            }
 
        } else {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        if (NT_SUCCESS(Status)) {
            IrpContext->Irp->IoStatus.Information = Length;
        }
 
    } _SEH2_FINALLY {
 
        if (GlobalDataResourceAcquired) {
            ExReleaseResourceLite(&Ext2Global->Resource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            Ext2CompleteIrpContext(IrpContext, Status);
        }
    } _SEH2_END
 
    return Status;
}

Referenced by Ext2DeviceControl().

◆ ext2_destroy_linux()

void ext2_destroy_linux ( )

Definition at line 1019 of file linux.c.

{
    ext2_destroy_bh();
}

Referenced by DriverEntry().

◆ ext2_init_linux()

int ext2_init_linux ( )

Definition at line 1004 of file linux.c.

{
    int rc = 0;
 
    rc = ext2_init_bh();
    if (rc != 0) {
        goto errorout;
    }
 
errorout:
 
    return rc;
}

Referenced by DriverEntry().

◆ Ext2AcquireFileForCcFlush()

NTSTATUS Ext2AcquireFileForCcFlush	(	IN PFILE_OBJECT	FileObject,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 1135 of file fastio.c.

{
    PEXT2_FCB Fcb = FileObject->FsContext;
 
    if (Fcb->Header.Resource != NULL) {
        ExAcquireResourceExclusiveLite(Fcb->Header.Resource, TRUE);
    }
 
    DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2AcquireFileForCcFlush: Fcb=%p\n", Fcb));
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

◆ Ext2AcquireFileForModWrite()

NTSTATUS Ext2AcquireFileForModWrite	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	EndingOffset,
		OUT PERESOURCE *	ResourceToRelease,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 1081 of file fastio.c.

{
    BOOLEAN ResourceAcquired = FALSE;
 
    PEXT2_FCB Fcb = FileObject->FsContext;
 
    *ResourceToRelease = Fcb->Header.Resource;
    ResourceAcquired = ExAcquireResourceExclusiveLite(*ResourceToRelease, FALSE);
    if (!ResourceAcquired) {
        *ResourceToRelease = NULL;
    }
 
    DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2AcquireFileForModWrite:  Fcb=%p Acquired=%d\n",
                             Fcb, ResourceAcquired));
 
    return (ResourceAcquired ? STATUS_SUCCESS : STATUS_CANT_WAIT);
}

Referenced by DriverEntry().

◆ Ext2AcquireForCreateSection()

VOID Ext2AcquireForCreateSection ( IN PFILE_OBJECT FileObject )

Definition at line 1043 of file fastio.c.

{
    PEXT2_FCB Fcb = FileObject->FsContext;
 
    if (Fcb->Header.Resource != NULL) {
        ExAcquireResourceExclusiveLite(Fcb->Header.Resource, TRUE);
    }
 
    DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2AcquireForCreateSection:  Fcb=%p\n", Fcb));
}

Referenced by DriverEntry().

◆ Ext2AcquireForLazyWrite()

BOOLEAN Ext2AcquireForLazyWrite	(	IN PVOID	Context,
		IN BOOLEAN	Wait
	)

Definition at line 27 of file cmcb.c.

{
    //
    // On a readonly filesystem this function still has to exist but it
    // doesn't need to do anything.
 
    PEXT2_FCB    Fcb;
 
    Fcb = (PEXT2_FCB) Context;
    ASSERT(Fcb != NULL);
    ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
           (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
#if EXT2_DEBUG
    DEBUG(CMCB_DEBUG_LEVEL, ("Ext2AcquireForLazyWrite: %s %s Fcb=%p\n",
                             Ext2GetCurrentProcessName(), "ACQUIRE_FOR_LAZY_WRITE", Fcb));
#endif
    if (!ExAcquireResourceExclusiveLite(Fcb->Header.Resource, Wait)) {
        return FALSE;
    }
 
    ASSERT(Fcb->LazyWriterThread == NULL);
    Fcb->LazyWriterThread = PsGetCurrentThread();
 
    ASSERT(IoGetTopLevelIrp() == NULL);
    IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 
    return TRUE;
}

Referenced by DriverEntry().

◆ Ext2AcquireForReadAhead()

BOOLEAN Ext2AcquireForReadAhead	(	IN PVOID	Context,
		IN BOOLEAN	Wait
	)

Definition at line 92 of file cmcb.c.

{
    PEXT2_FCB    Fcb = (PEXT2_FCB) Context;
 
    ASSERT(Fcb != NULL);
    ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
           (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
    DEBUG(CMCB_DEBUG_LEVEL, ("Ext2AcquireForReadAhead: i=%xh Fcb=%p\n",
                             Fcb->Mcb->Inode.i_ino, Fcb));
 
    if (!ExAcquireResourceSharedLite(Fcb->Header.Resource, Wait))
        return FALSE;
    ASSERT(IoGetTopLevelIrp() == NULL);
    IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
 
    return TRUE;
}

Referenced by DriverEntry().

◆ Ext2AddBlockExtent()

BOOLEAN Ext2AddBlockExtent	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Start,
		IN ULONG	Block,
		IN ULONG	Number
	)

Definition at line 1027 of file memory.c.

{
    LONGLONG    Vbn = 0;
    LONGLONG    Lbn = 0;
    LONGLONG    Length = 0;
 
    Vbn = ((LONGLONG) Start) << BLOCK_BITS;
    Lbn = ((LONGLONG) Block) << BLOCK_BITS;
    Length = ((LONGLONG)Number << BLOCK_BITS);
 
    if (Mcb) {
#if EXT2_DEBUG
        ULONG   _block = 0, _mapped = 0;
        BOOLEAN _rc = Ext2LookupBlockExtent(Vcb, Mcb, Start, &_block, &_mapped);
        if (_rc && _block != 0 && (_block != Block)) {
            DbgBreak();
        }
#endif
        return Ext2AddMcbExtent(Vcb, Mcb, Vbn, Lbn, Length);
 
    }
 
    ASSERT(Start == Block);
    return Ext2AddVcbExtent(Vcb, Vbn, Length);
}

Referenced by Ext2BuildExtents(), Ext2ExpandBlock(), Ext2ExpandExtent(), Ext2ExpandLast(), Ext2InitializeZone(), submit_bh_mdl(), and submit_bh_pin().

◆ Ext2AddEntry()

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

Referenced by Ext2CreateInode(), Ext2SetLinkInfo(), and Ext2SetRenameInfo().

◆ Ext2AddMcbExtent()

BOOLEAN Ext2AddMcbExtent	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN LONGLONG	Vbn,
		IN LONGLONG	Lbn,
		IN LONGLONG	Length
	)

Definition at line 790 of file memory.c.

{
    ULONG       TriedTimes = 0;
    LONGLONG    Base = 0;
    UCHAR       Bits = 0;
    BOOLEAN     rc = FALSE;
 
    Base = (LONGLONG)BLOCK_SIZE;
    Bits = (UCHAR)BLOCK_BITS;
 
    ASSERT ((Vbn & (Base - 1)) == 0);
    ASSERT ((Lbn & (Base - 1)) == 0);
    ASSERT ((Length & (Base - 1)) == 0);
 
    Vbn = (Vbn >> Bits) + 1;
    Lbn =  (Lbn >> Bits) + 1;
    Length = (Length >> Bits);
 
Again:
 
    _SEH2_TRY {
 
        rc = FsRtlAddLargeMcbEntry(
            &Mcb->Extents,
            Vbn,
            Lbn,
            Length
        );
 
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
 
        DbgBreak();
        rc = FALSE;
    } _SEH2_END;
 
    if (!rc && ++TriedTimes < 10) {
        Ext2Sleep(TriedTimes * 100);
        goto Again;
    }
 
    DEBUG(DL_EXT, ("Ext2AddMcbExtent: Vbn=%I64xh Lbn=%I64xh Length=%I64xh,"
                   " rc=%d Runs=%u\n", Vbn, Lbn, Length, rc,
                   FsRtlNumberOfRunsInLargeMcb(&Mcb->Extents)));
 
    if (rc) {
        Ext2CheckExtent(&Mcb->Extents, Vbn, Lbn, Length, TRUE);
    }
 
    return rc;
}

Referenced by Ext2AddBlockExtent().

◆ Ext2AddMcbMetaExts()

BOOLEAN Ext2AddMcbMetaExts	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Block,
		IN ULONG	Length
	)

Definition at line 941 of file memory.c.

{
    ULONG       TriedTimes = 0;
    LONGLONG    Lbn = Block + 1;
    BOOLEAN     rc = TRUE;
 
Again:
 
    _SEH2_TRY {
 
        rc = FsRtlAddLargeMcbEntry(
                &Mcb->MetaExts,
                Lbn,
                Lbn,
                Length
             );
 
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
 
        DbgBreak();
        rc = FALSE;
    } _SEH2_END;
 
    if (!rc && ++TriedTimes < 10) {
        Ext2Sleep(TriedTimes * 100);
        goto Again;
    }
 
    DEBUG(DL_EXT, ("Ext2AddMcbMetaExts: Block: %xh-%xh rc=%d Runs=%u\n", Block,
                   Length, rc, FsRtlNumberOfRunsInLargeMcb(&Mcb->MetaExts)));
 
    if (rc) {
        Ext2CheckExtent(&Mcb->MetaExts, Lbn, Lbn, Length, TRUE);
    }
 
    return rc;
}

Referenced by Ext2ExpandBlock(), Ext2ExpandLast(), and Ext2GetBlock().

◆ Ext2AddVcbExtent()

BOOLEAN Ext2AddVcbExtent	(	IN PEXT2_VCB	Vcb,
		IN LONGLONG	Vbn,
		IN LONGLONG	Length
	)

Definition at line 648 of file memory.c.

{
    ULONG       TriedTimes = 0;
 
    LONGLONG    Offset = 0;
    BOOLEAN     rc = FALSE;
 
    Offset = Vbn & (~(Vcb->IoUnitSize - 1));
    Length = (Vbn - Offset + Length + Vcb->IoUnitSize - 1) &
             ~(Vcb->IoUnitSize - 1);
 
    ASSERT ((Offset & (Vcb->IoUnitSize - 1)) == 0);
    ASSERT ((Length & (Vcb->IoUnitSize - 1)) == 0);
 
    Offset = (Offset >> Vcb->IoUnitBits) + 1;
    Length = (Length >> Vcb->IoUnitBits);
 
Again:
 
    _SEH2_TRY {
        rc = FsRtlAddLargeMcbEntry(
                &Vcb->Extents,
                Offset,
                Offset,
                Length
                );
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
        DbgBreak();
        rc = FALSE;
    } _SEH2_END;
 
    if (!rc && ++TriedTimes < 10) {
        Ext2Sleep(TriedTimes * 100);
        goto Again;
    }
 
    DEBUG(DL_EXT, ("Ext2AddVcbExtent: Vbn=%I64xh Length=%I64xh,"
                   " rc=%d Runs=%u\n", Offset, Length, rc,
                   FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));
 
    if (rc) {
        Ext2CheckExtent(&Vcb->Extents, Offset, Offset, Length, TRUE);
    }
 
    return rc;
}

Referenced by Ext2AddBlockExtent(), Ext2FreeBlock(), Ext2GetBlock(), Ext2TruncateBlock(), and Ext2WriteVolume().

◆ Ext2AllocateCcb()

PEXT2_CCB Ext2AllocateCcb	(	ULONG	Flags,
		PEXT2_MCB	SymLink
	)

Definition at line 320 of file memory.c.

{
    PEXT2_CCB Ccb;
 
    Ccb = (PEXT2_CCB) (ExAllocateFromNPagedLookasideList(
                           &(Ext2Global->Ext2CcbLookasideList)));
    if (!Ccb) {
        return NULL;
    }
 
    DEBUG(DL_RES, ( "ExtAllocateCcb: Ccb created: %ph.\n", Ccb));
 
    RtlZeroMemory(Ccb, sizeof(EXT2_CCB));
 
    Ccb->Identifier.Type = EXT2CCB;
    Ccb->Identifier.Size = sizeof(EXT2_CCB);
    Ccb->Flags = Flags;
 
    Ccb->SymLink = SymLink;
    if (SymLink) {
        ASSERT(SymLink->Refercount > 0);
        Ext2ReferMcb(SymLink);
        DEBUG(DL_INF, ( "ExtAllocateCcb: Ccb SymLink: %wZ.\n",
                        &Ccb->SymLink->FullName));
    }
 
    Ccb->DirectorySearchPattern.Length = 0;
    Ccb->DirectorySearchPattern.MaximumLength = 0;
    Ccb->DirectorySearchPattern.Buffer = 0;
 
    INC_MEM_COUNT(PS_CCB, Ccb, sizeof(EXT2_CCB));
 
    return Ccb;
}

Referenced by Ext2CreateFile(), and Ext2CreateVolume().

◆ Ext2AllocateEntry()

struct dentry * Ext2AllocateEntry ( )

Definition at line 416 of file memory.c.

{
    struct dentry *de;
 
    de = (struct dentry *)ExAllocateFromNPagedLookasideList(
             &(Ext2Global->Ext2DentryLookasideList));
    if (!de) {
        return NULL;
    }
 
    RtlZeroMemory(de, sizeof(struct dentry));
    INC_MEM_COUNT(PS_DENTRY, de, sizeof(struct dentry));
 
    return de;
}

Referenced by Ext2BuildEntry().

◆ Ext2AllocateExtent()

PEXT2_EXTENT Ext2AllocateExtent ( )

Definition at line 488 of file memory.c.

{
    PEXT2_EXTENT Extent;
 
    Extent = (PEXT2_EXTENT)ExAllocateFromNPagedLookasideList(
                 &(Ext2Global->Ext2ExtLookasideList));
    if (!Extent) {
        return NULL;
    }
 
    RtlZeroMemory(Extent, sizeof(EXT2_EXTENT));
    INC_MEM_COUNT(PS_EXTENT, Extent, sizeof(EXT2_EXTENT));
 
    return Extent;
}

Referenced by Ext2BuildExtents(), and Ext2WriteVolume().

◆ Ext2AllocateFcb()

PEXT2_FCB Ext2AllocateFcb	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb
	)

Definition at line 131 of file memory.c.

{
    PEXT2_FCB Fcb;
 
    ASSERT(ExIsResourceAcquiredExclusiveLite(&Vcb->FcbLock));
 
    Fcb = (PEXT2_FCB) ExAllocateFromNPagedLookasideList(
              &(Ext2Global->Ext2FcbLookasideList));
 
    if (!Fcb) {
        return NULL;
    }
 
    RtlZeroMemory(Fcb, sizeof(EXT2_FCB));
    Fcb->Identifier.Type = EXT2FCB;
    Fcb->Identifier.Size = sizeof(EXT2_FCB);
 
#ifndef _WIN2K_TARGET_
    ExInitializeFastMutex(&Fcb->Mutex);
    FsRtlSetupAdvancedHeader(&Fcb->Header,  &Fcb->Mutex);
#endif
 
    FsRtlInitializeOplock(&Fcb->Oplock);
    FsRtlInitializeFileLock (
        &Fcb->FileLockAnchor,
        NULL,
        NULL );
 
    Fcb->OpenHandleCount = 0;
    Fcb->ReferenceCount = 0;
    Fcb->Vcb = Vcb;
    Fcb->Inode = &Mcb->Inode;
 
    ASSERT(Mcb->Fcb == NULL);
    Ext2ReferMcb(Mcb);
    Fcb->Mcb = Mcb;
    Mcb->Fcb = Fcb;
 
    DEBUG(DL_RES, ("Ext2AllocateFcb: Fcb %p created: %wZ.\n",
                   Fcb, &Fcb->Mcb->FullName));
 
    RtlZeroMemory(&Fcb->Header, sizeof(FSRTL_COMMON_FCB_HEADER));
    Fcb->Header.NodeTypeCode = (USHORT) EXT2FCB;
    Fcb->Header.NodeByteSize = sizeof(EXT2_FCB);
    Fcb->Header.IsFastIoPossible = FastIoIsNotPossible;
    Fcb->Header.Resource = &(Fcb->MainResource);
    Fcb->Header.PagingIoResource = &(Fcb->PagingIoResource);
 
    Fcb->Header.FileSize.QuadPart = Mcb->Inode.i_size;
    Fcb->Header.ValidDataLength.QuadPart = Mcb->Inode.i_size;
    Fcb->Header.AllocationSize.QuadPart = CEILING_ALIGNED(ULONGLONG,
                                          Fcb->Header.FileSize.QuadPart, (ULONGLONG)Vcb->BlockSize);
 
    Fcb->SectionObject.DataSectionObject = NULL;
    Fcb->SectionObject.SharedCacheMap = NULL;
    Fcb->SectionObject.ImageSectionObject = NULL;
 
    ExInitializeResourceLite(&(Fcb->MainResource));
    ExInitializeResourceLite(&(Fcb->PagingIoResource));
 
    Ext2InsertFcb(Vcb, Fcb);
 
    INC_MEM_COUNT(PS_FCB, Fcb, sizeof(EXT2_FCB));
 
    return Fcb;
}

Referenced by Ext2CreateFile(), Ext2DeleteFile(), Ext2DeleteReparsePoint(), Ext2SetLinkInfo(), Ext2SetRenameInfo(), and Ext2SetReparsePoint().

◆ Ext2AllocateInode()

PEXT2_INODE Ext2AllocateInode ( PEXT2_VCB Vcb )

Definition at line 387 of file memory.c.

{
    PVOID inode = NULL;
 
    inode = ExAllocateFromNPagedLookasideList(
                &(Vcb->InodeLookasideList));
    if (!inode) {
        return NULL;
    }
 
    RtlZeroMemory(inode, INODE_SIZE);
 
    DEBUG(DL_INF, ("ExtAllocateInode: Inode created: %ph.\n", inode));
    INC_MEM_COUNT(PS_EXT2_INODE, inode, INODE_SIZE);
 
    return inode;
}

Referenced by ext4_fs_get_xattr_ref().

◆ Ext2AllocateIrpContext()

PEXT2_IRP_CONTEXT Ext2AllocateIrpContext	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 35 of file memory.c.

{
    PIO_STACK_LOCATION   irpSp;
    PEXT2_IRP_CONTEXT    IrpContext;
 
    ASSERT(DeviceObject != NULL);
    ASSERT(Irp != NULL);
 
    irpSp = IoGetCurrentIrpStackLocation(Irp);
 
    IrpContext = (PEXT2_IRP_CONTEXT) (
                     ExAllocateFromNPagedLookasideList(
                         &(Ext2Global->Ext2IrpContextLookasideList)));
 
    if (IrpContext == NULL) {
        return NULL;
    }
 
    RtlZeroMemory(IrpContext, sizeof(EXT2_IRP_CONTEXT) );
 
    IrpContext->Identifier.Type = EXT2ICX;
    IrpContext->Identifier.Size = sizeof(EXT2_IRP_CONTEXT);
 
    IrpContext->Irp = Irp;
    IrpContext->MajorFunction = irpSp->MajorFunction;
    IrpContext->MinorFunction = irpSp->MinorFunction;
    IrpContext->DeviceObject = DeviceObject;
    IrpContext->FileObject = irpSp->FileObject;
    if (NULL != IrpContext->FileObject) {
        IrpContext->Fcb = (PEXT2_FCB)IrpContext->FileObject->FsContext;
        IrpContext->Ccb = (PEXT2_CCB)IrpContext->FileObject->FsContext2;
    }
 
    if (IrpContext->FileObject != NULL) {
        IrpContext->RealDevice = IrpContext->FileObject->DeviceObject;
    } else if (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) {
        if (irpSp->Parameters.MountVolume.Vpb) {
            IrpContext->RealDevice = irpSp->Parameters.MountVolume.Vpb->RealDevice;
        }
    }
 
    if (IsFlagOn(irpSp->Flags, SL_WRITE_THROUGH)) {
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH);
    }
 
    if (IsFlagOn(irpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME)) {
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_VERIFY_READ);
    }
 
    if (IrpContext->MajorFunction == IRP_MJ_CLEANUP ||
        IrpContext->MajorFunction == IRP_MJ_CLOSE ||
        IrpContext->MajorFunction == IRP_MJ_SHUTDOWN ||
        IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL ||
        IrpContext->MajorFunction == IRP_MJ_PNP ) {
 
        if (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL ||
            IrpContext->MajorFunction == IRP_MJ_PNP) {
            if (IoGetCurrentIrpStackLocation(Irp)->FileObject == NULL ||
                IoIsOperationSynchronous(Irp)) {
                SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
            }
        } else {
            SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
        }
 
    } else if (IoIsOperationSynchronous(Irp)) {
 
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
    }
 
    IrpContext->IsTopLevel = (IoGetTopLevelIrp() == Irp);
    IrpContext->ExceptionInProgress = FALSE;
    INC_IRP_COUNT(IrpContext);
 
    return IrpContext;
}

Referenced by Ext2BuildRequest().

◆ Ext2AllocateMcb()

PEXT2_MCB Ext2AllocateMcb	(	IN PEXT2_VCB	Vcb,
		IN PUNICODE_STRING	FileName,
		IN PUNICODE_STRING	Parent,
		IN ULONG	FileAttr
	)

Definition at line 1430 of file memory.c.

{
    PEXT2_MCB   Mcb = NULL;
    NTSTATUS    Status = STATUS_SUCCESS;
 
    /* need wake the reaper thread if there are many Mcb allocated */
    if (Ext2Global->PerfStat.Current.Mcb > (((ULONG)Ext2Global->MaxDepth) * 4)) {
        KeSetEvent(&Ext2Global->McbReaper.Wait, 0, FALSE);
    }
 
    /* allocate Mcb from LookasideList */
    Mcb = (PEXT2_MCB) (ExAllocateFromNPagedLookasideList(
                           &(Ext2Global->Ext2McbLookasideList)));
 
    if (Mcb == NULL) {
        return NULL;
    }
 
    /* initialize Mcb header */
    RtlZeroMemory(Mcb, sizeof(EXT2_MCB));
    Mcb->Identifier.Type = EXT2MCB;
    Mcb->Identifier.Size = sizeof(EXT2_MCB);
    Mcb->FileAttr = FileAttr;
 
    Mcb->Inode.i_priv = (PVOID)Mcb;
    Mcb->Inode.i_sb = &Vcb->sb;
 
    /* initialize Mcb names */
    if (FileName) {
 
#if EXT2_DEBUG
        if ( FileName->Length == 2 &&
                FileName->Buffer[0] == L'\\') {
            DEBUG(DL_RES, ( "Ext2AllocateMcb: Root Mcb is to be created !\n"));
        }
 
        if ( FileName->Length == 2 &&
                FileName->Buffer[0] == L'.') {
            DbgBreak();
        }
 
        if ( FileName->Length == 4 &&
                FileName->Buffer[0] == L'.' &&
                FileName->Buffer[1] == L'.' ) {
            DbgBreak();
        }
#endif
 
        if (( FileName->Length >= 4 && FileName->Buffer[0] == L'.') &&
                ((FileName->Length == 4 && FileName->Buffer[1] != L'.') ||
                 FileName->Length >= 6 )) {
            SetFlag(Mcb->FileAttr, FILE_ATTRIBUTE_HIDDEN);
        }
 
        if (!Ext2BuildName(&Mcb->ShortName, FileName, NULL)) {
            goto errorout;
        }
        if (!Ext2BuildName(&Mcb->FullName, FileName, Parent)) {
            goto errorout;
        }
    }
 
    /* initialize Mcb Extents, it will raise an expcetion if failed */
    _SEH2_TRY {
        FsRtlInitializeLargeMcb(&(Mcb->Extents), NonPagedPool);
        FsRtlInitializeLargeMcb(&(Mcb->MetaExts), NonPagedPool);
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        DbgBreak();
    } _SEH2_END;
 
    if (!NT_SUCCESS(Status)) {
        goto errorout;
    }
 
    INC_MEM_COUNT(PS_MCB, Mcb, sizeof(EXT2_MCB));
    DEBUG(DL_INF, ( "Ext2AllocateMcb: Mcb %wZ created.\n", &Mcb->FullName));
 
    return Mcb;
 
errorout:
 
    if (Mcb) {
 
        if (Mcb->ShortName.Buffer) {
            DEC_MEM_COUNT(PS_MCB_NAME, Mcb->ShortName.Buffer,
                          Mcb->ShortName.MaximumLength);
            Ext2FreePool(Mcb->ShortName.Buffer, EXT2_FNAME_MAGIC);
        }
 
        if (Mcb->FullName.Buffer) {
            DEC_MEM_COUNT(PS_MCB_NAME, Mcb->FullName.Buffer,
                          Mcb->FullName.MaximumLength);
            Ext2FreePool(Mcb->FullName.Buffer, EXT2_FNAME_MAGIC);
        }
 
        ExFreeToNPagedLookasideList(&(Ext2Global->Ext2McbLookasideList), Mcb);
    }
 
    return NULL;
}

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

◆ Ext2AllocatePool()

PVOID Ext2AllocatePool	(	IN POOL_TYPE	PoolType,
		IN SIZE_T	NumberOfBytes,
		IN ULONG	Tag
	)

Definition at line 2684 of file debug.c.

{
    return ExAllocatePoolWithTag(
               PoolType,
               NumberOfBytes,
               Tag);
}

Referenced by DriverEntry(), Ext2BuildName(), Ext2CreateFile(), Ext2ExpandLast(), Ext2FillEntry(), Ext2FollowLink(), Ext2GetReparsePoint(), Ext2LoadSuper(), Ext2QueryDirectory(), Ext2QueryExtentMappings(), Ext2QueryRegistrySettings(), Ext2QueryVolumeParams(), Ext2ReadDisk(), Ext2ReadSync(), Ext2ReadWriteBlocks(), Ext2SetParentEntry(), Ext2SetReparsePoint(), and Ext2StartFloppyFlushDpc().

◆ Ext2AllowExtendedDasdIo()

NTSTATUS Ext2AllowExtendedDasdIo ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 407 of file fsctl.c.

{
    PIO_STACK_LOCATION IrpSp;
    PEXT2_VCB Vcb;
    PEXT2_CCB Ccb;
    NTSTATUS  status;
 
    IrpSp = IoGetCurrentIrpStackLocation(IrpContext->Irp);
 
    Vcb = (PEXT2_VCB) IrpSp->FileObject->FsContext;
    Ccb = (PEXT2_CCB) IrpSp->FileObject->FsContext2;
 
    ASSERT(Vcb != NULL);
 
    ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
           (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
    ASSERT(IsMounted(Vcb));
 
    if (Ccb) {
        SetLongFlag(Ccb->Flags, CCB_ALLOW_EXTENDED_DASD_IO);
        status = STATUS_SUCCESS;
    } else {
        status = STATUS_INVALID_PARAMETER;
    }
 
    Ext2CompleteIrpContext(IrpContext, status);
    return status;
}

Referenced by Ext2UserFsRequest().

◆ Ext2bhReaperThread()

VOID Ext2bhReaperThread ( PVOID Context )

Definition at line 3239 of file memory.c.

{
    PEXT2_REAPER    Reaper = Context;
    PEXT2_VCB       Vcb = NULL;
    LIST_ENTRY      List, *Link;
    LARGE_INTEGER   Timeout;
 
    BOOLEAN         GlobalAcquired = FALSE;
    BOOLEAN         DidNothing = FALSE;
    BOOLEAN         NonWait = FALSE;
 
    _SEH2_TRY {
 
        Reaper->Thread = PsGetCurrentThread();
 
        /* wake up DirverEntry */
        KeSetEvent(&Reaper->Engine, 0, FALSE);
 
        /* now process looping */
        while (!IsFlagOn(Reaper->Flags, EXT2_REAPER_FLAG_STOP)) {
 
            /* wait until it is waken or it times out */
            if (NonWait) {
                Timeout.QuadPart = (LONGLONG)-10*1000*10;
                NonWait = FALSE;
            } else if (DidNothing) {
                Timeout.QuadPart = Timeout.QuadPart * 2;
            } else {
                Timeout.QuadPart = (LONGLONG)-10*1000*1000*10; /* 10 seconds */
            }
            KeWaitForSingleObject(
                &Reaper->Wait,
                Executive,
                KernelMode,
                FALSE,
                &Timeout
            );
 
            if (IsFlagOn(Reaper->Flags, EXT2_REAPER_FLAG_STOP))
                break;
 
            InitializeListHead(&List);
 
            /* acquire global exclusive lock */
            ExAcquireResourceSharedLite(&Ext2Global->Resource, TRUE);
            GlobalAcquired = TRUE;
            /* search all Vcb to get unused resources freed to system */
            for (Link = Ext2Global->VcbList.Flink;
                 Link != &(Ext2Global->VcbList);
                 Link = Link->Flink ) {
 
                Vcb = CONTAINING_RECORD(Link, EXT2_VCB, Next);
                NonWait = Ext2QueryUnusedBH(Vcb, &List);
            }
            DidNothing = IsListEmpty(&List);
            if (DidNothing) {
                KeClearEvent(&Reaper->Wait);
            }
            if (GlobalAcquired) {
                ExReleaseResourceLite(&Ext2Global->Resource);
                GlobalAcquired = FALSE;
            }
 
            while (!IsListEmpty(&List)) {
                struct buffer_head *bh;
                Link = RemoveHeadList(&List);
                bh = CONTAINING_RECORD(Link, struct buffer_head, b_link);
                ASSERT(0 == atomic_read(&bh->b_count));
                free_buffer_head(bh);
            }
        }
 
    } _SEH2_FINALLY {
 
        if (GlobalAcquired) {
            ExReleaseResourceLite(&Ext2Global->Resource);
        }
 
        KeSetEvent(&Reaper->Engine, 0, FALSE);
    } _SEH2_END;
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}

Referenced by DriverEntry().

◆ Ext2BlockMap()

NTSTATUS Ext2BlockMap	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Index,
		IN BOOLEAN	bAlloc,
		OUT PULONG	pBlock,
		OUT PULONG	Number
	)

Definition at line 1127 of file fileinfo.c.

{
    NTSTATUS status;
 
    if (INODE_HAS_EXTENT(&Mcb->Inode)) {
        status = Ext2MapExtent(IrpContext, Vcb, Mcb, Index,
                               bAlloc, pBlock, Number );
    } else {
        status = Ext2MapIndirect(IrpContext, Vcb, Mcb, Index,
                                 bAlloc, pBlock, Number );
    }
 
    return status;
}

Referenced by Ext2BuildExtents().

◆ Ext2BuildEntry()

struct dentry * Ext2BuildEntry	(	PEXT2_VCB	Vcb,
		PEXT2_MCB	Dcb,
		PUNICODE_STRING	FileName
	)

Definition at line 444 of file memory.c.

{
    OEM_STRING      Oem = { 0 };
    struct dentry  *de = NULL;
    NTSTATUS        Status = STATUS_INSUFFICIENT_RESOURCES;
 
    _SEH2_TRY {
 
        de = Ext2AllocateEntry();
        if (!de) {
            DEBUG(DL_ERR, ("Ext2BuildEntry: failed to allocate dentry.\n"));
            _SEH2_LEAVE;
        }
        de->d_sb = &Vcb->sb;
        if (Dcb)
            de->d_parent = Dcb->de;
 
        Oem.MaximumLength = (USHORT)Ext2UnicodeToOEMSize(Vcb, FileName) + 1;
        Oem.Buffer = ExAllocatePool(PagedPool, Oem.MaximumLength);
        if (!Oem.Buffer) {
            DEBUG(DL_ERR, ( "Ex2BuildEntry: failed to allocate OEM name.\n"));
            _SEH2_LEAVE;
        }
        de->d_name.name = Oem.Buffer;
        RtlZeroMemory(Oem.Buffer, Oem.MaximumLength);
        Status = Ext2UnicodeToOEM(Vcb, &Oem, FileName);
        if (!NT_SUCCESS(Status)) {
            DEBUG(DL_CP, ("Ext2BuildEntry: failed to convert %S to OEM.\n", FileName->Buffer));
            _SEH2_LEAVE;
        }
        de->d_name.len  = Oem.Length;
 
    } _SEH2_FINALLY {
 
        if (!NT_SUCCESS(Status)) {
            if (de)
                Ext2FreeEntry(de);
        }
    } _SEH2_END;
 
    return de;
}

Referenced by Ext2AddEntry(), Ext2InitializeVcb(), and Ext2ScanDir().

◆ Ext2BuildExtents()

NTSTATUS Ext2BuildExtents	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONGLONG	Offset,
		IN ULONG	Size,
		IN BOOLEAN	bAlloc,
		OUT PEXT2_EXTENT *	Chain
	)

Definition at line 1207 of file memory.c.

{
    ULONG       Start, End;
    ULONG       Total = 0;
 
    LONGLONG    Lba = 0;
    NTSTATUS    Status = STATUS_SUCCESS;
 
    PEXT2_EXTENT  Extent = NULL;
    PEXT2_EXTENT  List = *Chain = NULL;
 
    if (!IsZoneInited(Mcb)) {
        Status = Ext2InitializeZone(IrpContext, Vcb, Mcb);
        if (!NT_SUCCESS(Status)) {
            DbgBreak();
        }
    }
 
    if ((IrpContext && IrpContext->Irp) &&
            ((IrpContext->Irp->Flags & IRP_NOCACHE) ||
             (IrpContext->Irp->Flags & IRP_PAGING_IO))) {
        Size = (Size + SECTOR_SIZE - 1) & (~(SECTOR_SIZE - 1));
    }
 
    Start = (ULONG)(Offset >> BLOCK_BITS);
    End = (ULONG)((Size + Offset + BLOCK_SIZE - 1) >> BLOCK_BITS);
 
    if (End > (ULONG)((Mcb->Inode.i_size + BLOCK_SIZE - 1) >> BLOCK_BITS) ) {
        End = (ULONG)((Mcb->Inode.i_size + BLOCK_SIZE - 1) >> BLOCK_BITS);
    }
 
    while (Size > 0 && Start < End) {
 
        ULONG   Mapped = 0;
        ULONG   Length = 0;
        ULONG   Block = 0;
 
        BOOLEAN rc = FALSE;
 
        /* try to map file offset to ext2 block upon Extents cache */
        if (IsZoneInited(Mcb)) {
            rc = Ext2LookupBlockExtent(
                     Vcb,
                     Mcb,
                     Start,
                     &Block,
                     &Mapped);
 
            if (!rc) {
                /* we likely get a sparse file here */
                Mapped = 1;
                Block = 0;
            }
        }
 
        /* try to BlockMap in case failed to access Extents cache */
        if (!IsZoneInited(Mcb) || (bAlloc && Block == 0)) {
 
            Status = Ext2BlockMap(
                             IrpContext,
                             Vcb,
                             Mcb,
                             Start,
                             bAlloc,
                             &Block,
                             &Mapped
                     );
            if (!NT_SUCCESS(Status)) {
                break;
            }
 
            /* skip wrong blocks, in case wrongly treating symlink
               target names as blocks, silly  */
            if (Block >= TOTAL_BLOCKS) {
                Block = 0;
            }
 
            /* add new allocated blocks to Mcb zone */
            if (IsZoneInited(Mcb) && Block) {
                if (!Ext2AddBlockExtent(Vcb, Mcb, Start, Block, Mapped)) {
                    DbgBreak();
                    ClearFlag(Mcb->Flags, MCB_ZONE_INITED);
                    Ext2ClearAllExtents(&Mcb->Extents);
                }
            }
        }
 
        /* calculate i/o extent */
        Lba = ((LONGLONG)Block << BLOCK_BITS) + Offset - ((LONGLONG)Start << BLOCK_BITS);
        Length = (ULONG)(((LONGLONG)(Start + Mapped) << BLOCK_BITS) - Offset);
        if (Length > Size) {
            Length = Size;
        }
 
        if (0 == Length) {
            DbgBreak();
            break;
        }
 
        Start += Mapped;
        Offset = (ULONGLONG)Start << BLOCK_BITS;
 
        if (Block != 0) {
 
            if (List && List->Lba + List->Length == Lba) {
 
                /* it's continuous upon previous Extent */
                List->Length += Length;
 
            } else {
 
                /* have to allocate a new Extent */
                Extent = Ext2AllocateExtent();
                if (!Extent) {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    DbgBreak();
                    break;
                }
 
                Extent->Lba = Lba;
                Extent->Length = Length;
                Extent->Offset = Total;
 
                /* insert new Extent to chain */
                if (List) {
                    List->Next = Extent;
                    List = Extent;
                } else {
                    *Chain = List = Extent;
                }
            }
        } else {
            if (bAlloc) {
                DbgBreak();
            }
        }
 
        Total += Length;
        Size  -= Length;
    }
 
    return Status;
}

Referenced by bmap(), Ext2GetRetrievalPointers(), Ext2QueryExtentMappings(), Ext2ReadInode(), and Ext2WriteInode().

◆ Ext2BuildName()

BOOLEAN Ext2BuildName	(	IN OUT PUNICODE_STRING	Target,
		IN PUNICODE_STRING	File,
		IN PUNICODE_STRING	Parent
	)

Definition at line 1361 of file memory.c.

{
    USHORT  Length = 0;
    USHORT  ParentLen = 0;
    BOOLEAN bBackslash = TRUE;
 
    /* free the original buffer */
    if (Target->Buffer) {
        DEC_MEM_COUNT(PS_MCB_NAME, Target->Buffer, Target->MaximumLength);
        Ext2FreePool(Target->Buffer, EXT2_FNAME_MAGIC);
        Target->Length = Target->MaximumLength = 0;
    }
 
    /* check the parent directory's name and backslash */
    if (Parent && Parent->Buffer && Parent->Length > 0) {
        ParentLen = Parent->Length / sizeof(WCHAR);
        if (Parent->Buffer[ParentLen - 1] == L'\\') {
            bBackslash = FALSE;
        }
    }
 
    if (Parent == NULL || File->Buffer[0] == L'\\') {
        /* must be root inode */
        ASSERT(ParentLen == 0);
        bBackslash = FALSE;
    }
 
    /* allocate and initialize new name buffer */
    Length  = File->Length;
    Length += (ParentLen + (bBackslash ? 1 : 0)) * sizeof(WCHAR);
 
    Target->Buffer = Ext2AllocatePool(
                         PagedPool,
                         Length + 2,
                         EXT2_FNAME_MAGIC
                     );
 
    if (!Target->Buffer) {
        DEBUG(DL_ERR, ( "Ex2BuildName: failed to allocate name bufer.\n"));
        return FALSE;
    }
    RtlZeroMemory(Target->Buffer, Length + 2);
 
    if (ParentLen) {
        RtlCopyMemory(&Target->Buffer[0],
                      Parent->Buffer,
                      ParentLen * sizeof(WCHAR));
    }
 
    if (bBackslash) {
        Target->Buffer[ParentLen++] = L'\\';
    }
 
    RtlCopyMemory( &Target->Buffer[ParentLen],
                   File->Buffer,
                   File->Length);
 
    INC_MEM_COUNT(PS_MCB_NAME, Target->Buffer, Length + 2);
    Target->Length = Length;
    Target->MaximumLength = Length + 2;
 
    return TRUE;
}

Referenced by Ext2AllocateMcb(), and Ext2SetRenameInfo().

◆ Ext2BuildRequest()

NTSTATUS Ext2BuildRequest	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Referenced by DriverEntry().

◆ Ext2CheckBitmapConsistency()

BOOLEAN Ext2CheckBitmapConsistency	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb
	)

Definition at line 1899 of file memory.c.

{
    ULONG i, j, InodeBlocks;
 
    for (i = 0; i < Vcb->sbi.s_groups_count; i++) {
 
        PEXT2_GROUP_DESC    gd;
        struct buffer_head  *bh = NULL;
 
        gd = ext4_get_group_desc(&Vcb->sb, i, &bh);
        if (!gd)
            continue;
        Ext2CheckSetBlock(IrpContext, Vcb, ext4_block_bitmap(&Vcb->sb, gd));
        Ext2CheckSetBlock(IrpContext, Vcb, ext4_inode_bitmap(&Vcb->sb, gd));
 
 
        if (i == Vcb->sbi.s_groups_count - 1) {
            InodeBlocks = ((INODES_COUNT % INODES_PER_GROUP) *
                           Vcb->InodeSize + Vcb->BlockSize - 1) /
                          (Vcb->BlockSize);
        } else {
            InodeBlocks = (INODES_PER_GROUP * Vcb->InodeSize +
                           Vcb->BlockSize - 1) / (Vcb->BlockSize);
        }
 
        for (j = 0; j < InodeBlocks; j++ )
            Ext2CheckSetBlock(IrpContext, Vcb, ext4_inode_table(&Vcb->sb, gd) + j);
 
        fini_bh(&bh);
    }
 
    return TRUE;
}

Referenced by Ext2InitializeVcb().

◆ Ext2CheckDismount()

BOOLEAN Ext2CheckDismount	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN BOOLEAN	bForce
	)

Definition at line 2592 of file fsctl.c.

{
    KIRQL   Irql;
    PVPB    Vpb = Vcb->Vpb, NewVpb = NULL;
    BOOLEAN bDeleted = FALSE, bTearDown = FALSE;
    ULONG   UnCleanCount = 0;
 
    NewVpb = ExAllocatePoolWithTag(NonPagedPool, VPB_SIZE, TAG_VPB);
    if (NewVpb == NULL) {
        DEBUG(DL_ERR, ( "Ex2CheckDismount: failed to allocate NewVpb.\n"));
        return FALSE;
    }
    DEBUG(DL_DBG, ("Ext2CheckDismount: NewVpb allocated: %p\n", NewVpb));
    INC_MEM_COUNT(PS_VPB, NewVpb, sizeof(VPB));
    memset(NewVpb, '_', VPB_SIZE);
    RtlZeroMemory(NewVpb, sizeof(VPB));
 
    ExAcquireResourceExclusiveLite(
        &Ext2Global->Resource, TRUE );
 
    ExAcquireResourceExclusiveLite(
        &Vcb->MainResource, TRUE );
 
    if (IrpContext &&
        IrpContext->MajorFunction == IRP_MJ_CREATE &&
        IrpContext->RealDevice == Vcb->RealDevice) {
        UnCleanCount = 2;
    } else {
        UnCleanCount = 1;
    }
 
    IoAcquireVpbSpinLock (&Irql);
 
    DEBUG(DL_DBG, ("Ext2CheckDismount: Vpb %p ioctl=%d Device %p\n",
                   Vpb, Vpb->ReferenceCount, Vpb->RealDevice));
 
    if (Vpb->ReferenceCount <= UnCleanCount) {
 
        if (!IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {
 
            ClearFlag(Vpb->Flags, VPB_MOUNTED);
            ClearFlag(Vpb->Flags, VPB_LOCKED);
 
            if ((Vcb->RealDevice != Vpb->RealDevice) &&
                    (Vcb->RealDevice->Vpb == Vpb)) {
                SetFlag(Vcb->RealDevice->Flags, DO_DEVICE_INITIALIZING);
                SetFlag(Vpb->Flags, VPB_PERSISTENT );
            }
 
            Ext2RemoveVcb(Vcb);
            SetLongFlag(Vcb->Flags, VCB_DISMOUNT_PENDING);
        }
 
        if (Vpb->ReferenceCount) {
            bTearDown = TRUE;
        } else {
            bDeleted = TRUE;
            Vpb->DeviceObject = NULL;
        }
 
        DEBUG(DL_DBG, ("Ext2CheckDismount: Vpb: %p bDeleted=%d bTearDown=%d\n",
                        Vpb, bDeleted, bTearDown));
 
 
    } else if (bForce) {
 
        DEBUG(DL_DBG, ( "Ext2CheckDismount: New/Old Vpb %p/%p Realdevice = %p\n",
                        NewVpb, Vcb->Vpb, Vpb->RealDevice));
 
        /* keep vpb president and later we'll free it */
        SetFlag(Vpb->Flags, VPB_PERSISTENT);
 
        Vcb->Vpb2 = Vcb->Vpb;
        NewVpb->Type = IO_TYPE_VPB;
        NewVpb->Size = sizeof(VPB);
        NewVpb->Flags = Vpb->Flags & VPB_REMOVE_PENDING;
        NewVpb->RealDevice = Vpb->RealDevice;
        NewVpb->RealDevice->Vpb = NewVpb;
        NewVpb = NULL;
        ClearFlag(Vpb->Flags, VPB_MOUNTED);
        SetLongFlag(Vcb->Flags, VCB_NEW_VPB);
        ClearLongFlag(Vcb->Flags, VCB_MOUNTED);
    }
 
    IoReleaseVpbSpinLock(Irql);
 
    ExReleaseResourceLite(&Vcb->MainResource);
    ExReleaseResourceLite(&Ext2Global->Resource);
 
    if (bTearDown) {
        DEBUG(DL_DBG, ( "Ext2CheckDismount: Tearing vcb %p ...\n", Vcb));
        Ext2TearDownStream(Vcb);
    }
 
    if (bDeleted) {
        DEBUG(DL_DBG, ( "Ext2CheckDismount: Deleting vcb %p ...\n", Vcb));
        Ext2DestroyVcb(Vcb);
    }
 
    if (NewVpb != NULL) {
        DEBUG(DL_DBG, ( "Ext2CheckDismount: freeing new Vpb %p\n", NewVpb));
        ExFreePoolWithTag(NewVpb, TAG_VPB);
        DEC_MEM_COUNT(PS_VPB, NewVpb, sizeof(VPB));
    }
 
    return bDeleted;
}

Referenced by Ext2DismountVolume(), Ext2ExceptionHandler(), Ext2FreeFcb(), and Ext2InvalidateVolumes().

◆ Ext2CheckExtent()

VOID Ext2CheckExtent	(	PLARGE_MCB	Zone,
		LONGLONG	Vbn,
		LONGLONG	Lbn,
		LONGLONG	Length,
		BOOLEAN	bAdded
	)

Definition at line 583 of file memory.c.

{
#if EXT2_DEBUG
    LONGLONG    DirtyLbn;
    LONGLONG    DirtyLen;
    LONGLONG    RunStart;
    LONGLONG    RunLength;
    ULONG       Index;
    BOOLEAN     bFound = FALSE;
 
    bFound = FsRtlLookupLargeMcbEntry(
                 Zone,
                 Vbn,
                 &DirtyLbn,
                 &DirtyLen,
                 &RunStart,
                 &RunLength,
                 &Index );
 
    if (!bAdded && (!bFound || DirtyLbn == -1)) {
        return;
    }
 
    if ( !bFound || (DirtyLbn == -1) ||
            (DirtyLbn != Lbn) ||
            (DirtyLen < Length)) {
 
        DbgBreak();
 
        for (Index = 0; TRUE; Index++) {
 
            if (!FsRtlGetNextLargeMcbEntry(
                        Zone,
                        Index,
                        &Vbn,
                        &Lbn,
                        &Length)) {
                break;
            }
 
            DEBUG(DL_EXT, ("Index = %xh Vbn = %I64xh Lbn = %I64xh Len = %I64xh\n",
                           Index, Vbn, Lbn, Length ));
        }
    }
#endif
}

Referenced by Ext2AddMcbExtent(), Ext2AddMcbMetaExts(), Ext2AddVcbExtent(), Ext2RemoveMcbExtent(), Ext2RemoveMcbMetaExts(), and Ext2RemoveVcbExtent().

◆ Ext2CheckFileAccess()

int Ext2CheckFileAccess	(	PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb,
		int	attempt
	)

Definition at line 51 of file access.c.

{
    return Ext2CheckInodeAccess(Vcb, &Mcb->Inode, attempt);
}

Referenced by Ext2CreateFile(), Ext2LookupFile(), Ext2SetFileInformation(), and Ext2WriteFile().

◆ Ext2CheckInodeAccess()

int Ext2CheckInodeAccess	(	PEXT2_VCB	Vcb,
		struct inode *	in,
		int	attempt
	)

Definition at line 20 of file access.c.

{
    int granted = 0;
 
    uid_t uid = Vcb->uid;
    gid_t gid = Vcb->gid;
 
    if (IsFlagOn(Vcb->Flags, VCB_USER_EIDS)) {
        uid = Vcb->euid;
        gid = Vcb->egid;
    }
 
    if (!uid || uid == in->i_uid) {
        /* grant all access for inode owner or root */
        granted = Ext2FileCanRead | Ext2FileCanWrite | Ext2FileCanExecute;
    } else if (gid == in->i_gid) {
        if (Ext2IsGroupReadOnly(in->i_mode))
            granted = Ext2FileCanRead | Ext2FileCanExecute;
        else if (Ext2IsGroupWritable(in->i_mode))
            granted = Ext2FileCanRead | Ext2FileCanWrite | Ext2FileCanExecute;
    } else {
        if (Ext2IsOtherReadOnly(in->i_mode))
            granted = Ext2FileCanRead | Ext2FileCanExecute;
        else if (Ext2IsOtherWritable(in->i_mode))
            granted = Ext2FileCanRead | Ext2FileCanWrite | Ext2FileCanExecute;
 
    }
 
    return IsFlagOn(granted, attempt);
}

Referenced by Ext2CheckFileAccess(), and Ext2ProcessEntry().

◆ Ext2CheckJournal()

INT Ext2CheckJournal	(	PEXT2_VCB	Vcb,
		PULONG	jNo
	)

Definition at line 55 of file recover.c.

{
    struct ext3_super_block* esb = NULL;
 
    /* check ext3 super block */
    esb = (struct ext3_super_block *)Vcb->SuperBlock;
    if (IsFlagOn(esb->s_feature_incompat,
                 EXT3_FEATURE_INCOMPAT_RECOVER)) {
        SetLongFlag(Vcb->Flags, VCB_JOURNAL_RECOVER);
    }
 
    /* must stop here if volume is read-only */
    if (IsVcbReadOnly(Vcb)) {
        goto errorout;
    }
 
    /* journal is external ? */
    if (esb->s_journal_inum == 0) {
        goto errorout;
    }
 
    /* oops: volume is corrupted */
    if (esb->s_journal_dev) {
        goto errorout;
    }
 
    /* return the journal inode number */
    *jNo = esb->s_journal_inum;
 
    return TRUE;
 
errorout:
 
    return FALSE;
}

Referenced by Ext2RecoverJournal().

◆ Ext2CheckSetBlock()

BOOLEAN Ext2CheckSetBlock	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		LONGLONG	Block
	)

Definition at line 1848 of file memory.c.

{
    PEXT2_GROUP_DESC    gd;
    struct buffer_head *gb = NULL;
    struct buffer_head *bh = NULL;
    ULONG               group, dwBlk, Length;
    RTL_BITMAP          bitmap;
    BOOLEAN             bModified = FALSE;
 
    group = (ULONG)(Block - EXT2_FIRST_DATA_BLOCK) / BLOCKS_PER_GROUP;
    dwBlk = (ULONG)(Block - EXT2_FIRST_DATA_BLOCK) % BLOCKS_PER_GROUP;
 
    gd = ext4_get_group_desc(&Vcb->sb, group, &gb);
    if (!gd) {
        return FALSE;
    }
    bh = sb_getblk(&Vcb->sb, ext4_block_bitmap(&Vcb->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;
    }
 
    if (dwBlk >= Length) {
        fini_bh(&gb);
        fini_bh(&bh);
        return FALSE;
    }
 
 
    RtlInitializeBitMap(&bitmap, (PULONG)bh->b_data, Length);
 
    if (RtlCheckBit(&bitmap, dwBlk) == 0) {
        DbgBreak();
        RtlSetBits(&bitmap, dwBlk, 1);
        bModified = TRUE;
        mark_buffer_dirty(bh);
    }
 
    fini_bh(&gb);
    fini_bh(&bh);
 
    return (!bModified);
}

Referenced by Ext2CheckBitmapConsistency().

◆ Ext2Cleanup()

NTSTATUS Ext2Cleanup ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 21 of file cleanup.c.

{
    PDEVICE_OBJECT  DeviceObject;
    NTSTATUS        Status = STATUS_SUCCESS;
    PEXT2_VCB       Vcb = NULL;
    PFILE_OBJECT    FileObject;
    PEXT2_FCB       Fcb = NULL;
    PEXT2_CCB       Ccb = NULL;
    PIRP            Irp = NULL;
    PEXT2_MCB       Mcb = NULL;
 
 
    BOOLEAN         VcbResourceAcquired = FALSE;
    BOOLEAN         FcbResourceAcquired = FALSE;
    BOOLEAN         FcbPagingIoResourceAcquired = FALSE;
    BOOLEAN         SymLinkDelete = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
        if (IsExt2FsDevice(DeviceObject))  {
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        Irp = IrpContext->Irp;
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        if (!IsVcbInited(Vcb)) {
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        FileObject = IrpContext->FileObject;
        Fcb = (PEXT2_FCB) FileObject->FsContext;
        if (!Fcb || (Fcb->Identifier.Type != EXT2VCB &&
                     Fcb->Identifier.Type != EXT2FCB)) {
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
        Mcb = Fcb->Mcb;
        Ccb = (PEXT2_CCB) FileObject->FsContext2;
 
        if (IsFlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE)) {
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        if (Fcb->Identifier.Type == EXT2VCB) {
 
            ExAcquireResourceExclusiveLite(
                    &Vcb->MainResource, TRUE);
            VcbResourceAcquired = TRUE;
 
            if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED) &&
                Vcb->LockFile == FileObject ){
 
                ClearFlag(Vcb->Flags, VCB_VOLUME_LOCKED);
                Vcb->LockFile = NULL;
                Ext2ClearVpbFlag(Vcb->Vpb, VPB_LOCKED);
            }
 
            if (Ccb) {
                Ext2DerefXcb(&Vcb->OpenHandleCount);
                Ext2DerefXcb(&Vcb->OpenVolumeCount);
            }
 
            IoRemoveShareAccess(FileObject, &Vcb->ShareAccess);
 
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
        FcbResourceAcquired =
            ExAcquireResourceExclusiveLite(
                &Fcb->MainResource,
                TRUE
            );
 
        if (IsFlagOn(FileObject->Flags, FO_CLEANUP_COMPLETE)) {
            if (IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED) &&
                    IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK) &&
                    !IsVcbReadOnly(Vcb) ) {
                Status = Ext2FlushFile(IrpContext, Fcb, Ccb);
            }
            _SEH2_LEAVE;
        }
 
        if (Ccb == NULL) {
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        if (IsDirectory(Fcb)) {
            if (IsFlagOn(Ccb->Flags, CCB_DELETE_ON_CLOSE))  {
                SetLongFlag(Fcb->Flags, FCB_DELETE_PENDING);
 
                FsRtlNotifyFullChangeDirectory(
                    Vcb->NotifySync,
                    &Vcb->NotifyList,
                    Ccb,
                    NULL,
                    FALSE,
                    FALSE,
                    0,
                    NULL,
                    NULL,
                    NULL );
            }
 
            FsRtlNotifyCleanup(Vcb->NotifySync, &Vcb->NotifyList, Ccb);
        }
 
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
               (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
 
        Ext2DerefXcb(&Vcb->OpenHandleCount);
        Ext2DerefXcb(&Fcb->OpenHandleCount);
 
        if (IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED)) {
            Fcb->Mcb->FileAttr |= FILE_ATTRIBUTE_ARCHIVE;
        }
 
        if (IsDirectory(Fcb)) {
 
            ext3_release_dir(Fcb->Inode, &Ccb->filp);
 
        } else {
 
            if ( IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED) &&
                    !IsFlagOn(Ccb->Flags, CCB_LAST_WRITE_UPDATED)) {
 
                LARGE_INTEGER   SysTime;
                KeQuerySystemTime(&SysTime);
 
                Fcb->Inode->i_atime =
                    Fcb->Inode->i_mtime = Ext2LinuxTime(SysTime);
                Fcb->Mcb->LastAccessTime =
                    Fcb->Mcb->LastWriteTime = Ext2NtTime(Fcb->Inode->i_atime);
 
                Ext2SaveInode(IrpContext, Vcb, Fcb->Inode);
 
                Ext2NotifyReportChange(
                    IrpContext,
                    Vcb,
                    Fcb->Mcb,
                    FILE_NOTIFY_CHANGE_ATTRIBUTES |
                    FILE_NOTIFY_CHANGE_LAST_WRITE |
                    FILE_NOTIFY_CHANGE_LAST_ACCESS,
                    FILE_ACTION_MODIFIED );
            }
 
            FsRtlCheckOplock( &Fcb->Oplock,
                              Irp,
                              IrpContext,
                              NULL,
                              NULL );
 
            Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
 
            if (!IsFlagOn(FileObject->Flags, FO_CACHE_SUPPORTED)) {
                Fcb->NonCachedOpenCount--;
            }
 
            if (IsFlagOn(Ccb->Flags, CCB_DELETE_ON_CLOSE))  {
                if (Ccb->SymLink || IsInodeSymLink(&Mcb->Inode)) {
                    SymLinkDelete = TRUE;
                } else {
                    SetLongFlag(Fcb->Flags, FCB_DELETE_PENDING);
                }
            }
 
            //
            // Drop any byte range locks this process may have on the file.
            //
 
            FsRtlFastUnlockAll(
                &Fcb->FileLockAnchor,
                FileObject,
                IoGetRequestorProcess(Irp),
                NULL  );
 
            //
            // If there are no byte range locks owned by other processes on the
            // file the fast I/O read/write functions doesn't have to check for
            // locks so we set IsFastIoPossible to FastIoIsPossible again.
            //
            if (!FsRtlGetNextFileLock(&Fcb->FileLockAnchor, TRUE)) {
                if (Fcb->Header.IsFastIoPossible != FastIoIsPossible) {
#if EXT2_DEBUG
                    DEBUG(DL_INF, (": %-16.16s %-31s %wZ\n",
                                   Ext2GetCurrentProcessName(),
                                   "FastIoIsPossible",
                                   &Fcb->Mcb->FullName
                                  ));
#endif
 
                    Fcb->Header.IsFastIoPossible = FastIoIsPossible;
                }
            }
 
            if (Fcb->OpenHandleCount == 0 && FlagOn(Fcb->Flags, FCB_ALLOC_IN_CREATE |
                                                                FCB_ALLOC_IN_SETINFO) ){
 
                if (FlagOn(Fcb->Flags, FCB_ALLOC_IN_SETINFO)) {
                    if (Fcb->Header.ValidDataLength.QuadPart < Fcb->Header.FileSize.QuadPart) {
                        if (!INODE_HAS_EXTENT(Fcb->Inode)) {
                        #if EXT2_PRE_ALLOCATION_SUPPORT
                            _SEH2_TRY {
                                CcZeroData( FileObject,
                                           &Fcb->Header.ValidDataLength,
                                           &Fcb->Header.AllocationSize,
                                           TRUE);
                            } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
                                DbgBreak();
                            } _SEH2_END;
                        #endif
                        }
                    }
                }
 
                if (FlagOn(Fcb->Flags, FCB_ALLOC_IN_CREATE)) {
 
                    LARGE_INTEGER Size;
 
                    ExAcquireResourceExclusiveLite(&Fcb->PagingIoResource, TRUE);
                    FcbPagingIoResourceAcquired = TRUE;
 
                    Size.QuadPart = CEILING_ALIGNED(ULONGLONG,
                                                    (ULONGLONG)Fcb->Mcb->Inode.i_size,
                                                    (ULONGLONG)BLOCK_SIZE);
                    if (!IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING)) {
 
                        Ext2TruncateFile(IrpContext, Vcb, Fcb->Mcb, &Size);
                        Fcb->Header.AllocationSize = Size;
                        Fcb->Header.FileSize.QuadPart = Mcb->Inode.i_size;
                        if (Fcb->Header.ValidDataLength.QuadPart > Fcb->Header.FileSize.QuadPart)
                            Fcb->Header.ValidDataLength.QuadPart = Fcb->Header.FileSize.QuadPart;
                        if (CcIsFileCached(FileObject)) {
                            CcSetFileSizes(FileObject,
                                           (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));
                        }
                    }
                    ClearLongFlag(Fcb->Flags, FCB_ALLOC_IN_CREATE|FCB_ALLOC_IN_WRITE|FCB_ALLOC_IN_SETINFO);
                    ExReleaseResourceLite(&Fcb->PagingIoResource);
                    FcbPagingIoResourceAcquired = FALSE;
                }
            }
        }
 
        IoRemoveShareAccess(FileObject, &Fcb->ShareAccess);
 
        if (!IsDirectory(Fcb)) {
 
            if ( IsFlagOn(FileObject->Flags, FO_CACHE_SUPPORTED) &&
                    (Fcb->NonCachedOpenCount == Fcb->OpenHandleCount) &&
                    (Fcb->SectionObject.DataSectionObject != NULL)) {
 
                if (!IsVcbReadOnly(Vcb)) {
                    CcFlushCache(&Fcb->SectionObject, NULL, 0, NULL);
                    ClearLongFlag(Fcb->Flags, FCB_FILE_MODIFIED);
                }
 
                /* purge cache if all remaining openings are non-cached */
                if (Fcb->NonCachedOpenCount > 0 ||
                    IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING)) {
                    if (ExAcquireResourceExclusiveLite(&(Fcb->PagingIoResource), TRUE)) {
                        ExReleaseResourceLite(&(Fcb->PagingIoResource));
                    }
 
                    /* CcPurge could generate recursive IRP_MJ_CLOSE request */
                    CcPurgeCacheSection( &Fcb->SectionObject,
                                         NULL,
                                         0,
                                         FALSE );
                }
            }
 
            CcUninitializeCacheMap(FileObject, NULL, NULL);
        }
 
        if (SymLinkDelete ||
            (IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING) &&
             Fcb->OpenHandleCount == 0) ) {
 
            //
            // Ext2DeleteFile will acquire these lock inside
            //
 
            if (FcbResourceAcquired) {
                ExReleaseResourceLite(&Fcb->MainResource);
                FcbResourceAcquired = FALSE;
            }
 
            //
            //  this file is to be deleted ...
            //
            if (Ccb->SymLink) {
                Mcb = Ccb->SymLink;
                FileObject->DeletePending = FALSE;
            }
 
            Status = Ext2DeleteFile(IrpContext, Vcb, Fcb, Mcb);
 
            if (NT_SUCCESS(Status)) {
                if (IsMcbDirectory(Mcb)) {
                    Ext2NotifyReportChange( IrpContext, Vcb, Mcb,
                                            FILE_NOTIFY_CHANGE_DIR_NAME,
                                            FILE_ACTION_REMOVED );
                } else {
                    Ext2NotifyReportChange( IrpContext, Vcb, Mcb,
                                            FILE_NOTIFY_CHANGE_FILE_NAME,
                                            FILE_ACTION_REMOVED );
                }
            }
 
            //
            // re-acquire the main resource lock
            //
 
            FcbResourceAcquired =
                ExAcquireResourceExclusiveLite(
                    &Fcb->MainResource,
                    TRUE
                );
            if (!SymLinkDelete) {
                 SetFlag(FileObject->Flags, FO_FILE_MODIFIED);
                if (CcIsFileCached(FileObject)) {
                    CcSetFileSizes(FileObject,
                                   (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));
                }
            }
        }
 
        DEBUG(DL_INF, ( "Ext2Cleanup: OpenCount=%u ReferCount=%u NonCahcedCount=%xh %wZ\n",
                        Fcb->OpenHandleCount, Fcb->ReferenceCount, Fcb->NonCachedOpenCount, &Fcb->Mcb->FullName));
 
        Status = STATUS_SUCCESS;
 
        if (FileObject) {
            SetFlag(FileObject->Flags, FO_CLEANUP_COMPLETE);
        }
 
    } _SEH2_FINALLY {
 
        if (FcbPagingIoResourceAcquired) {
            ExReleaseResourceLite(&Fcb->PagingIoResource);
        }
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            if (Status == STATUS_PENDING) {
                Ext2QueueRequest(IrpContext);
            } else {
                IrpContext->Irp->IoStatus.Status = Status;
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2CleanupAllMcbs()

VOID Ext2CleanupAllMcbs ( PEXT2_VCB Vcb )

Definition at line 1810 of file memory.c.

{
    BOOLEAN   LockAcquired = FALSE;
    PEXT2_MCB Mcb = NULL;
 
    _SEH2_TRY {
 
        ExAcquireResourceExclusiveLite(
            &Vcb->McbLock,
            TRUE );
        LockAcquired = TRUE;
 
#ifdef __REACTOS__
        while ((Mcb = Ext2FirstUnusedMcb(Vcb, TRUE, Vcb->NumOfMcb)) != 0) {
#else
        while (Mcb = Ext2FirstUnusedMcb(Vcb, TRUE, Vcb->NumOfMcb)) {
#endif
            while (Mcb) {
                PEXT2_MCB Next = Mcb->Next;
                if (IsMcbSymLink(Mcb)) {
                    Mcb->Target = NULL;
                }
                Ext2FreeMcb(Vcb, Mcb);
                Mcb = Next;
            }
        }
        Ext2FreeMcb(Vcb, Vcb->McbTree);
        Vcb->McbTree = NULL;
 
    } _SEH2_FINALLY {
 
        if (LockAcquired) {
            ExReleaseResourceLite(&Vcb->McbLock);
        }
    } _SEH2_END;
}

Referenced by Ext2DestroyVcb().

◆ Ext2ClearAllExtents()

VOID Ext2ClearAllExtents ( PLARGE_MCB Zone )

Definition at line 637 of file memory.c.

{
    _SEH2_TRY {
        FsRtlTruncateLargeMcb(Zone, (LONGLONG)0);
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
        DbgBreak();
    } _SEH2_END;
}

Referenced by Ext2BuildExtents(), Ext2ExpandBlock(), Ext2ExpandExtent(), Ext2ExpandLast(), Ext2InitializeZone(), Ext2TruncateBlock(), Ext2TruncateExtent(), Ext2TruncateFile(), and Ext2TruncateIndirectFast().

◆ 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().

◆ Ext2ClearVpbFlag()

VOID Ext2ClearVpbFlag	(	IN PVPB	Vpb,
		IN USHORT	Flag
	)

Definition at line 56 of file fsctl.c.

{
    KIRQL OldIrql;
 
    IoAcquireVpbSpinLock(&OldIrql);
    Vpb->Flags &= ~Flag;
    IoReleaseVpbSpinLock(OldIrql);
}

Referenced by Ext2Cleanup(), and Ext2UnlockVcb().

◆ Ext2Close()

NTSTATUS Ext2Close ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 26 of file close.c.

{
    PDEVICE_OBJECT  DeviceObject;
    NTSTATUS        Status = STATUS_SUCCESS;
    PEXT2_VCB       Vcb = NULL;
    PFILE_OBJECT    FileObject;
    PEXT2_FCB       Fcb = NULL;
    PEXT2_CCB       Ccb = NULL;
 
    BOOLEAN         VcbResourceAcquired = FALSE;
    BOOLEAN         FcbResourceAcquired = FALSE;
    BOOLEAN         FcbDerefDeferred = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_SUCCESS;
            Vcb = NULL;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DELAY_CLOSE)) {
 
            FileObject = NULL;
            Fcb = IrpContext->Fcb;
            Ccb = IrpContext->Ccb;
 
        } else {
 
            FileObject = IrpContext->FileObject;
            Fcb = (PEXT2_FCB) FileObject->FsContext;
            if (!Fcb) {
                Status = STATUS_SUCCESS;
                _SEH2_LEAVE;
            }
            ASSERT(Fcb != NULL);
            Ccb = (PEXT2_CCB) FileObject->FsContext2;
        }
 
        DEBUG(DL_INF, ( "Ext2Close: (VCB) Vcb = %p ReferCount = %d\n",
                         Vcb, Vcb->ReferenceCount));
 
        /*
         * WARNING: don't release Vcb resource lock here.
         *
         *  CcPurgeCacheSection will lead a recursive irp: IRP_MJ_CLOSE
         *  which would cause revrese order of lock acquirision:
         *  1) IRP_MJ_CLEANUP: a) Vcb lock -> b) Fcb lock
         *  2) IRP_MJ_CLOSE:   c) Vcb lock -> d) Fcb lock
         */
 
        if (Fcb->Identifier.Type == EXT2VCB) {
 
            if (!ExAcquireResourceExclusiveLite(
                            &Vcb->MainResource,
                            TRUE )) {
                DEBUG(DL_INF, ("Ext2Close: PENDING ... Vcb: %xh/%xh\n",
                                   Vcb->OpenHandleCount, Vcb->ReferenceCount));
                Status = STATUS_PENDING;
                _SEH2_LEAVE;
            }
            VcbResourceAcquired = TRUE;
 
            if (Ccb) {
 
                Ext2DerefXcb(&Vcb->ReferenceCount);
                Ext2FreeCcb(Vcb, Ccb);
 
                if (FileObject) {
                    FileObject->FsContext2 = Ccb = NULL;
                }
            }
 
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        if ( Fcb->Identifier.Type != EXT2FCB ||
             Fcb->Identifier.Size != sizeof(EXT2_FCB)) {
            _SEH2_LEAVE;
        }
 
        if (!ExAcquireResourceExclusiveLite(
                    &Fcb->MainResource,
                    TRUE )) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
        FcbResourceAcquired = TRUE;
 
        Fcb->Header.IsFastIoPossible = FastIoIsNotPossible;
 
        if (Ccb == NULL ||
            Ccb->Identifier.Type != EXT2CCB ||
            Ccb->Identifier.Size != sizeof(EXT2_CCB)) {
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        DEBUG(DL_INF, ( "Ext2Close: Fcb = %p OpenHandleCount= %u ReferenceCount=%u NonCachedCount=%u %wZ\n",
                        Fcb, Fcb->OpenHandleCount, Fcb->ReferenceCount, Fcb->NonCachedOpenCount, &Fcb->Mcb->FullName ));
 
        Ext2FreeCcb(Vcb, Ccb);
        if (FileObject) {
            FileObject->FsContext2 = Ccb = NULL;
        }
 
        /* only deref fcb, Ext2ReleaseFcb might lead deadlock */
        FcbDerefDeferred = TRUE;
        if (IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING) ||
            NULL == Fcb->Mcb ||
            IsFileDeleted(Fcb->Mcb)) {
            Fcb->TsDrop.QuadPart = 0;
        } else {
            KeQuerySystemTime(&Fcb->TsDrop);
        }
        Ext2DerefXcb(&Vcb->ReferenceCount);
 
        if (FileObject) {
            FileObject->FsContext = NULL;
        }
 
        Status = STATUS_SUCCESS;
 
    } _SEH2_FINALLY {
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
 
            if (Status == STATUS_PENDING) {
 
                Ext2QueueCloseRequest(IrpContext);
 
            } else {
 
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
 
        if (FcbDerefDeferred)
            Ext2DerefXcb(&Fcb->ReferenceCount);
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DeQueueCloseRequest(), and Ext2DispatchRequest().

◆ Ext2CompleteIrpContext()

NTSTATUS Ext2CompleteIrpContext	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN NTSTATUS	Status
	)

Definition at line 32 of file read.c.

{
    PIRP    Irp = NULL;
    BOOLEAN bPrint;
 
    Irp = IrpContext->Irp;
 
    if (Irp != NULL) {
 
        if (NT_ERROR(Status)) {
            Irp->IoStatus.Information = 0;
        }
 
        Irp->IoStatus.Status = Status;
        bPrint = !IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_REQUEUED);
 
        Ext2CompleteRequest(
            Irp, bPrint, (CCHAR)(NT_SUCCESS(Status)?
                                 IO_DISK_INCREMENT : IO_NO_INCREMENT) );
 
        IrpContext->Irp = NULL;
    }
 
    Ext2FreeIrpContext(IrpContext);
 
    return Status;
}

Referenced by Ex2ProcessMountPoint(), Ex2ProcessUserPerfStat(), Ext2AllowExtendedDasdIo(), Ext2Cleanup(), Ext2Close(), Ext2Create(), Ext2DeleteReparsePoint(), Ext2DeviceControlNormal(), Ext2DirectoryControl(), Ext2DismountVolume(), Ext2DispatchRequest(), Ext2ExceptionHandler(), Ext2FileSystemControl(), Ext2Flush(), Ext2GetReparsePoint(), Ext2GetRetrievalPointerBase(), Ext2GetRetrievalPointers(), Ext2InvalidateVolumes(), Ext2IsVolumeDirty(), Ext2IsVolumeMounted(), Ext2LockControl(), Ext2LockVolume(), Ext2MountVolume(), Ext2NotifyChangeDirectory(), Ext2OplockComplete(), Ext2OplockRequest(), Ext2ProcessUserProperty(), Ext2QueryDirectory(), Ext2QueryEa(), Ext2QueryFileInformation(), Ext2QueryRetrievalPointers(), Ext2QueryVolumeInformation(), Ext2Read(), Ext2ReadComplete(), Ext2ReadFile(), Ext2ReadVolume(), Ext2SetEa(), Ext2SetFileInformation(), Ext2SetReparsePoint(), Ext2SetVolumeInformation(), Ext2ShutDown(), Ext2UnlockVolume(), Ext2UserFsRequest(), Ext2VerifyVolume(), Ext2Write(), Ext2WriteComplete(), Ext2WriteFile(), and Ext2WriteVolume().

◆ Ext2CountExtents()

ULONG Ext2CountExtents ( IN PEXT2_EXTENT Chain )

Definition at line 513 of file memory.c.

{
    ULONG        count = 0;
    PEXT2_EXTENT List = Chain;
 
    while (List) {
        count += 1;
        List = List->Next;
    }
 
    return count;
}

Referenced by Ext2QueryExtentMappings().

◆ Ext2Create()

NTSTATUS Ext2Create ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 1951 of file create.c.

{
    PDEVICE_OBJECT      DeviceObject;
    PIRP                Irp;
    PIO_STACK_LOCATION  IrpSp;
    PEXT2_VCB           Vcb = 0;
    NTSTATUS            Status = STATUS_OBJECT_NAME_NOT_FOUND;
    PEXT2_FCBVCB        Xcb = NULL;
    BOOLEAN             PostIrp = FALSE;
    BOOLEAN             VcbResourceAcquired = FALSE;
 
    DeviceObject = IrpContext->DeviceObject;
    Irp = IrpContext->Irp;
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    Xcb = (PEXT2_FCBVCB) (IrpSp->FileObject->FsContext);
 
    if (IsExt2FsDevice(DeviceObject)) {
 
        DEBUG(DL_INF, ( "Ext2Create: Create on main device object.\n"));
 
        Status = STATUS_SUCCESS;
        Irp->IoStatus.Information = FILE_OPENED;
 
        Ext2CompleteIrpContext(IrpContext, Status);
 
        return Status;
    }
 
    _SEH2_TRY {
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb->Identifier.Type == EXT2VCB);
        IrpSp->FileObject->Vpb = Vcb->Vpb;
 
        if (!IsMounted(Vcb)) {
            DbgBreak();
            if (IsFlagOn(Vcb->Flags, VCB_DEVICE_REMOVED)) {
                Status = STATUS_NO_SUCH_DEVICE;
            } else {
                Status = STATUS_VOLUME_DISMOUNTED;
            }
            _SEH2_LEAVE;
        }
 
        if (!ExAcquireResourceExclusiveLite(
                    &Vcb->MainResource, TRUE)) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
        VcbResourceAcquired = TRUE;
 
        Ext2VerifyVcb(IrpContext, Vcb);
 
        if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED)) {
            Status = STATUS_ACCESS_DENIED;
            if (IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {
                Status = STATUS_VOLUME_DISMOUNTED;
            }
            _SEH2_LEAVE;
        }
 
        if ( ((IrpSp->FileObject->FileName.Length == 0) &&
                (IrpSp->FileObject->RelatedFileObject == NULL)) ||
                (Xcb && Xcb->Identifier.Type == EXT2VCB)  ) {
            Status = Ext2CreateVolume(IrpContext, Vcb);
        } else {
 
            Status = Ext2CreateFile(IrpContext, Vcb, &PostIrp);
        }
 
    } _SEH2_FINALLY {
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress && !PostIrp)  {
            if ( Status == STATUS_PENDING ||
                    Status == STATUS_CANT_WAIT) {
                Status = Ext2QueueRequest(IrpContext);
            } else {
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2CreateFile()

NTSTATUS Ext2CreateFile	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		OUT PBOOLEAN	OpPostIrp
	)

◆ Ext2CreateInode()

NTSTATUS Ext2CreateInode	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_FCB	pParentFcb,
		IN ULONG	Type,
		IN ULONG	FileAttr,
		IN PUNICODE_STRING	FileName
	)

◆ Ext2CreateMdl()

PMDL Ext2CreateMdl	(	IN PVOID	Buffer,
		IN ULONG	Length,
		IN LOCK_OPERATION	Operation
	)

Definition at line 64 of file block.c.

{
    NTSTATUS Status;
    PMDL Mdl = NULL;
 
    ASSERT (Buffer != NULL);
    Mdl = IoAllocateMdl (Buffer, Length, FALSE, FALSE, NULL);
    if (Mdl == NULL) {
        Status = STATUS_INSUFFICIENT_RESOURCES;
    } else {
        _SEH2_TRY {
            if (MmIsNonPagedSystemAddressValid(Buffer)) {
                MmBuildMdlForNonPagedPool(Mdl);
            } else {
                MmProbeAndLockPages(Mdl, KernelMode, op);
            }
            Status = STATUS_SUCCESS;
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
            IoFreeMdl (Mdl);
            Mdl = NULL;
            DbgBreak();
            Status = STATUS_INVALID_USER_BUFFER;
        } _SEH2_END;
    }
    return Mdl;
}

Referenced by get_block_bh_mdl().

◆ Ext2CreateVolume()

NTSTATUS Ext2CreateVolume	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb
	)

◆ Ext2DbgPrintCall()

VOID Ext2DbgPrintCall	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Referenced by Ext2BuildRequest().

◆ Ext2DbgPrintComplete()

VOID Ext2DbgPrintComplete	(	IN PIRP	Irp,
		IN BOOLEAN	bPrint
	)

◆ Ext2DeleteFile()

NTSTATUS Ext2DeleteFile	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_FCB	Fcb,
		PEXT2_MCB	Mcb
	)

Definition at line 1920 of file fileinfo.c.

{
    PEXT2_FCB       Dcb = NULL;
 
    NTSTATUS        Status = STATUS_UNSUCCESSFUL;
 
    BOOLEAN         VcbResourceAcquired = FALSE;
    BOOLEAN         FcbPagingIoAcquired = FALSE;
    BOOLEAN         FcbResourceAcquired = FALSE;
    BOOLEAN         DcbResourceAcquired = FALSE;
 
    LARGE_INTEGER   Size;
    LARGE_INTEGER   SysTime;
 
    BOOLEAN         bFcbLockAcquired = FALSE;
 
    DEBUG(DL_INF, ( "Ext2DeleteFile: File %wZ (%xh) will be deleted!\n",
                    &Mcb->FullName, Mcb->Inode.i_ino));
 
    if (IsFlagOn(Mcb->Flags, MCB_FILE_DELETED)) {
        return STATUS_SUCCESS;
    }
 
    if (!IsMcbSymLink(Mcb) && IsMcbDirectory(Mcb)) {
        if (!Ext2IsDirectoryEmpty(IrpContext, Vcb, Mcb)) {
            return STATUS_DIRECTORY_NOT_EMPTY;
        }
    }
 
    _SEH2_TRY {
 
        Ext2ReferMcb(Mcb);
 
        ExAcquireResourceExclusiveLite(&Vcb->MainResource, TRUE);
        VcbResourceAcquired = TRUE;
 
        ExAcquireResourceExclusiveLite(&Vcb->FcbLock, TRUE);
        bFcbLockAcquired = TRUE;
 
        /* Mcb->Parent could be NULL when working with layered file systems */
        if (Mcb->Parent) {
            Dcb = Mcb->Parent->Fcb;
            if (!Dcb)
                Dcb = Ext2AllocateFcb(Vcb, Mcb->Parent);
        }
        if (Dcb)
            Ext2ReferXcb(&Dcb->ReferenceCount);
 
        if (bFcbLockAcquired) {
            ExReleaseResourceLite(&Vcb->FcbLock);
            bFcbLockAcquired = FALSE;
        }
 
        if (Dcb) {
            DcbResourceAcquired =
                ExAcquireResourceExclusiveLite(&Dcb->MainResource, TRUE);
 
            /* remove it's entry form it's parent */
            Status = Ext2RemoveEntry(IrpContext, Vcb, Dcb, Mcb);
        }
 
        if (NT_SUCCESS(Status)) {
 
            SetFlag(Mcb->Flags, MCB_FILE_DELETED);
            Ext2RemoveMcb(Vcb, Mcb);
 
            if (Fcb) {
                FcbResourceAcquired =
                    ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE);
 
                FcbPagingIoAcquired =
                    ExAcquireResourceExclusiveLite(&Fcb->PagingIoResource, TRUE);
            }
 
            if (DcbResourceAcquired) {
                ExReleaseResourceLite(&Dcb->MainResource);
                DcbResourceAcquired = FALSE;
            }
 
            if (VcbResourceAcquired) {
                ExReleaseResourceLite(&Vcb->MainResource);
                VcbResourceAcquired = FALSE;
            }
 
            if (IsMcbSymLink(Mcb)) {
                if (Mcb->Inode.i_nlink > 0) {
                    Status = STATUS_CANNOT_DELETE;
                    _SEH2_LEAVE;
                }
            } else if (!IsMcbDirectory(Mcb)) {
                if (Mcb->Inode.i_nlink > 0) {
                    _SEH2_LEAVE;
                }
            } else {
                if (Mcb->Inode.i_nlink >= 2) {
                    _SEH2_LEAVE;
                }
            }
 
            if (S_ISLNK(Mcb->Inode.i_mode)) {
 
                /* for symlink, we should do differenctly  */
                if (Mcb->Inode.i_size > EXT2_LINKLEN_IN_INODE) {
                    Size.QuadPart = (LONGLONG)0;
                    Status = Ext2TruncateFile(IrpContext, Vcb, Mcb, &Size);
                }
 
            } else {
 
                /* truncate file size */
                Size.QuadPart = (LONGLONG)0;
                Status = Ext2TruncateFile(IrpContext, Vcb, Mcb, &Size);
 
                /* check file offset mappings */
                DEBUG(DL_EXT, ("Ext2DeleteFile ...: %wZ\n", &Mcb->FullName));
 
                if (Fcb) {
                    Fcb->Header.AllocationSize.QuadPart = Size.QuadPart;
                    if (Fcb->Header.FileSize.QuadPart > Size.QuadPart) {
                        Fcb->Header.FileSize.QuadPart = Size.QuadPart;
                        Fcb->Mcb->Inode.i_size = Size.QuadPart;
                    }
                    if (Fcb->Header.ValidDataLength.QuadPart > Fcb->Header.FileSize.QuadPart) {
                        Fcb->Header.ValidDataLength.QuadPart = Fcb->Header.FileSize.QuadPart;
                    }
                } else if (Mcb) {
                    /* Update the inode's data length . It should be ZERO if succeeds. */
                    if (Mcb->Inode.i_size > (loff_t)Size.QuadPart) {
                        Mcb->Inode.i_size = Size.QuadPart;
                    }
                }
            }
 
            /* set delete time and free the inode */
            KeQuerySystemTime(&SysTime);
            Mcb->Inode.i_nlink = 0;
            Mcb->Inode.i_dtime = Ext2LinuxTime(SysTime);
            Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
            Ext2FreeInode(IrpContext, Vcb, Mcb->Inode.i_ino, Ext2InodeType(Mcb));
        }
 
    } _SEH2_FINALLY {
 
        if (FcbPagingIoAcquired) {
            ExReleaseResourceLite(&Fcb->PagingIoResource);
        }
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (DcbResourceAcquired) {
            ExReleaseResourceLite(&Dcb->MainResource);
        }
 
        if (bFcbLockAcquired) {
            ExReleaseResourceLite(&Vcb->FcbLock);
        }
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (Dcb) {
            Ext2ReleaseFcb(Dcb);
        }
 
        Ext2DerefMcb(Mcb);
    } _SEH2_END;
 
    DEBUG(DL_INF, ( "Ext2DeleteFile: %wZ Succeed... EXT2SB->S_FREE_BLOCKS = %I64xh .\n",
                    &Mcb->FullName, ext3_free_blocks_count(SUPER_BLOCK)));
 
    return Status;
}

Referenced by Ext2Cleanup(), Ext2CreateFile(), Ext2SetLinkInfo(), and Ext2SetRenameInfo().

◆ Ext2DeQueueCloseRequest()

VOID Ext2DeQueueCloseRequest ( IN PVOID Context )

Definition at line 222 of file close.c.

{
    PEXT2_IRP_CONTEXT IrpContext;
 
    IrpContext = (PEXT2_IRP_CONTEXT) Context;
    ASSERT(IrpContext);
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    _SEH2_TRY {
 
        _SEH2_TRY {
 
            FsRtlEnterFileSystem();
            Ext2Close(IrpContext);
 
        } _SEH2_EXCEPT (Ext2ExceptionFilter(IrpContext, _SEH2_GetExceptionInformation())) {
 
            Ext2ExceptionHandler(IrpContext);
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        FsRtlExitFileSystem();
    } _SEH2_END;
}

Referenced by Ext2QueueCloseRequest().

◆ Ext2DeQueueRequest()

VOID Ext2DeQueueRequest ( IN PVOID Context )

Definition at line 190 of file dispatch.c.

{
    PEXT2_IRP_CONTEXT IrpContext;
 
    IrpContext = (PEXT2_IRP_CONTEXT) Context;
 
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    _SEH2_TRY {
 
        _SEH2_TRY {
 
            FsRtlEnterFileSystem();
 
            if (!IrpContext->IsTopLevel) {
                IoSetTopLevelIrp((PIRP) FSRTL_FSP_TOP_LEVEL_IRP);
            }
 
            Ext2DispatchRequest(IrpContext);
 
        } _SEH2_EXCEPT (Ext2ExceptionFilter(IrpContext, _SEH2_GetExceptionInformation())) {
 
            Ext2ExceptionHandler(IrpContext);
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        IoSetTopLevelIrp(NULL);
 
        FsRtlExitFileSystem();
    } _SEH2_END;
}

Referenced by Ext2QueueRequest().

◆ Ext2DestroyExtentChain()

VOID Ext2DestroyExtentChain ( IN PEXT2_EXTENT Chain )

Definition at line 546 of file memory.c.

{
    PEXT2_EXTENT Extent = NULL, List = Chain;
 
    while (List) {
        Extent = List->Next;
        Ext2FreeExtent(List);
        List = Extent;
    }
}

Referenced by Ext2GetRetrievalPointers(), Ext2QueryExtentMappings(), Ext2ReadInode(), Ext2WriteInode(), and Ext2WriteVolume().

◆ Ext2DestroyInode()

VOID Ext2DestroyInode	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_INODE	inode
	)

Definition at line 406 of file memory.c.

{
    ASSERT(inode != NULL);
 
    DEBUG(DL_INF, ("Ext2FreeInode: Inode = %ph.\n", inode));
 
    ExFreeToNPagedLookasideList(&(Vcb->InodeLookasideList), inode);
    DEC_MEM_COUNT(PS_EXT2_INODE, inode, INODE_SIZE);
}

Referenced by ext4_fs_get_xattr_ref(), and ext4_fs_put_xattr_ref().

◆ Ext2DestroyMdl()

VOID Ext2DestroyMdl ( IN PMDL Mdl )

Definition at line 97 of file block.c.

{
    ASSERT (Mdl != NULL);
    while (Mdl) {
        PMDL Next;
        Next = Mdl->Next;
        Mdl->Next = NULL;
        if (IsFlagOn(Mdl->MdlFlags, MDL_PAGES_LOCKED)) {
            MmUnlockPages (Mdl);
        }
        IoFreeMdl (Mdl);
        Mdl = Next;
    }
}

Referenced by free_buffer_head().

◆ Ext2DestroyVcb()

VOID Ext2DestroyVcb ( IN PEXT2_VCB Vcb )

Definition at line 2825 of file memory.c.

{
    ASSERT(Vcb != NULL);
    ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
           (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
    DEBUG(DL_FUN, ("Ext2DestroyVcb ...\n"));
 
    if (Vcb->Volume) {
        Ext2TearDownStream(Vcb);
    }
    ASSERT(NULL == Vcb->Volume);
 
    FsRtlNotifyUninitializeSync(&Vcb->NotifySync);
    Ext2ListExtents(&Vcb->Extents);
    FsRtlUninitializeLargeMcb(&(Vcb->Extents));
 
    Ext2CleanupAllMcbs(Vcb);
 
    Ext2DropBH(Vcb);
 
    if (Vcb->bd.bd_bh_cache)
        kmem_cache_destroy(Vcb->bd.bd_bh_cache);
    ExDeleteResourceLite(&Vcb->bd.bd_bh_lock);
 
    if (Vcb->SuperBlock) {
        Ext2FreePool(Vcb->SuperBlock, EXT2_SB_MAGIC);
        Vcb->SuperBlock = NULL;
    }
 
    if (IsFlagOn(Vcb->Flags, VCB_NEW_VPB)) {
        ASSERT(Vcb->Vpb2 != NULL);
        DEBUG(DL_DBG, ("Ext2DestroyVcb: Vpb2 to be freed: %p\n", Vcb->Vpb2));
        ExFreePoolWithTag(Vcb->Vpb2, TAG_VPB);
        DEC_MEM_COUNT(PS_VPB, Vcb->Vpb2, sizeof(VPB));
        Vcb->Vpb2 = NULL;
    }
 
    ObDereferenceObject(Vcb->TargetDeviceObject);
 
    ExDeleteNPagedLookasideList(&(Vcb->InodeLookasideList));
    ExDeleteResourceLite(&Vcb->FcbLock);
    ExDeleteResourceLite(&Vcb->McbLock);
    ExDeleteResourceLite(&Vcb->MetaInode);
    ExDeleteResourceLite(&Vcb->MetaBlock);
    ExDeleteResourceLite(&Vcb->sbi.s_gd_lock);
    ExDeleteResourceLite(&Vcb->PagingIoResource);
    ExDeleteResourceLite(&Vcb->MainResource);
 
    DEBUG(DL_DBG, ("Ext2DestroyVcb: DevObject=%p Vcb=%p\n", Vcb->DeviceObject, Vcb));
    IoDeleteDevice(Vcb->DeviceObject);
    DEC_MEM_COUNT(PS_VCB, Vcb->DeviceObject, sizeof(EXT2_VCB));
}

Referenced by Ext2CheckDismount(), and Ext2MountVolume().

◆ Ext2DeviceControl()

NTSTATUS Ext2DeviceControl ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 783 of file devctl.c.

{
    PIRP                Irp;
    PIO_STACK_LOCATION  irpSp;
    ULONG               code;
    ULONG               length;
    NTSTATUS            Status;
 
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    Irp = IrpContext->Irp;
 
    irpSp = IoGetCurrentIrpStackLocation(Irp);
 
    code = irpSp->Parameters.DeviceIoControl.IoControlCode;
    length = irpSp->Parameters.DeviceIoControl.OutputBufferLength;
 
    switch (code) {
 
    case IOCTL_APP_VOLUME_PROPERTY:
        Status = Ext2ProcessUserProperty(
                     IrpContext,
                     Irp->AssociatedIrp.SystemBuffer,
                     length
                 );
        break;
 
    case IOCTL_APP_QUERY_PERFSTAT:
        Status = Ex2ProcessUserPerfStat(
                     IrpContext,
                     Irp->AssociatedIrp.SystemBuffer,
                     length
                 );
        break;
 
    case IOCTL_APP_MOUNT_POINT:
        Status = Ex2ProcessMountPoint(
                     IrpContext,
                     Irp->AssociatedIrp.SystemBuffer,
                     length
                 );
        break;
 
#if EXT2_UNLOAD
    case IOCTL_PREPARE_TO_UNLOAD:
        Status = Ext2PrepareToUnload(IrpContext);
        break;
#endif
    default:
        Status = Ext2DeviceControlNormal(IrpContext);
    }
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2DeviceControlNormal()

NTSTATUS Ext2DeviceControlNormal ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 65 of file devctl.c.

{
    PDEVICE_OBJECT  DeviceObject;
    BOOLEAN         CompleteRequest = TRUE;
    NTSTATUS        Status = STATUS_UNSUCCESSFUL;
 
    PEXT2_VCB       Vcb;
 
    PIRP            Irp;
    PIO_STACK_LOCATION IrpSp;
    PIO_STACK_LOCATION NextIrpSp;
 
    PDEVICE_OBJECT  TargetDeviceObject;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        CompleteRequest = TRUE;
 
        DeviceObject = IrpContext->DeviceObject;
 
        if (IsExt2FsDevice(DeviceObject))  {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Irp = IrpContext->Irp;
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
        Vcb = (PEXT2_VCB) IrpSp->FileObject->FsContext;
 
        if (!((Vcb) && (Vcb->Identifier.Type == EXT2VCB) &&
                (Vcb->Identifier.Size == sizeof(EXT2_VCB)))) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        TargetDeviceObject = Vcb->TargetDeviceObject;
 
        //
        // Pass on the IOCTL to the driver below
        //
 
        CompleteRequest = FALSE;
 
        NextIrpSp = IoGetNextIrpStackLocation( Irp );
        *NextIrpSp = *IrpSp;
 
        IoSetCompletionRoutine(
            Irp,
            Ext2DeviceControlCompletion,
            NULL,
            FALSE,
            TRUE,
            TRUE );
 
        Status = IoCallDriver(TargetDeviceObject, Irp);
 
    } _SEH2_FINALLY  {
 
        if (!IrpContext->ExceptionInProgress) {
            if (IrpContext) {
                if (!CompleteRequest) {
                    IrpContext->Irp = NULL;
                }
 
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DeviceControl().

◆ Ext2DirectoryControl()

NTSTATUS Ext2DirectoryControl ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 1236 of file dirctl.c.

{
    NTSTATUS Status;
 
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    switch (IrpContext->MinorFunction) {
 
    case IRP_MN_QUERY_DIRECTORY:
        Status = Ext2QueryDirectory(IrpContext);
        break;
 
    case IRP_MN_NOTIFY_CHANGE_DIRECTORY:
        Status = Ext2NotifyChangeDirectory(IrpContext);
        break;
 
    default:
        Status = STATUS_INVALID_DEVICE_REQUEST;
        Ext2CompleteIrpContext(IrpContext, Status);
    }
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2DiskIoControl()

NTSTATUS Ext2DiskIoControl	(	IN PDEVICE_OBJECT	DeviceOjbect,
		IN ULONG	IoctlCode,
		IN PVOID	InputBuffer,
		IN ULONG	InputBufferSize,
		IN OUT PVOID	OutputBuffer,
		IN OUT PULONG	OutputBufferSize
	)

Definition at line 609 of file block.c.

{
    ULONG           OutBufferSize = 0;
    KEVENT          Event;
    PIRP            Irp;
    IO_STATUS_BLOCK IoStatus;
    NTSTATUS        Status;
 
    ASSERT(DeviceObject != NULL);
 
    if (OutputBufferSize)
    {
        OutBufferSize = *OutputBufferSize;
    }
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    Irp = IoBuildDeviceIoControlRequest(
              IoctlCode,
              DeviceObject,
              InputBuffer,
              InputBufferSize,
              OutputBuffer,
              OutBufferSize,
              FALSE,
              &Event,
              &IoStatus
          );
 
    if (Irp == NULL) {
        DEBUG(DL_ERR, ( "Ext2DiskIoControl: failed to build Irp!\n"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    Status = IoCallDriver(DeviceObject, Irp);
 
    if (Status == STATUS_PENDING)  {
        KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
        Status = IoStatus.Status;
    }
 
    if (OutputBufferSize) {
        *OutputBufferSize = (ULONG)(IoStatus.Information);
    }
 
    return Status;
}

Referenced by Ext2InitializeVcb(), Ext2MountVolume(), Ext2VerifyVcb(), and Ext2VerifyVolume().

◆ Ext2DiskShutDown()

NTSTATUS Ext2DiskShutDown ( PEXT2_VCB Vcb )

Definition at line 748 of file block.c.

{
    PIRP                Irp;
    KEVENT              Event;
 
    NTSTATUS            Status;
    IO_STATUS_BLOCK     IoStatus;
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    Irp = IoBuildSynchronousFsdRequest(IRP_MJ_SHUTDOWN,
                                       Vcb->TargetDeviceObject,
                                       NULL,
                                       0,
                                       NULL,
                                       &Event,
                                       &IoStatus);
 
    if (Irp) {
        Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
 
        if (Status == STATUS_PENDING) {
            KeWaitForSingleObject(&Event,
                                  Executive,
                                  KernelMode,
                                  FALSE,
                                  NULL);
 
            Status = IoStatus.Status;
        }
    } else  {
        Status = IoStatus.Status;
    }
 
    return Status;
}

Referenced by Ext2ShutDown().

◆ Ext2DismountVolume()

NTSTATUS Ext2DismountVolume ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 2521 of file fsctl.c.

{
    PDEVICE_OBJECT  DeviceObject;
    NTSTATUS        Status = STATUS_UNSUCCESSFUL;
    PEXT2_VCB       Vcb = NULL;
    BOOLEAN         VcbResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
 
        ASSERT(Vcb != NULL);
 
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        ASSERT(IsMounted(Vcb));
 
        ExAcquireResourceExclusiveLite(
            &Vcb->MainResource,
            TRUE );
 
        VcbResourceAcquired = TRUE;
 
        if ( IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {
            Status = STATUS_VOLUME_DISMOUNTED;
            _SEH2_LEAVE;
        }
 
        Ext2FlushFiles(IrpContext, Vcb, FALSE);
        Ext2FlushVolume(IrpContext, Vcb, FALSE);
 
        ExReleaseResourceLite(&Vcb->MainResource);
        VcbResourceAcquired = FALSE;
 
        Ext2PurgeVolume(Vcb, TRUE);
        Ext2CheckDismount(IrpContext, Vcb, TRUE);
 
        DEBUG(DL_INF, ( "Ext2Dismount: Volume dismount pending.\n"));
        Status = STATUS_SUCCESS;
 
    } _SEH2_FINALLY {
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            Ext2CompleteIrpContext(IrpContext,  Status);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2UserFsRequest().

◆ Ext2DispatchRequest()

NTSTATUS Ext2DispatchRequest ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 228 of file dispatch.c.

{
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    switch (IrpContext->MajorFunction) {
 
    case IRP_MJ_CREATE:
        return Ext2Create(IrpContext);
 
    case IRP_MJ_CLOSE:
        return Ext2Close(IrpContext);
 
    case IRP_MJ_READ:
        return Ext2Read(IrpContext);
 
    case IRP_MJ_WRITE:
        return Ext2Write(IrpContext);
 
    case IRP_MJ_FLUSH_BUFFERS:
        return Ext2Flush(IrpContext);
 
    case IRP_MJ_QUERY_INFORMATION:
        return Ext2QueryFileInformation(IrpContext);
 
    case IRP_MJ_SET_INFORMATION:
        return Ext2SetFileInformation(IrpContext);
 
    case IRP_MJ_QUERY_VOLUME_INFORMATION:
        return Ext2QueryVolumeInformation(IrpContext);
 
    case IRP_MJ_SET_VOLUME_INFORMATION:
        return Ext2SetVolumeInformation(IrpContext);
 
    case IRP_MJ_DIRECTORY_CONTROL:
        return Ext2DirectoryControl(IrpContext);
 
    case IRP_MJ_FILE_SYSTEM_CONTROL:
        return Ext2FileSystemControl(IrpContext);
 
    case IRP_MJ_DEVICE_CONTROL:
        return Ext2DeviceControl(IrpContext);
 
    case IRP_MJ_LOCK_CONTROL:
        return Ext2LockControl(IrpContext);
 
    case IRP_MJ_CLEANUP:
        return Ext2Cleanup(IrpContext);
 
    case IRP_MJ_SHUTDOWN:
        return Ext2ShutDown(IrpContext);
 
    case IRP_MJ_QUERY_EA:
        return Ext2QueryEa(IrpContext);
 
    case IRP_MJ_SET_EA:
        return Ext2SetEa(IrpContext);
 
#if (_WIN32_WINNT >= 0x0500)
    case IRP_MJ_PNP:
        return Ext2Pnp(IrpContext);
#endif //(_WIN32_WINNT >= 0x0500)
    default:
        DEBUG(DL_ERR, ( "Ext2DispatchRequest: Unexpected major function: %xh\n",
                        IrpContext->MajorFunction));
 
        Ext2CompleteIrpContext(IrpContext, STATUS_DRIVER_INTERNAL_ERROR);
 
        return STATUS_DRIVER_INTERNAL_ERROR;
    }
}

Referenced by Ext2BuildRequest(), and Ext2DeQueueRequest().

◆ 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().

◆ Ext2ExceptionFilter()

NTSTATUS Ext2ExceptionFilter	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXCEPTION_POINTERS	ExceptionPointer
	)

Definition at line 21 of file except.c.

{
    NTSTATUS Status = EXCEPTION_EXECUTE_HANDLER;
    NTSTATUS ExceptionCode;
    PEXCEPTION_RECORD ExceptRecord;
 
    ExceptRecord = ExceptionPointer->ExceptionRecord;
    ExceptionCode = ExceptRecord->ExceptionCode;
 
    DbgPrint("-------------------------------------------------------------\n");
    DbgPrint("Exception happends in Ext2Fsd (code %xh):\n", ExceptionCode);
    DbgPrint(".exr %p;.cxr %p;\n", ExceptionPointer->ExceptionRecord,
             ExceptionPointer->ContextRecord);
    DbgPrint("-------------------------------------------------------------\n");
 
    DbgBreak();
 
    //
    // Check IrpContext is valid or not
    //
 
    if (IrpContext) {
        if ((IrpContext->Identifier.Type != EXT2ICX) ||
            (IrpContext->Identifier.Size != sizeof(EXT2_IRP_CONTEXT))) {
            DbgBreak();
            IrpContext = NULL;
        } else if (IrpContext->DeviceObject) {
            PEXT2_VCB Vcb = NULL;
            Vcb = (PEXT2_VCB) IrpContext->DeviceObject->DeviceExtension;
            if (NULL == Vcb) {
                Status = EXCEPTION_EXECUTE_HANDLER;
            } else {
                if (Vcb->Identifier.Type == EXT2VCB && !IsMounted(Vcb)) {
                    Status = EXCEPTION_EXECUTE_HANDLER;
                }
            }
        }
    } else {
        if (FsRtlIsNtstatusExpected(ExceptionCode)) {
            return EXCEPTION_EXECUTE_HANDLER;
        } else {
            Ext2BugCheck( EXT2_BUGCHK_EXCEPT, (ULONG_PTR)ExceptRecord,
                          (ULONG_PTR)ExceptionPointer->ContextRecord,
                          (ULONG_PTR)ExceptRecord->ExceptionAddress );
        }
    }
 
    if (IrpContext) {
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
    }
 
    if ( Status == EXCEPTION_EXECUTE_HANDLER ||
         FsRtlIsNtstatusExpected(ExceptionCode)) {
        //
        // If the exception is expected execute our handler
        //
 
        DEBUG(DL_ERR, ( "Ext2ExceptionFilter: Catching exception %xh\n",
                         ExceptionCode));
 
        Status = EXCEPTION_EXECUTE_HANDLER;
 
        if (IrpContext) {
            IrpContext->ExceptionInProgress = TRUE;
            IrpContext->ExceptionCode = ExceptionCode;
        }
 
    } else  {
 
        //
        // Continue search for an higher level exception handler
        //
 
        DEBUG(DL_ERR, ( "Ext2ExceptionFilter: Passing on exception %#x\n",
                        ExceptionCode));
 
        Status = EXCEPTION_CONTINUE_SEARCH;
 
        if (IrpContext) {
            Ext2FreeIrpContext(IrpContext);
        }
    }
 
    return Status;
}

Referenced by Ext2BuildRequest(), Ext2DeQueueCloseRequest(), and Ext2DeQueueRequest().

◆ Ext2ExceptionHandler()

NTSTATUS Ext2ExceptionHandler ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 112 of file except.c.

{
    NTSTATUS Status;
 
    if (IrpContext) {
 
        if ( (IrpContext->Identifier.Type != EXT2ICX) ||
                (IrpContext->Identifier.Size != sizeof(EXT2_IRP_CONTEXT))) {
            DbgBreak();
            return STATUS_UNSUCCESSFUL;
        }
 
        Status = IrpContext->ExceptionCode;
 
        if (IrpContext->Irp) {
 
            //
            // Check if this error is a result of user actions
            //
 
            PEXT2_VCB  Vcb = NULL;
            PIRP Irp = IrpContext->Irp;
            PIO_STACK_LOCATION IrpSp;
 
            IrpSp = IoGetCurrentIrpStackLocation(Irp);
            Vcb = (PEXT2_VCB) IrpContext->DeviceObject->DeviceExtension;
 
            if (NULL == Vcb) {
                Status = STATUS_INVALID_PARAMETER;
            } else if (Vcb->Identifier.Type != EXT2VCB) {
                Status = STATUS_INVALID_PARAMETER;
            } else if (!IsMounted(Vcb)) {
                if (IsFlagOn(Vcb->Flags, VCB_DEVICE_REMOVED)) {
                    Status = STATUS_NO_SUCH_DEVICE;
                } else {
                    Status = STATUS_VOLUME_DISMOUNTED;
                }
            } else {
 
                /* queue it again if our request is at top level */
                if (IrpContext->IsTopLevel &&
                        ((Status == STATUS_CANT_WAIT) ||
                         ((Status == STATUS_VERIFY_REQUIRED) &&
                          (KeGetCurrentIrql() >= APC_LEVEL)))) {
 
                    Status = Ext2QueueRequest(IrpContext);
                }
            }
 
            if (Status == STATUS_PENDING) {
                goto errorout;
            }
 
            Irp->IoStatus.Status = Status;
 
            if (IoIsErrorUserInduced(Status)) {
 
                //
                //  Now we will generate a pop-up to user
                //
 
                PDEVICE_OBJECT RealDevice;
                PVPB           Vpb = NULL;
                PETHREAD       Thread;
 
                if (IrpSp->FileObject != NULL) {
                    Vpb = IrpSp->FileObject->Vpb;
                }
 
                //
                // Get the initial thread
                //
 
                Thread = Irp->Tail.Overlay.Thread;
                RealDevice = IoGetDeviceToVerify( Thread );
 
                if (RealDevice == NULL) {
                    //
                    // Get current thread
                    //
 
                    Thread = PsGetCurrentThread();
                    RealDevice = IoGetDeviceToVerify( Thread );
 
                    ASSERT( RealDevice != NULL );
                }
 
                Status =  IrpContext->ExceptionCode;
 
                if (RealDevice != NULL) {
 
                    if (IrpContext->ExceptionCode == STATUS_VERIFY_REQUIRED) {
 
                        Status = IoVerifyVolume (RealDevice, FALSE);
 
                        ExAcquireResourceSharedLite(&Vcb->MainResource, TRUE);
                        if (NT_SUCCESS(Status) && (!IsMounted(Vcb) ||
                                                   IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING))) {
                            Status = STATUS_WRONG_VOLUME;
                        }
                        ExReleaseResourceLite(&Vcb->MainResource);
 
                        if (Ext2CheckDismount(IrpContext, Vcb, FALSE)) {
                            Ext2CompleteIrpContext( IrpContext, STATUS_VOLUME_DISMOUNTED);
                            Status = STATUS_VOLUME_DISMOUNTED;
                            Irp = NULL;
                            goto errorout;
                        }
 
                        if ( (IrpContext->MajorFunction == IRP_MJ_CREATE) &&
                                (IrpContext->FileObject->RelatedFileObject == NULL) &&
                                ((Status == STATUS_SUCCESS) || (Status == STATUS_WRONG_VOLUME))) {
 
                            Irp->IoStatus.Information = IO_REMOUNT;
 
                            Ext2CompleteIrpContext( IrpContext, STATUS_REPARSE);
                            Status = STATUS_REPARSE;
                            Irp = NULL;
                        }
 
                        if (Irp) {
 
                            if (!NT_SUCCESS(Status)) {
                                IoSetHardErrorOrVerifyDevice(Irp, RealDevice);
                                ASSERT (STATUS_VERIFY_REQUIRED != Status);
                                Ext2NormalizeAndRaiseStatus(IrpContext, Status);
                            }
 
                            Status = Ext2QueueRequest(IrpContext);
                        }
 
                        goto errorout;
 
                    } else {
 
                        Status = STATUS_PENDING;
 
                        IoMarkIrpPending( Irp );
                        IoRaiseHardError( Irp, Vpb, RealDevice );
                        IoSetDeviceToVerify( Thread, NULL );
                        goto release_context;
                    }
                }
            }
 
            Ext2CompleteRequest(Irp, FALSE, IO_NO_INCREMENT);
        }
 
release_context:
 
        Ext2FreeIrpContext(IrpContext);
 
    } else {
 
        Status = STATUS_INVALID_PARAMETER;
    }
 
errorout:
 
    return Status;
}

Referenced by Ext2BuildRequest(), Ext2DeQueueCloseRequest(), and Ext2DeQueueRequest().

◆ Ext2ExpandExtent()

NTSTATUS Ext2ExpandExtent	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb,
		ULONG	Start,
		ULONG	End,
		PLARGE_INTEGER	Size
	)

Definition at line 151 of file extents.c.

{
    ULONG Count = 0, Number = 0, Block = 0;
    NTSTATUS Status = STATUS_SUCCESS;
 
    if (End <= Start)
        return Status;
 
    while (End > Start + Count) {
 
        Number = End - Start - Count;
        Status = Ext2DoExtentExpand(IrpContext, Vcb, Mcb, Start + Count,
                                    &Block, &Number);
        if (!NT_SUCCESS(Status)) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
        if (Number == 0) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            break;
        }
 
        if (Block && IsZoneInited(Mcb)) {
            if (!Ext2AddBlockExtent(Vcb, Mcb, Start + Count, Block, Number)) {
                DbgBreak();
                ClearFlag(Mcb->Flags, MCB_ZONE_INITED);
                Ext2ClearAllExtents(&Mcb->Extents);
            }
        }
        Count += Number;
    }
 
    Size->QuadPart = ((LONGLONG)(Start + Count)) << BLOCK_BITS;
 
    /* save inode whatever it succeeds to expand or not */
    Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
 
    return Status;
}

Referenced by Ext2ExpandFile().

◆ Ext2ExpandFile()

NTSTATUS Ext2ExpandFile	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb,
		PLARGE_INTEGER	Size
	)

Definition at line 1152 of file fileinfo.c.

{
    NTSTATUS status = STATUS_SUCCESS;
    ULONG    Start = 0;
    ULONG    End = 0;
 
    Start = (ULONG)((Mcb->Inode.i_size + BLOCK_SIZE - 1) >> BLOCK_BITS);
    End = (ULONG)((Size->QuadPart + BLOCK_SIZE - 1) >> BLOCK_BITS);
 
    /* it's a truncate operation, not expanding */
    if (Start >= End) {
        Size->QuadPart = ((LONGLONG) Start) << BLOCK_BITS;
        return STATUS_SUCCESS;
    }
 
    /* ignore special files */
    if (IsMcbSpecialFile(Mcb)) {
        return STATUS_INVALID_DEVICE_REQUEST;
    }
 
    /* expandind file extents */
    if (INODE_HAS_EXTENT(&Mcb->Inode)) {
 
        status = Ext2ExpandExtent(IrpContext, Vcb, Mcb, Start, End, Size);
 
    } else {
 
        BOOLEAN do_expand;
 
#if EXT2_PRE_ALLOCATION_SUPPORT
        do_expand = TRUE;
#else
        do_expand = (IrpContext->MajorFunction == IRP_MJ_WRITE) ||
                    IsMcbDirectory(Mcb);
#endif
        if (!do_expand)
            goto errorout;
 
        status = Ext2ExpandIndirect(IrpContext, Vcb, Mcb, Start, End, Size);
    }
 
errorout:
    return status;
}

Referenced by Ext2CreateFile(), Ext2SetFileInformation(), Ext2SupersedeOrOverWriteFile(), Ext2WriteFile(), and ext3_append().

◆ Ext2ExpandIndirect()

NTSTATUS Ext2ExpandIndirect	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb,
		ULONG	Start,
		ULONG	End,
		PLARGE_INTEGER	Size
	)

Definition at line 948 of file indirect.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    ULONG    Layer = 0;
    ULONG    Extra = 0;
    ULONG    Hint = 0;
    ULONG    Slot = 0;
    ULONG    Base = 0;
 
    Extra = End - Start;
 
    /* exceeds the biggest file size (indirect) */
    if (End > Vcb->max_data_blocks) {
        return STATUS_INVALID_PARAMETER;
    }
 
    for (Layer = 0; Layer < EXT2_BLOCK_TYPES && Extra; Layer++) {
 
        if (Start >= Vcb->max_blocks_per_layer[Layer]) {
 
            Base  += Vcb->max_blocks_per_layer[Layer];
            Start -= Vcb->max_blocks_per_layer[Layer];
 
        } else {
 
            /* get the slot in i_block array */
            if (Layer == 0) {
                Base = Slot = Start;
            } else {
                Slot = Layer + EXT2_NDIR_BLOCKS - 1;
            }
 
            /* set block hint to avoid fragments */
            if (Hint == 0) {
                if (Mcb->Inode.i_block[Slot] != 0) {
                    Hint = Mcb->Inode.i_block[Slot];
                } else if (Slot > 1) {
                    Hint = Mcb->Inode.i_block[Slot-1];
                }
            }
 
            /* now expand this slot */
            Status = Ext2ExpandBlock(
                         IrpContext,
                         Vcb,
                         Mcb,
                         Base,
                         Layer,
                         Start,
                         (Layer == 0) ? (Vcb->max_blocks_per_layer[Layer] - Start) : 1,
#ifdef __REACTOS__
                         (PULONG)&Mcb->Inode.i_block[Slot],
#else
                         &Mcb->Inode.i_block[Slot],
#endif
                         &Hint,
                         &Extra
                     );
            if (!NT_SUCCESS(Status)) {
                break;
            }
 
            Start = 0;
            if (Layer == 0) {
                Base = 0;
            }
            Base += Vcb->max_blocks_per_layer[Layer];
        }
    }
 
    Size->QuadPart = ((LONGLONG)(End - Extra)) << BLOCK_BITS;
 
    /* save inode whatever it succeeds to expand or not */
    Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
 
    return Status;
}

Referenced by Ext2ExpandFile().

◆ Ext2FastIoCheckIfPossible()

BOOLEAN Ext2FastIoCheckIfPossible	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN BOOLEAN	Wait,
		IN ULONG	LockKey,
		IN BOOLEAN	CheckForReadOperation,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 64 of file fastio.c.

{
    BOOLEAN          bPossible = FastIoIsNotPossible;
    PEXT2_FCB        Fcb;
    PEXT2_CCB        Ccb;
    LARGE_INTEGER    lLength;
 
    lLength.QuadPart = Length;
 
    _SEH2_TRY {
 
        FsRtlEnterFileSystem();
 
        _SEH2_TRY {
 
            if (IsExt2FsDevice(DeviceObject)) {
                _SEH2_LEAVE;
            }
 
            Fcb = (PEXT2_FCB) FileObject->FsContext;
            if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
                _SEH2_LEAVE;
            }
 
            ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
                   (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
            /* do nothing if target fie was deleted */
            if (FlagOn(Fcb->Flags, FCB_DELETE_PENDING)) {
                _SEH2_LEAVE;
            }
 
            if (IsDirectory(Fcb)) {
                _SEH2_LEAVE;
            }
 
            Ccb = (PEXT2_CCB) FileObject->FsContext2;
            if (Ccb == NULL) {
                _SEH2_LEAVE;
            }
 
            if (CheckForReadOperation) {
 
                bPossible = FsRtlFastCheckLockForRead(
                                &Fcb->FileLockAnchor,
                                FileOffset,
                                &lLength,
                                LockKey,
                                FileObject,
                                PsGetCurrentProcess());
 
            } else {
 
                if (!IsVcbReadOnly(Fcb->Vcb)) {
                    bPossible = FsRtlFastCheckLockForWrite(
                                    &Fcb->FileLockAnchor,
                                    FileOffset,
                                    &lLength,
                                    LockKey,
                                    FileObject,
                                    PsGetCurrentProcess());
                }
            }
 
#if EXT2_DEBUG
            DEBUG(DL_INF, ("Ext2FastIIOCheckPossible: %s %s %wZ\n",
                           Ext2GetCurrentProcessName(),
                           "FASTIO_CHECK_IF_POSSIBLE",
                           &Fcb->Mcb->FullName
                          ));
 
            DEBUG(DL_INF, (
                      "Ext2FastIIOCheckPossible: Offset: %I64xg Length: %xh Key: %u %s %s\n",
                      FileOffset->QuadPart,
                      Length,
                      LockKey,
                      (CheckForReadOperation ? "CheckForReadOperation:" :
                       "CheckForWriteOperation:"),
                      (bPossible ? "Succeeded" : "Failed")));
#endif
 
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
            bPossible = FastIoIsNotPossible;
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
    return bPossible;
}

Referenced by DriverEntry().

◆ Ext2FastIoLock()

BOOLEAN Ext2FastIoLock	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN PLARGE_INTEGER	Length,
		IN PEPROCESS	Process,
		IN ULONG	Key,
		IN BOOLEAN	FailImmediately,
		IN BOOLEAN	ExclusiveLock,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 517 of file fastio.c.

{
    BOOLEAN     Status = FALSE;
    PEXT2_FCB   Fcb;
 
    _SEH2_TRY {
 
        FsRtlEnterFileSystem();
 
        _SEH2_TRY {
 
            if (IsExt2FsDevice(DeviceObject)) {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                _SEH2_LEAVE;
            }
 
            Fcb = (PEXT2_FCB) FileObject->FsContext;
            if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
                   (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
            if (IsDirectory(Fcb)) {
                DbgBreak();
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
#if EXT2_DEBUG
            DEBUG(DL_INF, (
                      "Ext2FastIoLock: %s %s %wZ\n",
                      Ext2GetCurrentProcessName(),
                      "FASTIO_LOCK",
                      &Fcb->Mcb->FullName        ));
 
            DEBUG(DL_INF, (
                      "Ext2FastIoLock: Offset: %I64xh Length: %I64xh Key: %u %s%s\n",
                      FileOffset->QuadPart,
                      Length->QuadPart,
                      Key,
                      (FailImmediately ? "FailImmediately " : ""),
                      (ExclusiveLock ? "ExclusiveLock " : "") ));
#endif
 
            if (!FsRtlOplockIsFastIoPossible(&Fcb->Oplock)) {
                _SEH2_LEAVE;
            }
 
            Status = FsRtlFastLock(
                         &Fcb->FileLockAnchor,
                         FileObject,
                         FileOffset,
                         Length,
                         Process,
                         Key,
                         FailImmediately,
                         ExclusiveLock,
                         IoStatus,
                         NULL,
                         FALSE);
 
            if (Status) {
                Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
            }
 
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
            IoStatus->Status = _SEH2_GetExceptionCode();
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
#if EXT2_DEBUG
    if (Status == FALSE) {
        DEBUG(DL_ERR, (
                  "Ext2FastIoLock: %s %s *** Status: FALSE ***\n",
                  (PUCHAR) Process + ProcessNameOffset,
                  "FASTIO_LOCK"
              ));
    } else if (IoStatus->Status != STATUS_SUCCESS) {
        DEBUG(DL_ERR, (
                  "Ext2FastIoLock: %s %s *** Status: %s (%#x) ***\n",
                  (PUCHAR) Process + ProcessNameOffset,
                  "FASTIO_LOCK",
                  Ext2NtStatusToString(IoStatus->Status),
                  IoStatus->Status
              ));
    }
#endif
 
    return Status;
}

Referenced by DriverEntry().

◆ Ext2FastIoQueryBasicInfo()

BOOLEAN Ext2FastIoQueryBasicInfo	(	IN PFILE_OBJECT	FileObject,
		IN BOOLEAN	Wait,
		OUT PFILE_BASIC_INFORMATION	Buffer,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 280 of file fastio.c.

{
    PEXT2_FCB   Fcb = NULL;
    PEXT2_CCB   Ccb = NULL;
    PEXT2_MCB   Mcb = NULL;
    BOOLEAN     Status = FALSE;
    BOOLEAN     FcbMainResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        FsRtlEnterFileSystem();
 
        _SEH2_TRY {
 
            if (IsExt2FsDevice(DeviceObject)) {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                _SEH2_LEAVE;
            }
 
            Fcb = (PEXT2_FCB) FileObject->FsContext;
            if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
            Ccb = (PEXT2_CCB) FileObject->FsContext2;
            Mcb = Fcb->Mcb;
            ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
                   (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
#if EXT2_DEBUG
            DEBUG(DL_INF, (
                      "Ext2FastIoQueryBasicInfo: %s %s %wZ\n",
                      Ext2GetCurrentProcessName(),
                      "FASTIO_QUERY_BASIC_INFO",
                      &Fcb->Mcb->FullName
                  ));
#endif
            if (!IsFlagOn(Fcb->Flags, FCB_PAGE_FILE)) {
                if (!ExAcquireResourceSharedLite(
                            &Fcb->MainResource,
                            Wait)) {
                    _SEH2_LEAVE;
                }
                FcbMainResourceAcquired = TRUE;
            }
 
            RtlZeroMemory(Buffer, sizeof(FILE_BASIC_INFORMATION));
 
            /*
            typedef struct _FILE_BASIC_INFORMATION {
            LARGE_INTEGER   CreationTime;
            LARGE_INTEGER   LastAccessTime;
            LARGE_INTEGER   LastWriteTime;
            LARGE_INTEGER   ChangeTime;
            ULONG           FileAttributes;
            } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
            */
 
            Buffer->CreationTime = Mcb->CreationTime;
            Buffer->LastAccessTime = Mcb->LastAccessTime;
            Buffer->LastWriteTime = Mcb->LastWriteTime;
            Buffer->ChangeTime = Mcb->ChangeTime;
            Buffer->FileAttributes = Mcb->FileAttr;
            if (Buffer->FileAttributes == 0) {
                Buffer->FileAttributes = FILE_ATTRIBUTE_NORMAL;
            }
 
            IoStatus->Information = sizeof(FILE_BASIC_INFORMATION);
            IoStatus->Status = STATUS_SUCCESS;
 
            Status =  TRUE;
 
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
            IoStatus->Status = _SEH2_GetExceptionCode();
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        if (FcbMainResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
#if EXT2_DEBUG
 
    if (Status == FALSE) {
 
        DEBUG(DL_ERR, ("Ext2FastIoQueryBasicInfo: %s %s Status: FALSE ***\n",
                       Ext2GetCurrentProcessName(),
                       "FASTIO_QUERY_BASIC_INFO"));
 
    } else if (IoStatus->Status != STATUS_SUCCESS) {
 
        DEBUG(DL_ERR, (
                  "Ext2FastIoQueryBasicInfo: %s %s Status: %#x ***\n",
                  Ext2FastIoQueryBasicInfo,
                  "FASTIO_QUERY_BASIC_INFO",
                  IoStatus->Status
              ));
    }
#endif
 
    return Status;
}

Referenced by DriverEntry(), and Ext2FastIoQueryBasicInfo().

◆ Ext2FastIoQueryNetworkOpenInfo()

BOOLEAN Ext2FastIoQueryNetworkOpenInfo	(	IN PFILE_OBJECT	FileObject,
		IN BOOLEAN	Wait,
		OUT PFILE_NETWORK_OPEN_INFORMATION	Buffer,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Referenced by DriverEntry().

◆ Ext2FastIoQueryStandardInfo()

BOOLEAN Ext2FastIoQueryStandardInfo	(	IN PFILE_OBJECT	FileObject,
		IN BOOLEAN	Wait,
		OUT PFILE_STANDARD_INFORMATION	Buffer,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 396 of file fastio.c.

{
 
    BOOLEAN     Status = FALSE;
    PEXT2_VCB   Vcb = NULL;
    PEXT2_FCB   Fcb = NULL;
    BOOLEAN     FcbMainResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        FsRtlEnterFileSystem();
 
        _SEH2_TRY {
 
            if (IsExt2FsDevice(DeviceObject)) {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                _SEH2_LEAVE;
            }
 
            Fcb = (PEXT2_FCB) FileObject->FsContext;
            if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB)  {
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
                   (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
#if EXT2_DEBUG
            DEBUG(DL_INF, (
                      "Ext2FastIoQueryStandardInfo: %s %s %wZ\n",
                      Ext2GetCurrentProcessName(),
                      "FASTIO_QUERY_STANDARD_INFO",
                      &Fcb->Mcb->FullName ));
#endif
            Vcb = Fcb->Vcb;
 
            if (!IsFlagOn(Fcb->Flags, FCB_PAGE_FILE)) {
                if (!ExAcquireResourceSharedLite(
                            &Fcb->MainResource,
                            Wait        )) {
                    _SEH2_LEAVE;
                }
                FcbMainResourceAcquired = TRUE;
            }
 
            RtlZeroMemory(Buffer, sizeof(FILE_STANDARD_INFORMATION));
 
            /*
            typedef struct _FILE_STANDARD_INFORMATION {
            LARGE_INTEGER   AllocationSize;
            LARGE_INTEGER   EndOfFile;
            ULONG           NumberOfLinks;
            BOOLEAN         DeletePending;
            BOOLEAN         Directory;
            } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
            */
 
            Buffer->NumberOfLinks = Fcb->Inode->i_nlink;
            Buffer->DeletePending = IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING);
 
            if (IsDirectory(Fcb)) {
                Buffer->Directory = IsDirectory(Fcb);
                Buffer->AllocationSize.QuadPart = 0;
                Buffer->EndOfFile.QuadPart = 0;
            } else {
                Buffer->Directory = FALSE;
                Buffer->AllocationSize = Fcb->Header.AllocationSize;
                Buffer->EndOfFile = Fcb->Header.FileSize;
            }
 
            IoStatus->Information = sizeof(FILE_STANDARD_INFORMATION);
            IoStatus->Status = STATUS_SUCCESS;
#if EXT2_DEBUG
            DEBUG(DL_INF, ( "Ext2FastIoQueryStandInfo: AllocatieonSize = %I64xh FileSize = %I64xh\n",
                            Buffer->AllocationSize.QuadPart, Buffer->EndOfFile.QuadPart));
#endif
            Status =  TRUE;
 
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
            IoStatus->Status = _SEH2_GetExceptionCode();
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        if (FcbMainResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
#if EXT2_DEBUG
    if (Status == FALSE) {
        DEBUG(DL_INF, (
                  "Ext2FastIoQueryStandardInfo: %s %s Status: FALSE ***\n",
                  Ext2GetCurrentProcessName(),
                  "FASTIO_QUERY_STANDARD_INFO"            ));
    } else if (IoStatus->Status != STATUS_SUCCESS) {
        DEBUG(DL_INF, (
                  "Ext2FastIoQueryStandardInfo: %s %s Status: %#x ***\n",
                  Ext2GetCurrentProcessName(),
                  "FASTIO_QUERY_STANDARD_INFO",
                  IoStatus->Status            ));
    }
#endif
 
    return Status;
}

Referenced by DriverEntry().

◆ Ext2FastIoRead()

BOOLEAN Ext2FastIoRead	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN BOOLEAN	Wait,
		IN ULONG	LockKey,
		OUT PVOID	Buffer,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 172 of file fastio.c.

{
    PEXT2_FCB    Fcb;
    BOOLEAN      Status = FALSE;
 
    Fcb = (PEXT2_FCB) FileObject->FsContext;
    if (Fcb == NULL) {
        return FALSE;
    }
 
    ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
           (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
    Status = FsRtlCopyRead (
                 FileObject, FileOffset, Length, Wait,
                 LockKey, Buffer, IoStatus, DeviceObject);
 
    DEBUG(DL_IO, ("Ext2FastIoRead: %wZ Offset: %I64xh Length: %xh Key: %u Status: %d\n",
                  &Fcb->Mcb->ShortName, FileOffset->QuadPart, Length, LockKey, Status));
 
    return Status;
}

Referenced by DriverEntry().

◆ Ext2FastIoUnlockAll()

BOOLEAN Ext2FastIoUnlockAll	(	IN PFILE_OBJECT	FileObject,
		IN PEPROCESS	Process,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 736 of file fastio.c.

{
    BOOLEAN     Status = FALSE;
    PEXT2_FCB   Fcb;
 
    _SEH2_TRY {
 
        FsRtlEnterFileSystem();
 
        _SEH2_TRY {
 
            if (IsExt2FsDevice(DeviceObject)) {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                _SEH2_LEAVE;
            }
 
            Fcb = (PEXT2_FCB) FileObject->FsContext;
            if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
                DbgBreak();
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
                   (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
            if (IsDirectory(Fcb)) {
                DbgBreak();
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
#if EXT2_DEBUG
            DEBUG(DL_INF, (
                      "Ext2FastIoUnlockSingle: %s %s %wZ\n",
                      (PUCHAR) Process + ProcessNameOffset,
                      "FASTIO_UNLOCK_ALL",
                      &Fcb->Mcb->FullName
                  ));
#endif
 
            if (!FsRtlOplockIsFastIoPossible(&Fcb->Oplock)) {
                _SEH2_LEAVE;
            }
 
            IoStatus->Status = FsRtlFastUnlockAll(
                                   &Fcb->FileLockAnchor,
                                   FileObject,
                                   Process,
                                   NULL        );
 
            IoStatus->Information = 0;
            Status =  TRUE;
 
            Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
 
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
            IoStatus->Status = _SEH2_GetExceptionCode();
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
#if EXT2_DEBUG
    if (Status == FALSE) {
 
        DEBUG(DL_ERR, (
                  "Ext2FastIoUnlockSingle: %s %s *** Status: FALSE ***\n",
                  (PUCHAR) Process + ProcessNameOffset,
                  "FASTIO_UNLOCK_ALL"
              ));
    } else if (IoStatus->Status != STATUS_SUCCESS) {
        DEBUG(DL_ERR, (
                  "Ext2FastIoUnlockSingle: %s %s *** Status: %s (%#x) ***\n",
                  (PUCHAR) Process + ProcessNameOffset,
                  "FASTIO_UNLOCK_ALL",
                  Ext2NtStatusToString(IoStatus->Status),
                  IoStatus->Status
              ));
    }
#endif
 
    return Status;
}

Referenced by DriverEntry().

◆ Ext2FastIoUnlockAllByKey()

BOOLEAN Ext2FastIoUnlockAllByKey	(	IN PFILE_OBJECT	FileObject,
		IN PEPROCESS	Process,
		IN ULONG	Key,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 831 of file fastio.c.

{
    BOOLEAN     Status = FALSE;
    PEXT2_FCB   Fcb;
 
    _SEH2_TRY {
 
        FsRtlEnterFileSystem();
 
        _SEH2_TRY {
 
            if (IsExt2FsDevice(DeviceObject)) {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                _SEH2_LEAVE;
            }
 
            Fcb = (PEXT2_FCB) FileObject->FsContext;
            if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
                DbgBreak();
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
                   (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
            if (IsDirectory(Fcb)) {
                DbgBreak();
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
#if EXT2_DEBUG
            DEBUG(DL_INF, (
                      "Ext2FastIoUnlockAllByKey: %s %s %wZ\n",
                      (PUCHAR) Process + ProcessNameOffset,
                      "FASTIO_UNLOCK_ALL_BY_KEY",
                      &Fcb->Mcb->FullName
                  ));
 
            DEBUG(DL_INF, (
                      "Ext2FastIoUnlockAllByKey: Key: %u\n",
                      Key
                  ));
#endif
 
            if (!FsRtlOplockIsFastIoPossible(&Fcb->Oplock)) {
                _SEH2_LEAVE;
            }
 
            IoStatus->Status = FsRtlFastUnlockAllByKey(
                                   &Fcb->FileLockAnchor,
                                   FileObject,
                                   Process,
                                   Key,
                                   NULL
                               );
 
            IoStatus->Information = 0;
            Status =  TRUE;
 
            Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
 
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
            IoStatus->Status = _SEH2_GetExceptionCode();
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
#if EXT2_DEBUG
    if (Status == FALSE) {
 
        DEBUG(DL_ERR, (
                  "Ext2FastIoUnlockAllByKey: %s %s *** Status: FALSE ***\n",
                  (PUCHAR) Process + ProcessNameOffset,
                  "FASTIO_UNLOCK_ALL_BY_KEY"
              ));
    } else if (IoStatus->Status != STATUS_SUCCESS) {
 
        DEBUG(DL_ERR, (
                  "Ext2FastIoUnlockAllByKey: %s %s *** Status: %s (%#x) ***\n",
                  (PUCHAR) Process + ProcessNameOffset,
                  "FASTIO_UNLOCK_ALL_BY_KEY",
                  Ext2NtStatusToString(IoStatus->Status),
                  IoStatus->Status
              ));
    }
#endif
 
    return Status;
}

Referenced by DriverEntry().

◆ Ext2FastIoUnlockSingle()

BOOLEAN Ext2FastIoUnlockSingle	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN PLARGE_INTEGER	Length,
		IN PEPROCESS	Process,
		IN ULONG	Key,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 629 of file fastio.c.

{
    BOOLEAN     Status = FALSE;
    PEXT2_FCB   Fcb;
 
    _SEH2_TRY {
 
        FsRtlEnterFileSystem();
 
        _SEH2_TRY {
 
            if (IsExt2FsDevice(DeviceObject)) {
                IoStatus->Status = STATUS_INVALID_DEVICE_REQUEST;
                _SEH2_LEAVE;
            }
 
            Fcb = (PEXT2_FCB) FileObject->FsContext;
            if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
                DbgBreak();
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
                   (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
            if (IsDirectory(Fcb)) {
                DbgBreak();
                IoStatus->Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
#if EXT2_DEBUG
            DEBUG(DL_INF, (
                      "Ext2FastIoUnlockSingle: %s %s %wZ\n",
                      (PUCHAR) Process + ProcessNameOffset,
                      "FASTIO_UNLOCK_SINGLE",
                      &Fcb->Mcb->FullName        ));
 
            DEBUG(DL_INF, (
                      "Ext2FastIoUnlockSingle: Offset: %I64xh Length: %I64xh Key: %u\n",
                      FileOffset->QuadPart,
                      Length->QuadPart,
                      Key     ));
#endif
 
            if (!FsRtlOplockIsFastIoPossible(&Fcb->Oplock)) {
                _SEH2_LEAVE;
            }
 
            IoStatus->Status = FsRtlFastUnlockSingle(
                                   &Fcb->FileLockAnchor,
                                   FileObject,
                                   FileOffset,
                                   Length,
                                   Process,
                                   Key,
                                   NULL,
                                   FALSE);
 
            IoStatus->Information = 0;
            Status =  TRUE;
 
            Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
 
        } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
            IoStatus->Status = _SEH2_GetExceptionCode();
        } _SEH2_END;
 
    } _SEH2_FINALLY {
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
#if EXT2_DEBUG
    if (Status == FALSE) {
 
        DEBUG(DL_ERR, (
                  "Ext2FastIoUnlockSingle: %s %s *** Status: FALSE ***\n",
                  (PUCHAR) Process + ProcessNameOffset,
                  "FASTIO_UNLOCK_SINGLE"          ));
    } else if (IoStatus->Status != STATUS_SUCCESS) {
        DEBUG(DL_ERR, (
                  "Ext2FastIoUnlockSingle: %s %s *** Status: %s (%#x) ***\n",
                  (PUCHAR) Process + ProcessNameOffset,
                  "FASTIO_UNLOCK_SINGLE",
                  Ext2NtStatusToString(IoStatus->Status),
                  IoStatus->Status            ));
    }
#endif
 
    return Status;
}

Referenced by DriverEntry().

◆ Ext2FastIoWrite()

BOOLEAN Ext2FastIoWrite	(	IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	FileOffset,
		IN ULONG	Length,
		IN BOOLEAN	Wait,
		IN ULONG	LockKey,
		OUT PVOID	Buffer,
		OUT PIO_STATUS_BLOCK	IoStatus,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 207 of file fastio.c.

{
    PEXT2_FCB   Fcb = NULL;
    BOOLEAN     Status = FALSE;
    BOOLEAN     Locked = FALSE;
 
    Fcb = (PEXT2_FCB) FileObject->FsContext;
    if (Fcb == NULL)
        return FALSE;
 
    _SEH2_TRY {
 
        FsRtlEnterFileSystem();
 
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
        if (IsVcbReadOnly(Fcb->Vcb)) {
            _SEH2_LEAVE;
        }
 
        if (!ExAcquireResourceSharedLite(Fcb->Header.Resource, Wait)) {
            _SEH2_LEAVE;
        }
        Locked = TRUE;
 
        if (IsWritingToEof(*FileOffset) ||
            Fcb->Header.ValidDataLength.QuadPart < FileOffset->QuadPart + Length ||
            Fcb->Header.FileSize.QuadPart < FileOffset->QuadPart + Length ) {
            Status = FALSE;
            _SEH2_LEAVE;
        }
 
        if (Locked) {
            ExReleaseResourceLite(Fcb->Header.Resource);
            Locked = FALSE;
        }
 
        Status = FsRtlCopyWrite(FileObject, FileOffset, Length, Wait,
                                LockKey, Buffer, IoStatus, DeviceObject);
        if (Status) {
            if (IoStatus)
                Length = (ULONG)IoStatus->Information;
        }
 
    } _SEH2_FINALLY {
 
        if (Locked) {
            ExReleaseResourceLite(Fcb->Header.Resource);
        }
 
        FsRtlExitFileSystem();
    } _SEH2_END;
 
    DEBUG(DL_IO, ("Ext2FastIoWrite: %wZ Offset: %I64xh Length: %xh Key: %xh Status=%d\n",
                  &Fcb->Mcb->ShortName,  FileOffset->QuadPart, Length, LockKey, Status));
 
    return Status;
}

Referenced by DriverEntry().

◆ Ext2FcbReaperThread()

VOID Ext2FcbReaperThread ( PVOID Context )

Definition at line 3391 of file memory.c.

{
    PEXT2_REAPER    Reaper = Context;
    PEXT2_VCB       Vcb = NULL;
    LIST_ENTRY      List, *Link;
    LARGE_INTEGER   Timeout;
 
    BOOLEAN         GlobalAcquired = FALSE;
    BOOLEAN         DidNothing = FALSE;
    BOOLEAN         NonWait = FALSE;
 
    _SEH2_TRY {
 
        Reaper->Thread = PsGetCurrentThread();
 
        /* wake up DirverEntry */
        KeSetEvent(&Reaper->Engine, 0, FALSE);
 
        /* now process looping */
        while (!IsFlagOn(Reaper->Flags, EXT2_REAPER_FLAG_STOP)) {
 
            /* wait until it is waken or it times out */
            if (NonWait) {
                Timeout.QuadPart = (LONGLONG)-10*1000*100;
                NonWait = FALSE;
            } else if (DidNothing) {
                Timeout.QuadPart = Timeout.QuadPart * 2;
            } else {
                Timeout.QuadPart = (LONGLONG)-10*1000*1000*20; /* 20 seconds */
            }
            KeWaitForSingleObject(
                &Reaper->Wait,
                Executive,
                KernelMode,
                FALSE,
                &Timeout
            );
 
            if (IsFlagOn(Reaper->Flags, EXT2_REAPER_FLAG_STOP))
                break;
 
            InitializeListHead(&List);
 
            /* acquire global exclusive lock */
            ExAcquireResourceSharedLite(&Ext2Global->Resource, TRUE);
            GlobalAcquired = TRUE;
            /* search all Vcb to get unused resources freed to system */
            for (Link  = Ext2Global->VcbList.Flink;
                 Link != &(Ext2Global->VcbList);
                 Link  = Link->Flink ) {
 
                Vcb = CONTAINING_RECORD(Link, EXT2_VCB, Next);
                NonWait = Ext2QueryUnusedFcb(Vcb, &List);
            }
            DidNothing = IsListEmpty(&List);
            if (DidNothing) {
                KeClearEvent(&Reaper->Wait);
            }
            if (GlobalAcquired) {
                ExReleaseResourceLite(&Ext2Global->Resource);
                GlobalAcquired = FALSE;
            }
 
            while (!IsListEmpty(&List)) {
                PEXT2_FCB  Fcb;
                Link = RemoveHeadList(&List);
                Fcb = CONTAINING_RECORD(Link, EXT2_FCB, Next);
                ASSERT(0 == Fcb->ReferenceCount);
                Ext2FreeFcb(Fcb);
            }
        }
 
    } _SEH2_FINALLY {
 
        if (GlobalAcquired) {
            ExReleaseResourceLite(&Ext2Global->Resource);
        }
 
        KeSetEvent(&Reaper->Engine, 0, FALSE);
    } _SEH2_END;
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}

Referenced by DriverEntry().

◆ Ext2FileSystemControl()

NTSTATUS Ext2FileSystemControl ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 2848 of file fsctl.c.

{
    NTSTATUS    Status;
 
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    switch (IrpContext->MinorFunction) {
 
    case IRP_MN_USER_FS_REQUEST:
        Status = Ext2UserFsRequest(IrpContext);
        break;
 
    case IRP_MN_MOUNT_VOLUME:
        Status = Ext2MountVolume(IrpContext);
        break;
 
    case IRP_MN_VERIFY_VOLUME:
        Status = Ext2VerifyVolume(IrpContext);
        break;
 
    default:
 
        DEBUG(DL_ERR, ( "Ext2FilsSystemControl: Invalid Device Request.\n"));
        Status = STATUS_INVALID_DEVICE_REQUEST;
        Ext2CompleteIrpContext(IrpContext,  Status);
    }
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2FirstUnusedMcb()

PEXT2_MCB Ext2FirstUnusedMcb	(	PEXT2_VCB	Vcb,
		BOOLEAN	Wait,
		ULONG	Number
	)

Definition at line 2979 of file memory.c.

{
    PEXT2_MCB   Head = NULL;
    PEXT2_MCB   Tail = NULL;
    PEXT2_MCB   Mcb = NULL;
    PLIST_ENTRY List = NULL;
    ULONG       i = 0;
    LARGE_INTEGER   start, now;
 
    if (!ExAcquireResourceExclusiveLite(&Vcb->McbLock, Wait)) {
        return NULL;
    }
 
    KeQuerySystemTime(&start);
 
    while (Number--) {
 
        BOOLEAN     Skip = TRUE;
 
        if (IsListEmpty(&Vcb->McbList)) {
            break;
        }
 
        while (i++ < Vcb->NumOfMcb) {
 
            KeQuerySystemTime(&now);
            if (now.QuadPart > start.QuadPart + (LONGLONG)10*1000*1000) {
                break;
            }
 
            List = RemoveHeadList(&Vcb->McbList);
            Mcb = CONTAINING_RECORD(List, EXT2_MCB, Link);
            ASSERT(IsFlagOn(Mcb->Flags, MCB_VCB_LINK));
 
            if (Mcb->Fcb == NULL && !IsMcbRoot(Mcb) &&
                    Mcb->Refercount == 0 &&
                    (Mcb->Child == NULL || IsMcbSymLink(Mcb))) {
 
                Ext2RemoveMcb(Vcb, Mcb);
                ClearLongFlag(Mcb->Flags, MCB_VCB_LINK);
                Ext2DerefXcb(&Vcb->NumOfMcb);
 
                /* attach all Mcb into a chain*/
                if (Head) {
                    ASSERT(Tail != NULL);
                    Tail->Next = Mcb;
                    Tail = Mcb;
                } else {
                    Head = Tail = Mcb;
                }
                Tail->Next = NULL;
                Skip = FALSE;
 
            } else {
 
                InsertTailList(&Vcb->McbList, &Mcb->Link);
                Mcb = NULL;
            }
        }
 
        if (Skip)
            break;
    }
 
    ExReleaseResourceLite(&Vcb->McbLock);
 
    return Head;
}

Referenced by Ext2CleanupAllMcbs(), and Ext2McbReaperThread().

◆ Ext2Flush()

NTSTATUS Ext2Flush ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 148 of file flush.c.

{
    NTSTATUS                Status = STATUS_SUCCESS;
 
    PIRP                    Irp = NULL;
    PIO_STACK_LOCATION      IrpSp = NULL;
 
    PEXT2_VCB               Vcb = NULL;
    PEXT2_FCB               Fcb = NULL;
    PEXT2_FCBVCB            FcbOrVcb = NULL;
    PEXT2_CCB               Ccb = NULL;
    PFILE_OBJECT            FileObject = NULL;
 
    PDEVICE_OBJECT          DeviceObject = NULL;
 
    BOOLEAN                 MainResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext);
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        ASSERT(IsMounted(Vcb));
        if (IsVcbReadOnly(Vcb)) {
            Status =  STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        Irp = IrpContext->Irp;
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
        FileObject = IrpContext->FileObject;
        FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;
        ASSERT(FcbOrVcb != NULL);
 
        Ccb = (PEXT2_CCB) FileObject->FsContext2;
        if (Ccb == NULL) {
            Status =  STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        MainResourceAcquired =
            ExAcquireResourceExclusiveLite(&FcbOrVcb->MainResource, TRUE);
        ASSERT(MainResourceAcquired);
        DEBUG(DL_INF, ("Ext2Flush-pre:  total mcb records=%u\n",
                       FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));
 
        if (FcbOrVcb->Identifier.Type == EXT2VCB) {
 
            Ext2VerifyVcb(IrpContext, Vcb);
            Status = Ext2FlushFiles(IrpContext, (PEXT2_VCB)(FcbOrVcb), FALSE);
            if (NT_SUCCESS(Status)) {
                _SEH2_LEAVE;
            }
 
            Status = Ext2FlushVolume(IrpContext, (PEXT2_VCB)(FcbOrVcb), FALSE);
 
            if (NT_SUCCESS(Status) && IsFlagOn(Vcb->Volume->Flags, FO_FILE_MODIFIED)) {
                ClearFlag(Vcb->Volume->Flags, FO_FILE_MODIFIED);
            }
 
        } else if (FcbOrVcb->Identifier.Type == EXT2FCB) {
 
            Fcb = (PEXT2_FCB)(FcbOrVcb);
 
            Status = Ext2FlushFile(IrpContext, Fcb, Ccb);
            if (NT_SUCCESS(Status)) {
                if (IsFlagOn(FileObject->Flags, FO_FILE_MODIFIED)) {
                    Fcb->Mcb->FileAttr |= FILE_ATTRIBUTE_ARCHIVE;
                    ClearFlag(FileObject->Flags, FO_FILE_MODIFIED);
                }
            }
        }
 
        DEBUG(DL_INF, ("Ext2Flush-post: total mcb records=%u\n",
                       FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));
 
 
    } _SEH2_FINALLY {
 
        if (MainResourceAcquired) {
            ExReleaseResourceLite(&FcbOrVcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
 
            if (Vcb && Irp && IrpSp && !IsVcbReadOnly(Vcb)) {
 
                // Call the disk driver to flush the physial media.
                NTSTATUS DriverStatus;
                PIO_STACK_LOCATION NextIrpSp;
 
                NextIrpSp = IoGetNextIrpStackLocation(Irp);
 
                *NextIrpSp = *IrpSp;
 
                IoSetCompletionRoutine( Irp,
                                        Ext2FlushCompletionRoutine,
                                        NULL,
                                        TRUE,
                                        TRUE,
                                        TRUE );
 
                DriverStatus = IoCallDriver(Vcb->TargetDeviceObject, Irp);
 
                Status = (DriverStatus == STATUS_INVALID_DEVICE_REQUEST) ?
                         Status : DriverStatus;
 
                IrpContext->Irp = Irp = NULL;
            }
 
            Ext2CompleteIrpContext(IrpContext, Status);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2FlushFile()

NTSTATUS Ext2FlushFile	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_FCB	Fcb,
		IN PEXT2_CCB	Ccb
	)

Definition at line 58 of file flush.c.

{
    IO_STATUS_BLOCK     IoStatus = {0};
 
    ASSERT(Fcb != NULL);
    ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
           (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
    _SEH2_TRY {
 
        /* do nothing if target fie was deleted */
        if (FlagOn(Fcb->Flags, FCB_DELETE_PENDING)) {
            IoStatus.Status = STATUS_FILE_DELETED;
            _SEH2_LEAVE;
        }
 
        /* update timestamp and achieve attribute */
        if (Ccb != NULL) {
 
            if (!IsFlagOn(Ccb->Flags, CCB_LAST_WRITE_UPDATED)) {
 
                LARGE_INTEGER   SysTime;
                KeQuerySystemTime(&SysTime);
 
                Fcb->Inode->i_mtime = Ext2LinuxTime(SysTime);
                Fcb->Mcb->LastWriteTime = Ext2NtTime(Fcb->Inode->i_mtime);
                Ext2SaveInode(IrpContext, Fcb->Vcb, Fcb->Inode);
            }
        }
 
        if (IsDirectory(Fcb)) {
            IoStatus.Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        DEBUG(DL_INF, ( "Ext2FlushFile: Flushing File Inode=%xh %S ...\n",
                        Fcb->Inode->i_ino, Fcb->Mcb->ShortName.Buffer));
 
        CcFlushCache(&(Fcb->SectionObject), NULL, 0, &IoStatus);
        ClearFlag(Fcb->Flags, FCB_FILE_MODIFIED);
 
    } _SEH2_FINALLY {
 
        /* do cleanup here */
    } _SEH2_END;
 
    return IoStatus.Status;
}

Referenced by Ext2Cleanup(), Ext2Flush(), and Ext2FlushFiles().

◆ Ext2FlushFiles()

NTSTATUS Ext2FlushFiles	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN BOOLEAN	bShutDown
	)

Definition at line 112 of file flush.c.

{
    IO_STATUS_BLOCK    IoStatus;
 
    PEXT2_FCB       Fcb;
    PLIST_ENTRY     ListEntry;
 
    if (IsVcbReadOnly(Vcb)) {
        return STATUS_SUCCESS;
    }
 
    IoStatus.Status = STATUS_SUCCESS;
 
    DEBUG(DL_INF, ( "Flushing Files ...\n"));
 
    // Flush all Fcbs in Vcb list queue.
    for (ListEntry = Vcb->FcbList.Flink;
            ListEntry != &Vcb->FcbList;
            ListEntry = ListEntry->Flink ) {
 
        Fcb = CONTAINING_RECORD(ListEntry, EXT2_FCB, Next);
        ExAcquireResourceExclusiveLite(
            &Fcb->MainResource, TRUE);
        Ext2FlushFile(IrpContext, Fcb, NULL);
        ExReleaseResourceLite(&Fcb->MainResource);
    }
 
    return IoStatus.Status;
}

Referenced by Ext2CreateVolume(), Ext2DismountVolume(), Ext2Flush(), Ext2LockVolume(), Ext2ProcessVolumeProperty(), and Ext2ShutDown().

◆ 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().

◆ Ext2FlushVolume()

NTSTATUS Ext2FlushVolume	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN BOOLEAN	bShutDown
	)

Definition at line 43 of file flush.c.

{
    DEBUG(DL_INF, ( "Ext2FlushVolume: Flushing Vcb ...\n"));
 
    ExAcquireSharedStarveExclusive(&Vcb->PagingIoResource, TRUE);
    ExReleaseResourceLite(&Vcb->PagingIoResource);
 
    return Ext2FlushVcb(Vcb);
}

Referenced by Ext2CreateVolume(), Ext2DismountVolume(), Ext2Flush(), Ext2LockVolume(), Ext2ProcessVolumeProperty(), Ext2ReadVolume(), Ext2ShutDown(), and sync_blockdev().

◆ Ext2FollowLink()

NTSTATUS Ext2FollowLink	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Parent,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Linkdep
	)

Definition at line 67 of file create.c.

{
    NTSTATUS        Status = STATUS_LINK_FAILED;
 
    UNICODE_STRING  UniName;
    OEM_STRING      OemName;
    BOOLEAN         bOemBuffer = FALSE;
 
    PEXT2_MCB       Target = NULL;
 
    USHORT          i;
 
    _SEH2_TRY {
 
        RtlZeroMemory(&UniName, sizeof(UNICODE_STRING));
        RtlZeroMemory(&OemName, sizeof(OEM_STRING));
 
        /* exit if we jump into a possible symlink forever loop */
        if ((Linkdep + 1) > EXT2_MAX_NESTED_LINKS ||
            IoGetRemainingStackSize() < 1024) {
            _SEH2_LEAVE;
        }
 
        /* read the symlink target path */
        if (!Mcb->Inode.i_blocks) {
 
            OemName.Buffer = (PUCHAR) (&Mcb->Inode.i_block[0]);
            OemName.Length = (USHORT)Mcb->Inode.i_size;
            OemName.MaximumLength = OemName.Length + 1;
 
        } else {
 
            OemName.Length = (USHORT)Mcb->Inode.i_size;
            OemName.MaximumLength = OemName.Length + 1;
            OemName.Buffer = Ext2AllocatePool(PagedPool,
                                              OemName.MaximumLength,
                                              'NL2E');
            if (OemName.Buffer == NULL) {
                Status = STATUS_INSUFFICIENT_RESOURCES;
                _SEH2_LEAVE;
            }
            bOemBuffer = TRUE;
            RtlZeroMemory(OemName.Buffer, OemName.MaximumLength);
 
            Status = Ext2ReadSymlink(
                         IrpContext,
                         Vcb,
                         Mcb,
                         OemName.Buffer,
                         (ULONG)(Mcb->Inode.i_size),
                         NULL);
            if (!NT_SUCCESS(Status)) {
                _SEH2_LEAVE;
            }
        }
 
        /* convert Linux slash to Windows backslash */
        for (i=0; i < OemName.Length; i++) {
            if (OemName.Buffer[i] == '/') {
                OemName.Buffer[i] = '\\';
            }
        }
 
        /* convert oem string to unicode string */
        UniName.MaximumLength = (USHORT)Ext2OEMToUnicodeSize(Vcb, &OemName);
        if (UniName.MaximumLength <= 0) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
 
        UniName.MaximumLength += 2;
        UniName.Buffer = Ext2AllocatePool(PagedPool,
                                          UniName.MaximumLength,
                                          'NL2E');
        if (UniName.Buffer == NULL) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
        RtlZeroMemory(UniName.Buffer, UniName.MaximumLength);
        Status = Ext2OEMToUnicode(Vcb, &UniName, &OemName);
        if (!NT_SUCCESS(Status)) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
 
        /* search the real target */
        Status = Ext2LookupFile(
                     IrpContext,
                     Vcb,
                     &UniName,
                     Parent,
                     &Target,
                     Linkdep
                 );
        if (Target == NULL) {
            Status = STATUS_LINK_FAILED;
        }
 
        if (Target == NULL /* link target doesn't exist */      ||
            Target == Mcb  /* symlink points to itself */       ||
            IsMcbSpecialFile(Target) /* target not resolved*/   ||
            IsFileDeleted(Target)  /* target deleted */         ) {
 
            if (Target) {
                ASSERT(Target->Refercount > 0);
                Ext2DerefMcb(Target);
            }
            ClearLongFlag(Mcb->Flags, MCB_TYPE_SYMLINK);
            SetLongFlag(Mcb->Flags, MCB_TYPE_SPECIAL);
            Mcb->Target = NULL;
 
        } else if (IsMcbSymLink(Target)) {
 
            ASSERT(Target->Refercount > 0);
            ASSERT(Target->Target != NULL);
            Ext2ReferMcb(Target->Target);
            Mcb->Target = Target->Target;
            Ext2DerefMcb(Target);
            ASSERT(!IsMcbSymLink(Target->Target));
            SetLongFlag(Mcb->Flags, MCB_TYPE_SYMLINK);
            ClearLongFlag(Mcb->Flags, MCB_TYPE_SPECIAL);
            ASSERT(Mcb->Target->Refercount > 0);
 
        } else {
 
            Mcb->Target = Target;
            SetLongFlag(Mcb->Flags, MCB_TYPE_SYMLINK);
            ClearLongFlag(Mcb->Flags, MCB_TYPE_SPECIAL);
            ASSERT(Mcb->Target->Refercount > 0);
        }
 
        /* add directory flag to file attribute */
        if (Mcb->Target && IsMcbDirectory(Mcb->Target)) {
            Mcb->FileAttr |= FILE_ATTRIBUTE_DIRECTORY;
        }
 
    } _SEH2_FINALLY {
 
        if (bOemBuffer) {
            Ext2FreePool(OemName.Buffer, 'NL2E');
        }
 
        if (UniName.Buffer) {
            Ext2FreePool(UniName.Buffer, 'NL2E');
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2LookupFile(), and Ext2ProcessEntry().

◆ 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().

◆ Ext2FreeCcb()

VOID Ext2FreeCcb	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_CCB	Ccb
	)

Definition at line 356 of file memory.c.

{
    ASSERT(Ccb != NULL);
    ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
           (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
 
    DEBUG(DL_RES, ( "Ext2FreeCcb: Ccb = %ph.\n", Ccb));
 
    if (Ccb->SymLink) {
        DEBUG(DL_INF, ( "Ext2FreeCcb: Ccb SymLink: %wZ.\n",
                        &Ccb->SymLink->FullName));
        if (IsFileDeleted(Ccb->SymLink->Target)) {
            Ext2UnlinkMcb(Vcb, Ccb->SymLink);
            Ext2DerefMcb(Ccb->SymLink);
            Ext2LinkHeadMcb(Vcb, Ccb->SymLink);
        } else {
            Ext2DerefMcb(Ccb->SymLink);
        }
    }
 
    if (Ccb->DirectorySearchPattern.Buffer != NULL) {
        DEC_MEM_COUNT(PS_DIR_PATTERN, Ccb->DirectorySearchPattern.Buffer,
                      Ccb->DirectorySearchPattern.MaximumLength );
        Ext2FreePool(Ccb->DirectorySearchPattern.Buffer, EXT2_DIRSP_MAGIC);
    }
 
    ExFreeToNPagedLookasideList(&(Ext2Global->Ext2CcbLookasideList), Ccb);
    DEC_MEM_COUNT(PS_CCB, Ccb, sizeof(EXT2_CCB));
}

Referenced by Ext2Close(), and Ext2CreateFile().

◆ Ext2FreeEntry()

VOID Ext2FreeEntry ( IN struct dentry * de )

Definition at line 432 of file memory.c.

{
    ASSERT(de != NULL);
 
    if (de->d_name.name)
        ExFreePool(de->d_name.name);
 
    ExFreeToNPagedLookasideList(&(Ext2Global->Ext2DentryLookasideList), de);
    DEC_MEM_COUNT(PS_DENTRY, de, sizeof(struct dentry));
}

Referenced by Ext2AddEntry(), Ext2BuildEntry(), Ext2CreateInode(), Ext2FreeMcb(), Ext2LookupFile(), Ext2ScanDir(), and Ext2SetRenameInfo().

◆ Ext2FreeExtent()

VOID Ext2FreeExtent ( IN PEXT2_EXTENT Extent )

Definition at line 505 of file memory.c.

{
    ASSERT(Extent != NULL);
    ExFreeToNPagedLookasideList(&(Ext2Global->Ext2ExtLookasideList), Extent);
    DEC_MEM_COUNT(PS_EXTENT, Extent, sizeof(EXT2_EXTENT));
}

Referenced by bmap(), and Ext2DestroyExtentChain().

◆ Ext2FreeFcb()

VOID Ext2FreeFcb ( IN PEXT2_FCB Fcb )

Definition at line 240 of file memory.c.

{
    PEXT2_VCB   Vcb = Fcb->Vcb;
 
    _SEH2_TRY {
 
        ASSERT((Fcb != NULL) && (Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
        ASSERT(0 == Fcb->ReferenceCount);
 
#ifndef _WIN2K_TARGET_
        FsRtlTeardownPerStreamContexts(&Fcb->Header);
#endif
 
        FsRtlUninitializeFileLock(&Fcb->FileLockAnchor);
        FsRtlUninitializeOplock(&Fcb->Oplock);
        ExDeleteResourceLite(&Fcb->MainResource);
        ExDeleteResourceLite(&Fcb->PagingIoResource);
 
        Fcb->Identifier.Type = 0;
        Fcb->Identifier.Size = 0;
 
        ExFreeToNPagedLookasideList(&(Ext2Global->Ext2FcbLookasideList), Fcb);
        DEC_MEM_COUNT(PS_FCB, Fcb, sizeof(EXT2_FCB));
 
        if (0 == Ext2DerefXcb(&Vcb->ReferenceCount)) {
            if (!IsMounted(Vcb) || IsDispending(Vcb)) {
                Ext2CheckDismount(NULL, Vcb, FALSE);
            }
        }
 
    } _SEH2_FINALLY {
    } _SEH2_END;
}

Referenced by Ext2FcbReaperThread().

◆ 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().

◆ Ext2FreeIrpContext()

VOID Ext2FreeIrpContext ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 114 of file memory.c.

{
    ASSERT(IrpContext != NULL);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    /* free the IrpContext to NonPagedList */
    IrpContext->Identifier.Type = 0;
    IrpContext->Identifier.Size = 0;
 
    DEC_IRP_COUNT(IrpContext);
    ExFreeToNPagedLookasideList(&(Ext2Global->Ext2IrpContextLookasideList), IrpContext);
}

Referenced by Ext2CompleteIrpContext(), Ext2ExceptionFilter(), Ext2ExceptionHandler(), Ext2ReadFile(), Ext2ReadVolume(), Ext2WriteFile(), and Ext2WriteVolume().

◆ Ext2FreeMcb()

VOID Ext2FreeMcb	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb
	)

Definition at line 1538 of file memory.c.

{
#ifndef __REACTOS__
    PEXT2_MCB   Parent = Mcb->Parent;
#endif
 
    ASSERT(Mcb != NULL);
 
    ASSERT((Mcb->Identifier.Type == EXT2MCB) &&
           (Mcb->Identifier.Size == sizeof(EXT2_MCB)));
 
    if ((Mcb->Identifier.Type != EXT2MCB) ||
            (Mcb->Identifier.Size != sizeof(EXT2_MCB))) {
        return;
    }
 
    DEBUG(DL_INF, ( "Ext2FreeMcb: Mcb %wZ will be freed.\n", &Mcb->FullName));
 
    if (IsMcbSymLink(Mcb) && Mcb->Target) {
        Ext2DerefMcb(Mcb->Target);
    }
 
    if (FsRtlNumberOfRunsInLargeMcb(&Mcb->Extents)) {
        DEBUG(DL_EXT, ("List data extents for: %wZ\n", &Mcb->FullName));
        Ext2ListExtents(&Mcb->Extents);
    }
    FsRtlUninitializeLargeMcb(&(Mcb->Extents));
    if (FsRtlNumberOfRunsInLargeMcb(&Mcb->MetaExts)) {
        DEBUG(DL_EXT, ("List meta extents for: %wZ\n", &Mcb->FullName));
        Ext2ListExtents(&Mcb->MetaExts);
    }
    FsRtlUninitializeLargeMcb(&(Mcb->MetaExts));
    ClearLongFlag(Mcb->Flags, MCB_ZONE_INITED);
 
    if (Mcb->ShortName.Buffer) {
        DEC_MEM_COUNT(PS_MCB_NAME, Mcb->ShortName.Buffer,
                      Mcb->ShortName.MaximumLength);
        Ext2FreePool(Mcb->ShortName.Buffer, EXT2_FNAME_MAGIC);
    }
 
    if (Mcb->FullName.Buffer) {
        DEC_MEM_COUNT(PS_MCB_NAME, Mcb->FullName.Buffer,
                      Mcb->FullName.MaximumLength);
        Ext2FreePool(Mcb->FullName.Buffer, EXT2_FNAME_MAGIC);
    }
 
    /* free dentry */
    if (Mcb->de) {
        Ext2FreeEntry(Mcb->de);
    }
 
    Mcb->Identifier.Type = 0;
    Mcb->Identifier.Size = 0;
 
    ExFreeToNPagedLookasideList(&(Ext2Global->Ext2McbLookasideList), Mcb);
    DEC_MEM_COUNT(PS_MCB, Mcb, sizeof(EXT2_MCB));
}

Referenced by Ext2CleanupAllMcbs(), Ext2InitializeVcb(), Ext2LoadInternalJournal(), Ext2LookupFile(), Ext2McbReaperThread(), and Ext2RecoverJournal().

◆ Ext2FreePool()

VOID Ext2FreePool	(	IN PVOID	P,
		IN ULONG	Tag
	)

Definition at line 2697 of file debug.c.

{
    ExFreePoolWithTag(P, Tag);
}

Referenced by DriverEntry(), Ext2AllocateMcb(), Ext2BuildName(), Ext2CreateFile(), Ext2DestroyVcb(), Ext2ExpandBlock(), Ext2ExpandLast(), Ext2FillEntry(), Ext2FloppyFlush(), Ext2FollowLink(), Ext2FreeCcb(), Ext2FreeMcb(), Ext2GetReparsePoint(), Ext2GetRetrievalPointers(), Ext2LoadSuper(), Ext2MountVolume(), Ext2PerformRegistryVolumeParams(), Ext2QueryDirectory(), Ext2QueryExtentMappings(), Ext2QueryVolumeParams(), Ext2ReadDisk(), Ext2ReadSync(), Ext2ReadWriteBlockAsyncCompletionRoutine(), Ext2ReadWriteBlocks(), Ext2SetParentEntry(), Ext2SetReparsePoint(), and Ext2VerifyVolume().

◆ Ext2GetBlock()

NTSTATUS Ext2GetBlock	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Base,
		IN ULONG	Layer,
		IN ULONG	Start,
		IN ULONG	SizeArray,
		IN PULONG	BlockArray,
		IN BOOLEAN	bAlloc,
		IN OUT PULONG	Hint,
		OUT PULONG	Block,
		OUT PULONG	Number
	)

Definition at line 136 of file indirect.c.

{
    NTSTATUS    Status = STATUS_SUCCESS;
    PBCB        Bcb = NULL;
    PULONG      pData = NULL;
    ULONG       Slot = 0, i = 0;
    ULONG       Unit = 1;
 
    LARGE_INTEGER Offset;
 
    if (Layer == 0) {
 
        *Number = 1;
        if (BlockArray[0] == 0 && bAlloc) {
 
            /* now allocate new block */
            Status = Ext2ExpandLast(
                         IrpContext,
                         Vcb,
                         Mcb,
                         Base,
                         Layer,
                         NULL,
                         Hint,
                         &BlockArray[0],
                         Number
                     );
 
            if (!NT_SUCCESS(Status)) {
                goto errorout;
            }
        } else {
            /* check the block is valid or not */
            if (BlockArray[0] >= TOTAL_BLOCKS) {
                DbgBreak();
                Status = STATUS_DISK_CORRUPT_ERROR;
                goto errorout;
            }
        }
 
        *Block = BlockArray[0];
        for (i=1; i < SizeArray; i++) {
            if (BlockArray[i] == BlockArray[i-1] + 1) {
                *Number = *Number + 1;
            } else {
                break;
            }
        }
        *Hint = BlockArray[*Number - 1];
 
    } else if (Layer <= 3) {
 
        /* check the block is valid or not */
        if (BlockArray[0] == 0 || BlockArray[0] >= TOTAL_BLOCKS) {
            DbgBreak();
            Status = STATUS_DISK_CORRUPT_ERROR;
            goto errorout;
        }
 
        /* add block to meta extents */
        if (!Ext2AddMcbMetaExts(Vcb, Mcb, BlockArray[0], 1)) {
            DbgBreak();
            Ext2Sleep(500);
            Ext2AddMcbMetaExts(Vcb, Mcb, BlockArray[0], 1);
        }
 
        /* map memory in cache for the index block */
        Offset.QuadPart = ((LONGLONG)BlockArray[0]) << BLOCK_BITS;
        if ( !CcPinRead( Vcb->Volume,
                         (PLARGE_INTEGER) (&Offset),
                         BLOCK_SIZE,
                         PIN_WAIT,
                         &Bcb,
#ifdef __REACTOS__
                         (void **)&pData )) {
#else
                         &pData )) {
#endif
 
            DEBUG(DL_ERR, ( "Ext2GetBlock: Failed to PinLock block: %xh ...\n",
                            BlockArray[0] ));
            Status = STATUS_CANT_WAIT;
            goto errorout;
        }
 
        if (Layer > 1) {
            Unit = Vcb->max_blocks_per_layer[Layer - 1];
        } else {
            Unit = 1;
        }
 
        Slot  = Start / Unit;
        Start = Start % Unit;
 
        if (pData[Slot] == 0) {
 
            if (bAlloc) {
 
                /* we need allocate new block and zero all data in case
                   it's an in-direct block. Index stores the new block no. */
                ULONG   Count = 1;
                Status = Ext2ExpandLast(
                             IrpContext,
                             Vcb,
                             Mcb,
                             Base,
                             Layer,
                             NULL,
                             Hint,
                             &pData[Slot],
                             &Count
                         );
 
                if (!NT_SUCCESS(Status)) {
                    goto errorout;
                }
 
                /* refresh hint block */
                *Hint = pData[Slot];
 
                /* set dirty bit to notify system to flush */
                CcSetDirtyPinnedData(Bcb, NULL );
                SetFlag(Vcb->Volume->Flags, FO_FILE_MODIFIED);
                if (!Ext2AddVcbExtent(Vcb, Offset.QuadPart,
                                      (LONGLONG)BLOCK_SIZE)) {
                    DbgBreak();
                    Ext2Sleep(100);
                    if (!Ext2AddVcbExtent(Vcb, Offset.QuadPart,
                                          (LONGLONG)BLOCK_SIZE)) {
                        Status = STATUS_INSUFFICIENT_RESOURCES;
                        goto errorout;
                    }
                }
 
                /* save inode information here */
                Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
 
            } else {
 
                *Number = 1;
 
                if (Layer == 1) {
                    for (i = Slot + 1; i < BLOCK_SIZE/4; i++) {
                        if (pData[i] == 0) {
                            *Number = *Number + 1;
                        } else {
                            break;
                        }
                    }
                } else if (Layer == 2) {
                    *Number = BLOCK_SIZE/4 - Start;
                } else {
                    *Number = BLOCK_SIZE/4;
                }
 
                goto errorout;
            }
        }
 
        /* transfer to next recursion call */
        Status = Ext2GetBlock(
                     IrpContext,
                     Vcb,
                     Mcb,
                     Base,
                     Layer - 1,
                     Start,
                     BLOCK_SIZE/4 - Slot,
                     &pData[Slot],
                     bAlloc,
                     Hint,
                     Block,
                     Number
                 );
 
        if (!NT_SUCCESS(Status)) {
            goto errorout;
        }
    }
 
errorout:
 
    /* free the memory of pData */
    if (Bcb) {
        CcUnpinData(Bcb);
    }
 
    if (!NT_SUCCESS(Status)) {
        *Block = 0;
    }
 
    return Status;
}

Referenced by Ext2GetBlock(), and Ext2MapIndirect().

◆ Ext2GetInfoLength()

ULONG Ext2GetInfoLength ( IN FILE_INFORMATION_CLASS FileInformationClass )

Definition at line 30 of file dirctl.c.

{
    switch (FileInformationClass) {
 
    case FileDirectoryInformation:
        return FIELD_OFFSET(FILE_DIRECTORY_INFORMATION, FileName[0]);
 
    case FileFullDirectoryInformation:
        return FIELD_OFFSET(FILE_FULL_DIR_INFORMATION, FileName[0]);
 
    case FileBothDirectoryInformation:
        return FIELD_OFFSET(FILE_BOTH_DIR_INFORMATION, FileName[0]);
 
    case FileNamesInformation:
        return FIELD_OFFSET(FILE_NAMES_INFORMATION, FileName[0]);
 
    case FileIdFullDirectoryInformation:
        return FIELD_OFFSET(FILE_ID_FULL_DIR_INFORMATION, FileName[0]);
 
    case FileIdBothDirectoryInformation:
        return FIELD_OFFSET(FILE_ID_BOTH_DIR_INFORMATION, FileName[0]);
 
    default:
        break;
    }
 
    return 0;
}

Referenced by Ext2FillEntry(), and Ext2ProcessEntry().

◆ 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().

◆ Ext2GetProcessNameOffset()

ULONG Ext2GetProcessNameOffset ( VOID )

Referenced by DriverEntry().

◆ Ext2GetRetrievalPointerBase()

NTSTATUS Ext2GetRetrievalPointerBase ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 1160 of file fsctl.c.

{
    PIRP                Irp = NULL;
    PIO_STACK_LOCATION  IrpSp;
    PEXTENDED_IO_STACK_LOCATION EIrpSp;
 
    PDEVICE_OBJECT      DeviceObject;
    PFILE_OBJECT        FileObject;
 
    PEXT2_VCB           Vcb = NULL;
    PEXT2_FCB           Fcb = NULL;
    PEXT2_CCB           Ccb = NULL;
 
    PLARGE_INTEGER      FileAreaOffset;
 
    ULONG               OutputSize;
 
    NTSTATUS            Status = STATUS_SUCCESS;
 
    BOOLEAN FcbResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext);
        Irp = IrpContext->Irp;
        ASSERT(Irp);
 
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
        EIrpSp = (PEXTENDED_IO_STACK_LOCATION)IrpSp;
        ASSERT(IrpSp);
 
        OutputSize = EIrpSp->Parameters.FileSystemControl.OutputBufferLength;
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        /* This request is not allowed on the main device object */
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
        ASSERT(IsMounted(Vcb));
 
        FileObject = IrpContext->FileObject;
        Fcb = (PEXT2_FCB) FileObject->FsContext;
 
        /* check Fcb is valid or not */
        if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
        if (IsFlagOn(Fcb->Mcb->Flags, MCB_FILE_DELETED)) {
            Status = STATUS_FILE_DELETED;
            _SEH2_LEAVE;
        }
 
        Ccb = (PEXT2_CCB) FileObject->FsContext2;
        if (Ccb == NULL) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
               (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
 
        if (OutputSize < sizeof(LARGE_INTEGER)) {
            Status = STATUS_BUFFER_TOO_SMALL;
            _SEH2_LEAVE;
        }
 
        if (!ExAcquireResourceExclusiveLite (
                    &Fcb->MainResource, Ext2CanIWait())) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
        FcbResourceAcquired = TRUE;
 
        FileAreaOffset = (PLARGE_INTEGER) Ext2GetUserBuffer(Irp);
 
        /* probe user buffer */
 
        _SEH2_TRY {
            if (Irp->RequestorMode != KernelMode) {
                ProbeForWrite(FileAreaOffset, OutputSize, sizeof(UCHAR));
            }
 
        } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
 
            Status = STATUS_INVALID_USER_BUFFER;
        } _SEH2_END;
 
        if (!NT_SUCCESS(Status)) {
            _SEH2_LEAVE;
        }
 
        DEBUG(DL_DBG, ("Ext2GetRetrievalPointerBase: FileAreaOffset is 0.\n"));
 
        FileAreaOffset->QuadPart = 0; // sector offset to the first allocatable unit on the filesystem
 
        Irp->IoStatus.Information = sizeof(LARGE_INTEGER);
 
    } _SEH2_FINALLY {
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (!_SEH2_AbnormalTermination()) {
            if (Status == STATUS_PENDING || Status == STATUS_CANT_WAIT) {
                Status = Ext2QueueRequest(IrpContext);
            } else {
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2UserFsRequest().

◆ Ext2GetRetrievalPointers()

NTSTATUS Ext2GetRetrievalPointers ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 911 of file fsctl.c.

{
    PIRP                Irp = NULL;
    PIO_STACK_LOCATION  IrpSp;
    PEXTENDED_IO_STACK_LOCATION EIrpSp;
 
    PDEVICE_OBJECT      DeviceObject;
    PFILE_OBJECT        FileObject;
 
    PEXT2_VCB           Vcb = NULL;
    PEXT2_FCB           Fcb = NULL;
    PEXT2_CCB           Ccb = NULL;
 
    PSTARTING_VCN_INPUT_BUFFER  SVIB;
    PRETRIEVAL_POINTERS_BUFFER  RPSB;
 
    PEXT2_EXTENT        Chain = NULL;
    PEXT2_EXTENT        Extent = NULL;
 
    LONGLONG            Vbn = 0;
    ULONG               Length = 0;
    ULONG               i = 0;
 
    ULONG               UsedSize = 0;
    ULONG               InputSize;
    ULONG               OutputSize;
 
    NTSTATUS            Status = STATUS_SUCCESS;
 
    BOOLEAN FcbResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext);
        Irp = IrpContext->Irp;
        ASSERT(Irp);
 
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
        EIrpSp = (PEXTENDED_IO_STACK_LOCATION)IrpSp;
        ASSERT(IrpSp);
 
        InputSize = EIrpSp->Parameters.FileSystemControl.InputBufferLength;
        OutputSize = EIrpSp->Parameters.FileSystemControl.OutputBufferLength;
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        /* This request is not allowed on the main device object */
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
        ASSERT(IsMounted(Vcb));
 
        FileObject = IrpContext->FileObject;
        Fcb = (PEXT2_FCB) FileObject->FsContext;
 
        /* check Fcb is valid or not */
        if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
        if (IsFlagOn(Fcb->Mcb->Flags, MCB_FILE_DELETED)) {
            Status = STATUS_FILE_DELETED;
            _SEH2_LEAVE;
        }
 
        Ccb = (PEXT2_CCB) FileObject->FsContext2;
        if (Ccb == NULL) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
               (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
 
        if (InputSize  < sizeof(STARTING_VCN_INPUT_BUFFER) ||
                OutputSize < sizeof(RETRIEVAL_POINTERS_BUFFER) ) {
            Status = STATUS_BUFFER_TOO_SMALL;
            _SEH2_LEAVE;
        }
 
        if (!ExAcquireResourceExclusiveLite (
                    &Fcb->MainResource, Ext2CanIWait())) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
        FcbResourceAcquired = TRUE;
 
        SVIB = (PSTARTING_VCN_INPUT_BUFFER)
               EIrpSp->Parameters.FileSystemControl.Type3InputBuffer;
        RPSB = (PRETRIEVAL_POINTERS_BUFFER) Ext2GetUserBuffer(Irp);
 
        /* probe user buffer */
 
        _SEH2_TRY {
            if (Irp->RequestorMode != KernelMode) {
                ProbeForRead (SVIB, InputSize,  sizeof(UCHAR));
                ProbeForWrite(RPSB, OutputSize, sizeof(UCHAR));
            }
        } _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER) {
            Status = STATUS_INVALID_USER_BUFFER;
        } _SEH2_END;
 
        if (!NT_SUCCESS(Status)) {
            _SEH2_LEAVE;
        }
 
        UsedSize = FIELD_OFFSET(RETRIEVAL_POINTERS_BUFFER, Extents[0]);
 
        /* request size beyonds whole file size ? */
        DEBUG(DL_DBG, ("Ext2GetRetrievalPointers: Startin from Vbn: %I64xh\n",
                       SVIB->StartingVcn.QuadPart));
        Vbn = (SVIB->StartingVcn.QuadPart << BLOCK_BITS);
        if (Vbn >= Fcb->Header.AllocationSize.QuadPart ) {
            Status = STATUS_END_OF_FILE;
            _SEH2_LEAVE;
        }
 
        /* now building all the request extents */
        while (Vbn < Fcb->Header.AllocationSize.QuadPart) {
 
            ASSERT(Chain == NULL);
            Length = 0x80000000; /* 2g bytes */
            if (Fcb->Header.AllocationSize.QuadPart < Vbn + Length) {
                Length = (ULONG)(Fcb->Header.AllocationSize.QuadPart - Vbn);
            }
 
            /* build extents for sub-range */
            Status = Ext2BuildExtents(
                         IrpContext,
                         Vcb,
                         Fcb->Mcb,
                         Vbn,
                         Length,
                         FALSE,
                         &Chain);
 
            if (!NT_SUCCESS(Status)) {
                DbgBreak();
                _SEH2_LEAVE;
            }
 
            /* fill user buffer of RETRIEVAL_POINTERS_BUFFER */
            Extent = Chain;
            while (Extent) {
 
                DEBUG(DL_MAP, ("Ext2GetRetrievalPointers: %wZ %d Vbn = %I64xh Lbn = %I64xh\n",
                               &Fcb->Mcb->FullName, i,
                               ((Vbn + Extent->Offset) >> BLOCK_BITS),
                               Extent->Lba));
 
                RPSB->Extents[i].Lcn.QuadPart = (Extent->Lba >> BLOCK_BITS);
                RPSB->Extents[i].NextVcn.QuadPart = ((Vbn + Extent->Offset + Extent->Length) >> BLOCK_BITS);
                if (i == 0) {
                    RPSB->StartingVcn.QuadPart = ((Vbn + Extent->Offset) >> BLOCK_BITS);
                } else {
                    ASSERT(RPSB->Extents[i-1].NextVcn.QuadPart == ((Vbn + Extent->Offset) >> BLOCK_BITS));
                }
                if (UsedSize + sizeof(RETRIEVAL_POINTERS_BUFFER) > OutputSize) {
                    Status = STATUS_BUFFER_OVERFLOW;
                    _SEH2_LEAVE;
                }
                UsedSize += sizeof(LARGE_INTEGER) * 2;
                Irp->IoStatus.Information = (ULONG_PTR)UsedSize;
                RPSB->ExtentCount = ++i;
                Extent = Extent->Next;
            }
 
            if (Chain) {
                Ext2DestroyExtentChain(Chain);
                Chain = NULL;
            }
 
            Vbn = Vbn + Length;
        }
 
#if 0
        {
            NTSTATUS _s;
            ULONG  _i = 0;
            LARGE_INTEGER RequestVbn = Fcb->Header.AllocationSize;
            PLARGE_INTEGER MappedRuns = NULL;
 
            _s = Ext2QueryExtentMappings(
                     IrpContext,
                     Vcb,
                     Fcb,
                     &RequestVbn,
                     &MappedRuns
                 );
            if (!NT_SUCCESS(_s) || NULL == MappedRuns) {
                DbgBreak();
                goto exit_to_get_rps;
            }
 
            while (MappedRuns[_i*2 + 0].QuadPart != 0 ||
                    MappedRuns[_i*2 + 1].QuadPart != 0 ) {
                DEBUG(DL_MAP, ("Ext2QueryExtentMappings: %wZ %d Vbn = %I64xh Lbn = %I64xh\n",
                               &Fcb->Mcb->FullName, _i,
                               MappedRuns[_i*2 + 0].QuadPart,
                               MappedRuns[_i*2 + 1].QuadPart));
                _i++;
            }
 
exit_to_get_rps:
 
            if (MappedRuns) {
                Ext2FreePool(MappedRuns, 'RE2E');
            }
        }
#endif
 
    } _SEH2_FINALLY {
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (Chain) {
            Ext2DestroyExtentChain(Chain);
        }
 
        if (!_SEH2_AbnormalTermination()) {
            if (Status == STATUS_PENDING || Status == STATUS_CANT_WAIT) {
                Status = Ext2QueueRequest(IrpContext);
            } else {
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2UserFsRequest().

◆ Ext2GetUserBuffer()

PVOID Ext2GetUserBuffer ( IN PIRP Irp )

Definition at line 146 of file block.c.

{
    ASSERT(Irp != NULL);
 
    if (Irp->MdlAddress) {
 
#if (_WIN32_WINNT >= 0x0500)
        return MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
#else
        return MmGetSystemAddressForMdl(Irp->MdlAddress);
#endif
    } else {
 
        return Irp->UserBuffer;
    }
}

Referenced by Ext2GetRetrievalPointerBase(), Ext2GetRetrievalPointers(), Ext2QueryDirectory(), Ext2QueryEa(), Ext2ReadFile(), Ext2ReadInode(), Ext2ReadVolume(), Ext2WriteFile(), and Ext2WriteVolume().

◆ Ext2InitializeLabel()

NTSTATUS Ext2InitializeLabel	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_SUPER_BLOCK	Sb
	)

Definition at line 2253 of file memory.c.

{
    NTSTATUS            status;
 
    USHORT              Length;
    UNICODE_STRING      Label;
    OEM_STRING          OemName;
 
    Label.MaximumLength = 16 * sizeof(WCHAR);
    Label.Length    = 0;
    Label.Buffer    = Vcb->Vpb->VolumeLabel;
    Vcb->Vpb->VolumeLabelLength = 0;
    RtlZeroMemory(Label.Buffer, Label.MaximumLength);
 
    Length = 16;
    while (  (Length > 0) &&
             ((Sb->s_volume_name[Length -1]  == 0x00) ||
              (Sb->s_volume_name[Length - 1] == 0x20)  )
          ) {
        Length--;
    }
 
    if (Length == 0) {
        return STATUS_SUCCESS;
    }
 
    OemName.Buffer =  Sb->s_volume_name;
    OemName.MaximumLength = 16;
    OemName.Length = Length;
 
    status = Ext2OEMToUnicode(Vcb, &Label, &OemName);
    if (NT_SUCCESS(status)) {
        Vcb->Vpb->VolumeLabelLength = Label.Length;
    }
 
    return status;
}

Referenced by Ext2InitializeVcb(), and Ext2ProcessVolumeProperty().

◆ Ext2InitializeVcb()

NTSTATUS Ext2InitializeVcb	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_SUPER_BLOCK	Ext2Sb,
		PDEVICE_OBJECT	TargetDevice,
		PDEVICE_OBJECT	VolumeDevice,
		PVPB	Vpb
	)

Referenced by Ext2MountVolume().

◆ Ext2InitializeZone()

NTSTATUS Ext2InitializeZone	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb
	)

Definition at line 1121 of file memory.c.

{
    NTSTATUS    Status = STATUS_SUCCESS;
 
    ULONG       Start = 0;
    ULONG       End;
    ULONG       Block;
    ULONG       Mapped;
 
    Ext2ClearAllExtents(&Mcb->Extents);
    Ext2ClearAllExtents(&Mcb->MetaExts);
 
    ASSERT(Mcb != NULL);
    End = (ULONG)((Mcb->Inode.i_size + BLOCK_SIZE - 1) >> BLOCK_BITS);
 
    while (Start < End) {
 
        Block = Mapped = 0;
 
        /* mapping file offset to ext2 block */
        if (INODE_HAS_EXTENT(&Mcb->Inode)) {
            Status = Ext2MapExtent(
                         IrpContext,
                         Vcb,
                         Mcb,
                         Start,
                         FALSE,
                         &Block,
                         &Mapped
                     );
        } else {
            Status = Ext2MapIndirect(
                         IrpContext,
                         Vcb,
                         Mcb,
                         Start,
                         FALSE,
                         &Block,
                         &Mapped
                     );
        }
 
        if (!NT_SUCCESS(Status)) {
            goto errorout;
        }
 
        /* skip wrong blocks, in case wrongly treating symlink
           target names as blocks, silly  */
        if (Block >= TOTAL_BLOCKS) {
            Block = 0;
        }
 
        if (Block) {
            if (!Ext2AddBlockExtent(Vcb, Mcb, Start, Block, Mapped)) {
                DbgBreak();
                ClearFlag(Mcb->Flags, MCB_ZONE_INITED);
                Ext2ClearAllExtents(&Mcb->Extents);
                Status = STATUS_INSUFFICIENT_RESOURCES;
                goto errorout;
            }
            DEBUG(DL_MAP, ("Ext2InitializeZone %wZ: Block = %xh Mapped = %xh\n",
                           &Mcb->FullName, Block, Mapped));
        }
 
        /* Mapped is total number of continous blocks or NULL blocks */
        Start += Mapped;
    }
 
    /* set mcb zone as initialized */
    SetLongFlag(Mcb->Flags, MCB_ZONE_INITED);
 
errorout:
 
    if (!IsZoneInited(Mcb)) {
        Ext2ClearAllExtents(&Mcb->Extents);
        Ext2ClearAllExtents(&Mcb->MetaExts);
    }
 
    return Status;
}

Referenced by Ext2BuildExtents(), and Ext2TruncateIndirectFast().

◆ Ext2InodeType()

ULONG Ext2InodeType ( PEXT2_MCB Mcb )

Definition at line 1906 of file fileinfo.c.

{
    if (IsMcbSymLink(Mcb)) {
        return EXT2_FT_SYMLINK;
    }
 
    if (IsMcbDirectory(Mcb)) {
        return EXT2_FT_DIR;
    }
 
    return EXT2_FT_REG_FILE;
}

Referenced by Ext2DeleteFile().

◆ Ext2InsertFcb()

VOID Ext2InsertFcb	(	PEXT2_VCB	Vcb,
		PEXT2_FCB	Fcb
	)

Definition at line 309 of file memory.c.

{
    ASSERT(ExIsResourceAcquiredExclusiveLite(&Vcb->FcbLock));
 
    KeQuerySystemTime(&Fcb->TsDrop);
    Ext2ReferXcb(&Vcb->FcbCount);
    Ext2ReferXcb(&Vcb->ReferenceCount);
    InsertTailList(&Vcb->FcbList, &Fcb->Next);
}

Referenced by Ext2AllocateFcb().

◆ Ext2InsertMcb()

VOID Ext2InsertMcb	(	PEXT2_VCB	Vcb,
		PEXT2_MCB	Parent,
		PEXT2_MCB	Child
	)

Definition at line 1686 of file memory.c.

{
    BOOLEAN     LockAcquired = FALSE;
    PEXT2_MCB   Mcb = NULL;
 
    _SEH2_TRY {
 
        ExAcquireResourceExclusiveLite(
            &Vcb->McbLock,
            TRUE );
        LockAcquired = TRUE;
 
        /* use it's target if it's a symlink */
        if (IsMcbSymLink(Parent)) {
            Parent = Parent->Target;
            ASSERT(!IsMcbSymLink(Parent));
        }
 
        Mcb = Parent->Child;
        while (Mcb) {
            if (Mcb == Child) {
                break;
            }
            Mcb = Mcb->Next;
        }
 
        if (Mcb) {
            /* already attached in the list */
            DEBUG(DL_ERR, ( "Ext2InsertMcb: Child Mcb is alreay attached.\n"));
            if (!IsFlagOn(Mcb->Flags, MCB_ENTRY_TREE)) {
                SetLongFlag(Child->Flags, MCB_ENTRY_TREE);
                DEBUG(DL_ERR, ( "Ext2InsertMcb: Child Mcb's flag isn't set.\n"));
            }
 
            DbgBreak();
 
        } else {
 
            /* insert this Mcb into the head */
            Child->Next = Parent->Child;
            Parent->Child = Child;
            Child->Parent = Parent;
            Child->de->d_parent = Parent->de;
            Ext2ReferMcb(Parent);
            SetLongFlag(Child->Flags, MCB_ENTRY_TREE);
        }
 
    } _SEH2_FINALLY {
 
        if (LockAcquired) {
            ExReleaseResourceLite(&Vcb->McbLock);
        }
    } _SEH2_END;
}

Referenced by Ext2LookupFile(), and Ext2SetRenameInfo().

◆ Ext2InsertVcb()

VOID Ext2InsertVcb ( PEXT2_VCB Vcb )

Definition at line 1935 of file memory.c.

{
    InsertTailList(&(Ext2Global->VcbList), &Vcb->Next);
}

Referenced by Ext2MountVolume().

◆ Ext2IsDirectoryEmpty()

BOOLEAN Ext2IsDirectoryEmpty	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb
	)

Referenced by Ext2DeleteFile(), and Ext2IsFileRemovable().

◆ Ext2IsDot()

BOOLEAN Ext2IsDot ( PUNICODE_STRING name )

Definition at line 524 of file misc.c.

{
    return (name->Length == 2 && name->Buffer[0] == L'.');
}

Referenced by Ext2SearchMcbWithoutLock().

◆ Ext2IsDotDot()

BOOLEAN Ext2IsDotDot ( PUNICODE_STRING name )

Definition at line 529 of file misc.c.

{
    return (name->Length == 4 && name->Buffer[0] == L'.' &&
            name->Buffer[1] == L'.');
}

Referenced by Ext2SearchMcbWithoutLock().

◆ Ext2IsEaNameValid()

BOOLEAN Ext2IsEaNameValid ( IN OEM_STRING Name )

Definition at line 389 of file ea.c.

{
    ULONG Index;
    UCHAR Char;
 
    //
    //  Empty names are not valid
    //
 
    if (Name.Length == 0)
        return FALSE;
 
    //
    // Do not allow EA name longer than 255 bytes
    //
    if (Name.Length > 255)
        return FALSE;
 
    for (Index = 0; Index < (ULONG)Name.Length; Index += 1) {
 
        Char = Name.Buffer[Index];
 
        //
        //  Skip over and Dbcs chacters
        //
        if (FsRtlIsLeadDbcsCharacter(Char)) {
 
            ASSERT(Index != (ULONG)(Name.Length - 1));
            Index += 1;
            continue;
        }
 
        //
        //  Make sure this character is legal, and if a wild card, that
        //  wild cards are permissible.
        //
        if (!FsRtlIsAnsiCharacterLegalFat(Char, FALSE))
            return FALSE;
 
    }
 
    return TRUE;
}

Referenced by Ext2OverwriteEa(), and Ext2SetEa().

◆ Ext2IsFastIoPossible()

FAST_IO_POSSIBLE Ext2IsFastIoPossible ( IN PEXT2_FCB Fcb )

Definition at line 38 of file fastio.c.

{
    FAST_IO_POSSIBLE IsPossible = FastIoIsNotPossible;
 
    if (!Fcb || !FsRtlOplockIsFastIoPossible(&Fcb->Oplock))
        return IsPossible;
 
    IsPossible = FastIoIsQuestionable;
 
    if (!FsRtlAreThereCurrentFileLocks(&Fcb->FileLockAnchor)) {
        if (!IsVcbReadOnly(Fcb->Vcb) && !FlagOn(Fcb->Vcb->Flags, VCB_VOLUME_LOCKED)) {
            IsPossible = FastIoIsPossible;
        }
    }
 
    return IsPossible;
}

Referenced by Ext2Cleanup(), Ext2FastIoLock(), Ext2FastIoUnlockAll(), Ext2FastIoUnlockAllByKey(), Ext2FastIoUnlockSingle(), Ext2LockControl(), Ext2OplockRequest(), Ext2ReadFile(), Ext2SetFileInformation(), and Ext2WriteFile().

◆ Ext2IsFileRemovable()

NTSTATUS Ext2IsFileRemovable	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_FCB	Fcb,
		IN PEXT2_CCB	Ccb
	)

Definition at line 1239 of file fileinfo.c.

{
    PEXT2_MCB Mcb = Fcb->Mcb;
 
    if (Mcb->Inode.i_ino == EXT2_ROOT_INO) {
        return STATUS_CANNOT_DELETE;
    }
 
    if (IsMcbDirectory(Mcb)) {
        if (!Ext2IsDirectoryEmpty(IrpContext, Vcb, Mcb)) {
            return STATUS_DIRECTORY_NOT_EMPTY;
        }
    }
 
    if (!MmFlushImageSection(&Fcb->SectionObject,
                             MmFlushForDelete )) {
        return STATUS_CANNOT_DELETE;
    }
 
    if (IsMcbDirectory(Mcb)) {
        FsRtlNotifyFullChangeDirectory(
            Vcb->NotifySync,
            &Vcb->NotifyList,
            Ccb,
            NULL,
            FALSE,
            FALSE,
            0,
            NULL,
            NULL,
            NULL
        );
    }
 
    return STATUS_SUCCESS;
}

Referenced by Ext2CreateFile(), Ext2SetDispositionInfo(), Ext2SetLinkInfo(), and Ext2SetRenameInfo().

◆ Ext2IsHandleCountZero()

BOOLEAN Ext2IsHandleCountZero ( IN PEXT2_VCB Vcb )

Definition at line 68 of file fsctl.c.

{
    PEXT2_FCB   Fcb;
    PLIST_ENTRY List;
 
    for ( List = Vcb->FcbList.Flink;
            List != &Vcb->FcbList;
            List = List->Flink )  {
 
        Fcb = CONTAINING_RECORD(List, EXT2_FCB, Next);
 
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
        DEBUG(DL_INF, ( "Ext2IsHandleCountZero: Inode:%xh File:%S OpenHandleCount=%xh\n",
                        Fcb->Inode->i_ino, Fcb->Mcb->ShortName.Buffer, Fcb->OpenHandleCount));
 
        if (Fcb->OpenHandleCount) {
            return FALSE;
        }
    }
 
    return TRUE;
}

Referenced by Ext2LockVcb().

◆ Ext2IsMediaWriteProtected()

BOOLEAN Ext2IsMediaWriteProtected	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PDEVICE_OBJECT	TargetDevice
	)

Definition at line 2005 of file fsctl.c.

{
    PIRP            Irp;
    KEVENT          Event;
    NTSTATUS        Status;
    IO_STATUS_BLOCK IoStatus;
 
    KeInitializeEvent(&Event, NotificationEvent, FALSE);
 
    Irp = IoBuildDeviceIoControlRequest( IOCTL_DISK_IS_WRITABLE,
                                         TargetDevice,
                                         NULL,
                                         0,
                                         NULL,
                                         0,
                                         FALSE,
                                         &Event,
                                         &IoStatus );
 
    if (Irp == NULL) {
        return FALSE;
    }
 
    SetFlag(IoGetNextIrpStackLocation(Irp)->Flags, SL_OVERRIDE_VERIFY_VOLUME);
 
    Status = IoCallDriver(TargetDevice, Irp);
 
    if (Status == STATUS_PENDING) {
 
        (VOID) KeWaitForSingleObject( &Event,
                                      Executive,
                                      KernelMode,
                                      FALSE,
                                      (PLARGE_INTEGER)NULL );
 
        Status = IoStatus.Status;
    }
 
    return (BOOLEAN)(Status == STATUS_MEDIA_WRITE_PROTECTED);
}

Referenced by Ext2InitializeVcb(), and Ext2VerifyVolume().

◆ Ext2IsNameValid()

BOOLEAN Ext2IsNameValid ( PUNICODE_STRING FileName )

Definition at line 36 of file create.c.

{
    USHORT  i = 0;
    PUSHORT pName = (PUSHORT) FileName->Buffer;
 
    if (FileName == NULL) {
        return FALSE;
    }
 
    while (i < (FileName->Length / sizeof(WCHAR))) {
 
        if (pName[i] == 0) {
            break;
        }
 
        if (pName[i] == L'|'  || pName[i] == L':'  ||
                pName[i] == L'/'  || pName[i] == L'*'  ||
                pName[i] == L'?'  || pName[i] == L'\"' ||
                pName[i] == L'<'  || pName[i] == L'>'   ) {
 
            return FALSE;
        }
 
        i++;
    }
 
    return TRUE;
}

Referenced by Ext2CreateFile(), and Ext2LookupFile().

◆ Ext2IsSpecialSystemFile()

BOOLEAN Ext2IsSpecialSystemFile	(	IN PUNICODE_STRING	FileName,
		IN BOOLEAN	bDirectory
	)

Definition at line 224 of file create.c.

{
    PWSTR SpecialFileList[] = {
        L"pagefile.sys",
        L"swapfile.sys",
        L"hiberfil.sys",
        NULL
    };
 
    PWSTR SpecialDirList[] = {
        L"Recycled",
        L"RECYCLER",
        L"$RECYCLE.BIN",
        NULL
    };
 
    PWSTR   entryName;
    ULONG   length;
    int     i;
 
    for (i = 0; TRUE; i++) {
 
        if (bDirectory) {
            entryName = SpecialDirList[i];
        } else {
            entryName = SpecialFileList[i];
        }
 
        if (NULL == entryName) {
            break;
        }
 
        length = wcslen(entryName) * sizeof(WCHAR);
        if (FileName->Length == length) {
            if ( 0 == _wcsnicmp( entryName,
                                 FileName->Buffer,
                                 length / sizeof(WCHAR) )) {
                return TRUE;
            }
        }
    }
 
    return FALSE;
}

Referenced by Ext2LookupFile(), and Ext2ProcessEntry().

◆ Ext2IsVolumeMounted()

NTSTATUS Ext2IsVolumeMounted ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 2494 of file fsctl.c.

{
    PDEVICE_OBJECT      DeviceObject;
    PEXT2_VCB           Vcb = 0;
    NTSTATUS            Status = STATUS_SUCCESS;
 
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
 
    DeviceObject = IrpContext->DeviceObject;
 
    Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
 
    ASSERT(IsMounted(Vcb));
 
    Ext2VerifyVcb (IrpContext, Vcb);
 
    Ext2CompleteIrpContext(IrpContext,  Status);
 
    return Status;
}

Referenced by Ext2UserFsRequest().

◆ Ext2IsWearingCloak()

BOOLEAN Ext2IsWearingCloak	(	IN PEXT2_VCB	Vcb,
		IN POEM_STRING	OeName
	)

Definition at line 372 of file dirctl.c.

{
    size_t  PatLen = 0;
 
    /* we could not filter the files: "." and ".." */
    if (OemName->Length >= 1 && OemName->Buffer[0] == '.') {
 
        if ( OemName->Length == 2 && OemName->Buffer[1] == '.') {
            return FALSE;
        } else if (OemName->Length == 1) {
            return FALSE;
        }
    }
 
    /* checking name prefix */
    if (Vcb->bHidingPrefix) {
        PatLen = strlen(&Vcb->sHidingPrefix[0]);
        if (PatLen > 0 && PatLen <= OemName->Length) {
            if ( _strnicmp( OemName->Buffer,
                            Vcb->sHidingPrefix,
                            PatLen ) == 0) {
                return TRUE;
            }
        }
    }
 
    /* checking name suffix */
    if (Vcb->bHidingSuffix) {
        PatLen = strlen(&Vcb->sHidingSuffix[0]);
        if (PatLen > 0 && PatLen <= OemName->Length) {
            if ( _strnicmp(&OemName->Buffer[OemName->Length - PatLen],
                           Vcb->sHidingSuffix, PatLen ) == 0) {
                return TRUE;
            }
        }
    }
 
    return FALSE;
}

Referenced by Ext2FillEntry(), and Ext2QueryDirectory().

◆ Ext2JointExtents()

VOID Ext2JointExtents	(	IN PEXT2_EXTENT	Chain,
		IN PEXT2_EXTENT	Extent
	)

Definition at line 527 of file memory.c.

{
#ifndef __REACTOS__
    ULONG        count = 0;
#endif
    PEXT2_EXTENT List = Chain;
 
    while (List->Next) {
        List = List->Next;
    }
 
    List->Next = Extent;
}

Referenced by Ext2QueryExtentMappings().

◆ Ext2LinkHeadMcb()

VOID Ext2LinkHeadMcb	(	PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb
	)

Definition at line 2935 of file memory.c.

{
    if (Mcb->Inode.i_ino == EXT2_ROOT_INO) {
        return;
    }
 
    ExAcquireResourceExclusiveLite(&Vcb->McbLock, TRUE);
 
    if (!IsFlagOn(Mcb->Flags, MCB_VCB_LINK)) {
        InsertHeadList(&Vcb->McbList, &Mcb->Link);
        SetLongFlag(Mcb->Flags, MCB_VCB_LINK);
        Ext2ReferXcb(&Vcb->NumOfMcb);
    } else {
        DEBUG(DL_RES, ( "Ext2LinkHeadMcb: %wZ already linked.\n",
                        &Mcb->FullName));
    }
    ExReleaseResourceLite(&Vcb->McbLock);
}

Referenced by Ext2FreeCcb(), and Ext2UnlinkFcb().

◆ Ext2LinkTailMcb()

VOID Ext2LinkTailMcb	(	PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb
	)

Definition at line 2912 of file memory.c.

{
    if (Mcb->Inode.i_ino == EXT2_ROOT_INO) {
        return;
    }
 
    ExAcquireResourceExclusiveLite(&Vcb->McbLock, TRUE);
 
    if (IsFlagOn(Mcb->Flags, MCB_VCB_LINK)) {
        DEBUG(DL_RES, ( "Ext2LinkTailMcb: %wZ already linked.\n",
                        &Mcb->FullName));
    } else {
        InsertTailList(&Vcb->McbList, &Mcb->Link);
        SetLongFlag(Mcb->Flags, MCB_VCB_LINK);
        Ext2ReferXcb(&Vcb->NumOfMcb);
    }
 
    ExReleaseResourceLite(&Vcb->McbLock);
}

Referenced by Ext2LookupFile().

◆ Ext2LinuxError()

int Ext2LinuxError ( NTSTATUS Status )

Definition at line 304 of file misc.c.

{
    switch (Status) {
    case STATUS_ACCESS_DENIED:
        return (-EACCES);
 
    case STATUS_ACCESS_VIOLATION:
        return (-EFAULT);
 
    case STATUS_BUFFER_TOO_SMALL:
        return (-ETOOSMALL);
 
    case STATUS_INVALID_PARAMETER:
        return (-EINVAL);
 
    case STATUS_NOT_IMPLEMENTED:
    case STATUS_NOT_SUPPORTED:
        return (-EOPNOTSUPP);
 
    case STATUS_INVALID_ADDRESS:
    case STATUS_INVALID_ADDRESS_COMPONENT:
        return (-EADDRNOTAVAIL);
 
    case STATUS_NO_SUCH_DEVICE:
    case STATUS_NO_SUCH_FILE:
    case STATUS_OBJECT_NAME_NOT_FOUND:
    case STATUS_OBJECT_PATH_NOT_FOUND:
    case STATUS_NETWORK_BUSY:
    case STATUS_INVALID_NETWORK_RESPONSE:
    case STATUS_UNEXPECTED_NETWORK_ERROR:
        return (-ENETDOWN);
 
    case STATUS_BAD_NETWORK_PATH:
    case STATUS_NETWORK_UNREACHABLE:
    case STATUS_PROTOCOL_UNREACHABLE:
        return (-ENETUNREACH);
 
    case STATUS_LOCAL_DISCONNECT:
    case STATUS_TRANSACTION_ABORTED:
    case STATUS_CONNECTION_ABORTED:
        return (-ECONNABORTED);
 
    case STATUS_REMOTE_DISCONNECT:
    case STATUS_LINK_FAILED:
    case STATUS_CONNECTION_DISCONNECTED:
    case STATUS_CONNECTION_RESET:
    case STATUS_PORT_UNREACHABLE:
        return (-ECONNRESET);
 
    case STATUS_INSUFFICIENT_RESOURCES:
        return (-ENOMEM);
 
    case STATUS_PAGEFILE_QUOTA:
    case STATUS_NO_MEMORY:
    case STATUS_CONFLICTING_ADDRESSES:
    case STATUS_QUOTA_EXCEEDED:
    case STATUS_TOO_MANY_PAGING_FILES:
    case STATUS_WORKING_SET_QUOTA:
    case STATUS_COMMITMENT_LIMIT:
    case STATUS_TOO_MANY_ADDRESSES:
    case STATUS_REMOTE_RESOURCES:
        return (-ENOBUFS);
 
    case STATUS_INVALID_CONNECTION:
        return (-ENOTCONN);
 
    case STATUS_PIPE_DISCONNECTED:
        return (-ESHUTDOWN);
 
    case STATUS_TIMEOUT:
    case STATUS_IO_TIMEOUT:
    case STATUS_LINK_TIMEOUT:
        return (-ETIMEDOUT);
 
    case STATUS_REMOTE_NOT_LISTENING:
    case STATUS_CONNECTION_REFUSED:
        return (-ECONNREFUSED);
 
    case STATUS_HOST_UNREACHABLE:
        return (-EHOSTUNREACH);
 
    case STATUS_CANT_WAIT:
    case STATUS_PENDING:
        return (-EAGAIN);
 
    case STATUS_DEVICE_NOT_READY:
        return (-EIO);
 
    case STATUS_CANCELLED:
    case STATUS_REQUEST_ABORTED:
        return (-EINTR);
 
    case STATUS_BUFFER_OVERFLOW:
    case STATUS_INVALID_BUFFER_SIZE:
        return (-EMSGSIZE);
 
    case STATUS_ADDRESS_ALREADY_EXISTS:
        return (-EADDRINUSE);
    }
 
    if (NT_SUCCESS (Status))
        return 0;
 
    return (-EINVAL);
}

Referenced by ext3_bread(), and ext4_new_meta_blocks().

◆ Ext2LinuxTime()

ULONG Ext2LinuxTime ( IN LARGE_INTEGER SysTime )

Definition at line 51 of file misc.c.

{
    ULONG   Ext2Time = 0;
 
    if (!RtlTimeToSecondsSince1970(&SysTime, &Ext2Time)) {
        LARGE_INTEGER NtTime;
        KeQuerySystemTime(&NtTime);
        RtlTimeToSecondsSince1970(&NtTime, &Ext2Time);
    }
 
    return Ext2Time;
}

Referenced by Ext2Cleanup(), Ext2CreateInode(), Ext2DeleteFile(), Ext2FlushFile(), Ext2SetFileInformation(), Ext2SupersedeOrOverWriteFile(), and ext3_current_time().

◆ Ext2ListExtents()

BOOLEAN Ext2ListExtents ( PLARGE_MCB Extents )

Definition at line 558 of file memory.c.

{
    if (FsRtlNumberOfRunsInLargeMcb(Extents) != 0) {
 
        LONGLONG            DirtyVba;
        LONGLONG            DirtyLba;
        LONGLONG            DirtyLength;
        int                 i, n = 0;
 
        for (i = 0; FsRtlGetNextLargeMcbEntry(
                    Extents, i, &DirtyVba,
                    &DirtyLba, &DirtyLength); i++)  {
            if (DirtyVba > 0 && DirtyLba != -1) {
                DEBUG(DL_EXT, ("Vba:%I64xh Lba:%I64xh Len:%I64xh.\n", DirtyVba, DirtyLba, DirtyLength));
                n++;
            }
        }
 
        return n ? TRUE : FALSE;
    }
 
    return FALSE;
}

Referenced by Ext2DestroyVcb(), Ext2FreeMcb(), and Ext2TruncateFile().

◆ Ext2LoadAllNls()

int Ext2LoadAllNls ( )

Definition at line 118 of file nls.c.

{
    int rc;
 
    tables = NULL;
    spin_lock_init(&nls_lock);
 
    /* loading utf8 ... */
    LOAD_NLS(init_nls_utf8);
 
#ifdef FULL_CODEPAGES_SUPPORT
 
    /* loading chinese gb2312 and big5... */
    LOAD_NLS(init_nls_cp936);
    LOAD_NLS(init_nls_cp950);
 
    /* loading all others */
 
    LOAD_NLS(init_nls_ascii);
    LOAD_NLS(init_nls_cp1250);
    LOAD_NLS(init_nls_cp1251);
    LOAD_NLS(init_nls_cp1255);
    LOAD_NLS(init_nls_cp437);
    LOAD_NLS(init_nls_cp737);
    LOAD_NLS(init_nls_cp775);
    LOAD_NLS(init_nls_cp850);
    LOAD_NLS(init_nls_cp852);
    LOAD_NLS(init_nls_cp855);
    LOAD_NLS(init_nls_cp857);
    LOAD_NLS(init_nls_cp860);
    LOAD_NLS(init_nls_cp861);
    LOAD_NLS(init_nls_cp862);
    LOAD_NLS(init_nls_cp863);
    LOAD_NLS(init_nls_cp864);
    LOAD_NLS(init_nls_cp865);
    LOAD_NLS(init_nls_cp866);
    LOAD_NLS(init_nls_cp869);
    LOAD_NLS(init_nls_cp874);
    LOAD_NLS(init_nls_cp932);
    LOAD_NLS(init_nls_euc_jp);
    LOAD_NLS(init_nls_cp949);
    LOAD_NLS(init_nls_iso8859_1);
    LOAD_NLS(init_nls_iso8859_13);
    LOAD_NLS(init_nls_iso8859_14);
    LOAD_NLS(init_nls_iso8859_15);
    LOAD_NLS(init_nls_iso8859_2);
    LOAD_NLS(init_nls_iso8859_3);
    LOAD_NLS(init_nls_iso8859_4);
    LOAD_NLS(init_nls_iso8859_5);
    LOAD_NLS(init_nls_iso8859_6);
    LOAD_NLS(init_nls_iso8859_7);
    LOAD_NLS(init_nls_iso8859_9);
    LOAD_NLS(init_nls_koi8_r);
    LOAD_NLS(init_nls_koi8_u);
    LOAD_NLS(init_nls_koi8_ru);
 
#endif //FULL_CODEPAGES_SUPPORT
 
    return rc;
}

Referenced by DriverEntry().

◆ Ext2LoadBlock()

BOOLEAN Ext2LoadBlock	(	IN PEXT2_VCB	Vcb,
		IN ULONG	dwBlk,
		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().

◆ Ext2LoadInternalJournal()

PEXT2_MCB Ext2LoadInternalJournal	(	PEXT2_VCB	Vcb,
		ULONG	jNo
	)

Definition at line 29 of file recover.c.

{
    PEXT2_MCB   Jcb = NULL;
 
    Jcb = Ext2AllocateMcb(Vcb, NULL, NULL, 0);
    if (!Jcb) {
        goto errorout;
    }
 
    Jcb->Inode.i_ino = jNo;
    Jcb->Inode.i_sb = &Vcb->sb;
    if (!Ext2LoadInode(Vcb, &Jcb->Inode)) {
        DbgBreak();
        Ext2FreeMcb(Vcb, Jcb);
        goto errorout;
    }
 
errorout:
 
    return Jcb;
}

Referenced by Ext2RecoverJournal().

◆ 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().

◆ Ext2LockControl()

NTSTATUS Ext2LockControl ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 25 of file lock.c.

{
    PDEVICE_OBJECT  DeviceObject = NULL;
    PFILE_OBJECT    FileObject = NULL;
    PEXT2_FCB       Fcb = NULL;
    PIRP            Irp = NULL;
 
    NTSTATUS        Status = STATUS_UNSUCCESSFUL;
    BOOLEAN         CompleteContext = TRUE;
    BOOLEAN         CompleteIrp = TRUE;
    BOOLEAN         bFcbAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        FileObject = IrpContext->FileObject;
 
        Fcb = (PEXT2_FCB) FileObject->FsContext;
        ASSERT(Fcb != NULL);
        if (Fcb->Identifier.Type == EXT2VCB) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
        if (FlagOn(Fcb->Mcb->FileAttr, FILE_ATTRIBUTE_DIRECTORY)) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ExAcquireResourceSharedLite(&Fcb->MainResource, TRUE);
        bFcbAcquired = TRUE;
 
        Irp = IrpContext->Irp;
 
        CompleteIrp = FALSE;
 
        Status = FsRtlCheckOplock( &Fcb->Oplock,
                                   Irp,
                                   IrpContext,
                                   Ext2OplockComplete,
                                   NULL );
 
        if (Status != STATUS_SUCCESS) {
            CompleteContext = FALSE;
            _SEH2_LEAVE;
        }
 
        //
        // FsRtlProcessFileLock acquires FileObject->FsContext->Resource while
        // modifying the file locks and calls IoCompleteRequest when it's done.
        //
 
        Status = FsRtlProcessFileLock(
                     &Fcb->FileLockAnchor,
                     Irp,
                     NULL );
#if EXT2_DEBUG
        if (!NT_SUCCESS(Status)) {
            DEBUG(DL_ERR, (
                      "Ext2LockControl: %-16.16s %-31s Status: %#x ***\n",
                      Ext2GetCurrentProcessName(),
                      "IRP_MJ_LOCK_CONTROL",
                      Status          ));
        }
#endif
        Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
 
    } _SEH2_FINALLY {
 
        if (bFcbAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
 
            if (!CompleteIrp) {
                IrpContext->Irp = NULL;
            }
 
            if (CompleteContext) {
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2LockIrp()

VOID Ext2LockIrp	(	IN PVOID	Context,
		IN PIRP	Irp
	)

Definition at line 94 of file dispatch.c.

{
    PIO_STACK_LOCATION IrpSp;
    PEXT2_IRP_CONTEXT IrpContext;
 
    if (Irp == NULL) {
        return;
    }
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    IrpContext = (PEXT2_IRP_CONTEXT) Context;
 
    if ( IrpContext->MajorFunction == IRP_MJ_READ ||
            IrpContext->MajorFunction == IRP_MJ_WRITE ) {
 
        //
        //  lock the user's buffer to MDL, if the I/O is bufferred
        //
 
        if (!IsFlagOn(IrpContext->MinorFunction, IRP_MN_MDL)) {
 
            Ext2LockUserBuffer( Irp, IrpSp->Parameters.Write.Length,
                                (IrpContext->MajorFunction == IRP_MJ_READ) ?
                                IoWriteAccess : IoReadAccess );
        }
 
    } else if (IrpContext->MajorFunction == IRP_MJ_DIRECTORY_CONTROL
               && IrpContext->MinorFunction == IRP_MN_QUERY_DIRECTORY) {
 
        ULONG Length = ((PEXTENDED_IO_STACK_LOCATION) IrpSp)->Parameters.QueryDirectory.Length;
        Ext2LockUserBuffer(Irp, Length, IoWriteAccess);
 
    } else if (IrpContext->MajorFunction == IRP_MJ_QUERY_EA) {
 
        ULONG Length = ((PEXTENDED_IO_STACK_LOCATION) IrpSp)->Parameters.QueryEa.Length;
        Ext2LockUserBuffer(Irp, Length, IoWriteAccess);
 
    } else if (IrpContext->MajorFunction == IRP_MJ_SET_EA) {
        ULONG Length = ((PEXTENDED_IO_STACK_LOCATION) IrpSp)->Parameters.SetEa.Length;
        Ext2LockUserBuffer(Irp, Length, IoReadAccess);
 
    } else if ( (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL) &&
                (IrpContext->MinorFunction == IRP_MN_USER_FS_REQUEST) ) {
        PEXTENDED_IO_STACK_LOCATION EIrpSp = (PEXTENDED_IO_STACK_LOCATION)IrpSp;
        if ( (EIrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_VOLUME_BITMAP) ||
                (EIrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_RETRIEVAL_POINTERS) ||
                (EIrpSp->Parameters.FileSystemControl.FsControlCode == FSCTL_GET_RETRIEVAL_POINTER_BASE) ) {
            ULONG Length = EIrpSp->Parameters.FileSystemControl.OutputBufferLength;
            Ext2LockUserBuffer(Irp, Length, IoWriteAccess);
        }
    }
 
    //  Mark the request as pending status
 
    IoMarkIrpPending( Irp );
 
    return;
}

Referenced by Ext2CreateFile(), Ext2QueueRequest(), Ext2ReadFile(), and Ext2WriteFile().

◆ Ext2LockUserBuffer()

NTSTATUS Ext2LockUserBuffer	(	IN PIRP	Irp,
		IN ULONG	Length,
		IN LOCK_OPERATION	Operation
	)

Definition at line 113 of file block.c.

{
    NTSTATUS Status;
    ASSERT(Irp != NULL);
 
    if (Irp->MdlAddress != NULL) {
        return STATUS_SUCCESS;
    }
 
    IoAllocateMdl(Irp->UserBuffer, Length, FALSE, FALSE, Irp);
    if (Irp->MdlAddress == NULL) {
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    _SEH2_TRY {
 
        MmProbeAndLockPages(Irp->MdlAddress, Irp->RequestorMode, Operation);
        Status = STATUS_SUCCESS;
 
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
 
        DbgBreak();
        IoFreeMdl(Irp->MdlAddress);
        Irp->MdlAddress = NULL;
        Status = STATUS_INVALID_USER_BUFFER;
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2LockIrp(), Ext2QueryDirectory(), Ext2ReadFile(), Ext2ReadVolume(), Ext2WriteFile(), and Ext2WriteVolume().

◆ Ext2LockVcb()

NTSTATUS Ext2LockVcb	(	IN PEXT2_VCB	Vcb,
		IN PFILE_OBJECT	FileObject
	)

Definition at line 94 of file fsctl.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    _SEH2_TRY {
 
        if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED)) {
            DEBUG(DL_INF, ( "Ext2LockVolume: Volume is already locked.\n"));
            Status = STATUS_ACCESS_DENIED;
            _SEH2_LEAVE;
        }
 
        if (Vcb->OpenHandleCount > (ULONG)(FileObject ? 1 : 0)) {
            DEBUG(DL_INF, ( "Ext2LockVcb: There are still opened files.\n"));
 
            Status = STATUS_ACCESS_DENIED;
            _SEH2_LEAVE;
        }
 
        if (!Ext2IsHandleCountZero(Vcb)) {
            DEBUG(DL_INF, ( "Ext2LockVcb: Thare are still opened files.\n"));
 
            Status = STATUS_ACCESS_DENIED;
            _SEH2_LEAVE;
        }
 
        SetLongFlag(Vcb->Flags, VCB_VOLUME_LOCKED);
        Ext2SetVpbFlag(Vcb->Vpb, VPB_LOCKED);
        Vcb->LockFile = FileObject;
 
        DEBUG(DL_INF, ( "Ext2LockVcb: Volume locked.\n"));
 
    } _SEH2_FINALLY {
        // Nothing
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2LockVolume().

◆ Ext2LockVolume()

NTSTATUS Ext2LockVolume ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 136 of file fsctl.c.

{
    PIO_STACK_LOCATION IrpSp;
    PDEVICE_OBJECT  DeviceObject;
    PEXT2_VCB       Vcb = NULL;
    NTSTATUS        Status;
    BOOLEAN VcbResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        Status = STATUS_UNSUCCESSFUL;
 
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
 
        ASSERT(Vcb != NULL);
 
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        ASSERT(IsMounted(Vcb));
 
        IrpSp = IoGetCurrentIrpStackLocation(IrpContext->Irp);
 
#if (_WIN32_WINNT >= 0x0500)
        CcWaitForCurrentLazyWriterActivity();
#endif
        ExAcquireResourceExclusiveLite(
            &Vcb->MainResource,
            TRUE            );
 
        VcbResourceAcquired = TRUE;
 
        /* flush dirty data before locking the volume */
        if (!IsVcbReadOnly(Vcb)) {
            Ext2FlushFiles(IrpContext, Vcb, FALSE);
            Ext2FlushVolume(IrpContext, Vcb, FALSE);
        }
 
        Status = Ext2LockVcb(Vcb, IrpSp->FileObject);
 
    } _SEH2_FINALLY {
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            Ext2CompleteIrpContext(IrpContext,  Status);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2Format(), and Ext2UserFsRequest().

◆ Ext2Log2()

ULONG Ext2Log2 ( ULONG Value )

Definition at line 25 of file misc.c.

{
    ULONG Order = 0;
 
    ASSERT(Value > 0);
 
    while (Value) {
        Order++;
        Value >>= 1;
    }
 
    return (Order - 1);
}

Referenced by Ext2InitializeVcb().

◆ Ext2LookupBlockExtent()

BOOLEAN Ext2LookupBlockExtent	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Start,
		IN PULONG	Block,
		IN PULONG	Mapped
	)

Definition at line 1061 of file memory.c.

{
    LONGLONG    Vbn = 0;
    LONGLONG    Lbn = 0;
    LONGLONG    Length = 0;
 
    BOOLEAN     rc = FALSE;
 
    Vbn = ((LONGLONG) Start) << BLOCK_BITS;
 
    if (Mcb) {
        rc = Ext2LookupMcbExtent(Vcb, Mcb, Vbn, &Lbn, &Length);
    } else {
        rc = Ext2LookupVcbExtent(Vcb, Vbn, &Lbn, &Length);
    }
 
    if (rc) {
        *Mapped = (ULONG)(Length >> BLOCK_BITS);
        if (Lbn != -1 && Length > 0) {
            *Block = (ULONG)(Lbn >> BLOCK_BITS);
        } else {
            *Block = 0;
        }
    }
 
    return rc;
}

Referenced by Ext2AddBlockExtent(), and Ext2BuildExtents().

◆ Ext2LookupFile()

NTSTATUS Ext2LookupFile	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PUNICODE_STRING	FullName,
		IN PEXT2_MCB	Parent,
		OUT PEXT2_MCB *	Ext2Mcb,
		IN ULONG	Linkdep
	)

Definition at line 273 of file create.c.

{
    NTSTATUS        Status = STATUS_OBJECT_NAME_NOT_FOUND;
    UNICODE_STRING  FileName;
    PEXT2_MCB       Mcb = NULL;
    struct dentry  *de = NULL;
 
    USHORT          i = 0, End;
    ULONG           Inode;
 
    BOOLEAN         bParent = FALSE;
    BOOLEAN         bDirectory = FALSE;
    BOOLEAN         LockAcquired = FALSE;
    BOOLEAN         bNotFollow = FALSE;
 
    _SEH2_TRY {
 
        ExAcquireResourceExclusiveLite(&Vcb->McbLock, TRUE);
        LockAcquired = TRUE;
 
        bNotFollow = IsFlagOn(Linkdep, EXT2_LOOKUP_NOT_FOLLOW);
#ifndef __REACTOS__
        Linkdep = ClearFlag(Linkdep, EXT2_LOOKUP_FLAG_MASK);
#else
        ClearFlag(Linkdep, EXT2_LOOKUP_FLAG_MASK);
#endif
 
        *Ext2Mcb = NULL;
 
        DEBUG(DL_RES, ("Ext2LookupFile: %wZ\n", FullName));
 
        /* check names and parameters */
        if (FullName->Buffer[0] == L'\\') {
            Parent = Vcb->McbTree;
        } else if (Parent) {
            bParent = TRUE;
        } else {
            Parent = Vcb->McbTree;
        }
 
        /* make sure the parent is NULL */
        if (!IsMcbDirectory(Parent)) {
            Status =  STATUS_NOT_A_DIRECTORY;
            _SEH2_LEAVE;
        }
 
        /* use symlink's target as parent directory */
        if (IsMcbSymLink(Parent)) {
            Parent = Parent->Target;
            ASSERT(!IsMcbSymLink(Parent));
            if (IsFileDeleted(Parent)) {
                Status =  STATUS_NOT_A_DIRECTORY;
                _SEH2_LEAVE;
            }
        }
 
        if (NULL == Parent) {
            Status =  STATUS_NOT_A_DIRECTORY;
            _SEH2_LEAVE;
        }
 
        /* default is the parent Mcb*/
        Ext2ReferMcb(Parent);
        Mcb = Parent;
 
        /* is empty file name or root node */
        End = FullName->Length/sizeof(WCHAR);
        if ( (End == 0) || (End == 1 &&
                            FullName->Buffer[0] == L'\\')) {
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        /* is a directory expected ? */
        while (FullName->Buffer[End - 1] == L'\\') {
            bDirectory = TRUE;
            End -= 1;
        }
 
        /* loop with every sub name */
        while (i < End) {
 
            USHORT Start = 0;
 
            /* zero the prefix '\' */
            while (i < End && FullName->Buffer[i] == L'\\') i++;
            Start = i;
 
            /* zero the suffix '\' */
            while (i < End && (FullName->Buffer[i] != L'\\')) i++;
 
            if (i > Start) {
 
                FileName = *FullName;
                FileName.Buffer += Start;
                FileName.Length = (USHORT)((i - Start) * 2);
 
                /* make sure the parent is NULL */
                if (!IsMcbDirectory(Parent)) {
                    Status =  STATUS_NOT_A_DIRECTORY;
                    Ext2DerefMcb(Parent);
                    break;
                }
 
                if (IsMcbSymLink(Parent)) {
                    if (IsFileDeleted(Parent->Target)) {
                        Status =  STATUS_NOT_A_DIRECTORY;
                        Ext2DerefMcb(Parent);
                        break;
                    } else {
                        Ext2ReferMcb(Parent->Target);
                        Ext2DerefMcb(Parent);
                        Parent = Parent->Target;
                    }
                }
 
                /* search cached Mcb nodes */
                Mcb = Ext2SearchMcbWithoutLock(Parent, &FileName);
 
                if (Mcb) {
 
                    /* derefer the parent Mcb */
                    Ext2DerefMcb(Parent);
                    Status = STATUS_SUCCESS;
                    Parent = Mcb;
 
                    if (IsMcbSymLink(Mcb) && IsFileDeleted(Mcb->Target) &&
                        Mcb->Refercount == 1) {
 
                        ASSERT(Mcb->Target);
                        ASSERT(Mcb->Target->Refercount > 0);
                        Ext2DerefMcb(Mcb->Target);
                        Mcb->Target = NULL;
                        ClearLongFlag(Mcb->Flags, MCB_TYPE_SYMLINK);
                        SetLongFlag(Mcb->Flags, MCB_TYPE_SPECIAL);
                        Mcb->FileAttr = FILE_ATTRIBUTE_NORMAL;
                    }
 
                } else {
 
                    /* need create new Mcb node */
 
                    /* is a valid ext2 name */
                    if (!Ext2IsNameValid(&FileName)) {
                        Status = STATUS_OBJECT_NAME_INVALID;
                        Ext2DerefMcb(Parent);
                        break;
                    }
 
                    /* seach the disk */
                    de = NULL;
                    Status = Ext2ScanDir (
                                 IrpContext,
                                 Vcb,
                                 Parent,
                                 &FileName,
                                 &Inode,
                                 &de);
 
                    if (NT_SUCCESS(Status)) {
 
                        /* check it's real parent */
                        ASSERT (!IsMcbSymLink(Parent));
 
                        /* allocate Mcb ... */
                        Mcb = Ext2AllocateMcb(Vcb, &FileName, &Parent->FullName, 0);
                        if (!Mcb) {
                            Status = STATUS_INSUFFICIENT_RESOURCES;
                            Ext2DerefMcb(Parent);
                            break;
                        }
                        Mcb->de = de;
                        Mcb->de->d_inode = &Mcb->Inode;
                        Mcb->Inode.i_ino = Inode;
                        Mcb->Inode.i_sb = &Vcb->sb;
                        de = NULL;
 
                        /* load inode information */
                        if (!Ext2LoadInode(Vcb, &Mcb->Inode)) {
                            Status = STATUS_CANT_WAIT;
                            Ext2DerefMcb(Parent);
                            Ext2FreeMcb(Vcb, Mcb);
                            break;
                        }
 
                        /* set inode attribute */
                        if (!Ext2CheckFileAccess(Vcb, Mcb, Ext2FileCanWrite)) {
                            SetFlag(Mcb->FileAttr, FILE_ATTRIBUTE_READONLY);
                        }
 
                        if (S_ISDIR(Mcb->Inode.i_mode)) {
                            SetFlag(Mcb->FileAttr, FILE_ATTRIBUTE_DIRECTORY);
                        } else {
                            if (S_ISREG(Mcb->Inode.i_mode)) {
                                SetFlag(Mcb->FileAttr, FILE_ATTRIBUTE_NORMAL);
                            } else if (S_ISLNK(Mcb->Inode.i_mode)) {
                                SetFlag(Mcb->FileAttr, FILE_ATTRIBUTE_REPARSE_POINT);
                            } else {
                                SetLongFlag(Mcb->Flags, MCB_TYPE_SPECIAL);
                            }
                        }
 
                        /* process special files under root directory */
                        if (IsMcbRoot(Parent)) {
                            /* set hidden and system attributes for
                               Recycled / RECYCLER / pagefile.sys */
                            BOOLEAN IsDirectory = IsMcbDirectory(Mcb);
                            if (Ext2IsSpecialSystemFile(&Mcb->ShortName, IsDirectory)) {
                                SetFlag(Mcb->FileAttr, FILE_ATTRIBUTE_HIDDEN);
                                SetFlag(Mcb->FileAttr, FILE_ATTRIBUTE_SYSTEM);
                            }
                        }
 
                        Mcb->CreationTime = Ext2NtTime(Mcb->Inode.i_ctime);
                        Mcb->LastAccessTime = Ext2NtTime(Mcb->Inode.i_atime);
                        Mcb->LastWriteTime = Ext2NtTime(Mcb->Inode.i_mtime);
                        Mcb->ChangeTime = Ext2NtTime(Mcb->Inode.i_mtime);
 
                        /* process symlink */
                        if (S_ISLNK(Mcb->Inode.i_mode) && !bNotFollow) {
                            Ext2FollowLink( IrpContext,
                                            Vcb,
                                            Parent,
                                            Mcb,
                                            Linkdep+1
                                          );
                        }
 
                        /* add reference ... */
                        Ext2ReferMcb(Mcb);
 
                        /* add Mcb to it's parent tree*/
                        Ext2InsertMcb(Vcb, Parent, Mcb);
 
                        /* it's safe to deref Parent Mcb */
                        Ext2DerefMcb(Parent);
 
                        /* linking this Mcb*/
                        Ext2LinkTailMcb(Vcb, Mcb);
 
                        /* set parent to preare re-scan */
                        Parent = Mcb;
 
                    } else {
 
                        /* derefernce it's parent */
                        Ext2DerefMcb(Parent);
                        break;
                    }
                }
 
            } else {
 
                /* there seems too many \ or / */
                /* Mcb should be already set to Parent */
                ASSERT(Mcb == Parent);
                Status = STATUS_SUCCESS;
                break;
            }
        }
 
    } _SEH2_FINALLY {
 
        if (de) {
            Ext2FreeEntry(de);
        }
 
        if (NT_SUCCESS(Status)) {
            if (bDirectory) {
                if (IsMcbDirectory(Mcb)) {
                    *Ext2Mcb = Mcb;
                } else {
                    Ext2DerefMcb(Mcb);
                    Status = STATUS_NOT_A_DIRECTORY;
                }
            } else {
                *Ext2Mcb = Mcb;
            }
        }
 
        if (LockAcquired) {
            ExReleaseResourceLite(&Vcb->McbLock);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2CreateFile(), Ext2FollowLink(), Ext2ProcessEntry(), Ext2SetLinkInfo(), and Ext2SetRenameInfo().

◆ Ext2LookupMcbExtent()

BOOLEAN Ext2LookupMcbExtent	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN LONGLONG	Vbn,
		OUT PLONGLONG	Lbn,
		OUT PLONGLONG	Length
	)

Definition at line 897 of file memory.c.

{
    LONGLONG    offset;
    BOOLEAN     rc;
 
    offset = Vbn & (~((LONGLONG)BLOCK_SIZE - 1));
    ASSERT ((offset & (BLOCK_SIZE - 1)) == 0);
    offset = (offset >> BLOCK_BITS) + 1;
 
    rc = FsRtlLookupLargeMcbEntry(
             &(Mcb->Extents),
             offset,
             Lbn,
             Length,
             NULL,
             NULL,
             NULL
         );
 
    if (rc) {
 
        if (Lbn && ((*Lbn) != -1)) {
            ASSERT((*Lbn) > 0);
            (*Lbn) = (((*Lbn) - 1) << BLOCK_BITS);
            (*Lbn) += ((Vbn) & ((LONGLONG)BLOCK_SIZE - 1));
        }
 
        if (Length && *Length) {
            (*Length) <<= BLOCK_BITS;
            (*Length)  -= ((Vbn) & ((LONGLONG)BLOCK_SIZE - 1));
        }
    }
 
    return rc;
}

Referenced by Ext2LookupBlockExtent().

◆ Ext2LookupVcbExtent()

BOOLEAN Ext2LookupVcbExtent	(	IN PEXT2_VCB	Vcb,
		IN LONGLONG	Vbn,
		OUT PLONGLONG	Lbn,
		OUT PLONGLONG	Length
	)

Definition at line 747 of file memory.c.

{
    LONGLONG    offset;
    BOOLEAN     rc;
 
    offset = Vbn & (~(Vcb->IoUnitSize - 1));
    ASSERT ((offset & (Vcb->IoUnitSize - 1)) == 0);
    offset = (offset >> Vcb->IoUnitBits) + 1;
 
    rc = FsRtlLookupLargeMcbEntry(
             &(Vcb->Extents),
             offset,
             Lbn,
             Length,
             NULL,
             NULL,
             NULL
         );
 
    if (rc) {
 
        if (Lbn && ((*Lbn) != -1)) {
            ASSERT((*Lbn) > 0);
            (*Lbn) = (((*Lbn) - 1) << Vcb->IoUnitBits);
            (*Lbn) += ((Vbn) & (Vcb->IoUnitSize - 1));
        }
 
        if (Length && *Length) {
            (*Length) <<= Vcb->IoUnitBits;
            (*Length)  -= ((Vbn) & (Vcb->IoUnitSize - 1));
        }
    }
 
    return rc;
}

Referenced by Ext2LookupBlockExtent(), and Ext2WriteVolume().

◆ Ext2MapExtent()

NTSTATUS Ext2MapExtent	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Index,
		IN BOOLEAN	Alloc,
		OUT PULONG	Block,
		OUT PULONG	Number
	)

Definition at line 25 of file extents.c.

{
    EXT4_EXTENT_HEADER *eh;
    struct buffer_head bh_got = {0};
    int    flags, rc;
    ULONG max_blocks = 0;
 
    memset(&bh_got, 0, sizeof(struct buffer_head));
    eh = get_ext4_header(&Mcb->Inode);
 
    if (eh->eh_magic != EXT4_EXT_MAGIC) {
        if (Alloc) {
            /* now initialize inode extent root node */
            ext4_ext_tree_init(IrpContext, NULL, &Mcb->Inode);
        } else {
            /* return empty-mapping when inode extent isn't initialized */
            if (Block)
                *Block = 0;
            if (Number) {
                LONGLONG  _len = _len = Mcb->Inode.i_size;
                if (Mcb->Fcb)
                    _len = Mcb->Fcb->Header.AllocationSize.QuadPart;
                *Number = (ULONG)((_len + BLOCK_SIZE - 1) >> BLOCK_BITS);
            }
            return STATUS_SUCCESS;
        }
    }
 
    /* IrpContext is NULL when called during journal initialization */
    if (IsMcbDirectory(Mcb) || IrpContext == NULL ||
        IrpContext->MajorFunction == IRP_MJ_WRITE || !Alloc){
        flags = EXT4_GET_BLOCKS_IO_CONVERT_EXT;
        max_blocks = EXT_INIT_MAX_LEN;
    } else {
        flags = EXT4_GET_BLOCKS_IO_CREATE_EXT;
        max_blocks = EXT_UNWRITTEN_MAX_LEN;
    }
 
    if (Alloc) {
        if (Number && !*Number) {
            if (max_blocks > *Number) {
                max_blocks = *Number;
            }
        } else {
            max_blocks = 1;
        }
    }
 
    if ((rc = ext4_ext_get_blocks(
                            IrpContext,
                            NULL,
                            &Mcb->Inode,
                            Index,
                            max_blocks,
                            &bh_got,
                            Alloc,
                            flags)) < 0) {
        DEBUG(DL_ERR, ("Block insufficient resources, err: %d\n", rc));
        return Ext2WinntError(rc);
    }
    if (Alloc)
        Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
    if (Number)
        *Number = rc ? rc : 1;
    if (Block)
        *Block = (ULONG)bh_got.b_blocknr;
 
    return STATUS_SUCCESS;
}

Referenced by Ext2BlockMap(), Ext2InitializeZone(), and ext3_bread().

◆ Ext2MapIndirect()

NTSTATUS Ext2MapIndirect	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Index,
		IN BOOLEAN	bAlloc,
		OUT PULONG	pBlock,
		OUT PULONG	Number
	)

Definition at line 835 of file indirect.c.

{
    ULONG   Layer;
    ULONG   Slot;
 
    ULONG   Base = Index;
 
    NTSTATUS Status = STATUS_SUCCESS;
 
    *pBlock = 0;
    *Number = 0;
 
    for (Layer = 0; Layer < EXT2_BLOCK_TYPES; Layer++) {
 
        if (Index < Vcb->max_blocks_per_layer[Layer]) {
 
            ULONG   dwRet = 0, dwBlk = 0, dwHint = 0, dwArray = 0;
 
            Slot = (Layer==0) ? (Index):(Layer + EXT2_NDIR_BLOCKS - 1);
            dwBlk = Mcb->Inode.i_block[Slot];
 
            if (dwBlk == 0) {
 
                if (!bAlloc) {
 
                    *Number = 1;
                    goto errorout;
 
                } else {
 
                    if (Slot) {
                        dwHint = Mcb->Inode.i_block[Slot - 1];
                    }
 
                    /* allocate and zero block if necessary */
                    *Number = 1;
                    Status = Ext2ExpandLast(
                                 IrpContext,
                                 Vcb,
                                 Mcb,
                                 Base,
                                 Layer,
                                 NULL,
                                 &dwHint,
                                 &dwBlk,
                                 Number
                             );
 
                    if (!NT_SUCCESS(Status)) {
                        goto errorout;
                    }
 
                    /* save the it into inode*/
                    Mcb->Inode.i_block[Slot] = dwBlk;
 
                    /* save the inode */
                    if (!Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode)) {
                        DbgBreak();
                        Status = STATUS_UNSUCCESSFUL;
                        goto errorout;
                    }
                }
            }
 
            if (Layer == 0)
                dwArray = Vcb->max_blocks_per_layer[Layer] - Index;
            else
                dwArray = 1;
 
            /* querying block number of the index-th file block */
            Status = Ext2GetBlock(
                         IrpContext,
                         Vcb,
                         Mcb,
                         Base,
                         Layer,
                         Index,
                         dwArray,
#ifdef __REACTOS__
                        (PULONG)&Mcb->Inode.i_block[Slot],
#else
                        &Mcb->Inode.i_block[Slot],
#endif
                         bAlloc,
                         &dwHint,
                         &dwRet,
                         Number
                     );
 
            if (NT_SUCCESS(Status)) {
                *pBlock = dwRet;
            }
 
            break;
        }
 
        Index -= Vcb->max_blocks_per_layer[Layer];
    }
 
errorout:
 
    return Status;
}

Referenced by Ext2BlockMap(), Ext2InitializeZone(), and ext3_bread().

◆ Ext2McbReaperThread()

VOID Ext2McbReaperThread ( PVOID Context )

Definition at line 3055 of file memory.c.

{
    PEXT2_REAPER    Reaper = Context;
    PLIST_ENTRY     List = NULL;
    LARGE_INTEGER   Timeout;
 
    PEXT2_VCB       Vcb = NULL;
    PEXT2_MCB       Mcb  = NULL;
 
    ULONG           i, NumOfMcbs;
 
    BOOLEAN         GlobalAcquired = FALSE;
 
    BOOLEAN         DidNothing = TRUE;
    BOOLEAN         LastState  = TRUE;
    BOOLEAN         WaitLock;
 
    _SEH2_TRY {
 
        Reaper->Thread = PsGetCurrentThread();
 
        /* wake up DirverEntry */
        KeSetEvent(&Reaper->Engine, 0, FALSE);
 
        /* now process looping */
        while (!IsFlagOn(Reaper->Flags, EXT2_REAPER_FLAG_STOP)) {
 
            WaitLock = FALSE;
 
            /* calculate how long we need wait */
            if (Ext2Global->PerfStat.Current.Mcb > (((ULONG)Ext2Global->MaxDepth) * 128)) {
                Timeout.QuadPart = (LONGLONG)-1000*1000; /* 0.1 second */
                NumOfMcbs = Ext2Global->MaxDepth * 4;
                WaitLock = TRUE;
            } else if (Ext2Global->PerfStat.Current.Mcb > (((ULONG)Ext2Global->MaxDepth) * 32)) {
                Timeout.QuadPart = (LONGLONG)-1000*1000*5; /* 0.5 second */
                NumOfMcbs = Ext2Global->MaxDepth * 2;
                WaitLock = TRUE;
            } else if (Ext2Global->PerfStat.Current.Mcb > (((ULONG)Ext2Global->MaxDepth) * 8)) {
                Timeout.QuadPart = (LONGLONG)-1000*1000*10; /* 1 second */
                NumOfMcbs = Ext2Global->MaxDepth;
            } else if (Ext2Global->PerfStat.Current.Mcb > (((ULONG)Ext2Global->MaxDepth) * 2)) {
                Timeout.QuadPart = (LONGLONG)-2*1000*1000*10; /* 2 second */
                NumOfMcbs = Ext2Global->MaxDepth / 4;
            } else if (Ext2Global->PerfStat.Current.Mcb > (ULONG)Ext2Global->MaxDepth) {
                Timeout.QuadPart = (LONGLONG)-4*1000*1000*10; /* 4 seconds */
                NumOfMcbs = Ext2Global->MaxDepth / 8;
            } else if (DidNothing) {
                Timeout.QuadPart = (LONGLONG)-8*1000*1000*10; /* 8 seconds */
                if (LastState) {
                    Timeout.QuadPart *= 2;
                }
                NumOfMcbs = Ext2Global->MaxDepth / 16;
            } else {
                Timeout.QuadPart = (LONGLONG)-5*1000*1000*10; /* 5 seconds */
                if (LastState) {
                    Timeout.QuadPart *= 2;
                }
                NumOfMcbs = Ext2Global->MaxDepth / 32;
            }
 
            if (NumOfMcbs == 0)
                NumOfMcbs = 1;
 
            LastState = DidNothing;
 
            /* wait until it is waken or it times out */
            KeWaitForSingleObject(
                &Reaper->Wait,
                Executive,
                KernelMode,
                FALSE,
                &Timeout
            );
 
            if (IsFlagOn(Reaper->Flags, EXT2_REAPER_FLAG_STOP))
                break;
 
            DidNothing = TRUE;
 
            /* acquire global exclusive lock */
            if (!ExAcquireResourceSharedLite(&Ext2Global->Resource, WaitLock)) {
                continue;
            }
            GlobalAcquired = TRUE;
 
            /* search all Vcb to get unused resources freed to system */
            for (List = Ext2Global->VcbList.Flink;
                    List != &(Ext2Global->VcbList);
                    List = List->Flink ) {
 
                Vcb = CONTAINING_RECORD(List, EXT2_VCB, Next);
 
                Mcb = Ext2FirstUnusedMcb(Vcb, WaitLock, NumOfMcbs);
                while (Mcb) {
                    PEXT2_MCB   Next = Mcb->Next;
                    DEBUG(DL_RES, ( "Ext2ReaperThread: releasing Mcb (%p): %wZ"
                                    " Total: %xh\n", Mcb, &Mcb->FullName,
                                    Ext2Global->PerfStat.Current.Mcb));
                    Ext2FreeMcb(Vcb, Mcb);
                    Mcb = Next;
                    LastState = DidNothing = FALSE;
                }
            }
            if (DidNothing) {
                KeClearEvent(&Reaper->Wait);
            }
            if (GlobalAcquired) {
                ExReleaseResourceLite(&Ext2Global->Resource);
                GlobalAcquired = FALSE;
            }
        }
 
    } _SEH2_FINALLY {
 
        if (GlobalAcquired) {
            ExReleaseResourceLite(&Ext2Global->Resource);
        }
 
        KeSetEvent(&Reaper->Engine, 0, FALSE);
    } _SEH2_END;
 
    PsTerminateSystemThread(STATUS_SUCCESS);
}

Referenced by DriverEntry().

◆ Ext2MediaEjectControl()

VOID Ext2MediaEjectControl	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN BOOLEAN	bPrevent
	)

Definition at line 685 of file block.c.

{
    PIRP                    Irp;
    KEVENT                  Event;
    NTSTATUS                Status;
    PREVENT_MEDIA_REMOVAL   Prevent;
    IO_STATUS_BLOCK         IoStatus;
 
 
    ExAcquireResourceExclusiveLite(
        &Vcb->MainResource,
        TRUE            );
 
    if (bPrevent != IsFlagOn(Vcb->Flags, VCB_REMOVAL_PREVENTED)) {
        if (bPrevent) {
            SetFlag(Vcb->Flags, VCB_REMOVAL_PREVENTED);
        } else {
            ClearFlag(Vcb->Flags, VCB_REMOVAL_PREVENTED);
        }
    }
 
    ExReleaseResourceLite(&Vcb->MainResource);
 
    Prevent.PreventMediaRemoval = bPrevent;
 
    KeInitializeEvent( &Event, NotificationEvent, FALSE );
 
    Irp = IoBuildDeviceIoControlRequest( IOCTL_DISK_MEDIA_REMOVAL,
                                         Vcb->TargetDeviceObject,
                                         &Prevent,
                                         sizeof(PREVENT_MEDIA_REMOVAL),
                                         NULL,
                                         0,
                                         FALSE,
                                         NULL,
                                         &IoStatus );
 
    if (Irp != NULL) {
        IoSetCompletionRoutine( Irp,
                                Ext2MediaEjectControlCompletion,
                                &Event,
                                TRUE,
                                TRUE,
                                TRUE );
 
        Status = IoCallDriver(Vcb->TargetDeviceObject, Irp);
 
        if (Status == STATUS_PENDING) {
            Status = KeWaitForSingleObject( &Event,
                                            Executive,
                                            KernelMode,
                                            FALSE,
                                            NULL );
        }
    }
}

◆ Ext2MountVolume()

NTSTATUS Ext2MountVolume ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 2050 of file fsctl.c.

{
    PDEVICE_OBJECT              MainDeviceObject;
    BOOLEAN                     GlobalDataResourceAcquired = FALSE;
    PIRP                        Irp;
    PIO_STACK_LOCATION          IoStackLocation;
    PDEVICE_OBJECT              TargetDeviceObject;
    NTSTATUS                    Status = STATUS_UNRECOGNIZED_VOLUME;
    PDEVICE_OBJECT              VolumeDeviceObject = NULL;
    PEXT2_VCB                   Vcb = NULL, OldVcb = NULL;
    PVPB                        OldVpb = NULL, Vpb = NULL;
    PEXT2_SUPER_BLOCK           Ext2Sb = NULL;
    ULONG                       dwBytes;
    DISK_GEOMETRY               DiskGeometry;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        MainDeviceObject = IrpContext->DeviceObject;
 
        //
        //  Make sure we can wait.
        //
 
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
 
        //
        // This request is only allowed on the main device object
        //
        if (!IsExt2FsDevice(MainDeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        if (IsFlagOn(Ext2Global->Flags, EXT2_UNLOAD_PENDING)) {
            Status = STATUS_UNRECOGNIZED_VOLUME;
            _SEH2_LEAVE;
        }
 
#if 0
        if (IrpContext->RealDevice->Size >= sizeof(ULONG) + sizeof(DEVICE_OBJECT) &&
                *((PULONG)IrpContext->RealDevice->DeviceExtension) == 'DSSA') {
        } else {
            Status = STATUS_UNRECOGNIZED_VOLUME;
            _SEH2_LEAVE;
        }
#endif
 
        Irp = IrpContext->Irp;
        IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
        TargetDeviceObject =
            IoStackLocation->Parameters.MountVolume.DeviceObject;
 
        dwBytes = sizeof(DISK_GEOMETRY);
        Status = Ext2DiskIoControl(
                     TargetDeviceObject,
                     IOCTL_DISK_GET_DRIVE_GEOMETRY,
                     NULL,
                     0,
                     &DiskGeometry,
                     &dwBytes );
 
        if (!NT_SUCCESS(Status)) {
            _SEH2_LEAVE;
        }
 
        Status = IoCreateDevice(
                     MainDeviceObject->DriverObject,
                     sizeof(EXT2_VCB),
                     NULL,
                     FILE_DEVICE_DISK_FILE_SYSTEM,
                     0,
                     FALSE,
                     &VolumeDeviceObject );
 
        if (!NT_SUCCESS(Status)) {
            _SEH2_LEAVE;
        }
        INC_MEM_COUNT(PS_VCB, VolumeDeviceObject, sizeof(EXT2_VCB));
 
#ifdef _PNP_POWER_
        /* don't care about power management requests */
        VolumeDeviceObject->DeviceObjectExtension->PowerControlNeeded = FALSE;
#endif
 
        VolumeDeviceObject->StackSize = (CCHAR)(TargetDeviceObject->StackSize + 1);
        ClearFlag(VolumeDeviceObject->Flags, DO_DEVICE_INITIALIZING);
 
/*
        These are for buffer-address alignment requirements.
        Never do this check, unless you want fail user requests :)
 
        if (TargetDeviceObject->AlignmentRequirement >
                VolumeDeviceObject->AlignmentRequirement) {
 
            VolumeDeviceObject->AlignmentRequirement =
                TargetDeviceObject->AlignmentRequirement;
        }
 
        if (DiskGeometry.BytesPerSector - 1 >
                VolumeDeviceObject->AlignmentRequirement) {
            VolumeDeviceObject->AlignmentRequirement =
                DiskGeometry.BytesPerSector - 1;
            TargetDeviceObject->AlignmentRequirement =
                DiskGeometry.BytesPerSector - 1;
        }
*/
        (IoStackLocation->Parameters.MountVolume.Vpb)->DeviceObject =
            VolumeDeviceObject;
        Vpb = IoStackLocation->Parameters.MountVolume.Vpb;
 
        Vcb = (PEXT2_VCB) VolumeDeviceObject->DeviceExtension;
 
        RtlZeroMemory(Vcb, sizeof(EXT2_VCB));
        Vcb->Identifier.Type = EXT2VCB;
        Vcb->Identifier.Size = sizeof(EXT2_VCB);
        Vcb->TargetDeviceObject = TargetDeviceObject;
        Vcb->DiskGeometry = DiskGeometry;
        InitializeListHead(&Vcb->Next);
 
        Status = Ext2LoadSuper(Vcb, FALSE, &Ext2Sb);
        if (!NT_SUCCESS(Status)) {
            Vcb = NULL;
            Status = STATUS_UNRECOGNIZED_VOLUME;
            _SEH2_LEAVE;
        }
        ASSERT (NULL != Ext2Sb);
 
        /* check Linux Ext2/Ext3 volume magic */
        if (Ext2Sb->s_magic == EXT2_SUPER_MAGIC) {
            DEBUG(DL_INF, ( "Volume of ext2 file system is found.\n"));
        } else  {
            Status = STATUS_UNRECOGNIZED_VOLUME;
            Vcb = NULL;
            _SEH2_LEAVE;
        }
 
        DEBUG(DL_DBG, ("Ext2MountVolume: DevObject=%p Vcb=%p\n", VolumeDeviceObject, Vcb));
 
        /* initialize Vcb structure */
        Status = Ext2InitializeVcb( IrpContext, Vcb, Ext2Sb,
                                    TargetDeviceObject,
                                    VolumeDeviceObject, Vpb);
 
        if (NT_SUCCESS(Status))  {
 
            PLIST_ENTRY List;
 
            ExAcquireResourceExclusiveLite(&(Ext2Global->Resource), TRUE);
            GlobalDataResourceAcquired = TRUE;
 
            for (List = Ext2Global->VcbList.Flink;
                    List != &Ext2Global->VcbList;
                    List = List->Flink) {
 
                OldVcb = CONTAINING_RECORD(List, EXT2_VCB, Next);
                OldVpb = OldVcb->Vpb;
 
                /* in case we are already in the queue, should not happen */
                if (OldVpb == Vpb) {
                    continue;
                }
 
                if ( (OldVpb->SerialNumber == Vpb->SerialNumber) &&
                        (!IsMounted(OldVcb)) && (IsFlagOn(OldVcb->Flags, VCB_NEW_VPB)) &&
                        (OldVpb->RealDevice == TargetDeviceObject) &&
                        (OldVpb->VolumeLabelLength == Vpb->VolumeLabelLength) &&
                        (RtlEqualMemory(&OldVpb->VolumeLabel[0],
                                        &Vpb->VolumeLabel[0],
                                        Vpb->VolumeLabelLength)) &&
                        (RtlEqualMemory(&OldVcb->SuperBlock->s_uuid[0],
                                        &Vcb->SuperBlock->s_uuid[0], 16)) ) {
                    ClearFlag(OldVcb->Flags, VCB_MOUNTED);
                }
            }
 
            SetLongFlag(Vcb->Flags, VCB_MOUNTED);
            SetFlag(Vcb->Vpb->Flags, VPB_MOUNTED);
            Ext2InsertVcb(Vcb);
            Vcb = NULL;
            Vpb = NULL;
            ObDereferenceObject(TargetDeviceObject);
 
        } else {
 
            Vcb = NULL;
        }
 
    } _SEH2_FINALLY {
 
        if (GlobalDataResourceAcquired) {
            ExReleaseResourceLite(&Ext2Global->Resource);
        }
 
        if (!NT_SUCCESS(Status)) {
 
            if (!NT_SUCCESS(Status)) {
                if ( Vpb != NULL ) {
                    Vpb->DeviceObject = NULL;
                }
            }
 
            if (Vcb) {
                Ext2DestroyVcb(Vcb);
            } else {
                if (Ext2Sb) {
                    Ext2FreePool(Ext2Sb, EXT2_SB_MAGIC);
                }
                if (VolumeDeviceObject) {
                    IoDeleteDevice(VolumeDeviceObject);
                    DEC_MEM_COUNT(PS_VCB, VolumeDeviceObject, sizeof(EXT2_VCB));
                }
            }
        }
 
        if (!IrpContext->ExceptionInProgress) {
            Ext2CompleteIrpContext(IrpContext,  Status);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2FileSystemControl().

◆ 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().

◆ Ext2NoOpAcquire()

BOOLEAN Ext2NoOpAcquire	(	IN PVOID	Fcb,
		IN BOOLEAN	Wait
	)

Definition at line 138 of file cmcb.c.

{
    ASSERT(IoGetTopLevelIrp() == NULL);
    IoSetTopLevelIrp((PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
    return TRUE;
}

Referenced by DriverEntry().

◆ Ext2NoOpRelease()

VOID Ext2NoOpRelease ( IN PVOID Fcb )

Definition at line 153 of file cmcb.c.

{
    ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
    IoSetTopLevelIrp( NULL );
 
    return;
}

Referenced by DriverEntry().

◆ Ext2NotifyChangeDirectory()

NTSTATUS Ext2NotifyChangeDirectory ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 1029 of file dirctl.c.

{
    PDEVICE_OBJECT      DeviceObject;
    BOOLEAN             CompleteRequest = TRUE;
    NTSTATUS            Status = STATUS_UNSUCCESSFUL;
    PEXT2_VCB           Vcb = NULL;
    PEXT2_FCB           Fcb = NULL;
    PEXT2_CCB           Ccb = NULL;
    PIRP                Irp = NULL;
    PIO_STACK_LOCATION  IrpSp;
    PFILE_OBJECT        FileObject;
    ULONG               CompletionFilter;
    BOOLEAN             WatchTree;
 
    BOOLEAN             bFcbAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        //
        //  Always set the wait flag in the Irp context for the original request.
        //
 
        SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT );
 
        DeviceObject = IrpContext->DeviceObject;
 
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
 
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        FileObject = IrpContext->FileObject;
        Fcb = (PEXT2_FCB) FileObject->FsContext;
        ASSERT(Fcb);
        if (Fcb->Identifier.Type == EXT2VCB) {
            DbgBreak();
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
        Ccb = (PEXT2_CCB) FileObject->FsContext2;
        ASSERT(Ccb);
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
               (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
 
        /* do nothing if target fie was deleted */
        if (FlagOn(Fcb->Flags, FCB_DELETE_PENDING)) {
            Status = STATUS_FILE_DELETED;
            _SEH2_LEAVE;
        }
 
        if (!IsDirectory(Fcb)) {
            DbgBreak();
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        if (ExAcquireResourceExclusiveLite(
                    &Fcb->MainResource,
                    TRUE ))  {
            bFcbAcquired = TRUE;
        } else {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
 
        Irp = IrpContext->Irp;
 
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
#ifndef _GNU_NTIFS_
 
        CompletionFilter =
            IrpSp->Parameters.NotifyDirectory.CompletionFilter;
 
#else // _GNU_NTIFS_
 
        CompletionFilter = ((PEXTENDED_IO_STACK_LOCATION)
                            IrpSp)->Parameters.NotifyDirectory.CompletionFilter;
 
#endif // _GNU_NTIFS_
 
        WatchTree = IsFlagOn(IrpSp->Flags, SL_WATCH_TREE);
 
        if (FlagOn(Fcb->Flags, FCB_DELETE_PENDING)) {
            Status = STATUS_DELETE_PENDING;
            _SEH2_LEAVE;
        }
 
        FsRtlNotifyFullChangeDirectory( Vcb->NotifySync,
                                        &Vcb->NotifyList,
                                        FileObject->FsContext2,
                                        (PSTRING)(&Fcb->Mcb->FullName),
                                        WatchTree,
                                        FALSE,
                                        CompletionFilter,
                                        Irp,
                                        NULL,
                                        NULL );
 
        CompleteRequest = FALSE;
 
        Status = STATUS_PENDING;
 
        /*
            Currently the driver is read-only but here is an example on how to use the
            FsRtl-functions to report a change:
 
            ANSI_STRING TestString;
            USHORT      FileNamePartLength;
 
            RtlInitAnsiString(&TestString, "\\ntifs.h");
 
            FileNamePartLength = 7;
 
            FsRtlNotifyReportChange(
                Vcb->NotifySync,            // PNOTIFY_SYNC NotifySync
                &Vcb->NotifyList,           // PLIST_ENTRY  NotifyList
                &TestString,                // PSTRING      FullTargetName
                &FileNamePartLength,        // PUSHORT      FileNamePartLength
                FILE_NOTIFY_CHANGE_NAME     // ULONG        FilterMatch
                );
 
            or
 
            ANSI_STRING TestString;
 
            RtlInitAnsiString(&TestString, "\\ntifs.h");
 
            FsRtlNotifyFullReportChange(
                Vcb->NotifySync,            // PNOTIFY_SYNC NotifySync
                &Vcb->NotifyList,           // PLIST_ENTRY  NotifyList
                &TestString,                // PSTRING      FullTargetName
                1,                          // USHORT       TargetNameOffset
                NULL,                       // PSTRING      StreamName OPTIONAL
                NULL,                       // PSTRING      NormalizedParentName OPTIONAL
                FILE_NOTIFY_CHANGE_NAME,    // ULONG        FilterMatch
                0,                          // ULONG        Action
                NULL                        // PVOID        TargetContext
                );
        */
 
    } _SEH2_FINALLY {
 
        if (bFcbAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            if (CompleteRequest) {
                if (Status == STATUS_PENDING) {
                    Ext2QueueRequest(IrpContext);
                } else {
                    Ext2CompleteIrpContext(IrpContext, Status);
                }
            } else {
                IrpContext->Irp = NULL;
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DirectoryControl().

◆ Ext2NotifyReportChange()

VOID Ext2NotifyReportChange	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Filter,
		IN ULONG	Action
	)

Definition at line 1209 of file dirctl.c.

{
    USHORT          Offset;
 
    Offset = (USHORT) ( Mcb->FullName.Length -
                        Mcb->ShortName.Length);
 
    FsRtlNotifyFullReportChange( Vcb->NotifySync,
                                 &(Vcb->NotifyList),
                                 (PSTRING) (&Mcb->FullName),
                                 (USHORT) Offset,
                                 (PSTRING)NULL,
                                 (PSTRING) NULL,
                                 (ULONG) Filter,
                                 (ULONG) Action,
                                 (PVOID) NULL );
 
    // ASSERT(KeGetCurrentIrql() < DISPATCH_LEVEL);
}

Referenced by Ext2Cleanup(), Ext2CreateFile(), Ext2DeleteReparsePoint(), Ext2QueryEa(), Ext2SetEa(), Ext2SetFileInformation(), Ext2SetLinkInfo(), Ext2SetRenameInfo(), Ext2SetReparsePoint(), and Ext2WriteFile().

◆ Ext2NtStatusToString()

PUCHAR Ext2NtStatusToString ( IN NTSTATUS Status )

Referenced by Ext2FastIoLock(), Ext2FastIoUnlockAll(), Ext2FastIoUnlockAllByKey(), and Ext2FastIoUnlockSingle().

◆ Ext2NtTime()

LARGE_INTEGER Ext2NtTime ( IN ULONG i_time )

Definition at line 40 of file misc.c.

{
    LARGE_INTEGER SysTime;
 
    SysTime.QuadPart = 0;
    RtlSecondsSince1970ToTime(i_time, &SysTime);
 
    return SysTime;
}

Referenced by Ext2Cleanup(), Ext2FlushFile(), Ext2InitializeVcb(), Ext2LookupFile(), Ext2ProcessEntry(), Ext2RefreshSuper(), and Ext2SetFileInformation().

◆ Ext2OEMToUnicode()

NTSTATUS Ext2OEMToUnicode	(	IN PEXT2_VCB	Vcb,
		IN OUT PUNICODE_STRING	Oem,
		IN POEM_STRING	Unicode
	)

Definition at line 206 of file misc.c.

{
    NTSTATUS  Status;
 
 
    if (Vcb->Codepage.PageTable) {
        Status = Ext2MbsToUnicode(Vcb->Codepage.PageTable,
                                  Unicode, Oem);
 
        if (Status >0 && Status == Unicode->Length) {
            Status = STATUS_SUCCESS;
            goto errorout;
        }
    }
 
    Status = RtlOemStringToUnicodeString(
                 Unicode, Oem, FALSE );
 
    if (!NT_SUCCESS(Status)) {
        DbgBreak();
        goto errorout;
    }
 
errorout:
 
    return Status;
}

Referenced by Ext2FillEntry(), Ext2FollowLink(), Ext2GetReparsePoint(), Ext2InitializeLabel(), and Ext2QueryDirectory().

◆ Ext2OEMToUnicodeSize()

ULONG Ext2OEMToUnicodeSize	(	IN PEXT2_VCB	Vcb,
		IN PANSI_STRING	Oem
	)

Definition at line 183 of file misc.c.

{
    ULONG   Length = 0;
 
    if (Vcb->Codepage.PageTable) {
        Length = Ext2MbsToUnicode(Vcb->Codepage.PageTable, NULL, Oem);
        if (Length > 0) {
            goto errorout;
        }
    }
 
    Length = RtlOemStringToCountedUnicodeSize(Oem);
 
errorout:
 
    return Length;
}

Referenced by Ext2FillEntry(), Ext2FollowLink(), Ext2GetReparsePoint(), and Ext2QueryDirectory().

◆ Ext2OplockComplete()

VOID Ext2OplockComplete	(	IN PVOID	Context,
		IN PIRP	Irp
	)

Definition at line 45 of file dispatch.c.

{
    //
    //  Check on the return value in the Irp.
    //
 
    if (Irp->IoStatus.Status == STATUS_SUCCESS) {
 
        //
        //  queue the Irp context in the workqueue.
        //
 
        Ext2QueueRequest((PEXT2_IRP_CONTEXT)Context);
 
    } else {
 
        //
        //  complete the request in case of failure
        //
 
        Ext2CompleteIrpContext( (PEXT2_IRP_CONTEXT) Context,
                                Irp->IoStatus.Status );
    }
 
    return;
}

Referenced by Ext2CreateFile(), Ext2LockControl(), Ext2ReadFile(), and Ext2WriteFile().

◆ Ext2OplockRequest()

NTSTATUS Ext2OplockRequest ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 451 of file fsctl.c.

{
    NTSTATUS    Status;
 
    ULONG       FsCtrlCode;
    PDEVICE_OBJECT DeviceObject;
    PFILE_OBJECT   FileObject;
 
    PIRP Irp = NULL;
    PIO_STACK_LOCATION IrpSp;
    PEXTENDED_IO_STACK_LOCATION EIrpSp;
 
    PEXT2_VCB   Vcb = NULL;
    PEXT2_FCB   Fcb = NULL;
    PEXT2_CCB   Ccb = NULL;
 
    ULONG OplockCount = 0;
 
    BOOLEAN VcbResourceAcquired = FALSE;
    BOOLEAN FcbResourceAcquired = FALSE;
 
    ASSERT(IrpContext);
 
    _SEH2_TRY {
 
        Irp = IrpContext->Irp;
        ASSERT(Irp);
 
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
        ASSERT(IrpSp);
        EIrpSp = (PEXTENDED_IO_STACK_LOCATION)IrpSp;
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
 
        ASSERT(Vcb != NULL);
 
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        ASSERT(IsMounted(Vcb));
 
        FileObject = IrpContext->FileObject;
 
        Fcb = (PEXT2_FCB) FileObject->FsContext;
 
        //
        // This request is not allowed on volumes
        //
 
        if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
        if (IsFlagOn(Fcb->Mcb->Flags, MCB_FILE_DELETED)) {
            Status = STATUS_FILE_DELETED;
            _SEH2_LEAVE;
        }
 
        Ccb = (PEXT2_CCB) FileObject->FsContext2;
        if (Ccb == NULL) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
 
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
               (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
 
        FsCtrlCode = EIrpSp->Parameters.FileSystemControl.FsControlCode;
 
        switch (FsCtrlCode) {
 
        case FSCTL_REQUEST_OPLOCK_LEVEL_1:
        case FSCTL_REQUEST_OPLOCK_LEVEL_2:
        case FSCTL_REQUEST_BATCH_OPLOCK:
 
            VcbResourceAcquired =
                ExAcquireResourceSharedLite(
                    &Vcb->MainResource,
                    IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) );
 
            ClearFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
 
            FcbResourceAcquired =
                ExAcquireResourceExclusiveLite (
                    &Fcb->MainResource,
                    IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
 
            if (FsCtrlCode == FSCTL_REQUEST_OPLOCK_LEVEL_2) {
                OplockCount = (ULONG) FsRtlAreThereCurrentFileLocks(&Fcb->FileLockAnchor);
            } else {
                OplockCount = Fcb->OpenHandleCount;
            }
 
            break;
 
        case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE:
        case FSCTL_OPBATCH_ACK_CLOSE_PENDING :
        case FSCTL_OPLOCK_BREAK_NOTIFY:
        case FSCTL_OPLOCK_BREAK_ACK_NO_2:
 
            FcbResourceAcquired =
                ExAcquireResourceSharedLite (
                    &Fcb->MainResource,
                    IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
 
            break;
 
        default:
 
            Ext2BugCheck(EXT2_BUGCHK_FSCTL, FsCtrlCode, 0, 0);
        }
 
 
        //
        //  Call the FsRtl routine to grant/acknowledge oplock.
        //
 
        Status = FsRtlOplockFsctrl( &Fcb->Oplock,
                                    Irp,
                                    OplockCount );
 
        //
        //  Set the flag indicating if Fast I/O is possible
        //
 
        Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
        IrpContext->Irp = NULL;
 
    } _SEH2_FINALLY {
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (!_SEH2_AbnormalTermination()) {
            Ext2CompleteIrpContext(IrpContext, Status);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2UserFsRequest().

◆ Ext2Pnp()

NTSTATUS Ext2Pnp ( IN PEXT2_IRP_CONTEXT IrpContext )

Referenced by Ext2DispatchRequest().

◆ Ext2PnpCancelRemove()

NTSTATUS Ext2PnpCancelRemove	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb
	)

◆ Ext2PnpQueryRemove()

NTSTATUS Ext2PnpQueryRemove	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb
	)

◆ Ext2PnpRemove()

NTSTATUS Ext2PnpRemove	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb
	)

◆ Ext2PnpSurpriseRemove()

NTSTATUS Ext2PnpSurpriseRemove	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb
	)

◆ Ext2PreAcquireForCreateSection()

NTSTATUS Ext2PreAcquireForCreateSection	(	IN PFS_FILTER_CALLBACK_DATA	cd,
		OUT PVOID *	cc
	)

Definition at line 1178 of file fastio.c.

{
    PEXT2_FCB Fcb = (PEXT2_FCB)cd->FileObject->FsContext;
    NTSTATUS        status;
 
    ASSERT(cd->Operation == FS_FILTER_ACQUIRE_FOR_SECTION_SYNCHRONIZATION);
    ExAcquireResourceExclusiveLite(Fcb->Header.Resource, TRUE);
    if (cd->Parameters.AcquireForSectionSynchronization.SyncType != SyncTypeCreateSection) {
        status = STATUS_FSFILTER_OP_COMPLETED_SUCCESSFULLY;
    } else if (Fcb->ShareAccess.Writers == 0) {
        status = STATUS_FILE_LOCKED_WITH_ONLY_READERS;
    } else {
        status = STATUS_FILE_LOCKED_WITH_WRITERS;
    }
 
    return status;
}

Referenced by DriverEntry().

◆ Ext2PrepareToUnload()

NTSTATUS Ext2PrepareToUnload ( IN PEXT2_IRP_CONTEXT IrpContext )

Referenced by Ext2DeviceControl().

◆ Ext2Printf()

VOID __cdecl Ext2Printf	(	PCHAR	DebugMessage,
			...
	)

◆ Ext2ProcessEntry()

NTSTATUS Ext2ProcessEntry	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_FCB	Dcb,
		IN FILE_INFORMATION_CLASS	FileInformationClass,
		IN ULONG	in,
		IN PVOID	Buffer,
		IN ULONG	UsedLength,
		IN ULONG	Length,
		IN ULONG	FileIndex,
		IN PUNICODE_STRING	pName,
		OUT PULONG	EntrySize,
		IN BOOLEAN	Single
	)

Definition at line 60 of file dirctl.c.

{
    PFILE_DIRECTORY_INFORMATION     FDI = NULL;
    PFILE_FULL_DIR_INFORMATION      FFI = NULL;
    PFILE_ID_FULL_DIR_INFORMATION   FIF = NULL;
 
    PFILE_BOTH_DIR_INFORMATION      FBI = NULL;
    PFILE_ID_BOTH_DIR_INFORMATION   FIB = NULL;
 
    PFILE_NAMES_INFORMATION         FNI = NULL;
 
    PEXT2_MCB   Mcb = NULL;
    PEXT2_MCB   Target = NULL;
 
    NTSTATUS    Status = STATUS_SUCCESS;
    struct inode Inode = { 0 };
 
    ULONG InfoLength = 0;
    ULONG NameLength = 0;
#ifndef __REACTOS__
    ULONG dwBytes = 0;
#endif
    LONGLONG FileSize = 0;
    LONGLONG AllocationSize;
    ULONG   FileAttributes = 0;
 
    BOOLEAN IsEntrySymlink = FALSE;
 
    *EntrySize = 0;
    NameLength = pName->Length;
    ASSERT((UsedLength & 7) == 0);
 
    InfoLength = Ext2GetInfoLength(FileInformationClass);
    if (InfoLength == 0) {
        DEBUG(DL_ERR, ("Ext2ProcessDirEntry: Invalid Info Class %xh for %wZ in %wZ\n",
                       FileInformationClass, pName, &Dcb->Mcb->FullName ));
        return STATUS_INVALID_INFO_CLASS;
    }
 
    if (InfoLength + NameLength > Length)  {
        DEBUG(DL_INF, ( "Ext2PricessDirEntry: Buffer is not enough.\n"));
        Status = STATUS_BUFFER_OVERFLOW;
        if (UsedLength || InfoLength > Length) {
            DEBUG(DL_CP, ("Ext2ProcessDirEntry: Buffer overflows for %wZ in %wZ\n",
                          pName, &Dcb->Mcb->FullName ));
            return Status;
        }
    }
 
    DEBUG(DL_CP, ("Ext2ProcessDirEntry: %wZ in %wZ\n", pName, &Dcb->Mcb->FullName ));
 
    Mcb = Ext2SearchMcb(Vcb, Dcb->Mcb, pName);
    if (NULL != Mcb) {
        if (S_ISLNK(Mcb->Inode.i_mode) && NULL == Mcb->Target) {
            Ext2FollowLink( IrpContext, Vcb, Dcb->Mcb, Mcb, 0);
        }
 
    } else {
 
        Inode.i_ino = in;
        Inode.i_sb = &Vcb->sb;
        if (!Ext2LoadInode(Vcb, &Inode)) {
            DEBUG(DL_ERR, ("Ext2PricessDirEntry: Loading inode %xh (%wZ) error.\n",
                           in, pName ));
            DbgBreak();
            Status = STATUS_SUCCESS;
            goto errorout;
        }
 
        if (S_ISDIR(Inode.i_mode) || S_ISREG(Inode.i_mode)) {
        } else if (S_ISLNK(Inode.i_mode)) {
            DEBUG(DL_RES, ("Ext2ProcessDirEntry: SymLink: %wZ\\%wZ\n",
                           &Dcb->Mcb->FullName, pName));
            Ext2LookupFile(IrpContext, Vcb, pName, Dcb->Mcb, &Mcb,0);
 
            if (Mcb && IsMcbSpecialFile(Mcb)) {
                Ext2DerefMcb(Mcb);
                Mcb = NULL;
            }
        } else {
            Inode.i_size = 0;
        }
    }
 
    if (Mcb != NULL)  {
 
        FileAttributes = Mcb->FileAttr;
        if (IsMcbSymLink(Mcb)) {
            Target = Mcb->Target;
            ASSERT(Target);
            ASSERT(!IsMcbSymLink(Target));
            if (IsMcbDirectory(Target)) {
                FileSize = 0;
                FileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
            } else {
                FileSize = Target->Inode.i_size;
            }
            if (IsFileDeleted(Target)) {
                ClearFlag(FileAttributes, FILE_ATTRIBUTE_DIRECTORY);
                FileSize = 0;
            }
        } else {
            if (IsMcbDirectory(Mcb)) {
                FileSize = 0;
            } else {
                FileSize = Mcb->Inode.i_size;
            }
        }
 
        if (IsInodeSymLink(&Mcb->Inode)) {
            IsEntrySymlink = TRUE;
        }
 
    } else {
 
        if (S_ISDIR(Inode.i_mode)) {
            FileSize = 0;
        } else {
            FileSize  = Inode.i_size;
        }
 
        if (S_ISDIR(Inode.i_mode)) {
            FileAttributes = FILE_ATTRIBUTE_DIRECTORY;
        } else if (S_ISLNK(Inode.i_mode)) {
            FileAttributes = FILE_ATTRIBUTE_REPARSE_POINT;
            IsEntrySymlink = TRUE;
        } else {
            FileAttributes = FILE_ATTRIBUTE_NORMAL;
        }
 
        if (!Ext2CheckInodeAccess(Vcb, &Inode, Ext2FileCanWrite)) {
            SetFlag(FileAttributes, FILE_ATTRIBUTE_READONLY);
        }
    }
 
    if (FileAttributes == 0)
        FileAttributes = FILE_ATTRIBUTE_NORMAL;
 
    AllocationSize = CEILING_ALIGNED(ULONGLONG, FileSize, BLOCK_SIZE);
 
    /* process special files under root directory */
    if (IsRoot(Dcb)) {
        /* set hidden and system attributes for Recycled /
           RECYCLER / pagefile.sys */
        BOOLEAN IsDirectory = IsFlagOn(FileAttributes, FILE_ATTRIBUTE_DIRECTORY);
        if (Ext2IsSpecialSystemFile(pName, IsDirectory)) {
            SetFlag(FileAttributes, FILE_ATTRIBUTE_HIDDEN);
            SetFlag(FileAttributes, FILE_ATTRIBUTE_SYSTEM);
        }
    }
 
    /* set hidden attribute for all entries starting with '.' */
    if (( pName->Length >= 4 && pName->Buffer[0] == L'.') &&
            ((pName->Length == 4 && pName->Buffer[1] != L'.') ||
             pName->Length >= 6 )) {
        SetFlag(FileAttributes, FILE_ATTRIBUTE_HIDDEN);
    }
 
    switch (FileInformationClass) {
 
    case FileIdFullDirectoryInformation:
        FIF = (PFILE_ID_FULL_DIR_INFORMATION) ((PUCHAR)Buffer + UsedLength);
    case FileFullDirectoryInformation:
        FFI = (PFILE_FULL_DIR_INFORMATION) ((PUCHAR)Buffer + UsedLength);
    case FileDirectoryInformation:
        FDI = (PFILE_DIRECTORY_INFORMATION) ((PUCHAR)Buffer + UsedLength);
 
        if (!Single) {
            FDI->NextEntryOffset = CEILING_ALIGNED(ULONG, InfoLength + NameLength, 8);
        }
 
        FDI->FileIndex = FileIndex;
 
        if (Mcb) {
 
            FDI->CreationTime = Mcb->CreationTime;
            FDI->LastAccessTime = Mcb->LastAccessTime;
            FDI->LastWriteTime = Mcb->LastWriteTime;
            FDI->ChangeTime = Mcb->ChangeTime;
 
        } else {
 
            FDI->CreationTime = Ext2NtTime(Inode.i_ctime);
            FDI->LastAccessTime = Ext2NtTime(Inode.i_atime);
            FDI->LastWriteTime = Ext2NtTime(Inode.i_mtime);
            FDI->ChangeTime = Ext2NtTime(Inode.i_mtime);
        }
 
        FDI->FileAttributes = FileAttributes;
        FDI->EndOfFile.QuadPart = FileSize;
        FDI->AllocationSize.QuadPart = AllocationSize;
 
        FDI->FileNameLength = NameLength;
        if (InfoLength + NameLength > Length) {
            NameLength = Length - InfoLength;
        }
 
        if (FIF) {
            FIF->FileId.QuadPart = (LONGLONG) in;
            if (IsEntrySymlink) {
                FIF->EaSize = IO_REPARSE_TAG_SYMLINK;
            }
            RtlCopyMemory(&FIF->FileName[0], &pName->Buffer[0], NameLength);
        } else if (FFI) {
            if (IsEntrySymlink) {
                FFI->EaSize = IO_REPARSE_TAG_SYMLINK;
            }
            RtlCopyMemory(&FFI->FileName[0], &pName->Buffer[0], NameLength);
        } else {
            RtlCopyMemory(&FDI->FileName[0], &pName->Buffer[0], NameLength);
        }
 
        *EntrySize = InfoLength + NameLength;
        break;
 
 
    case FileIdBothDirectoryInformation:
        FIB = (PFILE_ID_BOTH_DIR_INFORMATION)((PUCHAR)Buffer + UsedLength);
    case FileBothDirectoryInformation:
        FBI = (PFILE_BOTH_DIR_INFORMATION) ((PUCHAR)Buffer + UsedLength);
 
        if (!Single) {
            FBI->NextEntryOffset = CEILING_ALIGNED(ULONG, InfoLength + NameLength, 8);
        }
 
        FBI->FileIndex = FileIndex;
        FBI->EndOfFile.QuadPart = FileSize;
        FBI->AllocationSize.QuadPart = AllocationSize;
 
        if (Mcb) {
 
            FBI->CreationTime = Mcb->CreationTime;
            FBI->LastAccessTime = Mcb->LastAccessTime;
            FBI->LastWriteTime = Mcb->LastWriteTime;
            FBI->ChangeTime = Mcb->ChangeTime;
 
        } else {
 
            FBI->CreationTime = Ext2NtTime(Inode.i_ctime);
            FBI->LastAccessTime = Ext2NtTime(Inode.i_atime);
            FBI->LastWriteTime = Ext2NtTime(Inode.i_mtime);
            FBI->ChangeTime = Ext2NtTime(Inode.i_mtime);
        }
 
        FBI->FileAttributes = FileAttributes;
 
        FBI->FileNameLength = NameLength;
        if (InfoLength + NameLength > Length) {
            NameLength = Length - InfoLength;
        }
 
        if (FIB) {
            FIB->FileId.QuadPart = (LONGLONG)in;
            if (IsEntrySymlink) {
                FIB->EaSize = IO_REPARSE_TAG_SYMLINK;
            }
            RtlCopyMemory(&FIB->FileName[0], &pName->Buffer[0], NameLength);
        } else {
            RtlCopyMemory(&FBI->FileName[0], &pName->Buffer[0], NameLength);
        }
 
        *EntrySize = InfoLength + NameLength;
        break;
 
    case FileNamesInformation:
 
        FNI = (PFILE_NAMES_INFORMATION) ((PUCHAR)Buffer + UsedLength);
        if (!Single) {
            FNI->NextEntryOffset = CEILING_ALIGNED(ULONG, InfoLength + NameLength, 8);
        }
 
        FNI->FileNameLength = NameLength;
        if (InfoLength + NameLength > Length) {
            NameLength = Length - InfoLength;
        }
        RtlCopyMemory(&FNI->FileName[0], &pName->Buffer[0], NameLength);
 
        *EntrySize = InfoLength + NameLength;
        break;
 
    default:
        Status = STATUS_INVALID_INFO_CLASS;
        break;
    }
 
    if (Mcb) {
        Ext2DerefMcb(Mcb);
    }
 
errorout:
 
    DEBUG(DL_CP, ("Ext2ProcessDirEntry: Status = %xh for %wZ in %wZ\n",
                  Status, pName, &Dcb->Mcb->FullName ));
 
    return Status;
}

Referenced by Ext2FillEntry(), and Ext2QueryDirectory().

◆ Ext2ProcessGlobalProperty()

NTSTATUS Ext2ProcessGlobalProperty	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PEXT2_VOLUME_PROPERTY3	Property,
		IN ULONG	Length
	)

Definition at line 240 of file devctl.c.

{
    PEXT2_VOLUME_PROPERTY3 Property2 = (PVOID)Property3;
    PEXT2_VOLUME_PROPERTY  Property = (PVOID)Property3;
    struct nls_table * PageTable = NULL;
 
    NTSTATUS        Status = STATUS_SUCCESS;
    BOOLEAN         GlobalDataResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        if (Length < 8 || !IsFlagOn(Property->Flags, EXT2_FLAG_VP_SET_GLOBAL)) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        /* query Ext2Fsd's version and built date/time*/
        if (Property->Command == APP_CMD_QUERY_VERSION) {
            PEXT2_VOLUME_PROPERTY_VERSION PVPV =
                (PEXT2_VOLUME_PROPERTY_VERSION) Property;
 
            if (Length < sizeof(EXT2_VOLUME_PROPERTY_VERSION)) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            RtlZeroMemory(&PVPV->Date[0],   0x20);
            RtlZeroMemory(&PVPV->Time[0],   0x20);
            RtlZeroMemory(&PVPV->Version[0],0x1C);
            strncpy(&PVPV->Version[0], gVersion, 0x1B);
            strncpy(&PVPV->Date[0], gDate, 0x1F);
            strncpy(&PVPV->Time[0], gTime, 0x1F);
            _SEH2_LEAVE;
        }
 
        /* must be property query/set commands */
        if (Property->Command == APP_CMD_SET_PROPERTY) {
            if (Length < sizeof(EXT2_VOLUME_PROPERTY)) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
        } else if (Property->Command == APP_CMD_SET_PROPERTY2) {
            if (Length < sizeof(EXT2_VOLUME_PROPERTY2)) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
        } else if (Property->Command == APP_CMD_SET_PROPERTY3) {
            if (Length < sizeof(EXT2_VOLUME_PROPERTY3)) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
        } else {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ExAcquireResourceExclusiveLite(&Ext2Global->Resource, TRUE);
        GlobalDataResourceAcquired = TRUE;
 
 
        switch (Property->Command) {
 
            case APP_CMD_SET_PROPERTY3:
 
            if (Property3->Flags2 & EXT2_VPROP3_AUTOMOUNT) {
                if (Property3->AutoMount)
                    SetLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT);
                else
                    ClearLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT);
            }
 
            case APP_CMD_SET_PROPERTY2:
 
            RtlZeroMemory(Ext2Global->sHidingPrefix, HIDINGPAT_LEN);
            if ((Ext2Global->bHidingPrefix = Property2->bHidingPrefix)) {
                RtlCopyMemory( Ext2Global->sHidingPrefix,
                               Property2->sHidingPrefix,
                               HIDINGPAT_LEN - 1);
            }
            RtlZeroMemory(Ext2Global->sHidingSuffix, HIDINGPAT_LEN);
            if ((Ext2Global->bHidingSuffix = Property2->bHidingSuffix)) {
                RtlCopyMemory( Ext2Global->sHidingSuffix,
                               Property2->sHidingSuffix,
                               HIDINGPAT_LEN - 1);
            }
 
            case APP_CMD_SET_PROPERTY:
 
            if (Property->bReadonly) {
                ClearLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING);
                ClearLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING);
            } else {
                SetLongFlag(Ext2Global->Flags, EXT2_SUPPORT_WRITING);
                if (Property->bExt3Writable) {
                    SetLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING);
                } else {
                    ClearLongFlag(Ext2Global->Flags, EXT3_FORCE_WRITING);
                }
            }
 
            PageTable = load_nls(Property->Codepage);
            if (PageTable) {
                memcpy(Ext2Global->Codepage.AnsiName, Property->Codepage, CODEPAGE_MAXLEN);
                Ext2Global->Codepage.PageTable = PageTable;
            }
 
            break;
 
            default:
            break;
        }
 
    } _SEH2_FINALLY {
 
        if (GlobalDataResourceAcquired) {
            ExReleaseResourceLite(&Ext2Global->Resource);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2ProcessUserProperty().

◆ Ext2ProcessUserProperty()

NTSTATUS Ext2ProcessUserProperty	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VOLUME_PROPERTY3	Property,
		IN ULONG	Length
	)

Definition at line 591 of file devctl.c.

{
    NTSTATUS    Status = STATUS_SUCCESS;
    PEXT2_VCB   Vcb = NULL;
    PDEVICE_OBJECT  DeviceObject = NULL;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        if (Property->Magic != EXT2_VOLUME_PROPERTY_MAGIC) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        DeviceObject = IrpContext->DeviceObject;
        if (IsExt2FsDevice(DeviceObject)) {
            Status = Ext2ProcessGlobalProperty(DeviceObject, Property, Length);
        } else {
            Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
            if (!((Vcb) && (Vcb->Identifier.Type == EXT2VCB) &&
                    (Vcb->Identifier.Size == sizeof(EXT2_VCB)))) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
            Status = Ext2ProcessVolumeProperty(Vcb, Property, Length);
        }
 
        if (NT_SUCCESS(Status)) {
            IrpContext->Irp->IoStatus.Information = Length;
        }
 
    } _SEH2_FINALLY {
 
        if (!IrpContext->ExceptionInProgress) {
            Ext2CompleteIrpContext(IrpContext, Status);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DeviceControl().

◆ Ext2ProcessVolumeProperty()

NTSTATUS Ext2ProcessVolumeProperty	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_VOLUME_PROPERTY3	Property,
		IN ULONG	Length
	)

Definition at line 368 of file devctl.c.

{
    struct nls_table * PageTable = NULL;
    PEXT2_VOLUME_PROPERTY2 Property2 = (PVOID)Property3;
    PEXT2_VOLUME_PROPERTY  Property = (PVOID)Property3;
    NTSTATUS Status = STATUS_SUCCESS;
    BOOLEAN VcbResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ExAcquireResourceExclusiveLite(&Vcb->MainResource, TRUE);
        VcbResourceAcquired = TRUE;
 
        if (Property->Command == APP_CMD_SET_PROPERTY ||
            Property->Command == APP_CMD_QUERY_PROPERTY) {
            if (Length < sizeof(EXT2_VOLUME_PROPERTY)) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
        } else if (Property->Command == APP_CMD_SET_PROPERTY2 ||
                   Property->Command == APP_CMD_QUERY_PROPERTY2) {
            if (Length < sizeof(EXT2_VOLUME_PROPERTY2)) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
        } else if (Property->Command == APP_CMD_SET_PROPERTY3 ||
                   Property->Command == APP_CMD_QUERY_PROPERTY3) {
            if (Length < sizeof(EXT2_VOLUME_PROPERTY3)) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
        }
 
        switch (Property->Command) {
 
        case APP_CMD_SET_PROPERTY3:
 
            if (Property3->Flags2 & EXT2_VPROP3_AUTOMOUNT) {
                if (Property3->AutoMount)
                    SetLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT);
                else
                    ClearLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT);
            }
            if (Property3->Flags2 & EXT2_VPROP3_USERIDS) {
                SetFlag(Vcb->Flags, VCB_USER_IDS);
                Vcb->uid = Property3->uid;
                Vcb->gid = Property3->gid;
                if (Property3->EIDS) {
                    Vcb->euid = Property3->euid;
                    Vcb->egid = Property3->egid;
                    SetFlag(Vcb->Flags, VCB_USER_EIDS);
                } else {
                    Vcb->euid = Vcb->egid = 0;
                    ClearFlag(Vcb->Flags, VCB_USER_EIDS);
                }
            } else {
                ClearFlag(Vcb->Flags, VCB_USER_IDS);
                ClearFlag(Vcb->Flags, VCB_USER_EIDS);
                Vcb->uid = Vcb->gid = 0;
                Vcb->euid = Vcb->egid = 0;
            }
 
        case APP_CMD_SET_PROPERTY2:
 
            RtlZeroMemory(Vcb->sHidingPrefix, HIDINGPAT_LEN);
#ifdef __REACTOS__
            if (Vcb->bHidingPrefix == Property2->bHidingPrefix) {
#else
            if (Vcb->bHidingPrefix = Property2->bHidingPrefix) {
#endif
                RtlCopyMemory( Vcb->sHidingPrefix,
                               Property2->sHidingPrefix,
                               HIDINGPAT_LEN - 1);
            }
 
            RtlZeroMemory(Vcb->sHidingSuffix, HIDINGPAT_LEN);
#ifdef __REACTOS__
            if (Vcb->bHidingSuffix == Property2->bHidingSuffix) {
#else
            if (Vcb->bHidingSuffix = Property2->bHidingSuffix) {
#endif
                RtlCopyMemory( Vcb->sHidingSuffix,
                               Property2->sHidingSuffix,
                               HIDINGPAT_LEN - 1);
            }
            Vcb->DrvLetter = Property2->DrvLetter;
 
        case APP_CMD_SET_PROPERTY:
 
            if (Property->bReadonly) {
                if (IsFlagOn(Vcb->Flags, VCB_INITIALIZED)) {
                    Ext2FlushFiles(NULL, Vcb, FALSE);
                    Ext2FlushVolume(NULL, Vcb, FALSE);
                }
                SetLongFlag(Vcb->Flags, VCB_READ_ONLY);
 
            } else {
 
                if (Property->bExt3Writable) {
                    SetLongFlag(Vcb->Flags, VCB_FORCE_WRITING);
                }
 
                if (!Vcb->IsExt3fs) {
                    ClearLongFlag(Vcb->Flags, VCB_READ_ONLY);
                } else if (!Property->bExt3Writable) {
                    SetLongFlag(Vcb->Flags, VCB_READ_ONLY);
                } else if (IsFlagOn(Vcb->Flags, VCB_JOURNAL_RECOVER)) {
                    ClearLongFlag(Vcb->Flags, VCB_READ_ONLY);
                    Ext2RecoverJournal(NULL, Vcb);
                    if (IsFlagOn(Vcb->Flags, VCB_JOURNAL_RECOVER)) {
                        SetLongFlag(Vcb->Flags, VCB_READ_ONLY);
                    } else {
                        ClearLongFlag(Vcb->Flags, VCB_READ_ONLY);
                    }
                } else {
                    ClearLongFlag(Vcb->Flags, VCB_READ_ONLY);
                }
            }
 
            PageTable = load_nls(Property->Codepage);
            memcpy(Vcb->Codepage.AnsiName, Property->Codepage, CODEPAGE_MAXLEN);
            Vcb->Codepage.PageTable = PageTable;
            if (Vcb->Codepage.PageTable) {
                Ext2InitializeLabel(Vcb, Vcb->SuperBlock);
            }
 
            break;
 
        case APP_CMD_QUERY_PROPERTY3:
 
            if (IsFlagOn(Ext2Global->Flags, EXT2_AUTO_MOUNT)) {
                SetFlag(Property3->Flags2, EXT2_VPROP3_AUTOMOUNT);
                Property3->AutoMount = TRUE;
            } else {
                ClearFlag(Property3->Flags2, EXT2_VPROP3_AUTOMOUNT);
                Property3->AutoMount = FALSE;
            }
 
            if (IsFlagOn(Vcb->Flags, VCB_USER_IDS)) {
                SetFlag(Property3->Flags2, EXT2_VPROP3_USERIDS);
                Property3->uid = Vcb->uid;
                Property3->gid = Vcb->gid;
                if (IsFlagOn(Vcb->Flags, VCB_USER_EIDS)) {
                    Property3->EIDS = TRUE;
                    Property3->euid = Vcb->euid;
                    Property3->egid = Vcb->egid;
                } else {
                    Property3->EIDS = FALSE;
                }
            } else {
                ClearFlag(Property3->Flags2, EXT2_VPROP3_USERIDS);
            }
 
        case APP_CMD_QUERY_PROPERTY2:
 
            RtlCopyMemory(Property2->UUID, Vcb->SuperBlock->s_uuid, 16);
            Property2->DrvLetter = Vcb->DrvLetter;
 
#ifdef __REACTOS__
            if (Property2->bHidingPrefix == Vcb->bHidingPrefix) {
#else
            if (Property2->bHidingPrefix = Vcb->bHidingPrefix) {
#endif
                RtlCopyMemory( Property2->sHidingPrefix,
                               Vcb->sHidingPrefix,
                               HIDINGPAT_LEN);
            } else {
                RtlZeroMemory( Property2->sHidingPrefix,
                               HIDINGPAT_LEN);
            }
 
#ifdef __REACTOS__
            if (Property2->bHidingSuffix == Vcb->bHidingSuffix) {
#else
            if (Property2->bHidingSuffix = Vcb->bHidingSuffix) {
#endif
                RtlCopyMemory( Property2->sHidingSuffix,
                               Vcb->sHidingSuffix,
                               HIDINGPAT_LEN);
            } else {
                RtlZeroMemory( Property2->sHidingSuffix,
                               HIDINGPAT_LEN);
            }
 
        case APP_CMD_QUERY_PROPERTY:
 
            Property->bExt2 = TRUE;
            Property->bExt3 = Vcb->IsExt3fs;
            Property->bReadonly = IsFlagOn(Vcb->Flags, VCB_READ_ONLY);
            if (!Property->bReadonly && Vcb->IsExt3fs) {
                Property->bExt3Writable = TRUE;
            } else {
                Property->bExt3Writable = FALSE;
            }
 
            RtlZeroMemory(Property->Codepage, CODEPAGE_MAXLEN);
            if (Vcb->Codepage.PageTable) {
                strncpy(Property->Codepage, Vcb->Codepage.PageTable->charset, CODEPAGE_MAXLEN);
            } else {
                strncpy(Property->Codepage, "default", CODEPAGE_MAXLEN);
            }
            break;
 
        default:
            Status = STATUS_INVALID_PARAMETER;
            break;
        }
 
    } _SEH2_FINALLY {
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2PerformRegistryVolumeParams(), and Ext2ProcessUserProperty().

◆ Ext2PurgeFile()

NTSTATUS Ext2PurgeFile	(	IN PEXT2_FCB	Fcb,
		IN BOOLEAN	FlushBeforePurge
	)

Definition at line 2811 of file fsctl.c.

{
    IO_STATUS_BLOCK    IoStatus;
 
    ASSERT(Fcb != NULL);
 
    ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
           (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
 
    if (!IsVcbReadOnly(Fcb->Vcb) && FlushBeforePurge) {
        DEBUG(DL_INF, ( "Ext2PurgeFile: CcFlushCache on %wZ.\n",
                        &Fcb->Mcb->FullName));
        ExAcquireSharedStarveExclusive(&Fcb->PagingIoResource, TRUE);
        ExReleaseResourceLite(&Fcb->PagingIoResource);
        CcFlushCache(&Fcb->SectionObject, NULL, 0, &IoStatus);
        ClearFlag(Fcb->Flags, FCB_FILE_MODIFIED);
    }
 
    if (Fcb->SectionObject.ImageSectionObject) {
        DEBUG(DL_INF, ( "Ext2PurgeFile: MmFlushImageSection on %wZ.\n",
                        &Fcb->Mcb->FullName));
        MmFlushImageSection(&Fcb->SectionObject, MmFlushForWrite);
    }
 
    if (Fcb->SectionObject.DataSectionObject) {
        DEBUG(DL_INF, ( "Ext2PurgeFile: CcPurgeCacheSection on %wZ.\n",
                        &Fcb->Mcb->FullName));
        CcPurgeCacheSection(&Fcb->SectionObject, NULL, 0, FALSE);
    }
 
    return STATUS_SUCCESS;
}

Referenced by Ext2PurgeVolume().

◆ Ext2PurgeVolume()

NTSTATUS Ext2PurgeVolume	(	IN PEXT2_VCB	Vcb,
		IN BOOLEAN	FlushBeforePurge
	)

Definition at line 2704 of file fsctl.c.

{
    PEXT2_FCB       Fcb;
    LIST_ENTRY      List, *Next;
 
    BOOLEAN         VcbResourceAcquired = FALSE;
    BOOLEAN         FcbResourceAcquired = FALSE;
    BOOLEAN         gdResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        ExAcquireResourceExclusiveLite(&Vcb->MainResource, TRUE);
        VcbResourceAcquired = TRUE;
 
        if (IsVcbReadOnly(Vcb)) {
            FlushBeforePurge = FALSE;
        }
 
        InitializeListHead(&List);
 
        ExAcquireResourceExclusiveLite(&Vcb->FcbLock, TRUE);
        FcbResourceAcquired = TRUE;
 
        while (!IsListEmpty(&Vcb->FcbList)) {
 
            Next = RemoveHeadList(&Vcb->FcbList);
            Fcb = CONTAINING_RECORD(Next, EXT2_FCB, Next);
 
            DEBUG(DL_INF, ( "Ext2PurgeVolume: %wZ refercount=%xh\n",
                            &Fcb->Mcb->FullName, Fcb->ReferenceCount));
            InsertTailList(&List, &Fcb->Next);
        }
 
        while (!IsListEmpty(&List)) {
 
            Next = RemoveHeadList(&List);
            Fcb = CONTAINING_RECORD(Next, EXT2_FCB, Next);
 
            if (ExAcquireResourceExclusiveLite(
                        &Fcb->MainResource,
                        TRUE )) {
 
                Ext2PurgeFile(Fcb, FlushBeforePurge);
 
                if (Fcb->ReferenceCount <= 1) {
                    Fcb->TsDrop.QuadPart = 0;
                    InsertHeadList(&Vcb->FcbList, &Fcb->Next);
                } else {
                    InsertTailList(&Vcb->FcbList, &Fcb->Next);
                }
                ExReleaseResourceLite(&Fcb->MainResource);
            }
        }
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->FcbLock);
            FcbResourceAcquired = FALSE;
        }
 
        /* acquire bd lock to avoid bh creation */
        ExAcquireResourceExclusiveLite(&Vcb->sbi.s_gd_lock, TRUE);
        gdResourceAcquired = TRUE;
 
        /* discard buffer_headers for group_desc */
        Ext2DropBH(Vcb);
 
        if (FlushBeforePurge) {
            ExAcquireSharedStarveExclusive(&Vcb->PagingIoResource, TRUE);
            ExReleaseResourceLite(&Vcb->PagingIoResource);
 
            CcFlushCache(&Vcb->SectionObject, NULL, 0, NULL);
        }
 
        if (Vcb->SectionObject.ImageSectionObject) {
            MmFlushImageSection(&Vcb->SectionObject, MmFlushForWrite);
        }
 
        if (Vcb->SectionObject.DataSectionObject) {
            CcPurgeCacheSection(&Vcb->SectionObject, NULL, 0, FALSE);
        }
 
        DEBUG(DL_INF, ( "Ext2PurgeVolume: Volume flushed and purged.\n"));
 
    } _SEH2_FINALLY {
 
        if (gdResourceAcquired) {
            ExReleaseResourceLite(&Vcb->sbi.s_gd_lock);
        }
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->FcbLock);
        }
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
    } _SEH2_END;
 
    return STATUS_SUCCESS;
}

Referenced by Ext2DismountVolume(), Ext2VerifyVolume(), and Ext2WriteVolume().

◆ 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().

◆ Ext2QueryDirectory()

NTSTATUS Ext2QueryDirectory ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 525 of file dirctl.c.

{
    PDEVICE_OBJECT          DeviceObject;
    NTSTATUS                Status = STATUS_UNSUCCESSFUL;
    PEXT2_VCB               Vcb = NULL;
    PFILE_OBJECT            FileObject = NULL;
    PEXT2_FCB               Fcb = NULL;
    PEXT2_MCB               Mcb = NULL;
    PEXT2_CCB               Ccb = NULL;
    PIRP                    Irp = NULL;
    PIO_STACK_LOCATION      IoStackLocation = NULL;
 
    ULONG                   Length;
    ULONG                   FileIndex;
    PUNICODE_STRING         FileName;
    PUCHAR                  Buffer;
 
    BOOLEAN                 RestartScan;
    BOOLEAN                 ReturnSingleEntry;
    BOOLEAN                 IndexSpecified;
    BOOLEAN                 FirstQuery;
    BOOLEAN                 FcbResourceAcquired = FALSE;
 
    USHORT                  NameLen;
    FILE_INFORMATION_CLASS  fi;
 
    OEM_STRING              Oem = { 0 };
    UNICODE_STRING          Unicode = { 0 };
    PEXT2_DIR_ENTRY2        pDir = NULL;
 
    ULONG                   ByteOffset;
    ULONG                   RecLen = 0;
    ULONG                   EntrySize = 0;
 
    EXT2_FILLDIR_CONTEXT    fc = { 0 };
 
    _SEH2_TRY {
 
        ASSERT(IrpContext);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        if (!IsMounted(Vcb)) {
            Status = STATUS_VOLUME_DISMOUNTED;
            _SEH2_LEAVE;
        }
 
        if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED)) {
            Status = STATUS_ACCESS_DENIED;
            _SEH2_LEAVE;
        }
 
        FileObject = IrpContext->FileObject;
        Fcb = (PEXT2_FCB) FileObject->FsContext;
        if (Fcb == NULL) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
        Mcb = Fcb->Mcb;
        if (NULL == Mcb) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
        ASSERT (!IsMcbSymLink(Mcb));
 
        //
        // This request is not allowed on volumes
        //
        if (Fcb->Identifier.Type == EXT2VCB) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
        if (!IsMcbDirectory(Mcb)) {
            Status = STATUS_NOT_A_DIRECTORY;
            _SEH2_LEAVE;
        }
 
        if (IsFileDeleted(Mcb)) {
            Status = STATUS_NOT_A_DIRECTORY;
            _SEH2_LEAVE;
        }
 
        Ccb = (PEXT2_CCB) FileObject->FsContext2;
 
        ASSERT(Ccb);
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
               (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
 
        Irp = IrpContext->Irp;
        IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
 
#ifndef _GNU_NTIFS_
 
        fi = IoStackLocation->Parameters.QueryDirectory.FileInformationClass;
 
        Length = IoStackLocation->Parameters.QueryDirectory.Length;
 
        FileName = (PUNICODE_STRING)IoStackLocation->Parameters.QueryDirectory.FileName;
 
        FileIndex = IoStackLocation->Parameters.QueryDirectory.FileIndex;
 
#else // _GNU_NTIFS_
 
        fi = ((PEXTENDED_IO_STACK_LOCATION)
              IoStackLocation)->Parameters.QueryDirectory.FileInformationClass;
 
        Length = ((PEXTENDED_IO_STACK_LOCATION)
                  IoStackLocation)->Parameters.QueryDirectory.Length;
 
        FileName = ((PEXTENDED_IO_STACK_LOCATION)
                    IoStackLocation)->Parameters.QueryDirectory.FileName;
 
        FileIndex = ((PEXTENDED_IO_STACK_LOCATION)
                     IoStackLocation)->Parameters.QueryDirectory.FileIndex;
 
#endif // _GNU_NTIFS_
 
        RestartScan = FlagOn(((PEXTENDED_IO_STACK_LOCATION)
                              IoStackLocation)->Flags, SL_RESTART_SCAN);
        ReturnSingleEntry = FlagOn(((PEXTENDED_IO_STACK_LOCATION)
                                    IoStackLocation)->Flags, SL_RETURN_SINGLE_ENTRY);
        IndexSpecified = FlagOn(((PEXTENDED_IO_STACK_LOCATION)
                                 IoStackLocation)->Flags, SL_INDEX_SPECIFIED);
 
        Buffer = Ext2GetUserBuffer(Irp);
        if (Buffer == NULL) {
            DbgBreak();
            Status = STATUS_INVALID_USER_BUFFER;
            _SEH2_LEAVE;
        }
 
        if (!IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
 
        if (!ExAcquireResourceSharedLite(
                    &Fcb->MainResource,
                    IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) )) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
        FcbResourceAcquired = TRUE;
 
        if (FileName != NULL) {
 
            if (Ccb->DirectorySearchPattern.Buffer != NULL) {
 
                FirstQuery = FALSE;
 
            } else {
 
                FirstQuery = TRUE;
 
                Ccb->DirectorySearchPattern.Length =
                    Ccb->DirectorySearchPattern.MaximumLength =
                        FileName->Length;
 
                Ccb->DirectorySearchPattern.Buffer =
                    Ext2AllocatePool(PagedPool, FileName->Length,
                                     EXT2_DIRSP_MAGIC);
 
                if (Ccb->DirectorySearchPattern.Buffer == NULL) {
                    DEBUG(DL_ERR, ( "Ex2QueryDirectory: failed to allocate SerarchPattern.\n"));
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    _SEH2_LEAVE;
                }
 
                INC_MEM_COUNT( PS_DIR_PATTERN,
                               Ccb->DirectorySearchPattern.Buffer,
                               Ccb->DirectorySearchPattern.MaximumLength);
 
                Status = RtlUpcaseUnicodeString(
                             &(Ccb->DirectorySearchPattern),
                             FileName,
                             FALSE);
 
                if (!NT_SUCCESS(Status)) {
                    _SEH2_LEAVE;
                }
            }
 
        } else if (Ccb->DirectorySearchPattern.Buffer != NULL) {
 
            FirstQuery = FALSE;
            FileName = &Ccb->DirectorySearchPattern;
 
        } else {
 
            FirstQuery = TRUE;
 
            Ccb->DirectorySearchPattern.Length =
                Ccb->DirectorySearchPattern.MaximumLength = 2;
 
            Ccb->DirectorySearchPattern.Buffer =
                Ext2AllocatePool(PagedPool, 4, EXT2_DIRSP_MAGIC);
 
            if (Ccb->DirectorySearchPattern.Buffer == NULL) {
                DEBUG(DL_ERR, ( "Ex2QueryDirectory: failed to allocate SerarchPattern (1st).\n"));
                Status = STATUS_INSUFFICIENT_RESOURCES;
                _SEH2_LEAVE;
            }
 
            INC_MEM_COUNT( PS_DIR_PATTERN,
                           Ccb->DirectorySearchPattern.Buffer,
                           Ccb->DirectorySearchPattern.MaximumLength);
 
            RtlZeroMemory(Ccb->DirectorySearchPattern.Buffer, 4);
            RtlCopyMemory(
                Ccb->DirectorySearchPattern.Buffer,
                L"*\0", 2);
        }
 
        if (IndexSpecified) {
            Ccb->filp.f_pos = FileIndex;
        } else {
            if (RestartScan || FirstQuery) {
                Ccb->filp.f_pos = FileIndex = 0;
            } else {
                FileIndex = (ULONG)Ccb->filp.f_pos;
            }
        }
 
        RtlZeroMemory(Buffer, Length);
 
        fc.efc_irp = IrpContext;
        fc.efc_buf = Buffer;
        fc.efc_size = Length;
        fc.efc_start = 0;
        fc.efc_single = ReturnSingleEntry;
        fc.efc_fi = fi;
        fc.efc_status = STATUS_SUCCESS;
 
#ifdef EXT2_HTREE_INDEX
 
        if (EXT3_HAS_COMPAT_FEATURE(Mcb->Inode.i_sb,
                                    EXT3_FEATURE_COMPAT_DIR_INDEX) &&
                ((EXT3_I(&Mcb->Inode)->i_flags & EXT3_INDEX_FL) ||
                 ((Mcb->Inode.i_size >> BLOCK_BITS) == 1)) ) {
            int rc = ext3_dx_readdir(&Ccb->filp, Ext2FillEntry, &fc);
            Status = fc.efc_status;
            if (rc != ERR_BAD_DX_DIR) {
                goto errorout;
            }
            /*
             * We don't set the inode dirty flag since it's not
             * critical that it get flushed back to the disk.
             */
            EXT3_I(&Mcb->Inode)->i_flags &= ~EXT3_INDEX_FL;
        }
#endif
 
        if (Mcb->Inode.i_size <= Ccb->filp.f_pos) {
            Status = STATUS_NO_MORE_FILES;
            _SEH2_LEAVE;
        }
 
        pDir = Ext2AllocatePool(
                   PagedPool,
                   sizeof(EXT2_DIR_ENTRY2),
                   EXT2_DENTRY_MAGIC
               );
 
        if (!pDir) {
            DEBUG(DL_ERR, ( "Ex2QueryDirectory: failed to allocate pDir.\n"));
            Status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
 
        INC_MEM_COUNT(PS_DIR_ENTRY, pDir, sizeof(EXT2_DIR_ENTRY2));
        ByteOffset = FileIndex;
 
        DEBUG(DL_CP, ("Ex2QueryDirectory: Dir: %wZ Index=%xh Pattern : %wZ.\n",
                      &Fcb->Mcb->FullName, FileIndex, &Ccb->DirectorySearchPattern));
 
        while ((ByteOffset < Mcb->Inode.i_size) &&
                (CEILING_ALIGNED(ULONG, fc.efc_start, 8) < Length)) {
 
            RtlZeroMemory(pDir, sizeof(EXT2_DIR_ENTRY2));
 
            Status = Ext2ReadInode(
                         IrpContext,
                         Vcb,
                         Mcb,
                         (ULONGLONG)ByteOffset,
                         (PVOID)pDir,
                         sizeof(EXT2_DIR_ENTRY2),
                         FALSE,
                         &EntrySize);
 
            if (!NT_SUCCESS(Status)) {
                DbgBreak();
                _SEH2_LEAVE;
            }
 
            if (pDir->rec_len == 0) {
                RecLen = BLOCK_SIZE - (ByteOffset & (BLOCK_SIZE - 1));
            } else {
                RecLen = ext3_rec_len_from_disk(pDir->rec_len);
            }
 
            if (!pDir->inode || pDir->inode >= INODES_COUNT) {
                goto ProcessNextEntry;
            }
 
            /* skip . and .. */
            if ((pDir->name_len == 1 && pDir->name[0] == '.') ||
                    (pDir->name_len == 2 && pDir->name[0] == '.' && pDir->name[1] == '.' )) {
                goto ProcessNextEntry;
            }
 
            Oem.Buffer = pDir->name;
            Oem.Length = (pDir->name_len & 0xff);
            Oem.MaximumLength = Oem.Length;
 
            if (Ext2IsWearingCloak(Vcb, &Oem)) {
                goto ProcessNextEntry;
            }
 
            NameLen = (USHORT) Ext2OEMToUnicodeSize(Vcb, &Oem);
 
            if (NameLen <= 0) {
                DEBUG(DL_CP, ("Ext2QueryDirectory: failed to count unicode length for inode: %xh\n",
                              pDir->inode));
                Status = STATUS_INSUFFICIENT_RESOURCES;
                break;
            }
 
            if ( Unicode.Buffer != NULL && Unicode.MaximumLength > NameLen) {
                /* reuse buffer */
            } else {
                /* free and re-allocate it */
                if (Unicode.Buffer) {
                    DEC_MEM_COUNT(PS_INODE_NAME,
                                  Unicode.Buffer,
                                  Unicode.MaximumLength);
                    Ext2FreePool(Unicode.Buffer, EXT2_INAME_MAGIC);
                }
                Unicode.MaximumLength = NameLen + 2;
                Unicode.Buffer = Ext2AllocatePool(
                                     PagedPool, Unicode.MaximumLength,
                                     EXT2_INAME_MAGIC
                                 );
                if (!Unicode.Buffer) {
                    DEBUG(DL_ERR, ( "Ex2QueryDirectory: failed to "
                                    "allocate InodeFileName.\n"));
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    _SEH2_LEAVE;
                }
                INC_MEM_COUNT(PS_INODE_NAME, Unicode.Buffer, Unicode.MaximumLength);
            }
 
            Unicode.Length = 0;
            RtlZeroMemory(Unicode.Buffer, Unicode.MaximumLength);
 
            Status = Ext2OEMToUnicode(Vcb, &Unicode, &Oem);
            if (!NT_SUCCESS(Status)) {
                DEBUG(DL_ERR, ( "Ex2QueryDirectory: Ext2OEMtoUnicode failed with %xh.\n", Status));
                Status = STATUS_INSUFFICIENT_RESOURCES;
                _SEH2_LEAVE;
            }
 
            DEBUG(DL_CP, ( "Ex2QueryDirectory: process inode: %xh / %wZ (%d).\n",
                           pDir->inode, &Unicode, Unicode.Length));
 
            if (FsRtlDoesNameContainWildCards(
                        &(Ccb->DirectorySearchPattern)) ?
                    FsRtlIsNameInExpression(
                        &(Ccb->DirectorySearchPattern),
                        &Unicode,
                        TRUE,
                        NULL) :
                    !RtlCompareUnicodeString(
                        &(Ccb->DirectorySearchPattern),
                        &Unicode,
                        TRUE)           ) {
 
                Status = Ext2ProcessEntry(
                             IrpContext,
                             Vcb,
                             Fcb,
                             fi,
                             pDir->inode,
                             Buffer,
                             CEILING_ALIGNED(ULONG, fc.efc_start, 8),
                             Length - CEILING_ALIGNED(ULONG, fc.efc_start, 8),
                             ByteOffset,
                             &Unicode,
                             &EntrySize,
                             ReturnSingleEntry
                         );
 
                if (NT_SUCCESS(Status)) {
                    if (EntrySize > 0) {
                        fc.efc_prev  = CEILING_ALIGNED(ULONG, fc.efc_start, 8);
                        fc.efc_start = fc.efc_prev + EntrySize;
                    } else {
                        DbgBreak();
                    }
                } else {
                    if (Status == STATUS_BUFFER_OVERFLOW) {
                        if (fc.efc_start == 0) {
                            fc.efc_start = EntrySize;
                        } else {
                            Status = STATUS_SUCCESS;
                        }
                    } else {
                        _SEH2_LEAVE;
                    }
                    break;
                }
            }
 
ProcessNextEntry:
 
            ByteOffset += RecLen;
            Ccb->filp.f_pos = ByteOffset;
 
            if (fc.efc_start && ReturnSingleEntry) {
                Status = STATUS_SUCCESS;
                goto errorout;
            }
        }
 
errorout:
 
        ((PULONG)((PUCHAR)Buffer + fc.efc_prev))[0] = 0;
        FileIndex = ByteOffset;
 
        if (Status == STATUS_BUFFER_OVERFLOW) {
            /* just return fc.efc_start/EntrySize bytes that we filled */
        } else if (!fc.efc_start) {
            if (NT_SUCCESS(Status)) {
                if (FirstQuery) {
                    Status = STATUS_NO_SUCH_FILE;
                } else {
                    Status = STATUS_NO_MORE_FILES;
                }
            }
        } else {
            Status = STATUS_SUCCESS;
        }
 
    } _SEH2_FINALLY {
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (pDir != NULL) {
            Ext2FreePool(pDir, EXT2_DENTRY_MAGIC);
            DEC_MEM_COUNT(PS_DIR_ENTRY, pDir, sizeof(EXT2_DIR_ENTRY2));
        }
 
        if (Unicode.Buffer != NULL) {
            DEC_MEM_COUNT(PS_INODE_NAME, Unicode.Buffer, Unicode.MaximumLength);
            Ext2FreePool(Unicode.Buffer, EXT2_INAME_MAGIC);
        }
 
        if (!IrpContext->ExceptionInProgress) {
 
            if ( Status == STATUS_PENDING ||
                    Status == STATUS_CANT_WAIT) {
 
                Status = Ext2LockUserBuffer(
                             IrpContext->Irp,
                             Length,
                             IoWriteAccess );
 
                if (NT_SUCCESS(Status)) {
                    Status = Ext2QueueRequest(IrpContext);
                } else {
                    Ext2CompleteIrpContext(IrpContext, Status);
                }
            } else {
                IrpContext->Irp->IoStatus.Information = fc.efc_start;
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DirectoryControl().

◆ Ext2QueryEa()

NTSTATUS Ext2QueryEa ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 94 of file ea.c.

{
    PIRP                Irp = NULL;
    PIO_STACK_LOCATION  IrpSp;
 
    PDEVICE_OBJECT      DeviceObject;
 
    PEXT2_VCB           Vcb = NULL;
    PEXT2_FCB           Fcb = NULL;
    PEXT2_CCB           Ccb = NULL;
    PEXT2_MCB           Mcb = NULL;
 
    PUCHAR  UserEaList;
    ULONG   UserEaListLength;
    ULONG   UserEaIndex;
 
    BOOLEAN RestartScan;
    BOOLEAN ReturnSingleEntry;
    BOOLEAN IndexSpecified;
 
    BOOLEAN             MainResourceAcquired = FALSE;
    BOOLEAN             XattrRefAcquired = FALSE;
 
    NTSTATUS            Status = STATUS_UNSUCCESSFUL;
 
    struct ext4_xattr_ref xattr_ref;
    PCHAR UserBuffer;
 
    ULONG UserBufferLength = 0;
    ULONG RemainingUserBufferLength = 0;
 
    PFILE_FULL_EA_INFORMATION FullEa, LastFullEa = NULL;
 
    _SEH2_TRY {
 
        Ccb = IrpContext->Ccb;
        ASSERT(Ccb != NULL);
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
            (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
        DeviceObject = IrpContext->DeviceObject;
        Vcb = (PEXT2_VCB)DeviceObject->DeviceExtension;
        Fcb = IrpContext->Fcb;
        Mcb = Fcb->Mcb;
        Irp = IrpContext->Irp;
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
        Irp->IoStatus.Information = 0;
 
        //
        // Receive input parameter from caller
        //
        UserBuffer = Ext2GetUserBuffer(Irp);
        if (!UserBuffer) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
        UserBufferLength = IrpSp->Parameters.QueryEa.Length;
        RemainingUserBufferLength = UserBufferLength;
        UserEaList = IrpSp->Parameters.QueryEa.EaList;
        UserEaListLength = IrpSp->Parameters.QueryEa.EaListLength;
        UserEaIndex = IrpSp->Parameters.QueryEa.EaIndex;
        RestartScan = BooleanFlagOn(IrpSp->Flags, SL_RESTART_SCAN);
        ReturnSingleEntry = BooleanFlagOn(IrpSp->Flags, SL_RETURN_SINGLE_ENTRY);
        IndexSpecified = BooleanFlagOn(IrpSp->Flags, SL_INDEX_SPECIFIED);
 
        if (!Mcb)
            _SEH2_LEAVE;
 
        //
        // We do not allow multiple instance gaining EA access to the same file
        //
        if (!ExAcquireResourceExclusiveLite(
            &Fcb->MainResource,
            IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT))) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
        MainResourceAcquired = TRUE;
 
        Status = Ext2WinntError(ext4_fs_get_xattr_ref(IrpContext, Vcb, Fcb->Mcb, &xattr_ref));
        if (!NT_SUCCESS(Status)) {
            DbgPrint("ext4_fs_get_xattr_ref() failed!\n");
            _SEH2_LEAVE;
        }
 
        FullEa = (PFILE_FULL_EA_INFORMATION)UserBuffer;
 
        XattrRefAcquired = TRUE;
 
        if (RemainingUserBufferLength)
            RtlZeroMemory(FullEa, RemainingUserBufferLength);
 
        if (UserEaList != NULL) {
            int i = 0;
            PFILE_GET_EA_INFORMATION GetEa;
            for (GetEa = (PFILE_GET_EA_INFORMATION)&UserEaList[0];
                    GetEa < (PFILE_GET_EA_INFORMATION)((PUCHAR)UserEaList
                    + UserEaListLength);
                GetEa = (GetEa->NextEntryOffset == 0
                    ? (PFILE_GET_EA_INFORMATION)MAXUINT_PTR
                    : (PFILE_GET_EA_INFORMATION)((PUCHAR)GetEa
                        + GetEa->NextEntryOffset))) {
 
                size_t ItemSize;
                OEM_STRING Str;
                ULONG EaEntrySize;
                BOOL is_last = !GetEa->NextEntryOffset;
 
                Str.MaximumLength = Str.Length = GetEa->EaNameLength;
                Str.Buffer = &GetEa->EaName[0];
 
                //
                // At the moment we only need to know whether the item exists
                // and its size.
                //
                Status = Ext2WinntError(ext4_fs_get_xattr(&xattr_ref,
                    EXT4_XATTR_INDEX_USER,
                    Str.Buffer,
                    Str.Length,
                    NULL,
                    0,
                    &ItemSize));
                if (!NT_SUCCESS(Status))
                    continue;
 
                //
                //  We were not able to locate the name therefore we must
                //  dummy up a entry for the query.  The needed Ea size is
                //  the size of the name + 4 (next entry offset) + 1 (flags)
                //  + 1 (name length) + 2 (value length) + the name length +
                //  1 (null byte) + Data Size.
                //
                EaEntrySize = 4 + 1 + 1 + 2 + GetEa->EaNameLength + 1 + ItemSize;
                if (!is_last)
                    EaEntrySize = ALIGN_UP(EaEntrySize, ULONG);
 
                if (EaEntrySize > RemainingUserBufferLength) {
 
                    Status = i ? STATUS_BUFFER_OVERFLOW : STATUS_BUFFER_TOO_SMALL;
                    _SEH2_LEAVE;
                }
                FullEa->NextEntryOffset = 0;
                FullEa->Flags = 0;
                FullEa->EaNameLength = GetEa->EaNameLength;
                FullEa->EaValueLength = (USHORT)ItemSize;
                RtlCopyMemory(&FullEa->EaName[0],
                    &GetEa->EaName[0],
                    GetEa->EaNameLength);
 
                //
                // This query must succeed, or is guarenteed to succeed
                // since we are only looking up
                // an EA entry in a in-memory tree structure.
                // Otherwise that means someone might be operating on
                // the xattr_ref without acquiring Inode lock.
                //
                ASSERT(NT_SUCCESS(Ext2WinntError(
                    ext4_fs_get_xattr(&xattr_ref,
                        EXT4_XATTR_INDEX_USER,
                        Str.Buffer,
                        Str.Length,
                        &FullEa->EaName[0] + FullEa->EaNameLength + 1,
                        ItemSize,
                        &ItemSize
                ))));
                FullEa->EaValueLength = (USHORT)ItemSize;
 
                // Link FullEa and LastFullEa together
                if (LastFullEa)
                    LastFullEa->NextEntryOffset = (ULONG)((PCHAR)FullEa -
                                                          (PCHAR)LastFullEa);
 
                LastFullEa = FullEa;
                FullEa = (PFILE_FULL_EA_INFORMATION)
                    ((PCHAR)FullEa + EaEntrySize);
                RemainingUserBufferLength -= EaEntrySize;
                i++;
            }
        } else if (IndexSpecified) {
            struct EaIterator EaIterator;
            //
            //  The user supplied an index into the Ea list.
            //
            if (RemainingUserBufferLength)
                RtlZeroMemory(FullEa, RemainingUserBufferLength);
 
            EaIterator.OverFlow = FALSE;
            EaIterator.RemainingUserBufferLength = UserBufferLength;
            // In this case, return only an entry.
            EaIterator.ReturnSingleEntry = TRUE;
            EaIterator.FullEa = (PFILE_FULL_EA_INFORMATION)UserBuffer;
            EaIterator.LastFullEa = NULL;
            EaIterator.UserBufferLength = UserBufferLength;
            EaIterator.EaIndex = UserEaIndex;
            EaIterator.EaIndexCounter = 1;
 
            xattr_ref.iter_arg = &EaIterator;
            ext4_fs_xattr_iterate(&xattr_ref, Ext2IterateAllEa);
 
            RemainingUserBufferLength = EaIterator.RemainingUserBufferLength;
 
            Status = STATUS_SUCCESS;
 
            // It seems that the item isn't found
            if (RemainingUserBufferLength == UserBufferLength)
                Status = STATUS_OBJECTID_NOT_FOUND;
 
            if (EaIterator.OverFlow) {
                if (RemainingUserBufferLength == UserBufferLength)
                    Status = STATUS_BUFFER_TOO_SMALL;
                else
                    Status = STATUS_BUFFER_OVERFLOW;
            }
 
        } else {
            struct EaIterator EaIterator;
            //
            //  Else perform a simple scan, taking into account the restart
            //  flag and the position of the next Ea stored in the Ccb.
            //
            if (RestartScan)
                Ccb->EaIndex = 1;
 
            if (RemainingUserBufferLength)
                RtlZeroMemory(FullEa, RemainingUserBufferLength);
 
            EaIterator.OverFlow = FALSE;
            EaIterator.RemainingUserBufferLength = UserBufferLength;
            EaIterator.ReturnSingleEntry = ReturnSingleEntry;
            EaIterator.FullEa = (PFILE_FULL_EA_INFORMATION)UserBuffer;
            EaIterator.LastFullEa = NULL;
            EaIterator.UserBufferLength = UserBufferLength;
            EaIterator.EaIndex = Ccb->EaIndex;
            EaIterator.EaIndexCounter = 1;
 
            xattr_ref.iter_arg = &EaIterator;
            ext4_fs_xattr_iterate(&xattr_ref, Ext2IterateAllEa);
 
            RemainingUserBufferLength = EaIterator.RemainingUserBufferLength;
 
            if (Ccb->EaIndex < EaIterator.EaIndexCounter)
                Ccb->EaIndex = EaIterator.EaIndexCounter;
 
            Status = STATUS_SUCCESS;
 
            if (EaIterator.OverFlow) {
                if (RemainingUserBufferLength == UserBufferLength)
                    Status = STATUS_BUFFER_TOO_SMALL;
                else
                    Status = STATUS_BUFFER_OVERFLOW;
            }
 
        }
    }
    _SEH2_FINALLY {
 
        if (XattrRefAcquired) {
            if (!NT_SUCCESS(Status)) {
                xattr_ref.dirty = FALSE;
                ext4_fs_put_xattr_ref(&xattr_ref);
            }
            else
                Status = Ext2WinntError(ext4_fs_put_xattr_ref(&xattr_ref));
        }
 
        if (MainResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (NT_SUCCESS(Status)) {
            Ext2NotifyReportChange(
                IrpContext,
                Vcb,
                Mcb,
                FILE_NOTIFY_CHANGE_EA,
                FILE_ACTION_MODIFIED);
            Irp->IoStatus.Information = UserBufferLength - RemainingUserBufferLength;
        }
 
        if (!_SEH2_AbnormalTermination()) {
            if (Status == STATUS_PENDING || Status == STATUS_CANT_WAIT) {
                Status = Ext2QueueRequest(IrpContext);
            }
            else {
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2QueryExtentMappings()

NTSTATUS Ext2QueryExtentMappings	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_FCB	Fcb,
		IN PLARGE_INTEGER	RequestVbn,
		OUT PLARGE_INTEGER *	pMappedRuns
	)

Definition at line 670 of file fsctl.c.

{
    PLARGE_INTEGER      MappedRuns = NULL;
    PLARGE_INTEGER      PartialRuns = NULL;
 
    PEXT2_EXTENT        Chain = NULL;
    PEXT2_EXTENT        Extent = NULL;
 
    LONGLONG            Vbn = 0;
    ULONG               Length = 0;
    ULONG               i = 0;
 
    NTSTATUS            Status = STATUS_SUCCESS;
 
    _SEH2_TRY {
 
        /* now building all the request extents */
        while (Vbn < RequestVbn->QuadPart) {
 
            Length = 0x80000000; /* 2g bytes */
            if (RequestVbn->QuadPart < Vbn + Length) {
                Length = (ULONG)(RequestVbn->QuadPart - Vbn);
            }
 
            /* build extents for sub-range */
            Extent = NULL;
            Status = Ext2BuildExtents(
                         IrpContext,
                         Vcb,
                         Fcb->Mcb,
                         Vbn,
                         Length,
                         FALSE,
                         &Extent);
 
            if (!NT_SUCCESS(Status)) {
                _SEH2_LEAVE;
            }
 
            if (Chain) {
                Ext2JointExtents(Chain, Extent);
            } else {
                Chain = Extent;
            }
 
            /* allocate extent array */
            PartialRuns = Ext2AllocatePool(
                              NonPagedPool,
                              (Ext2CountExtents(Chain) + 2) *
                              (2 * sizeof(LARGE_INTEGER)),
                              'RE2E');
 
            if (PartialRuns == NULL) {
                Status = STATUS_INSUFFICIENT_RESOURCES;
                _SEH2_LEAVE;
            }
            RtlZeroMemory(  PartialRuns,
                            (Ext2CountExtents(Chain) + 2) *
                            (2 * sizeof(LARGE_INTEGER)));
 
            if (MappedRuns) {
                RtlMoveMemory(PartialRuns,
                              MappedRuns,
                              i * 2 * sizeof(LARGE_INTEGER));
                Ext2FreePool(MappedRuns, 'RE2E');
            }
            MappedRuns = PartialRuns;
 
            /* walk all the Mcb runs in Extent */
            for (; Extent != NULL; Extent = Extent->Next) {
                MappedRuns[i*2 + 0].QuadPart = Vbn + Extent->Offset;
                MappedRuns[i*2 + 1].QuadPart = Extent->Lba;
                i = i+1;
            }
 
            Vbn = Vbn + Length;
        }
 
        *pMappedRuns = MappedRuns;
 
    } _SEH2_FINALLY {
 
        if (!NT_SUCCESS(Status) || Status == STATUS_PENDING) {
            if (MappedRuns) {
                Ext2FreePool(MappedRuns, 'RE2E');
            }
            *pMappedRuns = NULL;
        }
 
        if (Chain) {
            Ext2DestroyExtentChain(Chain);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2GetRetrievalPointers(), and Ext2QueryRetrievalPointers().

◆ Ext2QueryFileInformation()

NTSTATUS Ext2QueryFileInformation ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 48 of file fileinfo.c.

{
    PDEVICE_OBJECT          DeviceObject;
    NTSTATUS                Status = STATUS_UNSUCCESSFUL;
    PFILE_OBJECT            FileObject;
    PEXT2_VCB               Vcb = NULL;
    PEXT2_FCB               Fcb = NULL;
    PEXT2_MCB               Mcb = NULL;
    PEXT2_CCB               Ccb = NULL;
    PIRP                    Irp = NULL;
    PIO_STACK_LOCATION      IoStackLocation;
    FILE_INFORMATION_CLASS  FileInformationClass;
    ULONG                   Length;
    PVOID                   Buffer;
    BOOLEAN                 FcbResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        FileObject = IrpContext->FileObject;
        Fcb = (PEXT2_FCB) FileObject->FsContext;
        if (Fcb == NULL) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        //
        // This request is not allowed on volumes
        //
        if (Fcb->Identifier.Type == EXT2VCB) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        if (!((Fcb->Identifier.Type == EXT2FCB) &&
                (Fcb->Identifier.Size == sizeof(EXT2_FCB)))) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        Vcb = Fcb->Vcb;
 
        {
            if (!ExAcquireResourceSharedLite(
                        &Fcb->MainResource,
                        IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)
                    )) {
 
                Status = STATUS_PENDING;
                _SEH2_LEAVE;
            }
 
            FcbResourceAcquired = TRUE;
        }
 
        Ccb = (PEXT2_CCB) FileObject->FsContext2;
        ASSERT(Ccb != NULL);
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
               (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
        Mcb = Ccb->SymLink;
        if (!Mcb)
            Mcb = Fcb->Mcb;
 
        Irp = IrpContext->Irp;
        IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
        FileInformationClass =
            IoStackLocation->Parameters.QueryFile.FileInformationClass;
 
        Length = IoStackLocation->Parameters.QueryFile.Length;
        Buffer = Irp->AssociatedIrp.SystemBuffer;
        RtlZeroMemory(Buffer, Length);
 
        switch (FileInformationClass) {
 
        case FileBasicInformation:
        {
            PFILE_BASIC_INFORMATION FileBasicInformation;
 
            if (Length < sizeof(FILE_BASIC_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FileBasicInformation = (PFILE_BASIC_INFORMATION) Buffer;
 
            FileBasicInformation->CreationTime = Mcb->CreationTime;
            FileBasicInformation->LastAccessTime = Mcb->LastAccessTime;
            FileBasicInformation->LastWriteTime = Mcb->LastWriteTime;
            FileBasicInformation->ChangeTime = Mcb->ChangeTime;
 
            FileBasicInformation->FileAttributes = Mcb->FileAttr;
            if (IsLinkInvalid(Mcb)) {
                ClearFlag(FileBasicInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY);
            }
            if (FileBasicInformation->FileAttributes == 0) {
                FileBasicInformation->FileAttributes = FILE_ATTRIBUTE_NORMAL;
            }
 
            Irp->IoStatus.Information = sizeof(FILE_BASIC_INFORMATION);
            Status = STATUS_SUCCESS;
        }
        break;
 
        case FileStandardInformation:
        {
            PFILE_STANDARD_INFORMATION FSI;
 
            if (Length < sizeof(FILE_STANDARD_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FSI = (PFILE_STANDARD_INFORMATION) Buffer;
 
            FSI->NumberOfLinks = Mcb->Inode.i_nlink;
 
            if (IsVcbReadOnly(Fcb->Vcb))
                FSI->DeletePending = FALSE;
            else
                FSI->DeletePending = IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING);
 
            if (IsLinkInvalid(Mcb)) {
                FSI->Directory = FALSE;
                FSI->AllocationSize.QuadPart = 0;
                FSI->EndOfFile.QuadPart = 0;
            } else if (IsMcbDirectory(Mcb)) {
                FSI->Directory = TRUE;
                FSI->AllocationSize.QuadPart = 0;
                FSI->EndOfFile.QuadPart = 0;
            } else {
                FSI->Directory = FALSE;
                FSI->AllocationSize = Fcb->Header.AllocationSize;
                FSI->EndOfFile = Fcb->Header.FileSize;
            }
 
            Irp->IoStatus.Information = sizeof(FILE_STANDARD_INFORMATION);
            Status = STATUS_SUCCESS;
        }
        break;
 
        case FileInternalInformation:
        {
            PFILE_INTERNAL_INFORMATION FileInternalInformation;
 
            if (Length < sizeof(FILE_INTERNAL_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FileInternalInformation = (PFILE_INTERNAL_INFORMATION) Buffer;
 
            /* we use the inode number as the internal index */
            FileInternalInformation->IndexNumber.QuadPart = (LONGLONG)Mcb->Inode.i_ino;
 
            Irp->IoStatus.Information = sizeof(FILE_INTERNAL_INFORMATION);
            Status = STATUS_SUCCESS;
        }
        break;
 
 
        case FileEaInformation:
        {
            struct ext4_xattr_ref xattr_ref;
            PFILE_EA_INFORMATION FileEaInformation;
 
            if (Length < sizeof(FILE_EA_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FileEaInformation = (PFILE_EA_INFORMATION) Buffer;
            FileEaInformation->EaSize = 0;
 
            Status = Ext2WinntError(ext4_fs_get_xattr_ref(IrpContext, Vcb, Fcb->Mcb, &xattr_ref));
            if (!NT_SUCCESS(Status))
                _SEH2_LEAVE;
 
            xattr_ref.iter_arg = &FileEaInformation->EaSize;
            ext4_fs_xattr_iterate(&xattr_ref, Ext2IterateAllEa);
            ext4_fs_put_xattr_ref(&xattr_ref);
 
            if (FileEaInformation->EaSize)
                FileEaInformation->EaSize += 4;
 
            Irp->IoStatus.Information = sizeof(FILE_EA_INFORMATION);
            Status = STATUS_SUCCESS;
        }
        break;
 
        case FileNameInformation:
        {
            PFILE_NAME_INFORMATION FileNameInformation;
            ULONG   BytesToCopy = 0;
 
            if (Length < (ULONG)FIELD_OFFSET(FILE_NAME_INFORMATION, FileName) +
                    Mcb->FullName.Length) {
                BytesToCopy = Length - FIELD_OFFSET(FILE_NAME_INFORMATION, FileName);
                Status = STATUS_BUFFER_OVERFLOW;
            } else {
                BytesToCopy = Mcb->FullName.Length;
                Status = STATUS_SUCCESS;
            }
 
            FileNameInformation = (PFILE_NAME_INFORMATION) Buffer;
            FileNameInformation->FileNameLength = Mcb->FullName.Length;
 
            RtlCopyMemory(
                FileNameInformation->FileName,
                Mcb->FullName.Buffer,
                BytesToCopy );
 
            Irp->IoStatus.Information = BytesToCopy +
                                        + FIELD_OFFSET(FILE_NAME_INFORMATION, FileName);
        }
        break;
 
        case FilePositionInformation:
        {
            PFILE_POSITION_INFORMATION FilePositionInformation;
 
            if (Length < sizeof(FILE_POSITION_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FilePositionInformation = (PFILE_POSITION_INFORMATION) Buffer;
            FilePositionInformation->CurrentByteOffset =
                FileObject->CurrentByteOffset;
 
            Irp->IoStatus.Information = sizeof(FILE_POSITION_INFORMATION);
            Status = STATUS_SUCCESS;
        }
        break;
 
        case FileAllInformation:
        {
            PFILE_ALL_INFORMATION       FileAllInformation;
            PFILE_BASIC_INFORMATION     FileBasicInformation;
            PFILE_STANDARD_INFORMATION  FSI;
            PFILE_INTERNAL_INFORMATION  FileInternalInformation;
            PFILE_EA_INFORMATION        FileEaInformation;
            PFILE_POSITION_INFORMATION  FilePositionInformation;
            PFILE_NAME_INFORMATION      FileNameInformation;
 
            if (Length < sizeof(FILE_ALL_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FileAllInformation = (PFILE_ALL_INFORMATION) Buffer;
 
            FileBasicInformation =
                &FileAllInformation->BasicInformation;
 
            FSI =
                &FileAllInformation->StandardInformation;
 
            FileInternalInformation =
                &FileAllInformation->InternalInformation;
 
            FileEaInformation =
                &FileAllInformation->EaInformation;
 
            FilePositionInformation =
                &FileAllInformation->PositionInformation;
 
            FileNameInformation =
                &FileAllInformation->NameInformation;
 
            FileBasicInformation->CreationTime = Mcb->CreationTime;
            FileBasicInformation->LastAccessTime = Mcb->LastAccessTime;
            FileBasicInformation->LastWriteTime = Mcb->LastWriteTime;
            FileBasicInformation->ChangeTime = Mcb->ChangeTime;
 
            FileBasicInformation->FileAttributes = Mcb->FileAttr;
            if (IsMcbSymLink(Mcb) && IsFileDeleted(Mcb->Target)) {
                ClearFlag(FileBasicInformation->FileAttributes, FILE_ATTRIBUTE_DIRECTORY);
            }
            if (FileBasicInformation->FileAttributes == 0) {
                FileBasicInformation->FileAttributes = FILE_ATTRIBUTE_NORMAL;
            }
 
            FSI->NumberOfLinks = Mcb->Inode.i_nlink;
 
            if (IsVcbReadOnly(Fcb->Vcb))
                FSI->DeletePending = FALSE;
            else
                FSI->DeletePending = IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING);
 
            if (IsLinkInvalid(Mcb)) {
                FSI->Directory = FALSE;
                FSI->AllocationSize.QuadPart = 0;
                FSI->EndOfFile.QuadPart = 0;
            } else if (IsDirectory(Fcb)) {
                FSI->Directory = TRUE;
                FSI->AllocationSize.QuadPart = 0;
                FSI->EndOfFile.QuadPart = 0;
            } else {
                FSI->Directory = FALSE;
                FSI->AllocationSize = Fcb->Header.AllocationSize;
                FSI->EndOfFile = Fcb->Header.FileSize;
            }
 
            // The "inode number"
            FileInternalInformation->IndexNumber.QuadPart = (LONGLONG)Mcb->Inode.i_ino;
 
            // Romfs doesn't have any extended attributes
            FileEaInformation->EaSize = 0;
 
            FilePositionInformation->CurrentByteOffset =
                FileObject->CurrentByteOffset;
 
            FileNameInformation->FileNameLength = Mcb->ShortName.Length;
 
            if (Length < sizeof(FILE_ALL_INFORMATION) +
                    Mcb->ShortName.Length - sizeof(WCHAR)) {
                Irp->IoStatus.Information = sizeof(FILE_ALL_INFORMATION);
                Status = STATUS_BUFFER_OVERFLOW;
                RtlCopyMemory(
                    FileNameInformation->FileName,
                    Mcb->ShortName.Buffer,
                    Length - FIELD_OFFSET(FILE_ALL_INFORMATION,
                                          NameInformation.FileName)
                );
                _SEH2_LEAVE;
            }
 
            RtlCopyMemory(
                FileNameInformation->FileName,
                Mcb->ShortName.Buffer,
                Mcb->ShortName.Length
            );
 
            Irp->IoStatus.Information = sizeof(FILE_ALL_INFORMATION) +
                                        Mcb->ShortName.Length - sizeof(WCHAR);
#if 0
            sizeof(FILE_ACCESS_INFORMATION) -
            sizeof(FILE_MODE_INFORMATION) -
            sizeof(FILE_ALIGNMENT_INFORMATION);
#endif
 
            Status = STATUS_SUCCESS;
        }
        break;
 
        /*
        case FileAlternateNameInformation:
        {
            // TODO: Handle FileAlternateNameInformation
 
            // Here we would like to use RtlGenerate8dot3Name but I don't
            // know how to use the argument PGENERATE_NAME_CONTEXT
        }
        */
 
        case FileNetworkOpenInformation:
        {
            PFILE_NETWORK_OPEN_INFORMATION PFNOI;
 
            if (Length < sizeof(FILE_NETWORK_OPEN_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            PFNOI = (PFILE_NETWORK_OPEN_INFORMATION) Buffer;
 
            PFNOI->FileAttributes = Mcb->FileAttr;
            if (IsLinkInvalid(Mcb)) {
                ClearFlag(PFNOI->FileAttributes, FILE_ATTRIBUTE_DIRECTORY);
                PFNOI->AllocationSize.QuadPart = 0;
                PFNOI->EndOfFile.QuadPart = 0;
            } else if (IsDirectory(Fcb)) {
                PFNOI->AllocationSize.QuadPart = 0;
                PFNOI->EndOfFile.QuadPart = 0;
            } else {
                PFNOI->AllocationSize = Fcb->Header.AllocationSize;
                PFNOI->EndOfFile      = Fcb->Header.FileSize;
            }
 
            if (PFNOI->FileAttributes == 0) {
                PFNOI->FileAttributes = FILE_ATTRIBUTE_NORMAL;
            }
 
            PFNOI->CreationTime   = Mcb->CreationTime;
            PFNOI->LastAccessTime = Mcb->LastAccessTime;
            PFNOI->LastWriteTime  = Mcb->LastWriteTime;
            PFNOI->ChangeTime     = Mcb->ChangeTime;
 
 
            Irp->IoStatus.Information =
                sizeof(FILE_NETWORK_OPEN_INFORMATION);
            Status = STATUS_SUCCESS;
        }
        break;
 
#if (_WIN32_WINNT >= 0x0500)
 
        case FileAttributeTagInformation:
        {
            PFILE_ATTRIBUTE_TAG_INFORMATION FATI;
 
            if (Length < sizeof(FILE_ATTRIBUTE_TAG_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FATI = (PFILE_ATTRIBUTE_TAG_INFORMATION) Buffer;
            FATI->FileAttributes = Mcb->FileAttr;
            if (IsLinkInvalid(Mcb)) {
                ClearFlag(FATI->FileAttributes, FILE_ATTRIBUTE_DIRECTORY);
            }
            if (FATI->FileAttributes == 0) {
                FATI->FileAttributes = FILE_ATTRIBUTE_NORMAL;
            }
            FATI->ReparseTag = IO_REPARSE_TAG_RESERVED_ZERO;
            Irp->IoStatus.Information = sizeof(FILE_ATTRIBUTE_TAG_INFORMATION);
            Status = STATUS_SUCCESS;
        }
        break;
#endif // (_WIN32_WINNT >= 0x0500)
 
        case FileStreamInformation:
            Status = STATUS_INVALID_PARAMETER;
            break;
 
        default:
            DEBUG(DL_WRN, ( "Ext2QueryInformation: invalid class: %d\n",
                            FileInformationClass));
            Status = STATUS_INVALID_PARAMETER; /* STATUS_INVALID_INFO_CLASS; */
            break;
        }
 
    } _SEH2_FINALLY {
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            if (Status == STATUS_PENDING ||
                    Status == STATUS_CANT_WAIT) {
                Status = Ext2QueueRequest(IrpContext);
            } else {
                Ext2CompleteIrpContext(IrpContext,  Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2QueryGlobalParameters()

NTSTATUS Ext2QueryGlobalParameters ( IN PUNICODE_STRING RegistryPath )

Definition at line 199 of file init.c.

{
    RTL_QUERY_REGISTRY_TABLE    QueryTable[8];
    int                         i = 0;
    NTSTATUS                    Status;
 
    RtlZeroMemory(&QueryTable[0], sizeof(RTL_QUERY_REGISTRY_TABLE) * 8);
 
    /*
     * 1 writing support
     */
    QueryTable[i].Flags = 0;
    QueryTable[i].Name = WRITING_SUPPORT;
    QueryTable[i].DefaultType = REG_NONE;
    QueryTable[i].DefaultLength = 0;
    QueryTable[i].DefaultData = NULL;
    QueryTable[i].EntryContext = NULL;
    QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
    i++;
 
    /*
     * 2 checking bitmap
     */
    QueryTable[i].Flags = 0;
    QueryTable[i].Name = CHECKING_BITMAP;
    QueryTable[i].DefaultType = REG_NONE;
    QueryTable[i].DefaultLength = 0;
    QueryTable[i].DefaultData = NULL;
    QueryTable[i].EntryContext = NULL;
    QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
    i++;
 
    /*
     * 3 force writing
     */
    QueryTable[i].Flags = 0;
    QueryTable[i].Name = EXT3_FORCEWRITING;
    QueryTable[i].DefaultType = REG_NONE;
    QueryTable[i].DefaultLength = 0;
    QueryTable[i].DefaultData = NULL;
    QueryTable[i].EntryContext = NULL;
    QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
    i++;
 
    /*
     * 4 automount
     */
    QueryTable[i].Flags = 0;
    QueryTable[i].Name = AUTO_MOUNT;
    QueryTable[i].DefaultType = REG_NONE;
    QueryTable[i].DefaultLength = 0;
    QueryTable[i].DefaultData = NULL;
    QueryTable[i].EntryContext = NULL;
    QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
    i++;
 
    /*
     * 5 codepage
     */
    QueryTable[i].Flags = 0;
    QueryTable[i].Name = CODEPAGE_NAME;
    QueryTable[i].DefaultType = REG_NONE;
    QueryTable[i].DefaultLength = 0;
    QueryTable[i].DefaultData = NULL;
    QueryTable[i].EntryContext = NULL;
    QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
    i++;
 
    /*
     * 6 hidden prefix
     */
    QueryTable[i].Flags = 0;
    QueryTable[i].Name = HIDING_PREFIX;
    QueryTable[i].DefaultType = REG_NONE;
    QueryTable[i].DefaultLength = 0;
    QueryTable[i].DefaultData = NULL;
    QueryTable[i].EntryContext = NULL;
    QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
    i++;
 
 
    /*
     * 7 hidden suffix
     */
    QueryTable[i].Flags = 0;
    QueryTable[i].Name = HIDING_SUFFIX;
    QueryTable[i].DefaultType = REG_NONE;
    QueryTable[i].DefaultLength = 0;
    QueryTable[i].DefaultData = NULL;
    QueryTable[i].EntryContext = NULL;
    QueryTable[i].QueryRoutine = Ext2RegistryQueryCallback;
    i++;
 
    Status = RtlQueryRegistryValues(
                 RTL_REGISTRY_ABSOLUTE,
                 RegistryPath->Buffer,
                 &QueryTable[0],
                 NULL,
                 NULL
            );
 
    return NT_SUCCESS(Status);
}

Referenced by Ext2QueryRegistrySettings().

◆ Ext2QueryRegistrySettings()

BOOLEAN Ext2QueryRegistrySettings ( IN PUNICODE_STRING RegistryPath )

Definition at line 305 of file init.c.

{
    UNICODE_STRING              ParameterPath;
    UNICODE_STRING              UniName;
    ANSI_STRING                 AnsiName;
 
    ULONG                       WritingSupport = 0;
    ULONG                       CheckingBitmap = 0;
    ULONG                       Ext3ForceWriting = 0;
    ULONG                       AutoMount = 0;
 
    WCHAR                       UniBuffer[CODEPAGE_MAXLEN];
    USHORT                      Buffer[HIDINGPAT_LEN];
 
    NTSTATUS                    Status;
 
    ParameterPath.Length = 0;
    ParameterPath.MaximumLength =
        RegistryPath->Length + sizeof(PARAMETERS_KEY) + sizeof(WCHAR);
    ParameterPath.Buffer =
        (PWSTR) Ext2AllocatePool(
            PagedPool,
            ParameterPath.MaximumLength,
            'LG2E'
        );
    if (!ParameterPath.Buffer) {
        DbgBreak();
        DEBUG(DL_ERR, ( "Ex2QueryParameters: failed to allocate Parameters...\n"));
        return FALSE;
    }
 
    RtlCopyUnicodeString(&ParameterPath, RegistryPath);
    RtlAppendUnicodeToString(&ParameterPath, PARAMETERS_KEY);
 
    /* enable automount of ext2/3/4 volumes */
    SetLongFlag(Ext2Global->Flags, EXT2_AUTO_MOUNT);
 
    /* query parameter settings from registry */
    Ext2QueryGlobalParameters(&ParameterPath);
 
    /* set global codepage settings */
    if (wcslen(&Ext2Global->Codepage.PageName[0])) {
        UniName.Length = sizeof(WCHAR) * wcslen(&Ext2Global->Codepage.PageName[0]);
        UniName.MaximumLength = CODEPAGE_MAXLEN * sizeof(WCHAR);
        UniName.Buffer = &Ext2Global->Codepage.PageName[0];
        AnsiName.MaximumLength = CODEPAGE_MAXLEN;
        AnsiName.Length = 0;
        AnsiName.Buffer = &Ext2Global->Codepage.AnsiName[0];
        Status = RtlUnicodeStringToAnsiString(
                     &AnsiName,
                     &UniName,
                     FALSE);
        if (!NT_SUCCESS(Status)) {
            DEBUG(DL_ERR, ( "Ext2QueryParameters: Wrong CodePage %wZ ...\n", &UniName));
            RtlCopyMemory(&(Ext2Global->Codepage.AnsiName[0]),"default\0", 8);
        }
    } else {
        DEBUG(DL_ERR, ( "Ext2QueryParameters: CodePage not specified.\n"));
        RtlCopyMemory(&(Ext2Global->Codepage.AnsiName[0]),"default\0", 8);
    }
    Ext2Global->Codepage.AnsiName[CODEPAGE_MAXLEN - 1] = 0;
 
 
    /* set global hidden prefix pattern */
    if (wcslen(&Ext2Global->wHidingPrefix[0])) {
        UniName.Length = sizeof(WCHAR) * wcslen(&Ext2Global->wHidingPrefix[0]);
        UniName.MaximumLength = HIDINGPAT_LEN * sizeof(WCHAR);
        UniName.Buffer = &Ext2Global->wHidingPrefix[0];
        AnsiName.MaximumLength = HIDINGPAT_LEN;
        AnsiName.Length = 0;
        AnsiName.Buffer = &(Ext2Global->sHidingPrefix[0]);
 
        Status = RtlUnicodeStringToAnsiString(
                     &AnsiName,
                     &UniName,
                     FALSE);
        if (NT_SUCCESS(Status)) {
            Ext2Global->bHidingPrefix = TRUE;
        } else {
            DEBUG(DL_ERR, ( "Ext2QueryParameters: Wrong HidingPrefix ...\n"));
        }
    } else {
        DEBUG(DL_ERR, ( "Ext2QueryParameters: HidingPrefix not specified.\n"));
    }
    Ext2Global->sHidingPrefix[HIDINGPAT_LEN - 1] = 0;
 
 
    /* set global hidden suffix pattern */
    if (wcslen(&Ext2Global->wHidingSuffix[0])) {
        UniName.Length = sizeof(WCHAR) * wcslen(&Ext2Global->wHidingSuffix[0]);
        UniName.MaximumLength = HIDINGPAT_LEN * sizeof(WCHAR);
        UniName.Buffer = &Ext2Global->wHidingSuffix[0];
        AnsiName.MaximumLength = HIDINGPAT_LEN;
        AnsiName.Length = 0;
        AnsiName.Buffer = &(Ext2Global->sHidingSuffix[0]);
 
        Status = RtlUnicodeStringToAnsiString(
                     &AnsiName,
                     &UniName,
                     FALSE);
        if (NT_SUCCESS(Status)) {
            Ext2Global->bHidingSuffix = TRUE;
        } else {
            DEBUG(DL_ERR, ( "Ext2QueryParameters: Wrong HidingSuffix ...\n"));
        }
    } else {
        DEBUG(DL_ERR, ( "Ext2QueryParameters: HidingSuffix not specified.\n"));
    }
    Ext2Global->sHidingPrefix[HIDINGPAT_LEN - 1] = 0;
 
    Ext2Global->RegistryPath.Buffer = ParameterPath.Buffer;
    Ext2Global->RegistryPath.Length = 0;
    Ext2Global->RegistryPath.MaximumLength = ParameterPath.MaximumLength;
    RtlCopyUnicodeString(&Ext2Global->RegistryPath, RegistryPath);
    RtlAppendUnicodeToString(&Ext2Global->RegistryPath, VOLUMES_KEY);
 
    return TRUE;
}

Referenced by DriverEntry().

◆ Ext2QueryRetrievalPointers()

NTSTATUS Ext2QueryRetrievalPointers ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 774 of file fsctl.c.

{
    PIRP                Irp = NULL;
    PIO_STACK_LOCATION  IrpSp;
    PEXTENDED_IO_STACK_LOCATION EIrpSp;
 
    PDEVICE_OBJECT      DeviceObject;
    PFILE_OBJECT        FileObject;
 
    PEXT2_VCB           Vcb = NULL;
    PEXT2_FCB           Fcb = NULL;
    PEXT2_CCB           Ccb = NULL;
 
    PLARGE_INTEGER      RequestVbn;
    PLARGE_INTEGER *    pMappedRuns;
 
    ULONG               InputSize;
    ULONG               OutputSize;
 
    NTSTATUS            Status = STATUS_SUCCESS;
 
    BOOLEAN FcbResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext);
        Irp = IrpContext->Irp;
        ASSERT(Irp);
 
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
        EIrpSp = (PEXTENDED_IO_STACK_LOCATION)IrpSp;
        ASSERT(IrpSp);
 
        InputSize = EIrpSp->Parameters.FileSystemControl.InputBufferLength;
        OutputSize = EIrpSp->Parameters.FileSystemControl.OutputBufferLength;
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        DbgBreak();
 
        /* This request is not allowed on the main device object */
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
        ASSERT(IsMounted(Vcb));
 
        FileObject = IrpContext->FileObject;
        Fcb = (PEXT2_FCB) FileObject->FsContext;
 
        /* check Fcb is valid or not */
        if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
        if (IsFlagOn(Fcb->Mcb->Flags, MCB_FILE_DELETED)) {
            Status = STATUS_FILE_DELETED;
            _SEH2_LEAVE;
        }
 
        Ccb = (PEXT2_CCB) FileObject->FsContext2;
        if (Ccb == NULL) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
               (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
 
        /* Is requstor in kernel and Fcb a paging file ? */
        if (Irp->RequestorMode != KernelMode ||
                !IsFlagOn(Fcb->Flags, FCB_PAGE_FILE) ||
                InputSize != sizeof(LARGE_INTEGER) ||
                OutputSize != sizeof(PVOID)) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        if (!ExAcquireResourceExclusiveLite (
                    &Fcb->MainResource, Ext2CanIWait())) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
        FcbResourceAcquired = TRUE;
 
        RequestVbn  = EIrpSp->Parameters.FileSystemControl.Type3InputBuffer;
        pMappedRuns = Irp->UserBuffer;
 
        DbgBreak();
 
        /* request size beyonds whole file size */
        if (RequestVbn->QuadPart >= Fcb->Header.AllocationSize.QuadPart) {
            Status = STATUS_END_OF_FILE;
            _SEH2_LEAVE;
        }
 
        Status = Ext2QueryExtentMappings(
                     IrpContext,
                     Vcb,
                     Fcb,
                     RequestVbn,
                     pMappedRuns
                 );
 
    } _SEH2_FINALLY {
 
        if (FcbResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (!_SEH2_AbnormalTermination()) {
            if (Status == STATUS_PENDING || Status == STATUS_CANT_WAIT) {
                Status = Ext2QueueRequest(IrpContext);
            } else {
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2UserFsRequest().

◆ Ext2QueryVolumeInformation()

NTSTATUS Ext2QueryVolumeInformation ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 27 of file volinfo.c.

{
    PDEVICE_OBJECT          DeviceObject;
    PEXT2_VCB               Vcb = NULL;
    PIRP                    Irp = NULL;
    PIO_STACK_LOCATION      IoStackLocation = NULL;
    PVOID                   Buffer;
    ULONG                   Length;
    NTSTATUS                Status = STATUS_UNSUCCESSFUL;
    FS_INFORMATION_CLASS    FsInformationClass;
    BOOLEAN                 VcbResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        if (!IsMounted(Vcb)) {
            Status = STATUS_VOLUME_DISMOUNTED;
            _SEH2_LEAVE;
        }
 
        if (!ExAcquireResourceSharedLite(
                    &Vcb->MainResource,
                    IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)
                )) {
 
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
        VcbResourceAcquired = TRUE;
 
        Irp = IrpContext->Irp;
        IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
        FsInformationClass =
            IoStackLocation->Parameters.QueryVolume.FsInformationClass;
 
        Length = IoStackLocation->Parameters.QueryVolume.Length;
        Buffer = Irp->AssociatedIrp.SystemBuffer;
 
        RtlZeroMemory(Buffer, Length);
 
        switch (FsInformationClass) {
 
        case FileFsVolumeInformation:
        {
            PFILE_FS_VOLUME_INFORMATION FsVolInfo;
            ULONG                       VolumeLabelLength;
            ULONG                       RequiredLength;
 
            if (Length < sizeof(FILE_FS_VOLUME_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FsVolInfo = (PFILE_FS_VOLUME_INFORMATION) Buffer;
            FsVolInfo->VolumeCreationTime.QuadPart = 0;
            FsVolInfo->VolumeSerialNumber = Vcb->Vpb->SerialNumber;
            VolumeLabelLength = Vcb->Vpb->VolumeLabelLength;
            FsVolInfo->VolumeLabelLength = VolumeLabelLength;
            /* We don't support ObjectId */
            FsVolInfo->SupportsObjects = FALSE;
 
            RequiredLength = sizeof(FILE_FS_VOLUME_INFORMATION)
                             + VolumeLabelLength - sizeof(WCHAR);
 
            if (Length < RequiredLength) {
                Irp->IoStatus.Information =
                    sizeof(FILE_FS_VOLUME_INFORMATION);
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            RtlCopyMemory(FsVolInfo->VolumeLabel, Vcb->Vpb->VolumeLabel, Vcb->Vpb->VolumeLabelLength);
 
            Irp->IoStatus.Information = RequiredLength;
            Status = STATUS_SUCCESS;
        }
        break;
 
        case FileFsSizeInformation:
        {
            PFILE_FS_SIZE_INFORMATION FsSizeInfo;
 
            if (Length < sizeof(FILE_FS_SIZE_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FsSizeInfo = (PFILE_FS_SIZE_INFORMATION) Buffer;
            FsSizeInfo->TotalAllocationUnits.QuadPart =
                ext3_blocks_count(SUPER_BLOCK);
            FsSizeInfo->AvailableAllocationUnits.QuadPart =
                ext3_free_blocks_count(SUPER_BLOCK);
            FsSizeInfo->SectorsPerAllocationUnit =
                Vcb->BlockSize / Vcb->DiskGeometry.BytesPerSector;
            FsSizeInfo->BytesPerSector =
                Vcb->DiskGeometry.BytesPerSector;
 
            Irp->IoStatus.Information = sizeof(FILE_FS_SIZE_INFORMATION);
            Status = STATUS_SUCCESS;
        }
        break;
 
        case FileFsDeviceInformation:
        {
            PFILE_FS_DEVICE_INFORMATION FsDevInfo;
 
            if (Length < sizeof(FILE_FS_DEVICE_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FsDevInfo = (PFILE_FS_DEVICE_INFORMATION) Buffer;
            FsDevInfo->DeviceType =
                Vcb->TargetDeviceObject->DeviceType;
 
            if (FsDevInfo->DeviceType != FILE_DEVICE_DISK) {
                DbgBreak();
            }
 
            FsDevInfo->Characteristics =
                Vcb->TargetDeviceObject->Characteristics;
 
            if (IsVcbReadOnly(Vcb)) {
                SetFlag( FsDevInfo->Characteristics,
                         FILE_READ_ONLY_DEVICE   );
            }
 
            Irp->IoStatus.Information = sizeof(FILE_FS_DEVICE_INFORMATION);
            Status = STATUS_SUCCESS;
        }
        break;
 
        case FileFsAttributeInformation:
        {
            PFILE_FS_ATTRIBUTE_INFORMATION  FsAttrInfo;
            ULONG                           RequiredLength;
 
            if (Length < sizeof(FILE_FS_ATTRIBUTE_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            FsAttrInfo =
                (PFILE_FS_ATTRIBUTE_INFORMATION) Buffer;
            FsAttrInfo->FileSystemAttributes = FILE_SUPPORTS_HARD_LINKS |
                FILE_CASE_SENSITIVE_SEARCH | FILE_CASE_PRESERVED_NAMES |
                FILE_SUPPORTS_REPARSE_POINTS | FILE_SUPPORTS_EXTENDED_ATTRIBUTES;
            if (IsVcbReadOnly(Vcb)) {
                FsAttrInfo->FileSystemAttributes |= FILE_READ_ONLY_VOLUME;
            }
            FsAttrInfo->MaximumComponentNameLength = EXT2_NAME_LEN;
            FsAttrInfo->FileSystemNameLength = 8;
 
            RequiredLength = sizeof(FILE_FS_ATTRIBUTE_INFORMATION) +
                             8 - sizeof(WCHAR);
 
            if (Length < RequiredLength) {
                Irp->IoStatus.Information =
                    sizeof(FILE_FS_ATTRIBUTE_INFORMATION);
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            if (IsFlagOn(SUPER_BLOCK->s_feature_incompat, EXT4_FEATURE_INCOMPAT_EXTENTS)) {
                RtlCopyMemory(FsAttrInfo->FileSystemName,  L"EXT4\0", 10);
            } else if (Vcb->IsExt3fs) {
                RtlCopyMemory(FsAttrInfo->FileSystemName,  L"EXT3\0", 10);
            } else {
                RtlCopyMemory(FsAttrInfo->FileSystemName,  L"EXT2\0", 10);
            }
 
            Irp->IoStatus.Information = RequiredLength;
            Status = STATUS_SUCCESS;
        }
        break;
 
#if (_WIN32_WINNT >= 0x0500)
 
        case FileFsFullSizeInformation:
        {
            PFILE_FS_FULL_SIZE_INFORMATION PFFFSI;
 
            if (Length < sizeof(FILE_FS_FULL_SIZE_INFORMATION)) {
                Status = STATUS_BUFFER_OVERFLOW;
                _SEH2_LEAVE;
            }
 
            PFFFSI = (PFILE_FS_FULL_SIZE_INFORMATION) Buffer;
 
            /*
                            typedef struct _FILE_FS_FULL_SIZE_INFORMATION {
                                LARGE_INTEGER   TotalAllocationUnits;
                                LARGE_INTEGER   CallerAvailableAllocationUnits;
                                LARGE_INTEGER   ActualAvailableAllocationUnits;
                                ULONG           SectorsPerAllocationUnit;
                                ULONG           BytesPerSector;
                            } FILE_FS_FULL_SIZE_INFORMATION, *PFILE_FS_FULL_SIZE_INFORMATION;
            */
 
            {
                PFFFSI->TotalAllocationUnits.QuadPart =
                    ext3_blocks_count(SUPER_BLOCK);
 
                PFFFSI->CallerAvailableAllocationUnits.QuadPart =
                    ext3_free_blocks_count(SUPER_BLOCK);
 
                /* - Vcb->SuperBlock->s_r_blocks_count; */
                PFFFSI->ActualAvailableAllocationUnits.QuadPart =
                    ext3_free_blocks_count(SUPER_BLOCK);
            }
 
            PFFFSI->SectorsPerAllocationUnit =
                Vcb->BlockSize / Vcb->DiskGeometry.BytesPerSector;
 
            PFFFSI->BytesPerSector = Vcb->DiskGeometry.BytesPerSector;
 
            Irp->IoStatus.Information = sizeof(FILE_FS_FULL_SIZE_INFORMATION);
            Status = STATUS_SUCCESS;
        }
        break;
 
#endif // (_WIN32_WINNT >= 0x0500)
 
        default:
            Status = STATUS_INVALID_INFO_CLASS;
            break;
        }
 
    } _SEH2_FINALLY {
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            if (Status == STATUS_PENDING) {
                Ext2QueueRequest(IrpContext);
            } else {
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2QueueCloseRequest()

VOID Ext2QueueCloseRequest ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 190 of file close.c.

{
    ASSERT(IrpContext);
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_DELAY_CLOSE)) {
 
        if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_FILE_BUSY)) {
            Ext2Sleep(500); /* 0.5 sec*/
        } else {
            Ext2Sleep(50);  /* 0.05 sec*/
        }
 
    } else {
 
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
        SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_DELAY_CLOSE);
 
        IrpContext->Fcb = (PEXT2_FCB) IrpContext->FileObject->FsContext;
        IrpContext->Ccb = (PEXT2_CCB) IrpContext->FileObject->FsContext2;
    }
 
    ExInitializeWorkItem(
        &IrpContext->WorkQueueItem,
        Ext2DeQueueCloseRequest,
        IrpContext);
 
    ExQueueWorkItem(&IrpContext->WorkQueueItem, DelayedWorkQueue);
}

Referenced by Ext2Close().

◆ Ext2QueueRequest()

NTSTATUS Ext2QueueRequest ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 158 of file dispatch.c.

{
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    /* set the flags of "can wait" and "queued" */
    SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT);
    SetFlag(IrpContext->Flags, IRP_CONTEXT_FLAG_REQUEUED);
 
    /* make sure the buffer is kept valid in system context */
    Ext2LockIrp(IrpContext, IrpContext->Irp);
 
    /* initialize workite*/
    ExInitializeWorkItem(
        &IrpContext->WorkQueueItem,
        Ext2DeQueueRequest,
        IrpContext );
 
    /* dispatch it */
    ExQueueWorkItem(&IrpContext->WorkQueueItem, CriticalWorkQueue);
 
    return STATUS_PENDING;
}

Referenced by Ext2Cleanup(), Ext2Create(), Ext2DeferWrite(), Ext2DeleteReparsePoint(), Ext2ExceptionHandler(), Ext2GetReparsePoint(), Ext2GetRetrievalPointerBase(), Ext2GetRetrievalPointers(), Ext2NotifyChangeDirectory(), Ext2OplockComplete(), Ext2QueryDirectory(), Ext2QueryEa(), Ext2QueryFileInformation(), Ext2QueryRetrievalPointers(), Ext2QueryVolumeInformation(), Ext2ReadFile(), Ext2ReadVolume(), Ext2SetEa(), Ext2SetFileInformation(), Ext2SetReparsePoint(), Ext2SetVolumeInformation(), Ext2ShutDown(), Ext2WriteFile(), and Ext2WriteVolume().

◆ Ext2Read()

NTSTATUS Ext2Read ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 863 of file read.c.

{
    NTSTATUS            Status;
    PEXT2_VCB           Vcb;
    PEXT2_FCBVCB        FcbOrVcb;
    PDEVICE_OBJECT      DeviceObject;
    PFILE_OBJECT        FileObject;
    BOOLEAN             bCompleteRequest;
 
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    _SEH2_TRY {
 
        if (FlagOn(IrpContext->MinorFunction, IRP_MN_COMPLETE)) {
 
            Status =  Ext2ReadComplete(IrpContext);
            bCompleteRequest = FALSE;
 
        } else {
 
            DeviceObject = IrpContext->DeviceObject;
 
            if (IsExt2FsDevice(DeviceObject)) {
                Status = STATUS_INVALID_DEVICE_REQUEST;
                bCompleteRequest = TRUE;
                _SEH2_LEAVE;
            }
 
            Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
            if (Vcb->Identifier.Type != EXT2VCB ||
                    Vcb->Identifier.Size != sizeof(EXT2_VCB) ) {
                Status = STATUS_INVALID_DEVICE_REQUEST;
                bCompleteRequest = TRUE;
 
                _SEH2_LEAVE;
            }
 
            FileObject = IrpContext->FileObject;
 
            if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED) &&
                Vcb->LockFile != FileObject ) {
                Status = STATUS_ACCESS_DENIED;
#ifdef __REACTOS__
                bCompleteRequest = TRUE;
#endif
                _SEH2_LEAVE;
            }
 
            FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;
 
            if (FcbOrVcb->Identifier.Type == EXT2VCB) {
 
                Status = Ext2ReadVolume(IrpContext);
                bCompleteRequest = FALSE;
 
            } else if (FcbOrVcb->Identifier.Type == EXT2FCB) {
 
                if (IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {
                    Status = STATUS_TOO_LATE;
                    bCompleteRequest = TRUE;
                    _SEH2_LEAVE;
                }
 
                Status = Ext2ReadFile(IrpContext);
                bCompleteRequest = FALSE;
            } else {
                DEBUG(DL_ERR, ( "Ext2Read: Inavlid FileObject (Vcb or Fcb corrupted)\n"));
                DbgBreak();
 
                Status = STATUS_INVALID_PARAMETER;
                bCompleteRequest = TRUE;
            }
        }
 
    } _SEH2_FINALLY {
        if (bCompleteRequest) {
            Ext2CompleteIrpContext(IrpContext, Status);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2ReadDisk()

NTSTATUS Ext2ReadDisk	(	IN PEXT2_VCB	Vcb,
		IN ULONGLONG	Offset,
		IN ULONG	Size,
		IN PVOID	Buffer,
		IN BOOLEAN	bVerify
	)

Definition at line 559 of file block.c.

{
    NTSTATUS    Status;
    PUCHAR      Buf;
    ULONG       Length;
    ULONGLONG   Lba;
 
    Lba = Offset & (~((ULONGLONG)SECTOR_SIZE - 1));
    Length = (ULONG)(Size + Offset + SECTOR_SIZE - 1 - Lba) &
             (~((ULONG)SECTOR_SIZE - 1));
 
    Buf = Ext2AllocatePool(PagedPool, Length, EXT2_DATA_MAGIC);
    if (!Buf) {
        DEBUG(DL_ERR, ( "Ext2ReadDisk: failed to allocate Buffer.\n"));
        Status = STATUS_INSUFFICIENT_RESOURCES;
 
        goto errorout;
    }
    INC_MEM_COUNT(PS_DISK_BUFFER, Buf, Length);
 
    Status = Ext2ReadSync(  Vcb,
                            Lba,
                            Length,
                            Buf,
                            FALSE );
 
    if (!NT_SUCCESS(Status)) {
        DEBUG(DL_ERR, ("Ext2ReadDisk: disk i/o error: %xh.\n", Status));
        goto errorout;
    }
 
    RtlCopyMemory(Buffer, &Buf[Offset - Lba], Size);
 
errorout:
 
    if (Buf) {
        Ext2FreePool(Buf, EXT2_DATA_MAGIC);
        DEC_MEM_COUNT(PS_DISK_BUFFER, Buf, Length);
    }
 
    return Status;
}

Referenced by ext2_load_inode(), ext2_read_block(), ext2_read_inode(), Ext2LoadSuper(), read_bitmaps(), and zap_sector().

◆ Ext2ReadInode()

NTSTATUS Ext2ReadInode	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONGLONG	Offset,
		IN PVOID	Buffer,
		IN ULONG	Size,
		IN BOOLEAN	bDirectIo,
		OUT PULONG	dwReturn
	)

Definition at line 311 of file read.c.

{
    PEXT2_EXTENT    Chain = NULL;
    PEXT2_EXTENT    Extent = NULL, Prev = NULL;
 
    IO_STATUS_BLOCK IoStatus;
    NTSTATUS        Status = STATUS_UNSUCCESSFUL;
    ULONG           RealSize ;
 
    if (BytesRead) {
        *BytesRead = 0;
    }
 
    _SEH2_TRY {
 
        Ext2ReferMcb(Mcb);
 
        ASSERT((Mcb->Identifier.Type == EXT2MCB) &&
               (Mcb->Identifier.Size == sizeof(EXT2_MCB)));
 
        if ((Mcb->Identifier.Type != EXT2MCB) ||
                (Mcb->Identifier.Size != sizeof(EXT2_MCB))) {
            _SEH2_LEAVE;
        }
 
        if (Buffer == NULL && IrpContext != NULL)
            Buffer = Ext2GetUserBuffer(IrpContext->Irp);
 
 
        /* handle fast symlinks */
        if (S_ISLNK(Mcb->Inode.i_mode) && 0 == Mcb->Inode.i_blocks) {
 
            PUCHAR Data = (PUCHAR) (&Mcb->Inode.i_block[0]);
            if (!Buffer) {
                Status = STATUS_INSUFFICIENT_RESOURCES;
                _SEH2_LEAVE;
            }
 
            if (Offset < EXT2_LINKLEN_IN_INODE) {
                if ((ULONG)Offset + Size >= EXT2_LINKLEN_IN_INODE)
                    Size = EXT2_LINKLEN_IN_INODE - (ULONG)Offset - 1;
                RtlCopyMemory(Buffer, Data + (ULONG)Offset, Size);
                Status = STATUS_SUCCESS;
            } else {
                Status = STATUS_END_OF_FILE;
            }
            _SEH2_LEAVE;
        }
 
        //
        // Build the scatterred block ranges to be read
        //
 
        if (bDirectIo) {
            RealSize = CEILING_ALIGNED(ULONG, Size, SECTOR_SIZE - 1);
        } else {
            RealSize = Size;
        }
 
        Status = Ext2BuildExtents(
                     IrpContext,
                     Vcb,
                     Mcb,
                     Offset,
                     RealSize,
                     FALSE,
                     &Chain
                 );
 
        if (!NT_SUCCESS(Status)) {
            _SEH2_LEAVE;
        }
 
        if (Chain == NULL) {
            SafeZeroMemory((PCHAR)Buffer, Size);
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        /* for sparse file, we need zero the gaps */
        for (Extent = Chain; Buffer != NULL && Extent != NULL; Extent = Extent->Next) {
            if (NULL == Prev) {
                ASSERT(Extent == Chain);
                if (Extent->Offset) {
                    SafeZeroMemory((PCHAR)Buffer, Extent->Offset);
                }
            } else if (Extent->Offset > (Prev->Offset + Prev->Length)) {
                SafeZeroMemory((PCHAR)Buffer + Prev->Offset + Prev->Length,
                               Extent->Offset - Prev->Offset - Prev->Length);
            }
            if (NULL == Extent->Next) {
                if (Extent->Offset + Extent->Length < Size) {
                    SafeZeroMemory((PCHAR)Buffer + Extent->Offset + Extent->Length,
                                   Size - Extent->Offset - Extent->Length);
                }
            }
            Prev = Extent;
        }
 
        if (bDirectIo) {
 
            ASSERT(IrpContext != NULL);
 
            // Offset should be SECTOR_SIZE aligned ...
            Status = Ext2ReadWriteBlocks(
                         IrpContext,
                         Vcb,
                         Chain,
                         Size
                     );
        } else {
 
            for (Extent = Chain; Extent != NULL; Extent = Extent->Next) {
 
                if (!CcCopyRead(
                            Vcb->Volume,
                            (PLARGE_INTEGER)(&(Extent->Lba)),
                            Extent->Length,
                            PIN_WAIT,
                            (PVOID)((PUCHAR)Buffer + Extent->Offset),
                            &IoStatus
                        )) {
                    Status = STATUS_CANT_WAIT;
                } else {
                    Status = IoStatus.Status;
                }
 
                if (!NT_SUCCESS(Status)) {
                    break;
                }
            }
        }
 
    } _SEH2_FINALLY {
 
        if (Chain) {
            Ext2DestroyExtentChain(Chain);
        }
 
        Ext2DerefMcb(Mcb);
    } _SEH2_END;
 
    if (NT_SUCCESS(Status)) {
        if (BytesRead)
            *BytesRead = Size;
    }
 
    return Status;
}

Referenced by Ext2QueryDirectory(), Ext2ReadFile(), Ext2ReadSymlink(), and Ext2SetParentEntry().

◆ Ext2ReadSymlink()

NTSTATUS Ext2ReadSymlink	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN PVOID	Buffer,
		IN ULONG	Size,
		OUT PULONG	BytesRead
	)

Definition at line 1364 of file fsctl.c.

{
    return Ext2ReadInode (  IrpContext,
                            Vcb,
                            Mcb,
                            0,
                            Buffer,
                            Size,
                            FALSE,
                            BytesRead);
}

Referenced by Ext2FollowLink(), and Ext2GetReparsePoint().

◆ Ext2ReadSync()

NTSTATUS Ext2ReadSync	(	IN PEXT2_VCB	Vcb,
		IN ULONGLONG	Offset,
		IN ULONG	Length,
		OUT PVOID	Buffer,
		IN BOOLEAN	bVerify
	)

◆ Ext2ReadWriteBlocks()

NTSTATUS Ext2ReadWriteBlocks	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_EXTENT	Extent,
		IN ULONG	Length
	)

Definition at line 260 of file block.c.

{
    PIRP                Irp;
    PIRP                MasterIrp = IrpContext->Irp;
    PIO_STACK_LOCATION  IrpSp;
    PMDL                Mdl;
    PEXT2_RW_CONTEXT    pContext = NULL;
    PEXT2_EXTENT        Extent;
    KEVENT              Wait;
    NTSTATUS            Status = STATUS_SUCCESS;
    BOOLEAN             bMasterCompleted = FALSE;
    BOOLEAN             bBugCheck = FALSE;
 
    ASSERT(MasterIrp);
 
    _SEH2_TRY {
 
        pContext = Ext2AllocatePool(NonPagedPool, sizeof(EXT2_RW_CONTEXT), EXT2_RWC_MAGIC);
 
        if (!pContext) {
            DEBUG(DL_ERR, ( "Ex2ReadWriteBlocks: failed to allocate pContext.\n"));
            Status = STATUS_INSUFFICIENT_RESOURCES;
            _SEH2_LEAVE;
        }
 
        INC_MEM_COUNT(PS_RW_CONTEXT, pContext, sizeof(EXT2_RW_CONTEXT));
        RtlZeroMemory(pContext, sizeof(EXT2_RW_CONTEXT));
        pContext->Wait = Ext2CanIWait();
        pContext->MasterIrp = MasterIrp;
        pContext->Length = Length;
 
        if (IrpContext->MajorFunction == IRP_MJ_WRITE) {
            SetFlag(pContext->Flags, EXT2_RW_CONTEXT_WRITE);
        }
 
        if (pContext->Wait) {
 
            KeInitializeEvent(&(pContext->Event), NotificationEvent, FALSE);
 
        } else if (IrpContext->Fcb->Identifier.Type == EXT2FCB) {
 
            if (IsFlagOn(MasterIrp->Flags, IRP_PAGING_IO)) {
                pContext->Resource = &IrpContext->Fcb->PagingIoResource;
            } else {
                pContext->Resource = &IrpContext->Fcb->MainResource;
            }
 
            pContext->FileObject = IrpContext->FileObject;
            pContext->ThreadId = ExGetCurrentResourceThread();
        }
 
 
        if (NULL == Chain->Next && 0 == Chain->Offset) {
 
            /* we get only 1 extent to dispatch, then don't bother allocating new irps */
 
            /* setup the Stack location to do a read from the disk driver. */
            IrpSp = IoGetNextIrpStackLocation(MasterIrp);
            IrpSp->MajorFunction = IrpContext->MajorFunction;
            IrpSp->Parameters.Read.Length = Chain->Length;
            IrpSp->Parameters.Read.ByteOffset.QuadPart = Chain->Lba;
            if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH)) {
                SetFlag(IrpSp->Flags, SL_WRITE_THROUGH);
            }
            if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_VERIFY_READ)) {
                SetFlag(IrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME);
            }
 
            IoSetCompletionRoutine(
                    MasterIrp,
                    Ext2CanIWait() ?
                    Ext2ReadWriteBlockSyncCompletionRoutine :
                    Ext2ReadWriteBlockAsyncCompletionRoutine,
                    (PVOID) pContext,
                    TRUE,
                    TRUE,
                    TRUE );
 
            /* intialize context block */
            Chain->Irp = MasterIrp;
            pContext->Blocks = 1;
 
        } else {
 
            for (Extent = Chain; Extent != NULL; Extent = Extent->Next) {
 
                Irp = IoMakeAssociatedIrp(
                          MasterIrp,
                          (CCHAR)(Vcb->TargetDeviceObject->StackSize + 1) );
 
                if (!Irp) {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    _SEH2_LEAVE;
                }
 
                Mdl = IoAllocateMdl( (PCHAR)MasterIrp->UserBuffer +
                                     Extent->Offset,
                                     Extent->Length,
                                     FALSE,
                                     FALSE,
                                     Irp );
 
                if (!Mdl)  {
                    Status = STATUS_INSUFFICIENT_RESOURCES;
                    _SEH2_LEAVE;
                }
 
                IoBuildPartialMdl( MasterIrp->MdlAddress,
                                   Mdl,
                                   (PCHAR)MasterIrp->UserBuffer+Extent->Offset,
                                   Extent->Length );
 
                IoSetNextIrpStackLocation(Irp);
                IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
                IrpSp->MajorFunction = IrpContext->MajorFunction;
                IrpSp->Parameters.Read.Length = Extent->Length;
                IrpSp->Parameters.Read.ByteOffset.QuadPart = Extent->Lba;
 
                IoSetCompletionRoutine(
                    Irp,
                    Ext2CanIWait() ?
                    Ext2ReadWriteBlockSyncCompletionRoutine :
                    Ext2ReadWriteBlockAsyncCompletionRoutine,
                    (PVOID) pContext,
                    TRUE,
                    TRUE,
                    TRUE );
 
                IrpSp = IoGetNextIrpStackLocation(Irp);
 
                IrpSp->MajorFunction = IrpContext->MajorFunction;
                IrpSp->Parameters.Read.Length =Extent->Length;
                IrpSp->Parameters.Read.ByteOffset.QuadPart = Extent->Lba;
 
                /* set write through flag */
                if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH)) {
                    SetFlag( IrpSp->Flags, SL_WRITE_THROUGH );
                }
 
                /* set verify flag */
                if (IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_VERIFY_READ)) {
                    SetFlag(IrpSp->Flags, SL_OVERRIDE_VERIFY_VOLUME);
                }
 
                Extent->Irp = Irp;
                pContext->Blocks += 1;
            }
 
            MasterIrp->AssociatedIrp.IrpCount = pContext->Blocks;
            if (Ext2CanIWait()) {
                MasterIrp->AssociatedIrp.IrpCount += 1;
            }
        }
        if (!Ext2CanIWait()) {
            /* mark MasterIrp pending */
            IoMarkIrpPending(pContext->MasterIrp);
        }
 
        bBugCheck = TRUE;
 
        for (Extent = Chain; Extent != NULL; Extent = Extent->Next) {
            Status = IoCallDriver ( Vcb->TargetDeviceObject,
                                    Extent->Irp);
            Extent->Irp = NULL;
        }
 
        if (Ext2CanIWait()) {
            KeWaitForSingleObject( &(pContext->Event),
                                   Executive, KernelMode, FALSE, NULL );
            KeClearEvent( &(pContext->Event) );
        } else {
            bMasterCompleted = TRUE;
        }
 
    } _SEH2_FINALLY {
 
        for (Extent = Chain; Extent != NULL; Extent = Extent->Next)  {
            if (Extent->Irp != NULL ) {
                if (Extent->Irp->MdlAddress != NULL) {
                    IoFreeMdl(Extent->Irp->MdlAddress );
                }
                IoFreeIrp(Extent->Irp);
            }
        }
 
        if (IrpContext->ExceptionInProgress) {
 
            if (bBugCheck) {
                Ext2BugCheck(EXT2_BUGCHK_BLOCK, 0, 0, 0);
            }
 
        } else {
 
            if (Ext2CanIWait()) {
                if (MasterIrp) {
                    Status = MasterIrp->IoStatus.Status;
                }
                if (pContext) {
                    Ext2FreePool(pContext, EXT2_RWC_MAGIC);
                    DEC_MEM_COUNT(PS_RW_CONTEXT, pContext, sizeof(EXT2_RW_CONTEXT));
                }
            } else {
                if (bMasterCompleted) {
                    IrpContext->Irp = NULL;
                    Status = STATUS_PENDING;
                }
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2ReadInode(), Ext2ReadVolume(), Ext2WriteInode(), and Ext2WriteVolume().

◆ Ext2ReaperThread()

VOID Ext2ReaperThread ( PVOID Context )

◆ Ext2RecoverJournal()

INT Ext2RecoverJournal	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb
	)

Definition at line 95 of file recover.c.

{
    INT rc = 0;
    ULONG                   jNo = 0;
    PEXT2_MCB               jcb = NULL;
    struct block_device *   bd = &Vcb->bd;
#ifndef __REACTOS__
    struct super_block *    sb = &Vcb->sb;
#endif
    struct inode *          ji = NULL;
    journal_t *             journal = NULL;
    struct ext3_super_block *esb;
 
    ExAcquireResourceExclusiveLite(&Vcb->MainResource, TRUE);
 
    /* check journal inode number */
    if (!Ext2CheckJournal(Vcb, &jNo)) {
        rc = -1;
        goto errorout;
    }
 
    /* allocate journal Mcb */
    jcb =  Ext2LoadInternalJournal(Vcb, jNo);
    if (!jcb) {
        rc = -6;
        goto errorout;
    }
 
    /* allocate journal inode */
    ji = &jcb->Inode;
 
    /* initialize journal file from inode */
    journal = journal_init_inode(ji);
 
    /* initialzation succeeds ? */
    if (!journal) {
        iput(ji);
        rc = -8;
        goto errorout;
    }
 
    /* start journal recovery */
    rc = journal_load(journal);
    if (0 != rc) {
        rc = -9;
        DbgPrint("Ext2Fsd: recover_journal: failed "
                 "to recover journal data.\n");
    }
 
    /* reload super_block and group_description */
    Ext2RefreshSuper(IrpContext, Vcb);
    Ext2RefreshGroup(IrpContext, Vcb);
 
    /* wipe journal data and clear recover flag in sb */
    if (rc == 0) {
        journal_wipe_recovery(journal);
        ClearLongFlag(
            Vcb->SuperBlock->s_feature_incompat,
            EXT3_FEATURE_INCOMPAT_RECOVER );
        Ext2SaveSuper(IrpContext, Vcb);
        sync_blockdev(bd);
        ClearLongFlag(Vcb->Flags, VCB_JOURNAL_RECOVER);
    }
 
errorout:
 
    /* destroy journal structure */
    if (journal) {
        journal_destroy(journal);
    }
 
    /* destory journal Mcb */
    if (jcb) {
        Ext2FreeMcb(Vcb, jcb);
    }
 
    ExReleaseResourceLite(&Vcb->MainResource);
 
    return rc;
}

Referenced by Ext2InitializeVcb(), and Ext2ProcessVolumeProperty().

◆ 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().

◆ Ext2ReleaseFcb()

VOID Ext2ReleaseFcb ( IN PEXT2_FCB Fcb )

Definition at line 276 of file memory.c.

{
    PEXT2_VCB   Vcb = Fcb->Vcb;
    PEXT2_MCB   Mcb;
 
    if (0 != Ext2DerefXcb(&Fcb->ReferenceCount))
        return;
 
    ExAcquireResourceExclusiveLite(&Vcb->FcbLock, TRUE);
    ExAcquireResourceExclusiveLite(&Fcb->MainResource, TRUE);
 
    Mcb = Fcb->Mcb;
    RemoveEntryList(&Fcb->Next);
 
    if (IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING) ||
        NULL == Mcb || IsFileDeleted(Mcb)) {
        InsertHeadList(&Vcb->FcbList, &Fcb->Next);
        Fcb->TsDrop.QuadPart = 0;
    } else {
        InsertTailList(&Vcb->FcbList, &Fcb->Next);
        KeQuerySystemTime(&Fcb->TsDrop);
    }
    ExReleaseResourceLite(&Fcb->MainResource);
    ExReleaseResourceLite(&Vcb->FcbLock);
 
    if ((Vcb->FcbCount >> 6) > (ULONG)(Ext2Global->MaxDepth)) {
        KeSetEvent(&Ext2Global->FcbReaper.Wait, 0, FALSE);
    }
}

Referenced by Ext2CreateFile(), Ext2DeleteFile(), Ext2DeleteReparsePoint(), Ext2SetLinkInfo(), Ext2SetRenameInfo(), and Ext2SetReparsePoint().

◆ Ext2ReleaseFileForCcFlush()

NTSTATUS Ext2ReleaseFileForCcFlush	(	IN PFILE_OBJECT	FileObject,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 1156 of file fastio.c.

{
    PEXT2_FCB Fcb = FileObject->FsContext;
 
    DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2ReleaseFileForCcFlush: Fcb=%p\n", Fcb));
 
    if (Fcb->Header.Resource != NULL) {
        ExReleaseResourceLite(Fcb->Header.Resource);
    }
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

◆ Ext2ReleaseFileForModWrite()

NTSTATUS Ext2ReleaseFileForModWrite	(	IN PFILE_OBJECT	FileObject,
		IN PERESOURCE	ResourceToRelease,
		IN PDEVICE_OBJECT	DeviceObject
	)

Definition at line 1110 of file fastio.c.

{
    PEXT2_FCB Fcb = FileObject->FsContext;
 
    DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2ReleaseFileForModWrite: Fcb=%p\n", Fcb));
 
    if (ResourceToRelease != NULL) {
        ASSERT(ResourceToRelease == Fcb->Header.Resource);
        ExReleaseResourceLite(ResourceToRelease);
    } else {
        DbgBreak();
    }
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

◆ Ext2ReleaseForCreateSection()

VOID Ext2ReleaseForCreateSection ( IN PFILE_OBJECT FileObject )

Definition at line 1062 of file fastio.c.

{
    PEXT2_FCB Fcb = FileObject->FsContext;
 
    DEBUG(FASTIO_DEBUG_LEVEL, ("Ext2ReleaseForCreateSection:  Fcb=%p\n", Fcb));
 
    if (Fcb->Header.Resource != NULL) {
        ExReleaseResourceLite(Fcb->Header.Resource);
    }
}

Referenced by DriverEntry().

◆ Ext2ReleaseFromLazyWrite()

VOID Ext2ReleaseFromLazyWrite ( IN PVOID Context )

Definition at line 63 of file cmcb.c.

{
    //
    // On a readonly filesystem this function still has to exist but it
    // doesn't need to do anything.
    PEXT2_FCB Fcb = (PEXT2_FCB) Context;
 
    ASSERT(Fcb != NULL);
 
    ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
           (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
#if EXT2_DEBUG
    DEBUG(CMCB_DEBUG_LEVEL, ( "Ext2ReleaseFromLazyWrite: %s %s Fcb=%p\n",
                              Ext2GetCurrentProcessName(), "RELEASE_FROM_LAZY_WRITE", Fcb));
#endif
    ASSERT(Fcb->LazyWriterThread == PsGetCurrentThread());
    Fcb->LazyWriterThread = NULL;
 
    ExReleaseResourceLite(Fcb->Header.Resource);
 
    ASSERT(IoGetTopLevelIrp() == (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
    IoSetTopLevelIrp( NULL );
}

Referenced by DriverEntry().

◆ Ext2ReleaseFromReadAhead()

VOID Ext2ReleaseFromReadAhead ( IN PVOID Context )

Definition at line 117 of file cmcb.c.

{
    PEXT2_FCB Fcb = (PEXT2_FCB) Context;
 
    ASSERT(Fcb != NULL);
 
    ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
           (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
    DEBUG(CMCB_DEBUG_LEVEL, ("Ext2ReleaseFromReadAhead: i=%xh Fcb=%p\n",
                             Fcb->Mcb->Inode.i_ino, Fcb));
 
    IoSetTopLevelIrp(NULL);
    ExReleaseResourceLite(Fcb->Header.Resource);
}

Referenced by DriverEntry().

◆ Ext2RemoveBlockExtent()

BOOLEAN Ext2RemoveBlockExtent	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Start,
		IN ULONG	Number
	)

Definition at line 1097 of file memory.c.

{
    LONGLONG    Vbn = 0;
    LONGLONG    Length = 0;
    BOOLEAN     rc;
 
    Vbn = ((LONGLONG) Start) << BLOCK_BITS;
    Length = ((LONGLONG)Number << BLOCK_BITS);
 
    if (Mcb) {
        rc = Ext2RemoveMcbExtent(Vcb, Mcb, Vbn, Length);
    } else {
        rc = Ext2RemoveVcbExtent(Vcb, Vbn, Length);
    }
 
    return rc;
}

Referenced by Ext2FreeBlock(), Ext2NewBlock(), Ext2TruncateBlock(), and Ext2TruncateExtent().

◆ 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().

◆ Ext2RemoveMcb()

BOOLEAN Ext2RemoveMcb	(	PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb
	)

Definition at line 1746 of file memory.c.

{
    PEXT2_MCB   TmpMcb = NULL;
    BOOLEAN     LockAcquired = FALSE;
    BOOLEAN     bLinked = FALSE;
 
    _SEH2_TRY {
 
        ExAcquireResourceExclusiveLite(&Vcb->McbLock, TRUE);
        LockAcquired = TRUE;
 
        if (Mcb->Parent) {
 
            if (Mcb->Parent->Child == Mcb) {
                Mcb->Parent->Child = Mcb->Next;
                bLinked = TRUE;
            } else {
                TmpMcb = Mcb->Parent->Child;
 
                while (TmpMcb && TmpMcb->Next != Mcb) {
                    TmpMcb = TmpMcb->Next;
                }
 
                if (TmpMcb) {
                    TmpMcb->Next = Mcb->Next;
                    bLinked = TRUE;
                } else {
                    /* we got errors: link broken */
                }
            }
 
            if (bLinked) {
                if (IsFlagOn(Mcb->Flags, MCB_ENTRY_TREE)) {
                    DEBUG(DL_RES, ("Mcb %p %wZ removed from Mcb %p %wZ\n", Mcb,
                                   &Mcb->FullName, Mcb->Parent, &Mcb->Parent->FullName));
                    Ext2DerefMcb(Mcb->Parent);
                    ClearLongFlag(Mcb->Flags, MCB_ENTRY_TREE);
                } else {
                    DbgBreak();
                }
            } else {
                if (IsFlagOn(Mcb->Flags, MCB_ENTRY_TREE)) {
                    ClearLongFlag(Mcb->Flags, MCB_ENTRY_TREE);
                }
                DbgBreak();
            }
            Mcb->Parent = NULL;
            Mcb->de->d_parent = NULL;
        }
 
    } _SEH2_FINALLY {
 
        if (LockAcquired) {
            ExReleaseResourceLite(&Vcb->McbLock);
        }
    } _SEH2_END;
 
    return TRUE;
}

Referenced by Ext2DeleteFile(), Ext2FirstUnusedMcb(), Ext2SetRenameInfo(), and Ext2UnlinkFcb().

◆ Ext2RemoveMcbExtent()

BOOLEAN Ext2RemoveMcbExtent	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN LONGLONG	Vbn,
		IN LONGLONG	Length
	)

Definition at line 848 of file memory.c.

{
    ULONG       TriedTimes = 0;
    LONGLONG    Base = 0;
    UCHAR       Bits = 0;
    BOOLEAN     rc = TRUE;
 
    Base = (LONGLONG)BLOCK_SIZE;
    Bits = (UCHAR)BLOCK_BITS;
 
    ASSERT ((Vbn & (Base - 1)) == 0);
    ASSERT ((Length & (Base - 1)) == 0);
 
    Vbn = (Vbn >> Bits) + 1;
    Length = (Length >> Bits);
 
Again:
 
    _SEH2_TRY {
        FsRtlRemoveLargeMcbEntry(
            &Mcb->Extents,
            Vbn,
            Length
        );
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
        DbgBreak();
        rc = FALSE;
    } _SEH2_END;
 
    if (!rc && ++TriedTimes < 10) {
        Ext2Sleep(TriedTimes * 100);
        goto Again;
    }
 
    DEBUG(DL_EXT, ("Ext2RemoveMcbExtent: Vbn=%I64xh Length=%I64xh Runs=%u\n",
                   Vbn, Length, FsRtlNumberOfRunsInLargeMcb(&Mcb->Extents)));
    if (rc) {
        Ext2CheckExtent(&Mcb->Extents, Vbn, 0, Length, FALSE);
    }
 
    return rc;
}

Referenced by Ext2RemoveBlockExtent().

◆ Ext2RemoveMcbMetaExts()

BOOLEAN Ext2RemoveMcbMetaExts	(	IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Block,
		IN ULONG	Length
	)

Definition at line 985 of file memory.c.

{
    ULONG       TriedTimes = 0;
    LONGLONG    Lbn = Block + 1;
    BOOLEAN     rc = TRUE;
 
Again:
 
    _SEH2_TRY {
 
        FsRtlRemoveLargeMcbEntry(
            &Mcb->MetaExts,
            Lbn,
            Length
        );
 
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
        DbgBreak();
        rc = FALSE;
    } _SEH2_END;
 
    if (!rc && ++TriedTimes < 10) {
        Ext2Sleep(TriedTimes * 100);
        goto Again;
    }
 
    DEBUG(DL_EXT, ("Ext2RemoveMcbMetaExts: Block: %xh-%xhh Runs=%u\n", Block,
                    Length, FsRtlNumberOfRunsInLargeMcb(&Mcb->MetaExts)));
    if (rc) {
        Ext2CheckExtent(&Mcb->MetaExts, Lbn, 0, Length, FALSE);
    }
 
    return rc;
}

Referenced by Ext2TruncateBlock().

◆ Ext2RemoveVcb()

VOID Ext2RemoveVcb ( PEXT2_VCB Vcb )

Definition at line 1943 of file memory.c.

{
    RemoveEntryList(&Vcb->Next);
    InitializeListHead(&Vcb->Next);
}

Referenced by Ext2CheckDismount().

◆ Ext2RemoveVcbExtent()

BOOLEAN Ext2RemoveVcbExtent	(	IN PEXT2_VCB	Vcb,
		IN LONGLONG	Vbn,
		IN LONGLONG	Length
	)

Definition at line 700 of file memory.c.

{
    ULONG       TriedTimes = 0;
    LONGLONG    Offset = 0;
    BOOLEAN     rc = TRUE;
 
    Offset =  Vbn & (~(Vcb->IoUnitSize - 1));
    Length = (Length + Vbn - Offset + Vcb->IoUnitSize - 1) & (~(Vcb->IoUnitSize - 1));
 
    ASSERT ((Offset & (Vcb->IoUnitSize - 1)) == 0);
    ASSERT ((Length & (Vcb->IoUnitSize - 1)) == 0);
 
    Offset = (Offset >> Vcb->IoUnitBits) + 1;
    Length = (Length >> Vcb->IoUnitBits);
 
Again:
 
    _SEH2_TRY {
        FsRtlRemoveLargeMcbEntry(
            &Vcb->Extents,
            Offset,
            Length
        );
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
        DbgBreak();
        rc = FALSE;
    } _SEH2_END;
 
    if (!rc && ++TriedTimes < 10) {
        Ext2Sleep(TriedTimes * 100);
        goto Again;
    }
 
    DEBUG(DL_EXT, ("Ext2RemoveVcbExtent: Vbn=%I64xh Length=%I64xh Runs=%u\n",
                   Offset, Length, FsRtlNumberOfRunsInLargeMcb(&Vcb->Extents)));
    if (rc) {
        Ext2CheckExtent(&Vcb->Extents, Offset, 0, Length, FALSE);
    }
 
    return rc;
}

Referenced by Ext2RemoveBlockExtent(), and Ext2WriteVolume().

◆ Ext2SaveBlock()

BOOLEAN Ext2SaveBlock	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN ULONG	dwBlk,
		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().

◆ Ext2ScanDir()

NTSTATUS Ext2ScanDir	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Parent,
		IN PUNICODE_STRING	FileName,
		OUT PULONG	Inode,
		struct dentry **	dentry
	)

◆ Ext2SearchMcb()

PEXT2_MCB Ext2SearchMcb	(	PEXT2_VCB	Vcb,
		PEXT2_MCB	Parent,
		PUNICODE_STRING	FileName
	)

Definition at line 1598 of file memory.c.

{
    BOOLEAN   LockAcquired = FALSE;
    PEXT2_MCB Mcb = NULL;
 
    _SEH2_TRY {
        ExAcquireResourceSharedLite(&Vcb->McbLock, TRUE);
        LockAcquired = TRUE;
        Mcb = Ext2SearchMcbWithoutLock(Parent, FileName);
    } _SEH2_FINALLY {
        if (LockAcquired) {
            ExReleaseResourceLite(&Vcb->McbLock);
        }
    } _SEH2_END;
 
    return Mcb;
}

Referenced by Ext2ProcessEntry().

◆ Ext2SearchMcbWithoutLock()

PEXT2_MCB Ext2SearchMcbWithoutLock	(	PEXT2_MCB	Parent,
		PUNICODE_STRING	FileName
	)

Definition at line 1622 of file memory.c.

{
    PEXT2_MCB TmpMcb = NULL;
 
    DEBUG(DL_RES, ("Ext2SearchMcb: %wZ\n", FileName));
 
    _SEH2_TRY {
 
        Ext2ReferMcb(Parent);
 
        if (Ext2IsDot(FileName)) {
            TmpMcb = Parent;
            Ext2ReferMcb(Parent);
            _SEH2_LEAVE;
        }
 
        if (Ext2IsDotDot(FileName)) {
            if (IsMcbRoot(Parent)) {
                TmpMcb = Parent;
            } else {
                TmpMcb = Parent->Parent;
            }
            if (TmpMcb) {
                Ext2ReferMcb(TmpMcb);
            }
            _SEH2_LEAVE;
        }
 
        if (IsMcbSymLink(Parent)) {
            if (Parent->Target) {
                TmpMcb = Parent->Target->Child;
                ASSERT(!IsMcbSymLink(Parent->Target));
            } else {
                TmpMcb = NULL;
                _SEH2_LEAVE;
            }
        } else {
            TmpMcb = Parent->Child;
        }
 
        while (TmpMcb) {
 
            if (!RtlCompareUnicodeString(
                        &(TmpMcb->ShortName),
                        FileName, TRUE )) {
                Ext2ReferMcb(TmpMcb);
                break;
            }
 
            TmpMcb = TmpMcb->Next;
        }
 
    } _SEH2_FINALLY {
 
        Ext2DerefMcb(Parent);
    } _SEH2_END;
 
    return TmpMcb;
}

Referenced by Ext2LookupFile(), and Ext2SearchMcb().

◆ Ext2SetDispositionInfo()

NTSTATUS Ext2SetDispositionInfo	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_FCB	Fcb,
		PEXT2_CCB	Ccb,
		BOOLEAN	bDelete
	)

Definition at line 1282 of file fileinfo.c.

{
    PIRP    Irp = IrpContext->Irp;
    PIO_STACK_LOCATION IrpSp;
    NTSTATUS status = STATUS_SUCCESS;
    PEXT2_MCB  Mcb = Fcb->Mcb;
 
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    DEBUG(DL_INF, ( "Ext2SetDispositionInfo: bDelete=%x\n", bDelete));
 
    if (bDelete) {
 
        DEBUG(DL_INF, ( "Ext2SetDispositionInformation: Removing %wZ.\n",
                        &Mcb->FullName));
 
        if (Ccb->SymLink || IsInodeSymLink(&Mcb->Inode)) {
            /* always allow deleting on symlinks */
        } else {
            status = Ext2IsFileRemovable(IrpContext, Vcb, Fcb, Ccb);
        }
 
        if (NT_SUCCESS(status)) {
            SetLongFlag(Fcb->Flags, FCB_DELETE_PENDING);
            IrpSp->FileObject->DeletePending = TRUE;
        }
 
    } else {
 
        ClearLongFlag(Fcb->Flags, FCB_DELETE_PENDING);
        IrpSp->FileObject->DeletePending = FALSE;
    }
 
    return status;
}

Referenced by Ext2SetFileInformation().

◆ Ext2SetEa()

NTSTATUS Ext2SetEa ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 436 of file ea.c.

{
    PIRP                Irp = NULL;
    PIO_STACK_LOCATION  IrpSp;
 
    PDEVICE_OBJECT      DeviceObject;
 
    PEXT2_VCB           Vcb = NULL;
    PEXT2_FCB           Fcb = NULL;
    PEXT2_CCB           Ccb = NULL;
    PEXT2_MCB           Mcb = NULL;
 
    BOOLEAN             MainResourceAcquired = FALSE;
    BOOLEAN             FcbLockAcquired = FALSE;
    BOOLEAN             XattrRefAcquired = FALSE;
 
    NTSTATUS            Status = STATUS_UNSUCCESSFUL;
 
    struct ext4_xattr_ref xattr_ref;
    PCHAR UserBuffer;
    ULONG UserBufferLength;
 
    PFILE_FULL_EA_INFORMATION FullEa;
 
    _SEH2_TRY {
 
        Ccb = IrpContext->Ccb;
        ASSERT(Ccb != NULL);
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
            (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
        DeviceObject = IrpContext->DeviceObject;
        Vcb = (PEXT2_VCB)DeviceObject->DeviceExtension;
        Fcb = IrpContext->Fcb;
        Mcb = Fcb->Mcb;
        Irp = IrpContext->Irp;
        IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
        Irp->IoStatus.Information = 0;
 
        //
        // Receive input parameter from caller
        //
        UserBufferLength = IrpSp->Parameters.SetEa.Length;
        UserBuffer = Irp->UserBuffer;
 
        // Check if the EA buffer provided is valid
        Status = IoCheckEaBufferValidity((PFILE_FULL_EA_INFORMATION)UserBuffer,
            UserBufferLength,
            (PULONG)&Irp->IoStatus.Information);
        if (!NT_SUCCESS(Status))
            _SEH2_LEAVE;
 
        ExAcquireResourceExclusiveLite(&Vcb->FcbLock, TRUE);
        FcbLockAcquired = TRUE;
 
        if (!Mcb)
            _SEH2_LEAVE;
 
        //
        // We do not allow multiple instance gaining EA access to the same file
        //
        if (!ExAcquireResourceExclusiveLite(
            &Fcb->MainResource,
            IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT))) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
        MainResourceAcquired = TRUE;
 
        Status = Ext2WinntError(ext4_fs_get_xattr_ref(IrpContext, Vcb, Fcb->Mcb, &xattr_ref));
        if (!NT_SUCCESS(Status)) {
            DbgPrint("ext4_fs_get_xattr_ref() failed!\n");
            _SEH2_LEAVE;
        }
 
        XattrRefAcquired = TRUE;
 
        //
        // Remove all existing EA entries.
        //
        ext4_xattr_purge_items(&xattr_ref);
        xattr_ref.dirty = TRUE;
        Status = STATUS_SUCCESS;
 
        // Iterate the whole EA buffer to do inspection
        for (FullEa = (PFILE_FULL_EA_INFORMATION)UserBuffer;
            FullEa < (PFILE_FULL_EA_INFORMATION)&UserBuffer[UserBufferLength];
            FullEa = (PFILE_FULL_EA_INFORMATION)(FullEa->NextEntryOffset == 0 ?
                &UserBuffer[UserBufferLength] :
                (PCHAR)FullEa + FullEa->NextEntryOffset)) {
 
            OEM_STRING EaName;
 
            EaName.MaximumLength = EaName.Length = FullEa->EaNameLength;
            EaName.Buffer = &FullEa->EaName[0];
 
            // Check if EA's name is valid
            if (!Ext2IsEaNameValid(EaName)) {
                Irp->IoStatus.Information = (PCHAR)FullEa - UserBuffer;
                Status = STATUS_INVALID_EA_NAME;
                _SEH2_LEAVE;
            }
        }
 
        // Now add EA entries to the inode
        for (FullEa = (PFILE_FULL_EA_INFORMATION)UserBuffer;
            FullEa < (PFILE_FULL_EA_INFORMATION)&UserBuffer[UserBufferLength];
            FullEa = (PFILE_FULL_EA_INFORMATION)(FullEa->NextEntryOffset == 0 ?
                &UserBuffer[UserBufferLength] :
                (PCHAR)FullEa + FullEa->NextEntryOffset)) {
 
                int ret;
                OEM_STRING EaName;
 
                EaName.MaximumLength = EaName.Length = FullEa->EaNameLength;
                EaName.Buffer = &FullEa->EaName[0];
 
                Status = Ext2WinntError(ret =
                    ext4_fs_set_xattr_ordered(&xattr_ref,
                        EXT4_XATTR_INDEX_USER,
                        EaName.Buffer,
                        EaName.Length,
                        &FullEa->EaName[0] + FullEa->EaNameLength + 1,
                        FullEa->EaValueLength));
                if (!NT_SUCCESS(Status))
                    _SEH2_LEAVE;
 
        }
    } _SEH2_FINALLY {
 
        if (XattrRefAcquired) {
            if (!NT_SUCCESS(Status)) {
                xattr_ref.dirty = FALSE;
                ext4_fs_put_xattr_ref(&xattr_ref);
            } else
                Status = Ext2WinntError(ext4_fs_put_xattr_ref(&xattr_ref));
        }
 
        if (FcbLockAcquired) {
            ExReleaseResourceLite(&Vcb->FcbLock);
            FcbLockAcquired = FALSE;
        }
 
        if (MainResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (NT_SUCCESS(Status)) {
            Ext2NotifyReportChange(
                IrpContext,
                Vcb,
                Mcb,
                FILE_NOTIFY_CHANGE_EA,
                FILE_ACTION_MODIFIED);
        }
 
        if (!_SEH2_AbnormalTermination()) {
            if (Status == STATUS_PENDING || Status == STATUS_CANT_WAIT) {
                Status = Ext2QueueRequest(IrpContext);
            }
            else {
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2SetFileInformation()

NTSTATUS Ext2SetFileInformation ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 514 of file fileinfo.c.

{
    PDEVICE_OBJECT          DeviceObject;
    NTSTATUS                Status = STATUS_UNSUCCESSFUL;
    PEXT2_VCB               Vcb = NULL;
    PFILE_OBJECT            FileObject = NULL;
    PEXT2_FCB               Fcb = NULL;
    PEXT2_CCB               Ccb = NULL;
    PEXT2_MCB               Mcb = NULL;
    PIRP                    Irp = NULL;
    PIO_STACK_LOCATION      IoStackLocation = NULL;
    FILE_INFORMATION_CLASS  FileInformationClass;
 
    ULONG                   NotifyFilter = 0;
 
    ULONG                   Length;
    PVOID                   Buffer;
 
    BOOLEAN                 FcbMainResourceAcquired = FALSE;
    BOOLEAN                 FcbPagingIoResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
        DeviceObject = IrpContext->DeviceObject;
 
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        /* check io stack location of irp stack */
        Irp = IrpContext->Irp;
        IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
        FileInformationClass =
            IoStackLocation->Parameters.SetFile.FileInformationClass;
        Length = IoStackLocation->Parameters.SetFile.Length;
        Buffer = Irp->AssociatedIrp.SystemBuffer;
 
        /* check Vcb */
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
        if (!IsMounted(Vcb)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED)) {
            Status = STATUS_ACCESS_DENIED;
            _SEH2_LEAVE;
        }
 
        FileObject = IrpContext->FileObject;
        Fcb = (PEXT2_FCB) FileObject->FsContext;
 
        // This request is issued to volumes, just return success
        if (Fcb == NULL || Fcb->Identifier.Type == EXT2VCB) {
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
        ASSERT((Fcb->Identifier.Type == EXT2FCB) &&
               (Fcb->Identifier.Size == sizeof(EXT2_FCB)));
 
        if (IsFlagOn(Fcb->Mcb->Flags, MCB_FILE_DELETED)) {
            Status = STATUS_FILE_DELETED;
            _SEH2_LEAVE;
        }
 
        Ccb = (PEXT2_CCB) FileObject->FsContext2;
        ASSERT(Ccb != NULL);
        ASSERT((Ccb->Identifier.Type == EXT2CCB) &&
               (Ccb->Identifier.Size == sizeof(EXT2_CCB)));
        Mcb = Ccb->SymLink;
        if (Mcb) {
            if (IsFlagOn(Mcb->Flags, MCB_FILE_DELETED)) {
                Status = STATUS_FILE_DELETED;
                _SEH2_LEAVE;
            }
        } else {
            Mcb = Fcb->Mcb;
        }
 
        if (FileInformationClass != FilePositionInformation) {
            if (IsVcbReadOnly(Vcb)) {
                Status = STATUS_MEDIA_WRITE_PROTECTED;
                _SEH2_LEAVE;
            }
            if (!Ext2CheckFileAccess(Vcb, Mcb, Ext2FileCanWrite)) {
                Status = STATUS_ACCESS_DENIED;
                _SEH2_LEAVE;
            }
        }
 
        if ( !IsDirectory(Fcb) && !FlagOn(Fcb->Flags, FCB_PAGE_FILE) &&
                ((FileInformationClass == FileEndOfFileInformation) ||
                 (FileInformationClass == FileValidDataLengthInformation) ||
                 (FileInformationClass == FileAllocationInformation))) {
 
            Status = FsRtlCheckOplock( &Fcb->Oplock,
                                       Irp,
                                       IrpContext,
                                       NULL,
                                       NULL );
 
            if (Status != STATUS_SUCCESS) {
                _SEH2_LEAVE;
            }
 
            //
            //  Set the flag indicating if Fast I/O is possible
            //
 
            Fcb->Header.IsFastIoPossible = Ext2IsFastIoPossible(Fcb);
        }
 
        /* for renaming or set link, we must not grab any Fcb locks,
           and later we will get Dcb or Fcb resources exclusively.  */
        if (!IsFlagOn(Fcb->Flags, FCB_PAGE_FILE) &&
            FileInformationClass != FileRenameInformation &&
            FileInformationClass != FileLinkInformation) {
 
            if (!ExAcquireResourceExclusiveLite(
                        &Fcb->MainResource,
                        IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) )) {
                Status = STATUS_PENDING;
                _SEH2_LEAVE;
            }
 
            FcbMainResourceAcquired = TRUE;
 
            if ( FileInformationClass == FileAllocationInformation ||
                 FileInformationClass == FileEndOfFileInformation ||
                 FileInformationClass == FileValidDataLengthInformation) {
 
                if (!ExAcquireResourceExclusiveLite(
                            &Fcb->PagingIoResource,
                            IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) )) {
                    Status = STATUS_PENDING;
                    DbgBreak();
                    _SEH2_LEAVE;
                }
                FcbPagingIoResourceAcquired = TRUE;
            }
        }
 
        switch (FileInformationClass) {
 
        case FileBasicInformation:
        {
            PFILE_BASIC_INFORMATION FBI = (PFILE_BASIC_INFORMATION) Buffer;
            struct inode *Inode = &Mcb->Inode;
 
            if (FBI->CreationTime.QuadPart != 0 && FBI->CreationTime.QuadPart != -1) {
                Inode->i_ctime = Ext2LinuxTime(FBI->CreationTime);
                Mcb->CreationTime = Ext2NtTime(Inode->i_ctime);
                NotifyFilter |= FILE_NOTIFY_CHANGE_CREATION;
            }
 
            if (FBI->LastAccessTime.QuadPart != 0 && FBI->LastAccessTime.QuadPart != -1) {
                Inode->i_atime = Ext2LinuxTime(FBI->LastAccessTime);
                Mcb->LastAccessTime = Ext2NtTime(Inode->i_atime);
                NotifyFilter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
            }
 
            if (FBI->LastWriteTime.QuadPart != 0 && FBI->LastWriteTime.QuadPart != -1) {
                Inode->i_mtime = Ext2LinuxTime(FBI->LastWriteTime);
                Mcb->LastWriteTime = Ext2NtTime(Inode->i_mtime);
                NotifyFilter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
                SetFlag(Ccb->Flags, CCB_LAST_WRITE_UPDATED);
            }
 
            if (FBI->ChangeTime.QuadPart !=0 && FBI->ChangeTime.QuadPart != -1) {
                Mcb->ChangeTime = FBI->ChangeTime;
            }
 
            if (FBI->FileAttributes != 0) {
 
                BOOLEAN bIsDirectory = IsDirectory(Fcb);
                NotifyFilter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
 
                if (IsFlagOn(FBI->FileAttributes, FILE_ATTRIBUTE_READONLY)) {
                    Ext2SetOwnerReadOnly(Inode->i_mode);
                } else {
                    Ext2SetOwnerWritable(Inode->i_mode);
                }
 
                if (FBI->FileAttributes & FILE_ATTRIBUTE_TEMPORARY) {
                    SetFlag(FileObject->Flags, FO_TEMPORARY_FILE);
                } else {
                    ClearFlag(FileObject->Flags, FO_TEMPORARY_FILE);
                }
 
                Mcb->FileAttr = FBI->FileAttributes;
                if (bIsDirectory) {
                    SetFlag(Mcb->FileAttr, FILE_ATTRIBUTE_DIRECTORY);
                    ClearFlag(Mcb->FileAttr, FILE_ATTRIBUTE_NORMAL);
                }
            }
 
            if (NotifyFilter != 0) {
                if (Ext2SaveInode(IrpContext, Vcb, Inode)) {
                    Status = STATUS_SUCCESS;
                }
            }
 
            ClearFlag(NotifyFilter, FILE_NOTIFY_CHANGE_LAST_ACCESS);
            Status = STATUS_SUCCESS;
        }
 
        break;
 
        case FileAllocationInformation:
        {
            PFILE_ALLOCATION_INFORMATION FAI = (PFILE_ALLOCATION_INFORMATION)Buffer;
            LARGE_INTEGER  AllocationSize;
 
            if (IsMcbDirectory(Mcb) || IsMcbSpecialFile(Mcb)) {
                Status = STATUS_INVALID_DEVICE_REQUEST;
                _SEH2_LEAVE;
            } else {
                Status = STATUS_SUCCESS;
            }
 
            /* set Mcb to it's target */
            if (IsMcbSymLink(Mcb)) {
                ASSERT(Fcb->Mcb == Mcb->Target);
            }
            Mcb = Fcb->Mcb;
 
            /* get user specified allocationsize aligned with BLOCK_SIZE */
            AllocationSize.QuadPart = CEILING_ALIGNED(ULONGLONG,
                                      (ULONGLONG)FAI->AllocationSize.QuadPart,
                                      (ULONGLONG)BLOCK_SIZE);
 
            if (AllocationSize.QuadPart > Fcb->Header.AllocationSize.QuadPart) {
 
                Status = Ext2ExpandFile(IrpContext, Vcb, Mcb, &AllocationSize);
                Fcb->Header.AllocationSize = AllocationSize;
                NotifyFilter = FILE_NOTIFY_CHANGE_SIZE;
                SetLongFlag(Fcb->Flags, FCB_ALLOC_IN_SETINFO);
 
            } else if (AllocationSize.QuadPart < Fcb->Header.AllocationSize.QuadPart) {
 
                if (MmCanFileBeTruncated(&(Fcb->SectionObject), &AllocationSize))  {
 
                    /* truncate file blocks */
                    Status = Ext2TruncateFile(IrpContext, Vcb, Mcb, &AllocationSize);
 
                    if (NT_SUCCESS(Status)) {
                        ClearLongFlag(Fcb->Flags, FCB_ALLOC_IN_CREATE);
                    }
 
                    NotifyFilter = FILE_NOTIFY_CHANGE_SIZE;
                    Fcb->Header.AllocationSize.QuadPart = AllocationSize.QuadPart;
                    if (Mcb->Inode.i_size > (loff_t)AllocationSize.QuadPart) {
                        Mcb->Inode.i_size = AllocationSize.QuadPart;
                    }
                    Fcb->Header.FileSize.QuadPart = Mcb->Inode.i_size;
                    if (Fcb->Header.ValidDataLength.QuadPart > Fcb->Header.FileSize.QuadPart) {
                        Fcb->Header.ValidDataLength.QuadPart = Fcb->Header.FileSize.QuadPart;
                    }
 
                } else {
 
                    Status = STATUS_USER_MAPPED_FILE;
                    DbgBreak();
                    _SEH2_LEAVE;
                }
            }
 
            if (NotifyFilter) {
 
                SetFlag(FileObject->Flags, FO_FILE_MODIFIED);
                SetLongFlag(Fcb->Flags, FCB_FILE_MODIFIED);
                Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
                if (CcIsFileCached(FileObject)) {
                    CcSetFileSizes(FileObject, (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));
                }
            }
 
            DEBUG(DL_IO, ("Ext2SetInformation: %wZ NewSize=%I64xh AllocationSize=%I64xh "
                          "FileSize=%I64xh VDL=%I64xh i_size=%I64xh status = %xh\n",
                          &Fcb->Mcb->ShortName, AllocationSize.QuadPart,
                          Fcb->Header.AllocationSize.QuadPart,
                          Fcb->Header.FileSize.QuadPart, Fcb->Header.ValidDataLength.QuadPart,
                          Mcb->Inode.i_size, Status));
        }
 
        break;
 
        case FileEndOfFileInformation:
        {
            PFILE_END_OF_FILE_INFORMATION FEOFI = (PFILE_END_OF_FILE_INFORMATION) Buffer;
            LARGE_INTEGER NewSize, OldSize, EndOfFile;
 
            if (IsMcbDirectory(Mcb) || IsMcbSpecialFile(Mcb)) {
                Status = STATUS_INVALID_DEVICE_REQUEST;
                _SEH2_LEAVE;
            } else {
                Status = STATUS_SUCCESS;
            }
 
            /* set Mcb to it's target */
            if (IsMcbSymLink(Mcb)) {
                ASSERT(Fcb->Mcb == Mcb->Target);
            }
            Mcb = Fcb->Mcb;
 
            OldSize = Fcb->Header.AllocationSize;
            EndOfFile = FEOFI->EndOfFile;
 
            if (IoStackLocation->Parameters.SetFile.AdvanceOnly) {
 
                if (IsFlagOn(Fcb->Flags, FCB_DELETE_PENDING)) {
                    _SEH2_LEAVE;
                }
 
                if (EndOfFile.QuadPart > Fcb->Header.FileSize.QuadPart) {
                    EndOfFile.QuadPart = Fcb->Header.FileSize.QuadPart;
                }
 
                if (EndOfFile.QuadPart > Fcb->Header.ValidDataLength.QuadPart) {
                    Fcb->Header.ValidDataLength.QuadPart = EndOfFile.QuadPart;
                    NotifyFilter = FILE_NOTIFY_CHANGE_SIZE;
                }
 
                _SEH2_LEAVE;
            }
 
            NewSize.QuadPart = CEILING_ALIGNED(ULONGLONG,
                                               EndOfFile.QuadPart, BLOCK_SIZE);
 
            if (NewSize.QuadPart > OldSize.QuadPart) {
 
                Fcb->Header.AllocationSize = NewSize;
                Status = Ext2ExpandFile(
                                 IrpContext,
                                 Vcb,
                                 Mcb,
                                 &(Fcb->Header.AllocationSize)
                             );
                NotifyFilter = FILE_NOTIFY_CHANGE_SIZE;
                SetLongFlag(Fcb->Flags, FCB_ALLOC_IN_SETINFO);
 
 
            } else if (NewSize.QuadPart == OldSize.QuadPart) {
 
                /* we are luck ;) */
                Status = STATUS_SUCCESS;
 
            } else {
 
                /* don't truncate file data since it's still being written */
                if (IsFlagOn(Fcb->Flags, FCB_ALLOC_IN_WRITE)) {
 
                    Status = STATUS_SUCCESS;
 
                } else {
 
                    if (!MmCanFileBeTruncated(&(Fcb->SectionObject), &NewSize)) {
                        Status = STATUS_USER_MAPPED_FILE;
                        DbgBreak();
                        _SEH2_LEAVE;
                    }
 
                    /* truncate file blocks */
                    Status = Ext2TruncateFile(IrpContext, Vcb, Mcb, &NewSize);
 
                    /* restore original file size */
                    if (NT_SUCCESS(Status)) {
                        ClearLongFlag(Fcb->Flags, FCB_ALLOC_IN_CREATE);
                    }
 
                    /* update file allocateion size */
                    Fcb->Header.AllocationSize.QuadPart = NewSize.QuadPart;
 
                    ASSERT((loff_t)NewSize.QuadPart >= Mcb->Inode.i_size);
                    if ((loff_t)Fcb->Header.FileSize.QuadPart < Mcb->Inode.i_size) {
                        Fcb->Header.FileSize.QuadPart = Mcb->Inode.i_size;
                    }
                    if (Fcb->Header.ValidDataLength.QuadPart > Fcb->Header.FileSize.QuadPart) {
                        Fcb->Header.ValidDataLength.QuadPart = Fcb->Header.FileSize.QuadPart;
                    }
 
                    SetFlag(FileObject->Flags, FO_FILE_MODIFIED);
                    SetLongFlag(Fcb->Flags, FCB_FILE_MODIFIED);
                }
 
                NotifyFilter = FILE_NOTIFY_CHANGE_SIZE;
            }
 
            if (NT_SUCCESS(Status)) {
 
                Fcb->Header.FileSize.QuadPart = Mcb->Inode.i_size = EndOfFile.QuadPart;
                if (CcIsFileCached(FileObject)) {
                    CcSetFileSizes(FileObject, (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));
                }
 
                if (Fcb->Header.FileSize.QuadPart >= 0x80000000 &&
                        !IsFlagOn(SUPER_BLOCK->s_feature_ro_compat, EXT2_FEATURE_RO_COMPAT_LARGE_FILE)) {
                    SetFlag(SUPER_BLOCK->s_feature_ro_compat, EXT2_FEATURE_RO_COMPAT_LARGE_FILE);
                    Ext2SaveSuper(IrpContext, Vcb);
                }
 
                SetFlag(FileObject->Flags, FO_FILE_MODIFIED);
                SetLongFlag(Fcb->Flags, FCB_FILE_MODIFIED);
                NotifyFilter = FILE_NOTIFY_CHANGE_SIZE;
            }
 
 
            Ext2SaveInode( IrpContext, Vcb, &Mcb->Inode);
 
            DEBUG(DL_IO, ("Ext2SetInformation: FileEndOfFileInformation %wZ EndofFile=%I64xh "
                          "AllocatieonSize=%I64xh FileSize=%I64xh VDL=%I64xh i_size=%I64xh status = %xh\n",
                          &Fcb->Mcb->ShortName, EndOfFile.QuadPart, Fcb->Header.AllocationSize.QuadPart,
                          Fcb->Header.FileSize.QuadPart, Fcb->Header.ValidDataLength.QuadPart,
                          Mcb->Inode.i_size, Status));
        }
 
        break;
 
        case FileValidDataLengthInformation:
        {
            PFILE_VALID_DATA_LENGTH_INFORMATION FVDL = (PFILE_VALID_DATA_LENGTH_INFORMATION) Buffer;
            LARGE_INTEGER NewVDL;
 
            if (IsMcbDirectory(Mcb) || IsMcbSpecialFile(Mcb)) {
                Status = STATUS_INVALID_DEVICE_REQUEST;
                _SEH2_LEAVE;
            } else {
                Status = STATUS_SUCCESS;
            }
 
            NewVDL = FVDL->ValidDataLength;
            if ((NewVDL.QuadPart < Fcb->Header.ValidDataLength.QuadPart)) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
            if (NewVDL.QuadPart > Fcb->Header.FileSize.QuadPart)
                NewVDL = Fcb->Header.FileSize;
 
            if (!MmCanFileBeTruncated(FileObject->SectionObjectPointer,
                                      &NewVDL)) {
                Status = STATUS_USER_MAPPED_FILE;
                _SEH2_LEAVE;
            }
 
            Fcb->Header.ValidDataLength = NewVDL;
            FileObject->Flags |= FO_FILE_MODIFIED;
            if (CcIsFileCached(FileObject)) {
                CcSetFileSizes(FileObject, (PCC_FILE_SIZES)(&(Fcb->Header.AllocationSize)));
            }
        }
 
        break;
 
        case FileDispositionInformation:
        {
            PFILE_DISPOSITION_INFORMATION FDI = (PFILE_DISPOSITION_INFORMATION)Buffer;
 
            Status = Ext2SetDispositionInfo(IrpContext, Vcb, Fcb, Ccb, FDI->DeleteFile);
 
            DEBUG(DL_INF, ( "Ext2SetInformation: SetDispositionInformation: DeleteFile=%d %wZ status = %xh\n",
                            FDI->DeleteFile, &Mcb->ShortName, Status));
        }
 
        break;
 
        case FileRenameInformation:
        {
            Status = Ext2SetRenameInfo(IrpContext, Vcb, Fcb, Ccb);
        }
 
        break;
 
 
        case FileLinkInformation:
        {
            Status = Ext2SetLinkInfo(IrpContext, Vcb, Fcb, Ccb);
        }
 
        break;
 
        //
        // This is the only set file information request supported on read
        // only file systems
        //
        case FilePositionInformation:
        {
            PFILE_POSITION_INFORMATION FilePositionInformation;
 
            if (Length < sizeof(FILE_POSITION_INFORMATION)) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            FilePositionInformation = (PFILE_POSITION_INFORMATION) Buffer;
 
            if ((FlagOn(FileObject->Flags, FO_NO_INTERMEDIATE_BUFFERING)) &&
                    (FilePositionInformation->CurrentByteOffset.LowPart &
                     DeviceObject->AlignmentRequirement) ) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            FileObject->CurrentByteOffset =
                FilePositionInformation->CurrentByteOffset;
 
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        break;
 
        default:
            DEBUG(DL_WRN, ( "Ext2SetInformation: invalid class: %d\n",
                            FileInformationClass));
            Status = STATUS_INVALID_PARAMETER;/* STATUS_INVALID_INFO_CLASS; */
        }
 
    } _SEH2_FINALLY {
 
        if (FcbPagingIoResourceAcquired) {
            ExReleaseResourceLite(&Fcb->PagingIoResource);
        }
 
        if (NT_SUCCESS(Status) && (NotifyFilter != 0)) {
            Ext2NotifyReportChange(
                IrpContext,
                Vcb,
                Mcb,
                NotifyFilter,
                FILE_ACTION_MODIFIED );
 
        }
 
        if (FcbMainResourceAcquired) {
            ExReleaseResourceLite(&Fcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            if (Status == STATUS_PENDING ||
                    Status == STATUS_CANT_WAIT ) {
                DbgBreak();
                Status = Ext2QueueRequest(IrpContext);
            } else {
                Ext2CompleteIrpContext(IrpContext,  Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ 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().

◆ Ext2SetLinkInfo()

NTSTATUS Ext2SetLinkInfo	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_FCB	Fcb,
		PEXT2_CCB	Ccb
	)

Definition at line 1665 of file fileinfo.c.

{
    PEXT2_MCB               Mcb = Fcb->Mcb;
 
    PEXT2_FCB               TargetDcb = NULL;   /* Dcb of target directory */
    PEXT2_MCB               TargetMcb = NULL;
    PEXT2_FCB               ParentDcb = NULL;   /* Dcb of it's current parent */
    PEXT2_MCB               ParentMcb = NULL;
 
    PEXT2_FCB               ExistingFcb = NULL; /* Target file Fcb if it exists*/
    PEXT2_MCB               ExistingMcb = NULL;
    PEXT2_MCB               LinkMcb = NULL;     /* Mcb for new hardlink */
 
    UNICODE_STRING          FileName;
 
    NTSTATUS                Status;
 
    PIRP                    Irp;
    PIO_STACK_LOCATION      IrpSp;
 
    PFILE_OBJECT            FileObject;
    PFILE_OBJECT            TargetObject;
 
    BOOLEAN                 ReplaceIfExists;
    BOOLEAN                 bTargetRemoved = FALSE;
 
    BOOLEAN                 bFcbLockAcquired = FALSE;
 
    PFILE_LINK_INFORMATION  FLI;
 
    if (Ccb->SymLink) {
        Mcb = Ccb->SymLink;
    }
 
    if (IsMcbDirectory(Mcb)) {
        Status = STATUS_INVALID_PARAMETER;
        goto errorout;
    }
 
    Irp = IrpContext->Irp;
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    FileObject = IrpSp->FileObject;
    TargetObject = IrpSp->Parameters.SetFile.FileObject;
    ReplaceIfExists = IrpSp->Parameters.SetFile.ReplaceIfExists;
 
    FLI = (PFILE_LINK_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
 
    if (TargetObject == NULL) {
 
        UNICODE_STRING  NewName;
 
        NewName.Buffer = FLI->FileName;
        NewName.MaximumLength = NewName.Length = (USHORT)FLI->FileNameLength;
 
        while (NewName.Length > 0 && NewName.Buffer[NewName.Length/2 - 1] == L'\\') {
            NewName.Buffer[NewName.Length/2 - 1] = 0;
            NewName.Length -= 2;
        }
 
        while (NewName.Length > 0 && NewName.Buffer[NewName.Length/2 - 1] != L'\\') {
            NewName.Length -= 2;
        }
 
        NewName.Buffer = (USHORT *)((UCHAR *)NewName.Buffer + NewName.Length);
        NewName.Length = (USHORT)(FLI->FileNameLength - NewName.Length);
 
        FileName = NewName;
 
        TargetMcb = Mcb->Parent;
        if (IsMcbSymLink(TargetMcb)) {
            TargetMcb = TargetMcb->Target;
            ASSERT(!IsMcbSymLink(TargetMcb));
        }
 
        if (TargetMcb == NULL || FileName.Length >= EXT2_NAME_LEN*2) {
            Status = STATUS_OBJECT_NAME_INVALID;
            goto errorout;
        }
 
    } else {
 
        TargetDcb = (PEXT2_FCB)(TargetObject->FsContext);
        if (!TargetDcb || TargetDcb->Vcb != Vcb) {
            DbgBreak();
            Status = STATUS_INVALID_PARAMETER;
            goto errorout;
        }
 
        TargetMcb = TargetDcb->Mcb;
        FileName = TargetObject->FileName;
    }
 
    if (FsRtlDoesNameContainWildCards(&FileName)) {
        Status = STATUS_OBJECT_NAME_INVALID;
        goto errorout;
    }
 
    if (TargetMcb->Inode.i_ino == Mcb->Parent->Inode.i_ino) {
        if (FsRtlAreNamesEqual( &FileName,
                                &(Mcb->ShortName),
                                FALSE,
                                NULL )) {
            Status = STATUS_SUCCESS;
            goto errorout;
        }
    }
 
    ExAcquireResourceExclusiveLite(&Vcb->FcbLock, TRUE);
    bFcbLockAcquired = TRUE;
 
    TargetDcb = TargetMcb->Fcb;
    if (TargetDcb == NULL) {
        TargetDcb = Ext2AllocateFcb(Vcb, TargetMcb);
    }
    if (TargetDcb) {
        Ext2ReferXcb(&TargetDcb->ReferenceCount);
    }
 
    ParentMcb = Mcb->Parent;
    ParentDcb = ParentMcb->Fcb;
 
    if ((TargetMcb->Inode.i_ino != ParentMcb->Inode.i_ino)) {
 
        if (ParentDcb == NULL) {
            ParentDcb = Ext2AllocateFcb(Vcb, ParentMcb);
        }
    }
    if (ParentDcb) {
        Ext2ReferXcb(&ParentDcb->ReferenceCount);
    }
 
    if (bFcbLockAcquired) {
        ExReleaseResourceLite(&Vcb->FcbLock);
        bFcbLockAcquired = FALSE;
    }
 
    if (!TargetDcb || !ParentDcb) {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto errorout;
    }
 
    DEBUG(DL_RES, ("Ext2SetLinkInfo: %wZ\\%wZ -> %wZ\n",
                   &TargetMcb->FullName, &FileName, &Mcb->FullName));
 
    Status = Ext2LookupFile(IrpContext, Vcb, &FileName,
                            TargetMcb, &ExistingMcb, 0);
    if (NT_SUCCESS(Status) && ExistingMcb != Mcb) {
 
        if (!ReplaceIfExists) {
 
            Status = STATUS_OBJECT_NAME_COLLISION;
            DEBUG(DL_RES, ("Ext2SetRenameInfo: Target file %wZ exists\n",
                           &ExistingMcb->FullName));
            goto errorout;
 
        } else {
 
            if ( (ExistingFcb = ExistingMcb->Fcb) && !IsMcbSymLink(ExistingMcb) ) {
                Status = Ext2IsFileRemovable(IrpContext, Vcb, ExistingFcb, Ccb);
                if (!NT_SUCCESS(Status)) {
                    DEBUG(DL_REN, ("Ext2SetRenameInfo: Target file %wZ cannot be removed.\n",
                                   &ExistingMcb->FullName));
                    goto errorout;
                }
            }
 
            Status = Ext2DeleteFile(IrpContext, Vcb, ExistingFcb, ExistingMcb);
            if (!NT_SUCCESS(Status)) {
                DEBUG(DL_REN, ("Ext2SetRenameInfo: Failed to delete %wZ with status: %xh.\n",
                               &FileName, Status));
 
                goto errorout;
            }
            bTargetRemoved = TRUE;
        }
    }
 
    /* add new entry for new target name */
    Status = Ext2AddEntry(IrpContext, Vcb, TargetDcb, &Mcb->Inode, &FileName, NULL);
    if (!NT_SUCCESS(Status)) {
        DEBUG(DL_REN, ("Ext2SetLinkInfo: Failed to add entry for %wZ with status: %xh.\n",
                       &FileName, Status));
        goto errorout;
    }
 
    if (bTargetRemoved) {
        Ext2NotifyReportChange(
            IrpContext,
            Vcb,
            ExistingMcb,
            (IsMcbDirectory(ExistingMcb) ?
             FILE_NOTIFY_CHANGE_DIR_NAME :
             FILE_NOTIFY_CHANGE_FILE_NAME ),
            FILE_ACTION_REMOVED);
    }
 
    if (NT_SUCCESS(Status)) {
 
        Ext2LookupFile(IrpContext, Vcb, &FileName, TargetMcb, &LinkMcb, 0);
        if (!LinkMcb)
            goto errorout;
 
        Ext2NotifyReportChange(
            IrpContext,
            Vcb,
            LinkMcb,
            FILE_NOTIFY_CHANGE_FILE_NAME,
            FILE_ACTION_ADDED);
    }
 
errorout:
 
    if (bFcbLockAcquired) {
        ExReleaseResourceLite(&Vcb->FcbLock);
        bFcbLockAcquired = FALSE;
    }
 
    if (TargetDcb) {
        Ext2ReleaseFcb(TargetDcb);
    }
 
    if (ParentDcb) {
        Ext2ReleaseFcb(ParentDcb);
    }
 
    if (ExistingMcb)
        Ext2DerefMcb(ExistingMcb);
 
    if (LinkMcb)
        Ext2DerefMcb(LinkMcb);
 
    return Status;
}

Referenced by Ext2SetFileInformation().

◆ 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().

◆ Ext2SetRenameInfo()

NTSTATUS Ext2SetRenameInfo	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_FCB	Fcb,
		PEXT2_CCB	Ccb
	)

Definition at line 1325 of file fileinfo.c.

{
    PEXT2_MCB               Mcb = Fcb->Mcb;
 
    PEXT2_FCB               TargetDcb = NULL;   /* Dcb of target directory */
    PEXT2_MCB               TargetMcb = NULL;
    PEXT2_FCB               ParentDcb = NULL;   /* Dcb of it's current parent */
    PEXT2_MCB               ParentMcb = NULL;
 
    PEXT2_FCB               ExistingFcb = NULL; /* Target file Fcb if it exists*/
    PEXT2_MCB               ExistingMcb = NULL;
 
    UNICODE_STRING          FileName;
 
    NTSTATUS                Status;
 
    PIRP                    Irp;
    PIO_STACK_LOCATION      IrpSp;
 
    PFILE_OBJECT            FileObject;
    PFILE_OBJECT            TargetObject;
 
    struct dentry          *NewEntry = NULL;
 
    BOOLEAN                 ReplaceIfExists;
    BOOLEAN                 bMove = FALSE;
    BOOLEAN                 bTargetRemoved = FALSE;
 
    BOOLEAN                 bFcbLockAcquired = FALSE;
 
    PFILE_RENAME_INFORMATION    FRI;
 
    if (Ccb->SymLink) {
        Mcb = Ccb->SymLink;
    }
 
    if (Mcb->Inode.i_ino == EXT2_ROOT_INO) {
        Status = STATUS_INVALID_PARAMETER;
        goto errorout;
    }
 
    Irp = IrpContext->Irp;
    IrpSp = IoGetCurrentIrpStackLocation(Irp);
 
    FileObject = IrpSp->FileObject;
    TargetObject = IrpSp->Parameters.SetFile.FileObject;
    ReplaceIfExists = IrpSp->Parameters.SetFile.ReplaceIfExists;
 
    FRI = (PFILE_RENAME_INFORMATION)Irp->AssociatedIrp.SystemBuffer;
 
    if (TargetObject == NULL) {
 
        UNICODE_STRING  NewName;
 
        NewName.Buffer = FRI->FileName;
        NewName.MaximumLength = NewName.Length = (USHORT)FRI->FileNameLength;
 
        while (NewName.Length > 0 && NewName.Buffer[NewName.Length/2 - 1] == L'\\') {
            NewName.Buffer[NewName.Length/2 - 1] = 0;
            NewName.Length -= 2;
        }
 
        while (NewName.Length > 0 && NewName.Buffer[NewName.Length/2 - 1] != L'\\') {
            NewName.Length -= 2;
        }
 
        NewName.Buffer = (USHORT *)((UCHAR *)NewName.Buffer + NewName.Length);
        NewName.Length = (USHORT)(FRI->FileNameLength - NewName.Length);
 
        FileName = NewName;
 
        TargetMcb = Mcb->Parent;
        if (IsMcbSymLink(TargetMcb)) {
            TargetMcb = TargetMcb->Target;
            ASSERT(!IsMcbSymLink(TargetMcb));
        }
 
        if (TargetMcb == NULL || FileName.Length >= EXT2_NAME_LEN*2) {
            Status = STATUS_OBJECT_NAME_INVALID;
            goto errorout;
        }
 
    } else {
 
        TargetDcb = (PEXT2_FCB)(TargetObject->FsContext);
 
        if (!TargetDcb || TargetDcb->Vcb != Vcb) {
 
            DbgBreak();
 
            Status = STATUS_INVALID_PARAMETER;
            goto errorout;
        }
 
        TargetMcb = TargetDcb->Mcb;
        FileName = TargetObject->FileName;
    }
 
    if (FsRtlDoesNameContainWildCards(&FileName)) {
        Status = STATUS_OBJECT_NAME_INVALID;
        goto errorout;
    }
 
    if (TargetMcb->Inode.i_ino == Mcb->Parent->Inode.i_ino) {
        if (FsRtlAreNamesEqual( &FileName,
                                &(Mcb->ShortName),
                                FALSE,
                                NULL )) {
            Status = STATUS_SUCCESS;
            goto errorout;
        }
    } else {
        bMove = TRUE;
    }
 
    if (!bFcbLockAcquired) {
        ExAcquireResourceExclusiveLite(&Vcb->FcbLock, TRUE);
        bFcbLockAcquired = TRUE;
    }
 
    TargetDcb = TargetMcb->Fcb;
    if (TargetDcb == NULL) {
        TargetDcb = Ext2AllocateFcb(Vcb, TargetMcb);
    }
    if (TargetDcb) {
        Ext2ReferXcb(&TargetDcb->ReferenceCount);
    }
 
    ParentMcb = Mcb->Parent;
    ParentDcb = ParentMcb->Fcb;
 
    if ((TargetMcb->Inode.i_ino != ParentMcb->Inode.i_ino)) {
 
        if (ParentDcb == NULL) {
            ParentDcb = Ext2AllocateFcb(Vcb, ParentMcb);
        }
    }
    if (ParentDcb) {
        Ext2ReferXcb(&ParentDcb->ReferenceCount);
    }
 
    if (bFcbLockAcquired) {
        ExReleaseResourceLite(&Vcb->FcbLock);
        bFcbLockAcquired = FALSE;
    }
 
    if (!TargetDcb || !ParentDcb) {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto errorout;
    }
 
    DEBUG(DL_RES, ("Ext2SetRenameInfo: rename %wZ to %wZ\\%wZ\n",
                   &Mcb->FullName, &TargetMcb->FullName, &FileName));
 
    Status = Ext2LookupFile(
                 IrpContext,
                 Vcb,
                 &FileName,
                 TargetMcb,
                 &ExistingMcb,
                 0
             );
 
    if (NT_SUCCESS(Status) && ExistingMcb != Mcb) {
 
        if (!ReplaceIfExists) {
 
            Status = STATUS_OBJECT_NAME_COLLISION;
            DEBUG(DL_RES, ("Ext2SetRenameInfo: Target file %wZ exists\n",
                           &ExistingMcb->FullName));
            goto errorout;
 
        } else {
 
            if ( (ExistingFcb = ExistingMcb->Fcb) && !IsMcbSymLink(ExistingMcb) ) {
 
                Status = Ext2IsFileRemovable(IrpContext, Vcb, ExistingFcb, Ccb);
                if (!NT_SUCCESS(Status)) {
                    DEBUG(DL_REN, ("Ext2SetRenameInfo: Target file %wZ cannot be removed.\n",
                                   &ExistingMcb->FullName));
                    goto errorout;
                }
            }
 
            Status = Ext2DeleteFile(IrpContext, Vcb, ExistingFcb, ExistingMcb);
            if (!NT_SUCCESS(Status)) {
                DEBUG(DL_REN, ("Ext2SetRenameInfo: Failed to delete %wZ with status: %xh.\n",
                               &FileName, Status));
 
                goto errorout;
            }
 
            bTargetRemoved = TRUE;
        }
    }
 
    /* remove directory entry of old name */
    Status = Ext2RemoveEntry(IrpContext, Vcb, ParentDcb, Mcb);
    if (!NT_SUCCESS(Status)) {
        DEBUG(DL_REN, ("Ext2SetRenameInfo: Failed to remove entry %wZ with status %xh.\n",
                       &Mcb->FullName, Status));
        DbgBreak();
        goto errorout;
    }
 
    /* add new entry for new target name */
    Status = Ext2AddEntry(IrpContext, Vcb, TargetDcb, &Mcb->Inode, &FileName, &NewEntry);
    if (!NT_SUCCESS(Status)) {
        DEBUG(DL_REN, ("Ext2SetRenameInfo: Failed to add entry for %wZ with status: %xh.\n",
                       &FileName, Status));
        Ext2AddEntry(IrpContext, Vcb, ParentDcb, &Mcb->Inode, &Mcb->ShortName, &NewEntry);
        goto errorout;
    }
 
    /* correct the inode number in ..  entry */
    if (IsMcbDirectory(Mcb)) {
        Status = Ext2SetParentEntry(
                     IrpContext, Vcb, Fcb,
                     ParentMcb->Inode.i_ino,
                     TargetMcb->Inode.i_ino );
        if (!NT_SUCCESS(Status)) {
            DEBUG(DL_REN, ("Ext2SetRenameInfo: Failed to set parent refer of %wZ with %xh.\n",
                           &Mcb->FullName, Status));
            DbgBreak();
            goto errorout;
        }
    }
 
    /* Update current dentry from the newly created one. We need keep the original
       dentry to assure children's links are valid if current entry is a directory */
    if (Mcb->de) {
        char *np = Mcb->de->d_name.name;
        *(Mcb->de) = *NewEntry;
        NewEntry->d_name.name = np;
    }
 
    if (bTargetRemoved) {
        Ext2NotifyReportChange(
            IrpContext,
            Vcb,
            ExistingMcb,
            (IsMcbDirectory(ExistingMcb) ?
             FILE_NOTIFY_CHANGE_DIR_NAME :
             FILE_NOTIFY_CHANGE_FILE_NAME ),
            FILE_ACTION_REMOVED);
    }
 
    if (NT_SUCCESS(Status)) {
 
        if (bMove) {
            Ext2NotifyReportChange(
                IrpContext,
                Vcb,
                Mcb,
                (IsDirectory(Fcb) ?
                 FILE_NOTIFY_CHANGE_DIR_NAME :
                 FILE_NOTIFY_CHANGE_FILE_NAME ),
                FILE_ACTION_REMOVED);
 
        } else {
            Ext2NotifyReportChange(
                IrpContext,
                Vcb,
                Mcb,
                (IsDirectory(Fcb) ?
                 FILE_NOTIFY_CHANGE_DIR_NAME :
                 FILE_NOTIFY_CHANGE_FILE_NAME ),
                FILE_ACTION_RENAMED_OLD_NAME);
 
        }
 
        if (TargetMcb->Inode.i_ino != ParentMcb->Inode.i_ino) {
            Ext2RemoveMcb(Vcb, Mcb);
            Ext2InsertMcb(Vcb, TargetMcb, Mcb);
        }
 
        if (!Ext2BuildName( &Mcb->ShortName,
                            &FileName, NULL     )) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto errorout;
        }
 
        if (!Ext2BuildName( &Mcb->FullName,
                            &FileName,
                            &TargetMcb->FullName)) {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto errorout;
        }
 
        if (bMove) {
            Ext2NotifyReportChange(
                IrpContext,
                Vcb,
                Mcb,
                (IsDirectory(Fcb) ?
                 FILE_NOTIFY_CHANGE_DIR_NAME :
                 FILE_NOTIFY_CHANGE_FILE_NAME ),
                FILE_ACTION_ADDED);
        } else {
            Ext2NotifyReportChange(
                IrpContext,
                Vcb,
                Mcb,
                (IsDirectory(Fcb) ?
                 FILE_NOTIFY_CHANGE_DIR_NAME :
                 FILE_NOTIFY_CHANGE_FILE_NAME ),
                FILE_ACTION_RENAMED_NEW_NAME  );
        }
    }
 
errorout:
 
    if (bFcbLockAcquired) {
        ExReleaseResourceLite(&Vcb->FcbLock);
        bFcbLockAcquired = FALSE;
    }
 
    if (NewEntry)
        Ext2FreeEntry(NewEntry);
 
    if (TargetDcb) {
        Ext2ReleaseFcb(TargetDcb);
    }
 
    if (ParentDcb) {
        Ext2ReleaseFcb(ParentDcb);
    }
 
    if (ExistingMcb)
        Ext2DerefMcb(ExistingMcb);
 
    return Status;
}

Referenced by Ext2SetFileInformation().

◆ Ext2SetVolumeInformation()

NTSTATUS Ext2SetVolumeInformation ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 292 of file volinfo.c.

{
    PDEVICE_OBJECT          DeviceObject;
    NTSTATUS                Status = STATUS_UNSUCCESSFUL;
    PEXT2_VCB               Vcb = NULL;
    PIRP                    Irp;
    PIO_STACK_LOCATION      IoStackLocation;
    FS_INFORMATION_CLASS    FsInformationClass;
    BOOLEAN                 VcbResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
 
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
        ASSERT(IsMounted(Vcb));
 
        if (IsVcbReadOnly(Vcb)) {
            Status = STATUS_MEDIA_WRITE_PROTECTED;
            _SEH2_LEAVE;
        }
 
        if (!ExAcquireResourceExclusiveLite(
                    &Vcb->MainResource, TRUE)) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
        VcbResourceAcquired = TRUE;
 
        Ext2VerifyVcb(IrpContext, Vcb);
 
        Irp = IrpContext->Irp;
        IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
 
        //Notes: SetVolume is not defined in ntddk.h of win2k ddk,
        //       But it's same to QueryVolume ....
        FsInformationClass =
            IoStackLocation->Parameters./*SetVolume*/QueryVolume.FsInformationClass;
 
        switch (FsInformationClass) {
 
        case FileFsLabelInformation:
        {
            PFILE_FS_LABEL_INFORMATION      VolLabelInfo = NULL;
            ULONG                           VolLabelLen;
            UNICODE_STRING                  LabelName  ;
 
            OEM_STRING                      OemName;
 
            VolLabelInfo = (PFILE_FS_LABEL_INFORMATION) Irp->AssociatedIrp.SystemBuffer;
            VolLabelLen = VolLabelInfo->VolumeLabelLength;
 
            if (VolLabelLen > (16 * sizeof(WCHAR))) {
                Status = STATUS_INVALID_VOLUME_LABEL;
                _SEH2_LEAVE;
            }
 
            RtlCopyMemory( Vcb->Vpb->VolumeLabel,
                           VolLabelInfo->VolumeLabel,
                           VolLabelLen );
 
            RtlZeroMemory(Vcb->SuperBlock->s_volume_name, 16);
            LabelName.Buffer = VolLabelInfo->VolumeLabel;
            LabelName.MaximumLength = (USHORT)16 * sizeof(WCHAR);
            LabelName.Length = (USHORT)VolLabelLen;
 
            OemName.Buffer = SUPER_BLOCK->s_volume_name;
            OemName.Length  = 0;
            OemName.MaximumLength = 16;
 
            Ext2UnicodeToOEM(Vcb, &OemName, &LabelName);
            Vcb->Vpb->VolumeLabelLength = (USHORT) VolLabelLen;
 
            if (Ext2SaveSuper(IrpContext, Vcb)) {
                Status = STATUS_SUCCESS;
            }
 
            Irp->IoStatus.Information = 0;
        }
        break;
 
        default:
            Status = STATUS_INVALID_INFO_CLASS;
        }
 
    } _SEH2_FINALLY {
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            if (Status == STATUS_PENDING) {
                Ext2QueueRequest(IrpContext);
            } else {
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2SetVpbFlag()

VOID Ext2SetVpbFlag	(	IN PVPB	Vpb,
		IN USHORT	Flag
	)

Definition at line 44 of file fsctl.c.

{
    KIRQL OldIrql;
 
    IoAcquireVpbSpinLock(&OldIrql);
    Vpb->Flags |= Flag;
    IoReleaseVpbSpinLock(OldIrql);
}

Referenced by Ext2LockVcb().

◆ Ext2ShutDown()

NTSTATUS Ext2ShutDown ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 25 of file shutdown.c.

{
    NTSTATUS                Status;
 
    PIRP                    Irp;
 
    PEXT2_VCB               Vcb;
    PLIST_ENTRY             ListEntry;
 
    BOOLEAN                 GlobalResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        Status = STATUS_SUCCESS;
 
        ASSERT(IrpContext);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        Irp = IrpContext->Irp;
 
        if (!ExAcquireResourceExclusiveLite(
                    &Ext2Global->Resource,
                    IsFlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT) )) {
            Status = STATUS_PENDING;
            _SEH2_LEAVE;
        }
 
        GlobalResourceAcquired = TRUE;
 
        for (ListEntry = Ext2Global->VcbList.Flink;
                ListEntry != &(Ext2Global->VcbList);
                ListEntry = ListEntry->Flink ) {
 
            Vcb = CONTAINING_RECORD(ListEntry, EXT2_VCB, Next);
 
            if (ExAcquireResourceExclusiveLite(
                        &Vcb->MainResource,
                        TRUE )) {
 
                if (IsMounted(Vcb)) {
 
                    /* update mount count */
                    Vcb->SuperBlock->s_mnt_count++;
                    if (Vcb->SuperBlock->s_mnt_count >
                            Vcb->SuperBlock->s_max_mnt_count ) {
                        Vcb->SuperBlock->s_mnt_count =
                            Vcb->SuperBlock->s_max_mnt_count;
                    }
                    Ext2SaveSuper(IrpContext, Vcb);
 
                    /* flush dirty cache for all files */
                    Status = Ext2FlushFiles(IrpContext, Vcb, TRUE);
                    if (!NT_SUCCESS(Status)) {
                        DbgBreak();
                    }
 
                    /* flush volume stream's cache to disk */
                    Status = Ext2FlushVolume(IrpContext, Vcb, TRUE);
 
                    if (!NT_SUCCESS(Status) && Status != STATUS_MEDIA_WRITE_PROTECTED) {
                        DbgBreak();
                    }
 
                    /* send shutdown request to underlying disk */
                    Ext2DiskShutDown(Vcb);
                }
 
                ExReleaseResourceLite(&Vcb->MainResource);
            }
        }
 
        /*
                IoUnregisterFileSystem(Ext2Global->DiskdevObject);
                IoUnregisterFileSystem(Ext2Global->CdromdevObject);
        */
 
    } _SEH2_FINALLY {
 
        if (GlobalResourceAcquired) {
            ExReleaseResourceLite(&Ext2Global->Resource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            if (Status == STATUS_PENDING) {
                Ext2QueueRequest(IrpContext);
            } else {
                Ext2CompleteIrpContext(IrpContext, Status);
            }
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2Sleep()

VOID Ext2Sleep ( ULONG ms )

Definition at line 297 of file misc.c.

{
    LARGE_INTEGER Timeout;
    Timeout.QuadPart = (LONGLONG)ms*1000*(-10); /* ms/1000 sec*/
    KeDelayExecutionThread(KernelMode, TRUE, &Timeout);
}

Referenced by Ext2AddMcbExtent(), Ext2AddMcbMetaExts(), Ext2AddVcbExtent(), Ext2ExpandBlock(), Ext2ExpandLast(), Ext2GetBlock(), Ext2QueueCloseRequest(), Ext2RemoveMcbExtent(), Ext2RemoveMcbMetaExts(), Ext2RemoveVcbExtent(), Ext2TruncateBlock(), get_block_bh_mdl(), and get_block_bh_pin().

◆ Ext2StartFloppyFlushDpc()

VOID Ext2StartFloppyFlushDpc	(	PEXT2_VCB	Vcb,
		PEXT2_FCB	Fcb,
		PFILE_OBJECT	FileObject
	)

Definition at line 139 of file write.c.

{
    LARGE_INTEGER          OneSecond;
    PEXT2_FLPFLUSH_CONTEXT Context;
 
    ASSERT(IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK));
 
    Context = Ext2AllocatePool(
                  NonPagedPool,
                  sizeof(EXT2_FLPFLUSH_CONTEXT),
                  EXT2_FLPFLUSH_MAGIC
              );
 
    if (!Context) {
        DEBUG(DL_ERR, ( "Ex2StartFloppy...: failed to allocate Context\n"));
        DbgBreak();
        return;
    }
 
    KeInitializeTimer(&Context->Timer);
 
    KeInitializeDpc( &Context->Dpc,
                     Ext2FloppyFlushDpc,
                     Context );
 
    ExInitializeWorkItem( &Context->Item,
                          Ext2FloppyFlush,
                          Context );
 
    Context->Vcb = Vcb;
    Context->Fcb = Fcb;
    Context->FileObject = FileObject;
 
    if (FileObject) {
        ObReferenceObject(FileObject);
    }
 
    OneSecond.QuadPart = (LONGLONG)-1*1000*1000*10;
    KeSetTimer( &Context->Timer,
                OneSecond,
                &Context->Dpc );
}

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

◆ Ext2StartReaper()

NTSTATUS Ext2StartReaper	(	PEXT2_REAPER	Reaper,
		EXT2_REAPER_RELEASE	Free
	)

Definition at line 3478 of file memory.c.

{
    NTSTATUS status = STATUS_SUCCESS;
    OBJECT_ATTRIBUTES  oa;
    HANDLE   handle = 0;
    LARGE_INTEGER timeout;
 
    Reaper->Free = Free;
 
    /* initialize wait event */
    KeInitializeEvent(
        &Reaper->Wait,
        SynchronizationEvent, FALSE
    );
 
    /* Reaper thread engine event */
    KeInitializeEvent(
        &Reaper->Engine,
        SynchronizationEvent, FALSE
    );
 
    /* initialize oa */
    InitializeObjectAttributes(
        &oa,
        NULL,
        OBJ_CASE_INSENSITIVE |
        OBJ_KERNEL_HANDLE,
        NULL,
        NULL
    );
 
    /* start a new system thread */
    status = PsCreateSystemThread(
                 &handle,
                 0,
                 &oa,
                 NULL,
                 NULL,
                 Free,
                 (PVOID)Reaper
             );
 
    if (NT_SUCCESS(status)) {
        ZwClose(handle);
 
        /* make sure Reaperthread is started */
        timeout.QuadPart = (LONGLONG)-10*1000*1000*2; /* 2 seconds */
        status = KeWaitForSingleObject(
                     &Reaper->Engine,
                     Executive,
                     KernelMode,
                     FALSE,
                     &timeout
                 );
        if (status != STATUS_SUCCESS) {
            status = STATUS_INSUFFICIENT_RESOURCES;
        }
    }
 
    return status;
}

Referenced by DriverEntry().

◆ Ext2StopReaper()

VOID Ext2StopReaper ( PEXT2_REAPER Reaper )

Definition at line 3546 of file memory.c.

{
    LARGE_INTEGER timeout;
 
    Reaper->Flags |= EXT2_REAPER_FLAG_STOP;
    KeSetEvent(&Reaper->Wait, 0, FALSE);
 
    /* make sure Reaperthread is started */
    timeout.QuadPart = (LONGLONG)-10*1000*1000*2; /* 2 seconds */
    KeWaitForSingleObject(
                     &Reaper->Engine,
                     Executive,
                     KernelMode,
                     FALSE,
                     &timeout);
}

Referenced by DriverEntry().

◆ Ext2SupersedeOrOverWriteFile()

NTSTATUS Ext2SupersedeOrOverWriteFile	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PFILE_OBJECT	FileObject,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_FCB	Fcb,
		IN PLARGE_INTEGER	AllocationSize,
		IN ULONG	Disposition
	)

Definition at line 2137 of file create.c.

{
    LARGE_INTEGER   CurrentTime;
    LARGE_INTEGER   Size;
 
    KeQuerySystemTime(&CurrentTime);
 
    Size.QuadPart = 0;
    if (!MmCanFileBeTruncated(&(Fcb->SectionObject), &(Size))) {
        return STATUS_USER_MAPPED_FILE;
    }
 
    /* purge all file cache and shrink cache windows size */
    CcPurgeCacheSection(&Fcb->SectionObject, NULL, 0, FALSE);
    Fcb->Header.AllocationSize.QuadPart =
        Fcb->Header.FileSize.QuadPart =
            Fcb->Header.ValidDataLength.QuadPart = 0;
    CcSetFileSizes(FileObject,
                   (PCC_FILE_SIZES)&Fcb->Header.AllocationSize);
 
    Size.QuadPart = CEILING_ALIGNED(ULONGLONG,
                                    (ULONGLONG)AllocationSize->QuadPart,
                                    (ULONGLONG)BLOCK_SIZE);
 
    if ((loff_t)Size.QuadPart > Fcb->Inode->i_size) {
        Ext2ExpandFile(IrpContext, Vcb, Fcb->Mcb, &Size);
    } else {
        Ext2TruncateFile(IrpContext, Vcb, Fcb->Mcb, &Size);
    }
 
    Fcb->Header.AllocationSize = Size;
    if (Fcb->Header.AllocationSize.QuadPart > 0) {
        SetLongFlag(Fcb->Flags, FCB_ALLOC_IN_CREATE);
        CcSetFileSizes(FileObject,
                       (PCC_FILE_SIZES)&Fcb->Header.AllocationSize );
    }
 
    /* remove all extent mappings */
    DEBUG(DL_EXT, ("Ext2SuperSede ...: %wZ\n", &Fcb->Mcb->FullName));
    Fcb->Inode->i_size = 0;
 
    if (Disposition == FILE_SUPERSEDE) {
        Fcb->Inode->i_ctime = Ext2LinuxTime(CurrentTime);
    }
    Fcb->Inode->i_atime =
        Fcb->Inode->i_mtime = Ext2LinuxTime(CurrentTime);
    Ext2SaveInode(IrpContext, Vcb, Fcb->Inode);
 
    // See if we need to overwrite EA of the file
    return Ext2OverwriteEa(IrpContext, Vcb, Fcb, &IrpContext->Irp->IoStatus);
}

Referenced by Ext2CreateFile().

◆ Ext2SyncUninitializeCacheMap()

VOID Ext2SyncUninitializeCacheMap ( IN PFILE_OBJECT FileObject )

Definition at line 2883 of file memory.c.

{
    CACHE_UNINITIALIZE_EVENT UninitializeCompleteEvent;
    NTSTATUS WaitStatus;
    LARGE_INTEGER Ext2LargeZero = {0,0};
 
 
    KeInitializeEvent( &UninitializeCompleteEvent.Event,
                       SynchronizationEvent,
                       FALSE);
 
    CcUninitializeCacheMap( FileObject,
                            &Ext2LargeZero,
                            &UninitializeCompleteEvent );
 
    WaitStatus = KeWaitForSingleObject( &UninitializeCompleteEvent.Event,
                                        Executive,
                                        KernelMode,
                                        FALSE,
                                        NULL);
 
    ASSERT (NT_SUCCESS(WaitStatus));
}

Referenced by Ext2InitializeVcb(), and Ext2TearDownStream().

◆ Ext2TearDownStream()

VOID Ext2TearDownStream ( IN PEXT2_VCB Vcb )

Definition at line 2798 of file memory.c.

{
    PFILE_OBJECT    Stream = Vcb->Volume;
    IO_STATUS_BLOCK IoStatus;
 
    ASSERT(Vcb != NULL);
    ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
           (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
    if (Stream) {
 
        Vcb->Volume = NULL;
 
        if (IsFlagOn(Stream->Flags, FO_FILE_MODIFIED)) {
            CcFlushCache(&(Vcb->SectionObject), NULL, 0, &IoStatus);
            ClearFlag(Stream->Flags, FO_FILE_MODIFIED);
        }
 
        if (Stream->PrivateCacheMap) {
            Ext2SyncUninitializeCacheMap(Stream);
        }
 
        ObDereferenceObject(Stream);
    }
}

Referenced by Ext2CheckDismount(), and Ext2DestroyVcb().

◆ Ext2TotalBlocks()

ULONG Ext2TotalBlocks	(	PEXT2_VCB	Vcb,
		PLARGE_INTEGER	Size,
		PULONG	pMeta
	)

Definition at line 1077 of file fileinfo.c.

{
    ULONG Blocks, Meta =0, Remain;
 
    Blocks = (ULONG)((Size->QuadPart + BLOCK_SIZE - 1) >> BLOCK_BITS);
    if (Blocks <= EXT2_NDIR_BLOCKS)
        goto errorout;
    Blocks -= EXT2_NDIR_BLOCKS;
 
    Meta += 1;
    if (Blocks <= Vcb->max_blocks_per_layer[1]) {
        goto errorout;
    }
    Blocks -= Vcb->max_blocks_per_layer[1];
 
level2:
 
    if (Blocks <= Vcb->max_blocks_per_layer[2]) {
        Meta += 1 + ((Blocks + BLOCK_SIZE/4 - 1) >> (BLOCK_BITS - 2));
        goto errorout;
    }
    Meta += 1 + BLOCK_SIZE/4;
    Blocks -= Vcb->max_blocks_per_layer[2];
 
    if (Blocks > Vcb->max_blocks_per_layer[3]) {
        Blocks  = Vcb->max_blocks_per_layer[3];
    }
 
    ASSERT(Vcb->max_blocks_per_layer[2]);
    Remain = Blocks % Vcb->max_blocks_per_layer[2];
    Blocks = Blocks / Vcb->max_blocks_per_layer[2];
    Meta += 1 + Blocks * (1 + BLOCK_SIZE/4);
    if (Remain) {
        Blocks = Remain;
        goto level2;
    }
 
errorout:
 
    if (pMeta)
        *pMeta = Meta;
    Blocks = (ULONG)((Size->QuadPart + BLOCK_SIZE - 1) >> BLOCK_BITS);
    return (Blocks + Meta);
}

Referenced by Ext2CreateFile().

◆ Ext2TraceIrpContext()

__inline VOID Ext2TraceIrpContext	(	BOOLEAN	_n,
		PEXT2_IRP_CONTEXT	IrpContext
	)

Definition at line 1174 of file ext2fs.h.

{
    if (_n) {
        INC_MEM_COUNT(PS_IRP_CONTEXT, IrpContext, sizeof(EXT2_IRP_CONTEXT));
        InterlockedIncrement(&(Ext2Global->PerfStat.Irps[IrpContext->MajorFunction].Current));
    } else {
        DEC_MEM_COUNT(PS_IRP_CONTEXT, IrpContext, sizeof(EXT2_IRP_CONTEXT));
        InterlockedIncrement(&Ext2Global->PerfStat.Irps[IrpContext->MajorFunction].Processed);
        InterlockedDecrement(&Ext2Global->PerfStat.Irps[IrpContext->MajorFunction].Current);
    }
}

◆ Ext2TraceMemory()

__inline VOID Ext2TraceMemory	(	BOOLEAN	_n,
		int	_i,
		PVOID	_p,
		LONG	_s
	)

Definition at line 1157 of file ext2fs.h.

{
    if (_n) {
        InterlockedIncrement(&Ext2Global->PerfStat.Current.Slot[_i]);
        InterlockedIncrement(&Ext2Global->PerfStat.Total.Slot[_i]);
        InterlockedExchangeAdd(&Ext2Global->PerfStat.Size.Slot[_i], _s);
    } else {
        InterlockedDecrement(&Ext2Global->PerfStat.Current.Slot[_i]);
        InterlockedExchangeAdd(&Ext2Global->PerfStat.Size.Slot[_i], -1 * _s);
    }
}

◆ Ext2TruncateBlock()

NTSTATUS Ext2TruncateBlock	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONG	Base,
		IN ULONG	Start,
		IN ULONG	Layer,
		IN ULONG	SizeArray,
		IN PULONG	BlockArray,
		IN PULONG	Extra
	)

Definition at line 632 of file indirect.c.

{
    NTSTATUS    Status = STATUS_SUCCESS;
    ULONG       i = 0;
    ULONG       Slot = 0;
    ULONG       Skip = 0;
 
    LONGLONG    Offset;
    PBCB        Bcb = NULL;
    PULONG      pData = NULL;
 
    ASSERT(Mcb != NULL);
 
    for (i = 0; i < SizeArray; i++) {
 
        if (Layer == 0) {
 
            ULONG   Number = 1;
 
            while (Extra &&  SizeArray > i + 1 && Number < *Extra) {
 
                if (BlockArray[SizeArray - i - 1] ==
                    BlockArray[SizeArray - i - 2] + 1) {
 
                    BlockArray[SizeArray - i - 1] = 0;
                    Number++;
                    SizeArray--;
 
                } else {
                    break;
                }
            }
 
            if (BlockArray[SizeArray - i - 1]) {
 
                Status = Ext2FreeBlock(IrpContext, Vcb, BlockArray[SizeArray - i - 1], Number);
                if (NT_SUCCESS(Status)) {
                    ASSERT(Mcb->Inode.i_blocks >= (Number << (BLOCK_BITS - 9)));
                    if (Mcb->Inode.i_blocks < (Number << (BLOCK_BITS - 9))) {
                        Mcb->Inode.i_blocks = 0;
                        DbgBreak();
                    } else {
                        Mcb->Inode.i_blocks -= (Number << (BLOCK_BITS - 9));
                    }
                    BlockArray[SizeArray - i - 1] = 0;
                }
            }
 
            if (Extra) {
 
                /* dec blocks count */
                ASSERT(*Extra >= Number);
                *Extra = *Extra - Number;
 
                /* remove block mapping frm Mcb Extents */
                if (!Ext2RemoveBlockExtent(Vcb, Mcb, Base + SizeArray - 1 - i, Number)) {
                    DbgBreak();
                    ClearFlag(Mcb->Flags, MCB_ZONE_INITED);
                    Ext2ClearAllExtents(&Mcb->Extents);
                }
            }
 
        } else {
 
            ASSERT(Layer <= 3);
 
            if (BlockArray[SizeArray - i - 1] >= TOTAL_BLOCKS) {
                DbgBreak();
                BlockArray[SizeArray - i - 1] = 0;
            }
 
            if (i == 0) {
                if (Layer > 1) {
                    Slot  = Start / Vcb->max_blocks_per_layer[Layer - 1];
                    Start = Start % Vcb->max_blocks_per_layer[Layer - 1];
                } else {
                    Slot  = Start;
                    Start = (BLOCK_SIZE / 4) - 1;
                }
            } else {
                Slot = Start = (BLOCK_SIZE / 4) - 1;
            }
 
            Skip = (SizeArray - i - 1) * Vcb->max_blocks_per_layer[Layer];
 
            if (BlockArray[SizeArray - i - 1]) {
 
                Offset = (LONGLONG) (BlockArray[SizeArray - i - 1]);
                Offset = Offset << BLOCK_BITS;
 
                if (!CcPinRead( Vcb->Volume,
                                (PLARGE_INTEGER) (&Offset),
                                BLOCK_SIZE,
                                PIN_WAIT,
                                &Bcb,
#ifdef __REACTOS__
                                (void **)&pData )) {
#else
                                &pData )) {
#endif
 
                    DEBUG(DL_ERR, ( "Ext2TruncateBlock: PinLock failed on block %xh ...\n",
                                    BlockArray[SizeArray - i - 1]));
                    Status = STATUS_CANT_WAIT;
                    DbgBreak();
                    goto errorout;
                }
 
                Status = Ext2TruncateBlock(
                             IrpContext,
                             Vcb,
                             Mcb,
                             Base + Skip,
                             Start,
                             Layer - 1,
                             Slot + 1,
                             &pData[0],
                             Extra
                         );
 
                if (!NT_SUCCESS(Status)) {
                    break;
                }
 
                CcSetDirtyPinnedData(Bcb, NULL);
                Ext2AddVcbExtent(Vcb, Offset, (LONGLONG)BLOCK_SIZE);
 
                if (*Extra || Ext2IsBlockEmpty(pData, BLOCK_SIZE/4)) {
 
                    Ext2TruncateBlock(
                                 IrpContext,
                                 Vcb,
                                 Mcb,
                                 Base + Skip,    /* base */
                                 0,              /* start */
                                 0,              /* layer */
                                 1,
                                 &BlockArray[SizeArray - i - 1],
                                 NULL
                             );
 
                    if (!Ext2RemoveMcbMetaExts(Vcb, Mcb, BlockArray[SizeArray - i - 1], 1)) {
                        DbgBreak();
                        Ext2Sleep(500);
                        Ext2RemoveMcbMetaExts(Vcb, Mcb, BlockArray[SizeArray - i - 1], 1);
                    }
                }
 
                if (pData) {
                    CcUnpinData(Bcb);
                    Bcb = NULL;
                    pData = NULL;
                }
 
            } else {
 
                if (Layer > 1) {
                    if (*Extra > Slot * Vcb->max_blocks_per_layer[Layer - 1] + Start + 1) {
                        *Extra -= (Slot * Vcb->max_blocks_per_layer[Layer - 1] + Start + 1);
                    } else {
                        *Extra  = 0;
                    }
                } else {
                    if (*Extra > Slot + 1) {
                        *Extra -= (Slot + 1);
                    } else {
                        *Extra  = 0;
                    }
                }
 
                if (!Ext2RemoveBlockExtent(Vcb, Mcb, Base + Skip, (Start + 1))) {
                    DbgBreak();
                    ClearFlag(Mcb->Flags, MCB_ZONE_INITED);
                    Ext2ClearAllExtents(&Mcb->Extents);
                }
            }
        }
 
        if (Extra && *Extra == 0) {
            break;
        }
    }
 
errorout:
 
    if (pData) {
        CcUnpinData(Bcb);
    }
 
    return Status;
}

Referenced by Ext2TruncateBlock(), and Ext2TruncateIndirect().

◆ Ext2TruncateExtent()

NTSTATUS Ext2TruncateExtent	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb,
		PLARGE_INTEGER	Size
	)

Definition at line 200 of file extents.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    ULONG    Extra = 0;
    ULONG    Wanted = 0;
    ULONG    End;
    ULONG    Removed;
    int      err;
 
    /* translate file size to block */
    End = Vcb->max_data_blocks;
    Wanted = (ULONG)((Size->QuadPart + BLOCK_SIZE - 1) >> BLOCK_BITS);
 
    /* calculate blocks to be freed */
    Extra = End - Wanted;
 
    err = ext4_ext_truncate(IrpContext, &Mcb->Inode, Wanted);
    if (err == 0) {
        if (!Ext2RemoveBlockExtent(Vcb, Mcb, Wanted, Extra)) {
            ClearFlag(Mcb->Flags, MCB_ZONE_INITED);
            Ext2ClearAllExtents(&Mcb->Extents);
        }
        Extra = 0;
    } else {
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }
 
    if (!NT_SUCCESS(Status)) {
        Size->QuadPart += ((ULONGLONG)Extra << BLOCK_BITS);
    }
 
    if (Mcb->Inode.i_size > (loff_t)(Size->QuadPart))
        Mcb->Inode.i_size = (loff_t)(Size->QuadPart);
 
    /* Save modifications on i_blocks field and i_size field of the inode. */
    Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
 
    return Status;
}

Referenced by Ext2TruncateFile().

◆ Ext2TruncateFile()

NTSTATUS Ext2TruncateFile	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb,
		PLARGE_INTEGER	AllocationSize
	)

Definition at line 1204 of file fileinfo.c.

{
    NTSTATUS status = STATUS_SUCCESS;
 
    if (INODE_HAS_EXTENT(&Mcb->Inode)) {
        status = Ext2TruncateExtent(IrpContext, Vcb, Mcb, Size);
    } else {
        status = Ext2TruncateIndirect(IrpContext, Vcb, Mcb, Size);
    }
 
    /* check and clear data/meta mcb extents */
    if (Size->QuadPart == 0) {
 
        /* check and remove all data extents */
        if (Ext2ListExtents(&Mcb->Extents)) {
            DbgBreak();
        }
        Ext2ClearAllExtents(&Mcb->Extents);
        /* check and remove all meta extents */
        if (Ext2ListExtents(&Mcb->MetaExts)) {
            DbgBreak();
        }
        Ext2ClearAllExtents(&Mcb->MetaExts);
        ClearLongFlag(Mcb->Flags, MCB_ZONE_INITED);
    }
 
    return status;
}

Referenced by Ext2Cleanup(), Ext2CreateFile(), Ext2DeleteFile(), Ext2SetFileInformation(), Ext2SetReparsePoint(), Ext2SupersedeOrOverWriteFile(), Ext2TruncateSymlink(), and Ext2WriteSymlink().

◆ Ext2TruncateIndirect()

NTSTATUS Ext2TruncateIndirect	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb,
		PLARGE_INTEGER	Size
	)

Definition at line 1099 of file indirect.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
 
    ULONG    Layer = 0;
 
    ULONG    Extra = 0;
    ULONG    Wanted = 0;
    ULONG    End;
    ULONG    Base;
 
    ULONG    SizeArray = 0;
    PULONG   BlockArray = NULL;
 
    /* translate file size to block */
    End = Base = Vcb->max_data_blocks;
    Wanted = (ULONG)((Size->QuadPart + BLOCK_SIZE - 1) >> BLOCK_BITS);
 
    /* do fast deletion here */
    if (Wanted == 0) {
        Status = Ext2TruncateIndirectFast(IrpContext, Vcb, Mcb);
        if (NT_SUCCESS(Status))
            goto errorout;
    }
 
    /* calculate blocks to be freed */
    Extra = End - Wanted;
 
    for (Layer = EXT2_BLOCK_TYPES; Layer > 0 && Extra; Layer--) {
 
        if (Vcb->max_blocks_per_layer[Layer - 1] == 0) {
            continue;
        }
 
        Base -= Vcb->max_blocks_per_layer[Layer - 1];
 
        if (Layer - 1 == 0) {
#ifdef __REACTOS__
            BlockArray = (PULONG)&Mcb->Inode.i_block[0];
#else
            BlockArray = &Mcb->Inode.i_block[0];
#endif
            SizeArray = End;
            ASSERT(End == EXT2_NDIR_BLOCKS && Base == 0);
        } else {
#ifdef __REACTOS__
            BlockArray = (PULONG)&Mcb->Inode.i_block[EXT2_NDIR_BLOCKS - 1 + Layer - 1];
#else
            BlockArray = &Mcb->Inode.i_block[EXT2_NDIR_BLOCKS - 1 + Layer - 1];
#endif
            SizeArray = 1;
        }
 
        Status = Ext2TruncateBlock(
                     IrpContext,
                     Vcb,
                     Mcb,
                     Base,
                     End - Base - 1,
                     Layer - 1,
                     SizeArray,
                     BlockArray,
                     &Extra
                 );
        if (!NT_SUCCESS(Status)) {
            break;
        }
 
        End = Base;
    }
 
errorout:
 
    if (!NT_SUCCESS(Status)) {
        Size->QuadPart += ((ULONGLONG)Extra << BLOCK_BITS);
    }
 
    /* save inode */
    if (Mcb->Inode.i_size > (loff_t)(Size->QuadPart))
        Mcb->Inode.i_size = (loff_t)(Size->QuadPart);
    Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
 
    return Status;
}

Referenced by Ext2TruncateFile().

◆ Ext2TruncateSymlink()

NTSTATUS Ext2TruncateSymlink	(	PEXT2_IRP_CONTEXT	IrpContext,
		PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb,
		ULONG	Size
	)

Definition at line 1751 of file fsctl.c.

{
    NTSTATUS status = STATUS_SUCCESS;
    PUCHAR   data = (PUCHAR)&Mcb->Inode.i_block;
    ULONG    len = (ULONG)Mcb->Inode.i_size;
    LARGE_INTEGER NewSize;
 
    if (len < EXT2_LINKLEN_IN_INODE && !Mcb->Inode.i_blocks) {
 
        RtlZeroMemory(data + Size, EXT2_LINKLEN_IN_INODE - Size);
        Mcb->Inode.i_size = Size;
        Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
 
    } else {
        NewSize.QuadPart = Size;
        status = Ext2TruncateFile(IrpContext, Vcb, Mcb, &NewSize);
        if (!NT_SUCCESS(status)) {
            goto out;
        }
    }
 
out:
    return status;
}

Referenced by Ext2DeleteReparsePoint().

◆ Ext2UnicodeToOEM()

NTSTATUS Ext2UnicodeToOEM	(	IN PEXT2_VCB	Vcb,
		IN OUT POEM_STRING	Oem,
		IN PUNICODE_STRING	Unicode
	)

Definition at line 261 of file misc.c.

{
    NTSTATUS Status;
 
    if (Vcb->Codepage.PageTable) {
 
        Status = Ext2UnicodeToMbs(Vcb->Codepage.PageTable,
                                  Oem, Unicode);
        if (Status > 0 && Status == Oem->Length) {
            Status = STATUS_SUCCESS;
        } else {
            Status = STATUS_UNSUCCESSFUL;
            DbgBreak();
        }
 
        goto errorout;
    }
 
    Status = RtlUnicodeStringToOemString(
                 Oem, Unicode, FALSE );
 
    if (!NT_SUCCESS(Status))
    {
        DbgBreak();
        goto errorout;
    }
 
errorout:
 
    return Status;
}

Referenced by Ext2BuildEntry(), Ext2SetReparsePoint(), and Ext2SetVolumeInformation().

◆ Ext2UnicodeToOEMSize()

ULONG Ext2UnicodeToOEMSize	(	IN PEXT2_VCB	Vcb,
		IN PUNICODE_STRING	Unicode
	)

Definition at line 239 of file misc.c.

{
    ULONG   Length = 0;
 
    if (Vcb->Codepage.PageTable) {
        Length = Ext2UnicodeToMbs(Vcb->Codepage.PageTable,
                                  NULL, Unicode);
        if (Length > 0) {
            return Length;
        }
 
        DbgBreak();
    }
 
    return RtlxUnicodeStringToOemSize(Unicode);
}

Referenced by Ext2BuildEntry(), and Ext2SetReparsePoint().

◆ Ext2UnlinkFcb()

VOID Ext2UnlinkFcb ( IN PEXT2_FCB Fcb )

Definition at line 202 of file memory.c.

{
    PEXT2_VCB  Vcb = Fcb->Vcb;
    PEXT2_MCB  Mcb;
 
    ExAcquireResourceExclusiveLite(&Vcb->McbLock, TRUE);
    Mcb = Fcb->Mcb;
 
    DEBUG(DL_INF, ("Ext2FreeFcb: Fcb (%p) to be unlinked: %wZ.\n",
                    Fcb, Mcb ? &Mcb->FullName : NULL));
 
    if ((Mcb != NULL) &&
        (Mcb->Identifier.Type == EXT2MCB) &&
        (Mcb->Identifier.Size == sizeof(EXT2_MCB))) {
 
        ASSERT (Mcb->Fcb == Fcb);
        if (IsMcbSpecialFile(Mcb) ||
            IsFileDeleted(Mcb)) {
 
            ASSERT(!IsRoot(Fcb));
            Ext2RemoveMcb(Vcb, Mcb);
            Mcb->Fcb = NULL;
 
            Ext2UnlinkMcb(Vcb, Mcb);
            Ext2DerefMcb(Mcb);
            Ext2LinkHeadMcb(Vcb, Mcb);
 
        } else {
            Mcb->Fcb = NULL;
            Ext2DerefMcb(Mcb);
        }
        Fcb->Mcb = NULL;
    }
 
    ExReleaseResourceLite(&Vcb->McbLock);
}

Referenced by Ext2QueryUnusedFcb().

◆ Ext2UnlinkMcb()

VOID Ext2UnlinkMcb	(	PEXT2_VCB	Vcb,
		PEXT2_MCB	Mcb
	)

Definition at line 2957 of file memory.c.

{
    if (Mcb->Inode.i_ino == EXT2_ROOT_INO) {
        return;
    }
 
    ExAcquireResourceExclusiveLite(&Vcb->McbLock, TRUE);
 
    if (IsFlagOn(Mcb->Flags, MCB_VCB_LINK)) {
        RemoveEntryList(&(Mcb->Link));
        ClearLongFlag(Mcb->Flags, MCB_VCB_LINK);
        Ext2DerefXcb(&Vcb->NumOfMcb);
    } else {
        DEBUG(DL_RES, ( "Ext2UnlinkMcb: %wZ already unlinked.\n",
                        &Mcb->FullName));
    }
    ExReleaseResourceLite(&Vcb->McbLock);
}

Referenced by Ext2FreeCcb(), and Ext2UnlinkFcb().

◆ Ext2UnloadAllNls()

VOID Ext2UnloadAllNls ( )

Definition at line 181 of file nls.c.

{
 
#ifdef FULL_CODEPAGES_SUPPORT
 
    UNLOAD_NLS(init_nls_ascii);
    UNLOAD_NLS(init_nls_cp1250);
    UNLOAD_NLS(exit_nls_cp1251);
    UNLOAD_NLS(exit_nls_cp1255);
    UNLOAD_NLS(exit_nls_cp437);
    UNLOAD_NLS(exit_nls_cp737);
    UNLOAD_NLS(exit_nls_cp775);
    UNLOAD_NLS(exit_nls_cp850);
    UNLOAD_NLS(exit_nls_cp852);
    UNLOAD_NLS(exit_nls_cp855);
    UNLOAD_NLS(exit_nls_cp857);
    UNLOAD_NLS(exit_nls_cp860);
    UNLOAD_NLS(exit_nls_cp861);
    UNLOAD_NLS(exit_nls_cp862);
    UNLOAD_NLS(exit_nls_cp863);
    UNLOAD_NLS(exit_nls_cp864);
    UNLOAD_NLS(exit_nls_cp865);
    UNLOAD_NLS(exit_nls_cp866);
    UNLOAD_NLS(exit_nls_cp869);
    UNLOAD_NLS(exit_nls_cp874);
    UNLOAD_NLS(exit_nls_euc_jp);
    UNLOAD_NLS(exit_nls_cp932);
    UNLOAD_NLS(exit_nls_cp949);
    UNLOAD_NLS(exit_nls_iso8859_1);
    UNLOAD_NLS(exit_nls_iso8859_13);
    UNLOAD_NLS(exit_nls_iso8859_14);
    UNLOAD_NLS(exit_nls_iso8859_15);
    UNLOAD_NLS(exit_nls_iso8859_2);
    UNLOAD_NLS(exit_nls_iso8859_3);
    UNLOAD_NLS(exit_nls_iso8859_4);
    UNLOAD_NLS(exit_nls_iso8859_5);
    UNLOAD_NLS(exit_nls_iso8859_6);
    UNLOAD_NLS(exit_nls_iso8859_7);
    UNLOAD_NLS(exit_nls_iso8859_9);
    UNLOAD_NLS(exit_nls_koi8_ru);
    UNLOAD_NLS(exit_nls_koi8_r);
    UNLOAD_NLS(exit_nls_koi8_u);
 
    /* unloading chinese codepages */
    UNLOAD_NLS(exit_nls_cp950);
    UNLOAD_NLS(exit_nls_cp936);
 
#endif //FULL_CODEPAGES_SUPPORT
 
    /* unloading nls of utf8  */
    UNLOAD_NLS(exit_nls_utf8);
}

◆ Ext2UnlockVcb()

NTSTATUS Ext2UnlockVcb	(	IN PEXT2_VCB	Vcb,
		IN PFILE_OBJECT	FileObject
	)

Definition at line 206 of file fsctl.c.

{
    NTSTATUS        Status;
 
    _SEH2_TRY {
 
        if (FileObject && FileObject->FsContext != Vcb) {
            Status = STATUS_NOT_LOCKED;
            _SEH2_LEAVE;
        }
 
        if (!FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED)) {
            DEBUG(DL_ERR, ( ": Ext2UnlockVcb: Volume is not locked.\n"));
            Status = STATUS_NOT_LOCKED;
            _SEH2_LEAVE;
        }
 
        if (Vcb->LockFile == FileObject) {
            ClearFlag(Vcb->Flags, VCB_VOLUME_LOCKED);
            Ext2ClearVpbFlag(Vcb->Vpb, VPB_LOCKED);
            DEBUG(DL_INF, ( "Ext2UnlockVcb: Volume unlocked.\n"));
            Status = STATUS_SUCCESS;
        } else {
            Status = STATUS_NOT_LOCKED;
        }
 
    } _SEH2_FINALLY {
        // Nothing
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2UnlockVolume().

◆ Ext2UnlockVolume()

NTSTATUS Ext2UnlockVolume ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 241 of file fsctl.c.

{
    PIO_STACK_LOCATION IrpSp = NULL;
    PDEVICE_OBJECT  DeviceObject = NULL;
    PEXT2_VCB       Vcb = NULL;
    NTSTATUS        Status;
    BOOLEAN         VcbResourceAcquired = FALSE;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
        IrpSp = IoGetCurrentIrpStackLocation(IrpContext->Irp);
 
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_PARAMETER;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        ExAcquireResourceExclusiveLite(
            &Vcb->MainResource,
            TRUE );
        VcbResourceAcquired = TRUE;
 
        Status = Ext2UnlockVcb(Vcb, IrpSp->FileObject);
 
    } _SEH2_FINALLY {
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            Ext2CompleteIrpContext(IrpContext,  Status);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2UserFsRequest().

◆ 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().

◆ Ext2UserFsRequest()

NTSTATUS Ext2UserFsRequest ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 1903 of file fsctl.c.

{
    PIRP                Irp;
    PIO_STACK_LOCATION  IoStackLocation;
    ULONG               FsControlCode;
    NTSTATUS            Status;
 
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    Irp = IrpContext->Irp;
    IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
 
#ifndef _GNU_NTIFS_
    FsControlCode =
        IoStackLocation->Parameters.FileSystemControl.FsControlCode;
#else
    FsControlCode = ((PEXTENDED_IO_STACK_LOCATION)
                     IoStackLocation)->Parameters.FileSystemControl.FsControlCode;
#endif
 
    switch (FsControlCode) {
 
    case FSCTL_GET_REPARSE_POINT:
        Status = Ext2GetReparsePoint(IrpContext);
        break;
 
    case FSCTL_SET_REPARSE_POINT:
        Status = Ext2SetReparsePoint(IrpContext);
        break;
 
    case FSCTL_DELETE_REPARSE_POINT:
        Status = Ext2DeleteReparsePoint(IrpContext);
        break;
 
    case FSCTL_LOCK_VOLUME:
        Status = Ext2LockVolume(IrpContext);
        break;
 
    case FSCTL_UNLOCK_VOLUME:
        Status = Ext2UnlockVolume(IrpContext);
        break;
 
    case FSCTL_DISMOUNT_VOLUME:
        Status = Ext2DismountVolume(IrpContext);
        break;
 
    case FSCTL_IS_VOLUME_MOUNTED:
        Status = Ext2IsVolumeMounted(IrpContext);
        break;
 
    case FSCTL_INVALIDATE_VOLUMES:
        Status = Ext2InvalidateVolumes(IrpContext);
        break;
 
#if (_WIN32_WINNT >= 0x0500)
    case FSCTL_ALLOW_EXTENDED_DASD_IO:
        Status = Ext2AllowExtendedDasdIo(IrpContext);
        break;
#endif //(_WIN32_WINNT >= 0x0500)
 
    case FSCTL_REQUEST_OPLOCK_LEVEL_1:
    case FSCTL_REQUEST_OPLOCK_LEVEL_2:
    case FSCTL_REQUEST_BATCH_OPLOCK:
    case FSCTL_OPLOCK_BREAK_ACKNOWLEDGE:
    case FSCTL_OPBATCH_ACK_CLOSE_PENDING:
    case FSCTL_OPLOCK_BREAK_NOTIFY:
    case FSCTL_OPLOCK_BREAK_ACK_NO_2:
 
        Status = Ext2OplockRequest(IrpContext);
        break;
 
    case FSCTL_IS_VOLUME_DIRTY:
        Status = Ext2IsVolumeDirty(IrpContext);
        break;
 
    case FSCTL_QUERY_RETRIEVAL_POINTERS:
        Status = Ext2QueryRetrievalPointers(IrpContext);
        break;
 
    case FSCTL_GET_RETRIEVAL_POINTERS:
        Status = Ext2GetRetrievalPointers(IrpContext);
        break;
 
    case FSCTL_GET_RETRIEVAL_POINTER_BASE:
        Status = Ext2GetRetrievalPointerBase(IrpContext);
        break;
 
    default:
 
        DEBUG(DL_INF, ( "Ext2UserFsRequest: Invalid User Request: %xh.\n", FsControlCode));
        Status = STATUS_INVALID_DEVICE_REQUEST;
 
        Ext2CompleteIrpContext(IrpContext,  Status);
    }
 
    return Status;
}

Referenced by Ext2FileSystemControl().

◆ Ext2VerifyVcb()

VOID Ext2VerifyVcb	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb
	)

Definition at line 2277 of file fsctl.c.

{
    NTSTATUS                Status = STATUS_SUCCESS;
 
    BOOLEAN                 bVerify = FALSE;
    ULONG                   ChangeCount = 0;
    ULONG                   dwBytes;
 
    PIRP                    Irp;
    PEXTENDED_IO_STACK_LOCATION      IrpSp;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
 
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        Irp = IrpContext->Irp;
        IrpSp = (PEXTENDED_IO_STACK_LOCATION)IoGetCurrentIrpStackLocation(Irp);
 
        bVerify = IsFlagOn(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
 
        if ( (IsFlagOn(Vcb->Flags, VCB_REMOVABLE_MEDIA) ||
                IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK)) && !bVerify ) {
 
            dwBytes = sizeof(ULONG);
            Status = Ext2DiskIoControl(
                         Vcb->TargetDeviceObject,
                         IOCTL_DISK_CHECK_VERIFY,
                         NULL,
                         0,
                         &ChangeCount,
                         &dwBytes );
 
            if ( STATUS_VERIFY_REQUIRED == Status ||
                    STATUS_DEVICE_NOT_READY == Status ||
                    STATUS_NO_MEDIA_IN_DEVICE == Status ||
                    (NT_SUCCESS(Status) &&
                     (ChangeCount != Vcb->ChangeCount))) {
 
                KIRQL Irql;
 
                IoAcquireVpbSpinLock(&Irql);
                if (Vcb->Vpb == Vcb->Vpb->RealDevice->Vpb) {
                    SetFlag(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
                }
                IoReleaseVpbSpinLock(Irql);
 
            } else {
 
                if (!NT_SUCCESS(Status)) {
                    Ext2NormalizeAndRaiseStatus(IrpContext, Status);
                }
            }
        }
 
        if ( IsFlagOn(Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME)) {
            IoSetHardErrorOrVerifyDevice( Irp, Vcb->Vpb->RealDevice );
            Ext2NormalizeAndRaiseStatus ( IrpContext,
                                          STATUS_VERIFY_REQUIRED );
        }
 
        if (IsMounted(Vcb)) {
 
            if ( (IrpContext->MajorFunction == IRP_MJ_WRITE) ||
                    (IrpContext->MajorFunction == IRP_MJ_SET_INFORMATION) ||
                    (IrpContext->MajorFunction == IRP_MJ_SET_EA) ||
                    (IrpContext->MajorFunction == IRP_MJ_FLUSH_BUFFERS) ||
                    (IrpContext->MajorFunction == IRP_MJ_SET_VOLUME_INFORMATION) ||
                    (IrpContext->MajorFunction == IRP_MJ_FILE_SYSTEM_CONTROL &&
                     IrpContext->MinorFunction == IRP_MN_USER_FS_REQUEST &&
                     IrpSp->Parameters.FileSystemControl.FsControlCode ==
                     FSCTL_MARK_VOLUME_DIRTY)) {
 
                if (IsFlagOn(Vcb->Flags, VCB_WRITE_PROTECTED)) {
 
                    KIRQL Irql;
 
                    IoAcquireVpbSpinLock(&Irql);
                    if (Vcb->Vpb == Vcb->Vpb->RealDevice->Vpb) {
                        SetFlag (Vcb->Vpb->RealDevice->Flags, DO_VERIFY_VOLUME);
                    }
                    IoReleaseVpbSpinLock(Irql);
 
                    IoSetHardErrorOrVerifyDevice( Irp, Vcb->Vpb->RealDevice );
 
                    Ext2RaiseStatus(IrpContext, STATUS_MEDIA_WRITE_PROTECTED);
                }
            }
        }
 
    } _SEH2_FINALLY {
 
    } _SEH2_END;
 
}

Referenced by Ext2Create(), Ext2Flush(), Ext2IsVolumeMounted(), and Ext2SetVolumeInformation().

◆ Ext2VerifyVolume()

NTSTATUS Ext2VerifyVolume ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 2378 of file fsctl.c.

{
    PDEVICE_OBJECT          DeviceObject;
    NTSTATUS                Status = STATUS_UNSUCCESSFUL;
    PEXT2_SUPER_BLOCK       ext2_sb = NULL;
    PEXT2_VCB               Vcb = NULL;
    BOOLEAN                 VcbResourceAcquired = FALSE;
    PIRP                    Irp;
    ULONG                   ChangeCount = 0;
    ULONG                   dwBytes;
 
    _SEH2_TRY {
 
        ASSERT(IrpContext != NULL);
        ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
               (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
        DeviceObject = IrpContext->DeviceObject;
        //
        // This request is not allowed on the main device object
        //
        if (IsExt2FsDevice(DeviceObject)) {
            Status = STATUS_INVALID_DEVICE_REQUEST;
            _SEH2_LEAVE;
        }
 
        Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
        ASSERT(Vcb != NULL);
        ASSERT((Vcb->Identifier.Type == EXT2VCB) &&
               (Vcb->Identifier.Size == sizeof(EXT2_VCB)));
 
        VcbResourceAcquired =
            ExAcquireResourceExclusiveLite(
                &Vcb->MainResource,
                TRUE );
 
        if (!FlagOn(Vcb->TargetDeviceObject->Flags, DO_VERIFY_VOLUME)) {
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        if (!IsMounted(Vcb)) {
            Status = STATUS_WRONG_VOLUME;
            _SEH2_LEAVE;
        }
 
        dwBytes = sizeof(ULONG);
        Status = Ext2DiskIoControl(
                     Vcb->TargetDeviceObject,
                     IOCTL_DISK_CHECK_VERIFY,
                     NULL,
                     0,
                     &ChangeCount,
                     &dwBytes );
 
 
        if (!NT_SUCCESS(Status)) {
            Status = STATUS_WRONG_VOLUME;
            _SEH2_LEAVE;
        } else {
            Vcb->ChangeCount = ChangeCount;
        }
 
        Irp = IrpContext->Irp;
 
        Status = Ext2LoadSuper(Vcb, TRUE, &ext2_sb);
 
        if (!NT_SUCCESS(Status)) {
            _SEH2_LEAVE;
        }
 
        ASSERT(NULL != ext2_sb);
        if ((ext2_sb->s_magic == EXT2_SUPER_MAGIC) &&
                (memcmp(ext2_sb->s_uuid, SUPER_BLOCK->s_uuid, 16) == 0) &&
                (memcmp(ext2_sb->s_volume_name, SUPER_BLOCK->s_volume_name, 16) ==0)) {
 
            ClearFlag(Vcb->TargetDeviceObject->Flags, DO_VERIFY_VOLUME);
 
            if (Ext2IsMediaWriteProtected(IrpContext, Vcb->TargetDeviceObject)) {
                SetLongFlag(Vcb->Flags, VCB_WRITE_PROTECTED);
            } else {
                ClearLongFlag(Vcb->Flags, VCB_WRITE_PROTECTED);
            }
 
            DEBUG(DL_INF, ( "Ext2VerifyVolume: Volume verify succeeded.\n"));
 
        } else {
 
            Status = STATUS_WRONG_VOLUME;
            Ext2PurgeVolume(Vcb, FALSE);
 
            SetLongFlag(Vcb->Flags, VCB_DISMOUNT_PENDING);
            ClearFlag(Vcb->TargetDeviceObject->Flags, DO_VERIFY_VOLUME);
 
            DEBUG(DL_INF, ( "Ext2VerifyVolume: Volume verify failed.\n"));
        }
 
    } _SEH2_FINALLY {
 
        if (ext2_sb)
            Ext2FreePool(ext2_sb, EXT2_SB_MAGIC);
 
        if (VcbResourceAcquired) {
            ExReleaseResourceLite(&Vcb->MainResource);
        }
 
        if (!IrpContext->ExceptionInProgress) {
            Ext2CompleteIrpContext(IrpContext,  Status);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2FileSystemControl().

◆ Ext2WinntError()

NTSTATUS Ext2WinntError ( int rc )

Definition at line 410 of file misc.c.

{
    switch (rc) {
 
    case 0:
        return STATUS_SUCCESS;
 
    case -EPERM:
    case -EACCES:
        return STATUS_ACCESS_DENIED;
 
    case -ENOENT:
        return  STATUS_OBJECT_NAME_NOT_FOUND;
 
    case -EFAULT:
        return STATUS_ACCESS_VIOLATION;
 
    case -ETOOSMALL:
        return STATUS_BUFFER_TOO_SMALL;
 
    case -EBADMSG:
    case -EBADF:
    case -EINVAL:
    case -EFBIG:
        return STATUS_INVALID_PARAMETER;
 
    case -EBUSY:
        return STATUS_DEVICE_BUSY;
 
    case -ENOSYS:
        return STATUS_NOT_IMPLEMENTED;
 
    case -ENOSPC:
        return STATUS_DISK_FULL;
 
    case -EOPNOTSUPP:
        return STATUS_NOT_SUPPORTED;
 
    case -EDEADLK:
        return STATUS_POSSIBLE_DEADLOCK;
 
    case -EEXIST:
        return STATUS_OBJECT_NAME_COLLISION;
 
    case -EIO:
        return STATUS_UNEXPECTED_IO_ERROR;
 
    case -ENOTDIR:
        return STATUS_NOT_A_DIRECTORY;
 
    case -EISDIR:
        return STATUS_FILE_IS_A_DIRECTORY;
 
    case -ENOTEMPTY:
        return STATUS_DIRECTORY_NOT_EMPTY;
 
    case -ENODEV:
        return STATUS_NO_SUCH_DEVICE;
 
    case -ENXIO:
        return STATUS_INVALID_ADDRESS;
 
    case -EADDRNOTAVAIL:
        return STATUS_INVALID_ADDRESS;
 
    case -ENETDOWN:
        return STATUS_UNEXPECTED_NETWORK_ERROR;
 
    case -ENETUNREACH:
        return STATUS_NETWORK_UNREACHABLE;
 
    case -ECONNABORTED:
        return STATUS_CONNECTION_ABORTED;
 
    case -ECONNRESET:
        return STATUS_CONNECTION_RESET;
 
    case -ENOMEM:
        return STATUS_INSUFFICIENT_RESOURCES;
 
    case -ENOBUFS:
        return STATUS_NO_MEMORY;
 
    case -ENOTCONN:
        return STATUS_INVALID_CONNECTION;
 
    case -ESHUTDOWN:
        return STATUS_CONNECTION_DISCONNECTED;
 
    case -ETIMEDOUT:
        return STATUS_TIMEOUT;
 
    case -ECONNREFUSED:
        return STATUS_CONNECTION_REFUSED;
 
    case -EHOSTUNREACH:
        return STATUS_HOST_UNREACHABLE;
 
    case -EAGAIN:
        return STATUS_CANT_WAIT;
 
    case -EINTR:
        return  STATUS_CANCELLED;
 
    case -EMSGSIZE:
        return STATUS_INVALID_BUFFER_SIZE;
 
    case -EADDRINUSE:
        return STATUS_ADDRESS_ALREADY_EXISTS;
    }
 
    return STATUS_UNSUCCESSFUL;
}

Referenced by Ext2AddDotEntries(), Ext2AddEntry(), Ext2DoExtentExpand(), Ext2FreeInode(), Ext2MapExtent(), Ext2NewBlock(), Ext2NewInode(), Ext2OverwriteEa(), Ext2QueryEa(), Ext2QueryFileInformation(), Ext2RemoveEntry(), and Ext2SetEa().

◆ Ext2Write()

NTSTATUS Ext2Write ( IN PEXT2_IRP_CONTEXT IrpContext )

Definition at line 1355 of file write.c.

{
    NTSTATUS            Status;
    PEXT2_FCBVCB        FcbOrVcb;
    PDEVICE_OBJECT      DeviceObject;
    PFILE_OBJECT        FileObject;
    PEXT2_VCB           Vcb;
    BOOLEAN             bCompleteRequest = TRUE;
 
    ASSERT(IrpContext);
 
    ASSERT((IrpContext->Identifier.Type == EXT2ICX) &&
           (IrpContext->Identifier.Size == sizeof(EXT2_IRP_CONTEXT)));
 
    _SEH2_TRY {
 
        if (IsFlagOn(IrpContext->MinorFunction, IRP_MN_COMPLETE)) {
 
            Status =  Ext2WriteComplete(IrpContext);
            bCompleteRequest = FALSE;
 
        } else {
 
            DeviceObject = IrpContext->DeviceObject;
            if (IsExt2FsDevice(DeviceObject)) {
                Status = STATUS_INVALID_DEVICE_REQUEST;
                _SEH2_LEAVE;
            }
            FileObject = IrpContext->FileObject;
 
            Vcb = (PEXT2_VCB) DeviceObject->DeviceExtension;
 
            if (Vcb->Identifier.Type != EXT2VCB ||
                    Vcb->Identifier.Size != sizeof(EXT2_VCB) ) {
                Status = STATUS_INVALID_PARAMETER;
                _SEH2_LEAVE;
            }
 
            if (IsVcbReadOnly(Vcb)) {
                Status = STATUS_MEDIA_WRITE_PROTECTED;
                _SEH2_LEAVE;
            }
 
            if (FlagOn(Vcb->Flags, VCB_VOLUME_LOCKED) &&
                Vcb->LockFile != FileObject ) {
                Status = STATUS_ACCESS_DENIED;
                _SEH2_LEAVE;
            }
 
            FcbOrVcb = (PEXT2_FCBVCB) FileObject->FsContext;
 
            if (FcbOrVcb->Identifier.Type == EXT2VCB) {
 
                Status = Ext2WriteVolume(IrpContext);
                if (!NT_SUCCESS(Status)) {
                    DbgBreak();
                }
                bCompleteRequest = FALSE;
 
            } else if (FcbOrVcb->Identifier.Type == EXT2FCB) {
 
                if (IsFlagOn(Vcb->Flags, VCB_DISMOUNT_PENDING)) {
                    Status = STATUS_TOO_LATE;
                    _SEH2_LEAVE;
                }
 
                Status = Ext2WriteFile(IrpContext);
                if (!NT_SUCCESS(Status)) {
                    DbgBreak();
                }
 
                bCompleteRequest = FALSE;
            } else {
                Status = STATUS_INVALID_PARAMETER;
            }
        }
 
    } _SEH2_FINALLY {
 
        if (bCompleteRequest) {
            Ext2CompleteIrpContext(IrpContext, Status);
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2DispatchRequest().

◆ Ext2WriteInode()

NTSTATUS Ext2WriteInode	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN ULONGLONG	Offset,
		IN PVOID	Buffer,
		IN ULONG	Size,
		IN BOOLEAN	bDirectIo,
		OUT PULONG	dwReturn
	)

Definition at line 668 of file write.c.

{
    PEXT2_EXTENT    Chain = NULL;
    NTSTATUS        Status = STATUS_UNSUCCESSFUL;
 
    _SEH2_TRY {
 
        if (BytesWritten) {
            *BytesWritten = 0;
        }
 
        Status = Ext2BuildExtents (
                     IrpContext,
                     Vcb,
                     Mcb,
                     Offset,
                     Size,
                     S_ISDIR(Mcb->Inode.i_mode) ? FALSE : TRUE,
                     &Chain
                 );
 
        if (!NT_SUCCESS(Status)) {
            _SEH2_LEAVE;
        }
 
        if (Chain == NULL) {
            Status = STATUS_SUCCESS;
            _SEH2_LEAVE;
        }
 
        if (bDirectIo) {
 
            ASSERT(IrpContext != NULL);
 
            //
            // We assume the offset is aligned.
            //
 
            Status = Ext2ReadWriteBlocks(
                         IrpContext,
                         Vcb,
                         Chain,
                         Size
                     );
 
        } else {
 
            PEXT2_EXTENT Extent;
            for (Extent = Chain; Extent != NULL; Extent = Extent->Next) {
 
                if ( !Ext2SaveBuffer(
                            IrpContext,
                            Vcb,
                            Extent->Lba,
                            Extent->Length,
                            (PVOID)((PUCHAR)Buffer + Extent->Offset)
                        )) {
                    _SEH2_LEAVE;
                }
            }
 
            if (IsFlagOn(Vcb->Flags, VCB_FLOPPY_DISK)) {
 
                DEBUG(DL_FLP, ("Ext2WriteInode is starting FlushingDpc...\n"));
                Ext2StartFloppyFlushDpc(Vcb, NULL, NULL);
            }
 
            Status = STATUS_SUCCESS;
        }
 
    } _SEH2_FINALLY {
 
        if (Chain) {
            Ext2DestroyExtentChain(Chain);
        }
 
        if (NT_SUCCESS(Status) && BytesWritten) {
            *BytesWritten = Size;
        }
    } _SEH2_END;
 
    return Status;
}

Referenced by Ext2SetParentEntry(), Ext2WriteFile(), and Ext2WriteSymlink().

◆ Ext2WriteSymlink()

NTSTATUS Ext2WriteSymlink	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PEXT2_MCB	Mcb,
		IN PVOID	Buffer,
		IN ULONG	Size,
		OUT PULONG	BytesWritten
	)

Definition at line 1519 of file fsctl.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    PUCHAR   Data = (PUCHAR)(&Mcb->Inode.i_block[0]);
 
    if (Size >= EXT2_LINKLEN_IN_INODE) {
 
        /* initialize inode i_block[] */
        if (0 == Mcb->Inode.i_blocks) {
            memset(Data, 0, EXT2_LINKLEN_IN_INODE);
            ClearFlag(Mcb->Inode.i_flags, EXT4_EXTENTS_FL);
            Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
        }
 
        Status = Ext2WriteInode(IrpContext, Vcb, Mcb,
                                0, Buffer, Size,
                                FALSE, BytesWritten);
        if (!NT_SUCCESS(Status)) {
            goto out;
        }
 
    } else {
 
        /* free inode blocks before writing in line */
        if (Mcb->Inode.i_blocks) {
            LARGE_INTEGER Zero = {0, 0};
            Ext2TruncateFile(IrpContext, Vcb, Mcb, &Zero);
        }
 
        ClearFlag(Mcb->Inode.i_flags, EXT4_EXTENTS_FL);
        memset(Data, 0, EXT2_LINKLEN_IN_INODE);
        RtlCopyMemory(Data, Buffer, Size);
    }
 
    Mcb->Inode.i_size = Size;
    Ext2SaveInode(IrpContext, Vcb, &Mcb->Inode);
 
    if (BytesWritten) {
        *BytesWritten = Size;
    }
 
out:
    return Status;
}

Referenced by Ext2SetReparsePoint().

◆ 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().

◆ Ext2ZeroData()

BOOLEAN Ext2ZeroData	(	IN PEXT2_IRP_CONTEXT	IrpContext,
		IN PEXT2_VCB	Vcb,
		IN PFILE_OBJECT	FileObject,
		IN PLARGE_INTEGER	Start,
		IN PLARGE_INTEGER	End
	)

Definition at line 186 of file write.c.

{
    PEXT2_FCB       Fcb;
    PBCB            Bcb;
    PVOID           Ptr;
    ULONG           Size;
    BOOLEAN         rc = TRUE;
 
    ASSERT (End && Start && End->QuadPart > Start->QuadPart);
    Fcb = (PEXT2_FCB) FileObject->FsContext;
 
    /* skip data zero if we've already tracked unwritten part */
    if (0 == (  End->LowPart & (BLOCK_SIZE -1)) &&
        0 == (Start->LowPart & (BLOCK_SIZE -1))) {
 
        if (INODE_HAS_EXTENT(Fcb->Inode)) {
            return TRUE;
        } else {
#if !EXT2_PRE_ALLOCATION_SUPPORT
            return TRUE;
#endif
        }
    }
 
    /* clear data in range [Start, End) */
    _SEH2_TRY {
        rc = CcZeroData(FileObject, Start, End, Ext2CanIWait());
    } _SEH2_EXCEPT (EXCEPTION_EXECUTE_HANDLER) {
        DbgBreak();
    } _SEH2_END;
 
    return rc;
}

Referenced by Ext2WriteFile().

◆ ext3_add_entry()

int ext3_add_entry	(	struct ext2_icb *	icb,
		struct dentry *	dentry,
		struct inode *	inode
	)

Definition at line 1946 of file htree.c.

{
    struct inode *dir = dentry->d_parent->d_inode;
    struct buffer_head *bh;
    struct ext3_dir_entry_2 *de;
    struct super_block *sb;
    int retval;
#ifdef EXT2_HTREE_INDEX
    int dx_fallback=0;
#endif
    unsigned blocksize;
    ext3_lblk_t block, blocks;
 
    sb = dir->i_sb;
    blocksize = sb->s_blocksize;
    if (!dentry->d_name.len)
        return -EINVAL;
 
#ifdef EXT2_HTREE_INDEX
    if (is_dx(dir)) {
        retval = ext3_dx_add_entry(icb, dentry, inode);
        if (!retval || (retval != ERR_BAD_DX_DIR))
            return retval;
        EXT3_I(dir)->i_flags &= ~EXT3_INDEX_FL;
        dx_fallback++;
        ext3_save_inode(icb, dir);
    }
#endif
 
    blocks = (ext3_lblk_t)(dir->i_size >> sb->s_blocksize_bits);
    for (block = 0; block < blocks; block++) {
        bh = ext3_bread(icb, dir, block, &retval);
        if (!bh)
            return retval;
        retval = add_dirent_to_buf(icb, dentry, inode, NULL, bh);
        if (retval != -ENOSPC)
            return retval;
 
#ifdef EXT2_HTREE_INDEX
        if (blocks == 1 && !dx_fallback &&
                EXT3_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_DIR_INDEX))
            return make_indexed_dir(icb, dentry, inode, bh);
#endif
 
        brelse(bh);
    }
    bh = ext3_append(icb, dir, &block, &retval);
    if (!bh)
        return retval;
    de = (struct ext3_dir_entry_2 *) bh->b_data;
    de->inode = 0;
    de->rec_len = ext3_rec_len_to_disk(blocksize);
    return add_dirent_to_buf(icb, dentry, inode, de, bh);
}

Referenced by Ext2AddEntry().

◆ ext3_append()

struct buffer_head * ext3_append	(	struct ext2_icb *	icb,
		struct inode *	inode,
		ext3_lblk_t *	block,
		int *	err
	)

Definition at line 279 of file htree.c.

{
    PEXT2_MCB   mcb = CONTAINING_RECORD(inode, EXT2_MCB, Inode);
    PEXT2_FCB   dcb = mcb->Fcb;
    NTSTATUS    status;
 
    ASSERT(dcb);
    ASSERT(inode == dcb->Inode);
 
    /* allocate new block since there's no space for us */
    *block = (ext3_lblk_t)(inode->i_size >> inode->i_sb->s_blocksize_bits);
    dcb->Header.AllocationSize.QuadPart += dcb->Vcb->BlockSize;
    status = Ext2ExpandFile(icb, dcb->Vcb, mcb, &(dcb->Header.AllocationSize));
    if (NT_SUCCESS(status)) {
 
        /* update Dcb */
        dcb->Header.ValidDataLength = dcb->Header.FileSize = dcb->Header.AllocationSize;
        mcb->Inode.i_size = dcb->Header.AllocationSize.QuadPart;
 
        /* save parent directory's inode */
        Ext2SaveInode(icb, dcb->Vcb, inode);
    }
 
    return ext3_bread(icb, inode, *block, err);
}

Referenced by Ext2AddDotEntries(), and ext3_add_entry().

◆ 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_blocks_count()

static ext3_fsblk_t ext3_blocks_count ( struct ext3_super_block * es )

inlinestatic

Definition at line 1745 of file ext2fs.h.

{
    return ((ext3_fsblk_t)le32_to_cpu(es->s_blocks_count_hi) << 32) |
           le32_to_cpu(es->s_blocks_count);
}

Referenced by Ext2InitializeVcb(), Ext2QueryVolumeInformation(), ext4_check_descriptors(), and ext4_init_block_bitmap().

◆ ext3_blocks_count_set()

static void ext3_blocks_count_set	(	struct ext3_super_block *	es,
		ext3_fsblk_t	blk
	)

inlinestatic

Definition at line 1763 of file ext2fs.h.

{
    es->s_blocks_count = cpu_to_le32((u32)blk);
    es->s_blocks_count_hi = cpu_to_le32(blk >> 32);
}

◆ ext3_bread()

struct buffer_head * ext3_bread	(	struct ext2_icb *	icb,
		struct inode *	inode,
		unsigned long	block,
		int *	err
	)

Definition at line 230 of file htree.c.

{
    struct buffer_head * bh = NULL;
    NTSTATUS    status = STATUS_SUCCESS;
    ULONG       lbn = 0, num = 0;
 
    PEXT2_MCB   Mcb = CONTAINING_RECORD(inode, EXT2_MCB, Inode);
 
    /* for symlink file, read it's target instead */
    if (NULL != Mcb && IsMcbSymLink(Mcb))
        Mcb = Mcb->Target;
    if (NULL == Mcb) {
        *err = -EINVAL;
        return NULL;
    }
 
    /* mapping file offset to ext2 block */
    if (INODE_HAS_EXTENT(&Mcb->Inode)) {
        status = Ext2MapExtent(icb, inode->i_sb->s_priv,
                               Mcb, block, FALSE,
                               &lbn, &num);
    } else {
        status = Ext2MapIndirect(icb, inode->i_sb->s_priv,
                                 Mcb, block, FALSE,
                                 &lbn, &num);
    }
 
    if (!NT_SUCCESS(status)) {
        *err = Ext2LinuxError(status);
        return bh;
    }
 
    bh = sb_getblk(inode->i_sb, lbn);
    if (!bh) {
        *err = -ENOMEM;
        return bh;
    }
    if (buffer_uptodate(bh))
        return bh;
 
    *err = bh_submit_read(bh);
    if (*err) {
        __brelse(bh);
        return NULL;
    }
    return bh;
}

Referenced by ext3_add_entry(), ext3_append(), ext3_find_entry(), and ext3_is_dir_empty().

◆ 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_current_time()

__u32 ext3_current_time ( struct inode * in )

Definition at line 204 of file htree.c.

{
    LARGE_INTEGER   SysTime;
    KeQuerySystemTime(&SysTime);
 
    return Ext2LinuxTime(SysTime);
}

Referenced by add_dirent_to_buf(), Ext2RemoveEntry(), and Ext2SetFileType().

◆ ext3_dec_count()

void ext3_dec_count ( struct inode * inode )

Definition at line 312 of file htree.c.

{
    inode->i_nlink--;
}

Referenced by Ext2RemoveEntry(), Ext2SetFileType(), and Ext2SetReparsePoint().

◆ ext3_delete_entry()

int ext3_delete_entry	(	struct ext2_icb *	icb,
		struct inode *	dir,
		struct ext3_dir_entry_2 *	de_del,
		struct buffer_head *	bh
	)

Definition at line 2005 of file htree.c.

{
    struct ext3_dir_entry_2 *de, *pde = NULL;
    size_t i = 0;
 
    de = (struct ext3_dir_entry_2 *) bh->b_data;
    while (i < bh->b_size) {
        if (!ext3_check_dir_entry("ext3_delete_entry", dir, de, bh, i))
            return -EIO;
        if (de == de_del)  {
            if (pde)
                pde->rec_len = ext3_rec_len_to_disk(
                                   ext3_rec_len_from_disk(pde->rec_len) +
                                   ext3_rec_len_from_disk(de->rec_len));
            else
                de->inode = 0;
            dir->i_version++;
            /* ext3_journal_dirty_metadata(handle, bh); */
            set_buffer_dirty(bh);
            return 0;
        }
        i += ext3_rec_len_from_disk(de->rec_len);
        pde = de;
        de = ext3_next_entry(de);
    }
    return -ENOENT;
}

Referenced by Ext2RemoveEntry().

◆ ext3_dx_find_entry()

struct buffer_head * ext3_dx_find_entry	(	struct ext2_icb *	,
		struct dentry *	dentry,
		struct ext3_dir_entry_2 **	res_dir,
		int *	err
	)

Referenced by ext3_find_entry().

◆ ext3_dx_readdir()

int ext3_dx_readdir	(	struct file *	filp,
		filldir_t	filldir,
		void *	context
	)

Referenced by Ext2QueryDirectory().

◆ ext3_find_entry()

struct buffer_head * ext3_find_entry	(	struct ext2_icb *	icb,
		struct dentry *	dentry,
		struct ext3_dir_entry_2 **	res_dir
	)

Definition at line 2166 of file htree.c.

{
    struct inode *dir = dentry->d_parent->d_inode;
    struct super_block *sb = dir->i_sb;
    struct buffer_head *bh_use[NAMEI_RA_SIZE];
    struct buffer_head *bh, *ret = NULL;
    ext3_lblk_t start, block, b;
    int ra_max = 0;     /* Number of bh's in the readahead
                   buffer, bh_use[] */
    int ra_ptr = 0;     /* Current index into readahead
                   buffer */
    int num = 0;
    ext3_lblk_t  nblocks;
    int i, err;
    int namelen = dentry->d_name.len;
 
    *res_dir = NULL;
    if (namelen > EXT3_NAME_LEN)
        return NULL;
 
#ifdef EXT2_HTREE_INDEX
    if (icb->MajorFunction != IRP_MJ_CREATE && is_dx(dir)) {
        bh = ext3_dx_find_entry(icb, dentry, res_dir, &err);
        /*
         * On success, or if the error was file not found,
         * return.  Otherwise, fall back to doing a search the
         * old fashioned way.
         */
        if (bh || (err != ERR_BAD_DX_DIR))
            return bh;
        dxtrace(printk("ext4_find_entry: dx failed, "
                       "falling back\n"));
    }
#endif
 
    nblocks = (ext3_lblk_t)(dir->i_size >> EXT3_BLOCK_SIZE_BITS(sb));
    start = 0;
    block = start;
restart:
    do {
        /*
         * We deal with the read-ahead logic here.
         */
        if (ra_ptr >= ra_max) {
            /* Refill the readahead buffer */
            ra_ptr = 0;
            b = block;
            for (ra_max = 0; ra_max < NAMEI_RA_SIZE; ra_max++) {
                /*
                 * Terminate if we reach the end of the
                 * directory and must wrap, or if our
                 * search has finished at this block.
                 */
                if (b >= nblocks || (num && block == start)) {
                    bh_use[ra_max] = NULL;
                    break;
                }
                num++;
                bh = ext3_bread(icb, dir, b++, &err);
                bh_use[ra_max] = bh;
            }
        }
        if ((bh = bh_use[ra_ptr++]) == NULL)
            goto next;
        wait_on_buffer(bh);
        if (!buffer_uptodate(bh)) {
            /* read error, skip block & hope for the best */
            ext3_error(sb, __FUNCTION__, "reading directory #%lu "
                       "offset %lu", dir->i_ino,
                       (unsigned long)block);
            brelse(bh);
            goto next;
        }
        i = search_dirblock(bh, dir, dentry,
                            block << EXT3_BLOCK_SIZE_BITS(sb), res_dir);
        if (i == 1) {
            ret = bh;
            goto cleanup_and_exit;
        } else {
            brelse(bh);
            if (i < 0)
                goto cleanup_and_exit;
        }
next:
        if (++block >= nblocks)
            block = 0;
    } while (block != start);
 
    /*
     * If the directory has grown while we were searching, then
     * search the last part of the directory before giving up.
     */
    block = nblocks;
    nblocks = (ext3_lblk_t)(dir->i_size >> EXT3_BLOCK_SIZE_BITS(sb));
    if (block < nblocks) {
        start = 0;
        goto restart;
    }
 
cleanup_and_exit:
    /* Clean up the read-ahead blocks */
    for (; ra_ptr < ra_max; ra_ptr++)
        brelse(bh_use[ra_ptr]);
    return ret;
}

Referenced by Ext2RemoveEntry(), Ext2ScanDir(), and Ext2SetFileType().

◆ ext3_free_blocks_count()

static ext3_fsblk_t ext3_free_blocks_count ( struct ext3_super_block * es )

inlinestatic

Definition at line 1757 of file ext2fs.h.

{
    return ((ext3_fsblk_t)le32_to_cpu(es->s_free_blocks_count_hi) << 32) |
           le32_to_cpu(es->s_free_blocks_count);
}

Referenced by Ext2CreateFile(), Ext2DeleteFile(), and Ext2QueryVolumeInformation().

◆ ext3_free_blocks_count_set()

static void ext3_free_blocks_count_set	(	struct ext3_super_block *	es,
		ext3_fsblk_t	blk
	)

inlinestatic

Definition at line 1770 of file ext2fs.h.

{
    es->s_free_blocks_count = cpu_to_le32((u32)blk);
    es->s_free_blocks_count_hi = cpu_to_le32(blk >> 32);
}

Referenced by Ext2UpdateVcbStat(), and ext4_check_descriptors().

◆ ext3_inc_count()

void ext3_inc_count ( struct inode * inode )

Definition at line 307 of file htree.c.

{
    inode->i_nlink++;
}

Referenced by Ext2AddEntry(), and Ext2SetFileType().

◆ 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_is_dir_empty()

int ext3_is_dir_empty	(	struct ext2_icb *	icb,
		struct inode *	inode
	)

Definition at line 2038 of file htree.c.

{
    unsigned int offset;
    struct buffer_head *bh;
    struct ext3_dir_entry_2 *de, *de1;
    struct super_block *sb;
    int err = 0;
 
    sb = inode->i_sb;
    if (inode->i_size < EXT3_DIR_REC_LEN(1) + EXT3_DIR_REC_LEN(2) ||
            !(bh = ext3_bread(icb, inode, 0, &err))) {
        if (err)
            ext3_error(inode->i_sb, __FUNCTION__,
                       "error %d reading directory #%lu offset 0",
                       err, inode->i_ino);
        else
            ext3_warning(inode->i_sb, __FUNCTION__,
                         "bad directory (dir #%lu) - no data block",
                         inode->i_ino);
        return 1;
    }
    de = (struct ext3_dir_entry_2 *) bh->b_data;
    de1 = ext3_next_entry(de);
    if (le32_to_cpu(de->inode) != inode->i_ino ||
            !le32_to_cpu(de1->inode) ||
            strcmp(".", de->name) ||
            strcmp("..", de1->name)) {
        ext3_warning(inode->i_sb, "empty_dir",
                     "bad directory (dir #%lu) - no `.' or `..'",
                     inode->i_ino);
        brelse(bh);
        return 1;
    }
    offset = ext3_rec_len_from_disk(de->rec_len) +
             ext3_rec_len_from_disk(de1->rec_len);
    de = ext3_next_entry(de1);
    while (offset < inode->i_size) {
        if (!bh ||
                (void *) de >= (void *) (bh->b_data+sb->s_blocksize)) {
            err = 0;
            brelse(bh);
            bh = ext3_bread(icb, inode, offset >> EXT3_BLOCK_SIZE_BITS(sb), &err);
            if (!bh) {
                if (err)
                    ext3_error(sb, __FUNCTION__, "error %d reading directory"
                               " #%lu offset %u", err, inode->i_ino, offset);
                offset += sb->s_blocksize;
                continue;
            }
            de = (struct ext3_dir_entry_2 *) bh->b_data;
        }
        if (!ext3_check_dir_entry("empty_dir", inode, de, bh, offset)) {
            de = (struct ext3_dir_entry_2 *)(bh->b_data +
                                             sb->s_blocksize);
            offset = (offset | (sb->s_blocksize - 1)) + 1;
            continue;
        }
        if (le32_to_cpu(de->inode)) {
            brelse(bh);
            return 0;
        }
        offset += ext3_rec_len_from_disk(de->rec_len);
        de = ext3_next_entry(de);
    }
    brelse(bh);
    return 1;
}

Referenced by Ext2IsDirectoryEmpty().

◆ ext3_mark_inode_dirty()

int ext3_mark_inode_dirty	(	struct ext2_icb *	icb,
		struct inode *	in
	)

Definition at line 360 of file htree.c.

{
    if (Ext2SaveInode(icb, in->i_sb->s_priv, in))
        return 0;
 
    return -ENOMEM;
}

Referenced by add_dirent_to_buf(), Ext2AddDotEntries(), Ext2AddEntry(), Ext2RemoveEntry(), and Ext2SetFileType().

◆ 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().

◆ ext3_r_blocks_count()

static ext3_fsblk_t ext3_r_blocks_count ( struct ext3_super_block * es )

inlinestatic

Definition at line 1751 of file ext2fs.h.

{
    return ((ext3_fsblk_t)le32_to_cpu(es->s_r_blocks_count_hi) << 32) |
           le32_to_cpu(es->s_r_blocks_count);
}

◆ ext3_r_blocks_count_set()

static void ext3_r_blocks_count_set	(	struct ext3_super_block *	es,
		ext3_fsblk_t	blk
	)

inlinestatic

Definition at line 1777 of file ext2fs.h.

{
    es->s_r_blocks_count = cpu_to_le32((u32)blk);
    es->s_r_blocks_count_hi = cpu_to_le32(blk >> 32);
}

◆ ext3_set_de_type()

void ext3_set_de_type	(	struct super_block *	sb,
		struct ext3_dir_entry_2 *	de,
		umode_t	mode
	)

Definition at line 347 of file htree.c.

{
    if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_FILETYPE))
        de->file_type = ext3_type_by_mode(mode);
}

Referenced by add_dirent_to_buf(), Ext2AddDotEntries(), and Ext2SetFileType().

◆ ext3_update_dx_flag()

void ext3_update_dx_flag ( struct inode * inode )

Definition at line 368 of file htree.c.

{
    if (!EXT3_HAS_COMPAT_FEATURE(inode->i_sb,
                                 EXT3_FEATURE_COMPAT_DIR_INDEX))
        EXT3_I(inode)->i_flags &= ~EXT3_INDEX_FL;
}

Referenced by add_dirent_to_buf(), and Ext2RemoveEntry().

◆ ext3_warning()

void ext3_warning	(	struct super_block *	sb,
		const char *	function,
		char *	fmt,
			...
	)

Definition at line 212 of file htree.c.

{
#if DX_DEBUG
    va_list args;
 
    va_start(args, fmt);
    printk("EXT3-fs warning (device %s): %s: ",
           sb->s_id, function);
    printk(fmt, args);
    printk("\n");
    va_end(args);
#endif
}

Referenced by Ext2RemoveEntry(), 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_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_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_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_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_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);
}

◆ 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);
}

◆ 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_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().

Variable Documentation

◆ Ext2Global

PEXT2_GLOBAL Ext2Global

extern

Definition at line 16 of file init.c.

Referenced by Ext2TraceIrpContext(), and Ext2TraceMemory().

◆ ProcessNameOffset

ULONG ProcessNameOffset

extern

Referenced by DriverEntry(), Ext2FastIoLock(), Ext2FastIoUnlockAll(), Ext2FastIoUnlockAllByKey(), and Ext2FastIoUnlockSingle().

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ AUTO_MOUNT

◆ BLOCK_BITS

◆ BLOCK_SIZE

◆ BLOCKS_PER_GROUP

◆ BooleanFlagOn

◆ CanExt2Wait

◆ CanIWrite

◆ CCB_ALLOW_EXTENDED_DASD_IO

◆ CCB_DELETE_ON_CLOSE

◆ CCB_FROM_POOL

◆ CCB_LAST_WRITE_UPDATED

◆ CCB_OPEN_REPARSE_POINT

◆ CCB_VOLUME_DASD_PURGE

◆ CDROM_NAME

◆ CEILING_ALIGNED

◆ CHECKING_BITMAP

◆ CL_ASSERT

◆ ClearFlag

◆ ClearLongFlag

◆ COCKLOFT_ALIGNED

◆ CODEPAGE_NAME

◆ DbgBreak

◆ DEBUG

◆ DEC_IRP_COUNT

◆ DEC_MEM_COUNT

◆ DEFAULT_SECTOR_SIZE

◆ DEVICE_NAME

◆ DL_BH

◆ DL_BLK

◆ DL_CP

◆ DL_DBG

◆ DL_DEFAULT

◆ DL_ERR

◆ DL_EXT

◆ DL_FUN

◆ DL_HTI

◆ DL_INF

◆ DL_IO

◆ DL_JNL

◆ DL_LOW

◆ DL_MAP

◆ DL_NVR

◆ DL_PNP

◆ DL_REN

◆ DL_RES

◆ DL_VIT

◆ DL_WRN

◆ DOS_DEVICE_NAME

◆ DRIVER_NAME

◆ EGID

◆ EUID

◆ EXT2_AUTO_MOUNT

◆ EXT2_BLOCK_TYPES

◆ EXT2_BUGCHK_BLOCK

◆ EXT2_BUGCHK_CLEANUP

◆ EXT2_BUGCHK_CLOSE

◆ EXT2_BUGCHK_CMCB

◆ EXT2_BUGCHK_CREATE

◆ EXT2_BUGCHK_DEBUG

◆ EXT2_BUGCHK_DEVCTL

◆ EXT2_BUGCHK_DIRCTL

◆ EXT2_BUGCHK_DISPATCH

◆ EXT2_BUGCHK_EXCEPT

◆ EXT2_BUGCHK_EXT2

◆ EXT2_BUGCHK_FASTIO

◆ EXT2_BUGCHK_FILEINFO

◆ EXT2_BUGCHK_FLUSH

◆ EXT2_BUGCHK_FSCTL

◆ EXT2_BUGCHK_INIT

◆ EXT2_BUGCHK_LAST

◆ EXT2_BUGCHK_LOCK

◆ EXT2_BUGCHK_MEMORY

◆ EXT2_BUGCHK_MISC