mirror of
https://github.com/reactos/reactos.git
synced 2024-08-29 22:58:34 +00:00
3110 lines
74 KiB
C
3110 lines
74 KiB
C
/*
|
|
* COPYRIGHT: See COPYRIGHT.TXT
|
|
* PROJECT: Ext2 File System Driver for WinNT/2K/XP
|
|
* FILE: Ext2fs.h
|
|
* PURPOSE: Header file: ext2 structures
|
|
* PROGRAMMER: Matt Wu <mattwu@163.com>
|
|
* HOMEPAGE: http://www.ext2fsd.com
|
|
* UPDATE HISTORY:
|
|
*/
|
|
|
|
#ifndef _EXT2_HEADER_
|
|
#define _EXT2_HEADER_
|
|
|
|
/* INCLUDES *************************************************************/
|
|
#include <linux/module.h>
|
|
#include <ntdddisk.h>
|
|
#ifdef __REACTOS__
|
|
#include <ndk/rtlfuncs.h>
|
|
#include <pseh/pseh2.h>
|
|
typedef IO_STACK_LOCATION EXTENDED_IO_STACK_LOCATION, *PEXTENDED_IO_STACK_LOCATION;
|
|
#endif
|
|
#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>
|
|
|
|
/* DEBUG ****************************************************************/
|
|
#if DBG
|
|
# define EXT2_DEBUG 1
|
|
#else
|
|
# define EXT2_DEBUG 0
|
|
#endif
|
|
|
|
#define EXT_DEBUG_BREAKPOINT FALSE
|
|
|
|
#if EXT2_DEBUG && EXT_DEBUG_BREAKPOINT
|
|
//#if _X86_
|
|
//#define DbgBreak() __asm int 3
|
|
//#else
|
|
#define DbgBreak() KdBreakPoint()
|
|
//#endif
|
|
#else
|
|
#define DbgBreak()
|
|
#endif
|
|
|
|
/* STRUCTS & CONSTS******************************************************/
|
|
|
|
#define EXT2FSD_VERSION "0.69"
|
|
|
|
|
|
/* WDK DEFINITIONS ******************************************************/
|
|
|
|
|
|
/* COMPILER SWITCH / OPTIONS ********************************************/
|
|
|
|
//
|
|
// Ext2Fsd build options
|
|
//
|
|
|
|
// To support driver dynamics unload
|
|
|
|
#define EXT2_UNLOAD FALSE
|
|
|
|
// To support inode size expansion (fallocate)
|
|
|
|
#define EXT2_PRE_ALLOCATION_SUPPORT TRUE
|
|
|
|
//
|
|
// Constants
|
|
//
|
|
|
|
#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)
|
|
|
|
typedef struct ext3_super_block EXT2_SUPER_BLOCK, *PEXT2_SUPER_BLOCK;
|
|
typedef struct ext3_inode EXT2_INODE, *PEXT2_INODE;
|
|
typedef struct ext4_group_desc EXT2_GROUP_DESC, *PEXT2_GROUP_DESC;
|
|
typedef struct ext3_dir_entry EXT2_DIR_ENTRY, *PEXT2_DIR_ENTRY;
|
|
typedef struct ext3_dir_entry_2 EXT2_DIR_ENTRY2, *PEXT2_DIR_ENTRY2;
|
|
|
|
#define CEILING_ALIGNED(T, A, B) (((A) + (B) - 1) & (~((T)(B) - 1)))
|
|
#define COCKLOFT_ALIGNED(T, A, B) (((A) + (B)) & (~((T)(B) - 1)))
|
|
|
|
|
|
|
|
/*
|
|
* Compile-time assertion: (Lustre version)
|
|
*
|
|
* Check an invariant described by a constant expression at compile time by
|
|
* forcing a compiler error if it does not hold. \a cond must be a constant
|
|
* expression as defined by the ISO C Standard:
|
|
*
|
|
* 6.8.4.2 The switch statement
|
|
* ....
|
|
* [#3] The expression of each case label shall be an integer
|
|
* constant expression and no two of the case constant
|
|
* expressions in the same switch statement shall have the same
|
|
* value after conversion...
|
|
*
|
|
*/
|
|
|
|
#define CL_ASSERT(cond) do {switch('x') {case (cond): case 0: break;}} while (0)
|
|
|
|
/* File System Releated *************************************************/
|
|
|
|
#define DRIVER_NAME "Ext2Fsd"
|
|
#define DEVICE_NAME L"\\Ext2Fsd"
|
|
#define CDROM_NAME L"\\Ext2CdFsd"
|
|
|
|
// Registry
|
|
|
|
#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"
|
|
|
|
// To support ext2fsd unload routine
|
|
#if EXT2_UNLOAD
|
|
//
|
|
// Private IOCTL to make the driver ready to unload
|
|
//
|
|
#define IOCTL_PREPARE_TO_UNLOAD \
|
|
CTL_CODE(FILE_DEVICE_UNKNOWN, 2048, METHOD_NEITHER, FILE_WRITE_ACCESS)
|
|
|
|
#endif // EXT2_UNLOAD
|
|
|
|
#include "common.h"
|
|
|
|
#ifndef _GNU_NTIFS_
|
|
typedef IO_STACK_LOCATION EXTENDED_IO_STACK_LOCATION, *PEXTENDED_IO_STACK_LOCATION;
|
|
#endif
|
|
|
|
#define IsFlagOn(a,b) ((BOOLEAN)(FlagOn(a,b) == b))
|
|
#ifndef FlagOn
|
|
#define FlagOn(_F,_SF) ((_F) & (_SF))
|
|
#endif
|
|
|
|
#ifndef BooleanFlagOn
|
|
#define BooleanFlagOn(F,SF) ((BOOLEAN)(((F) & (SF)) != 0))
|
|
#endif
|
|
|
|
#ifndef SetFlag
|
|
#define SetFlag(_F,_SF) ((_F) |= (_SF))
|
|
#endif
|
|
|
|
#ifndef ClearFlag
|
|
#define ClearFlag(_F,_SF) ((_F) &= ~(_SF))
|
|
#endif
|
|
|
|
#ifndef min
|
|
#define min(a,b) (((a) < (b)) ? (a) : (b))
|
|
#endif
|
|
|
|
#ifndef max
|
|
#define max(a,b) (((a) > (b)) ? (a) : (b))
|
|
#endif
|
|
|
|
#ifdef _WIN2K_TARGET_
|
|
#define InterlockedOr _InterlockedOr
|
|
LONG
|
|
_InterlockedAnd (
|
|
IN OUT LONG volatile *Target,
|
|
IN LONG Set
|
|
);
|
|
|
|
#pragma intrinsic (_InterlockedAnd)
|
|
#define InterlockedAnd _InterlockedAnd
|
|
|
|
LONG
|
|
_InterlockedXor (
|
|
IN OUT LONG volatile *Target,
|
|
IN LONG Set
|
|
);
|
|
|
|
#pragma intrinsic (_InterlockedXor)
|
|
#define InterlockedXor _InterlockedXor
|
|
|
|
#endif /* only for win2k */
|
|
|
|
#if EXT2_DEBUG
|
|
|
|
#define SetLongFlag(_F,_SF) Ext2SetFlag((PULONG)&(_F), (ULONG)(_SF))
|
|
#define ClearLongFlag(_F,_SF) Ext2ClearFlag((PULONG)&(_F), (ULONG)(_SF))
|
|
|
|
#ifdef __REACTOS__
|
|
static
|
|
#endif
|
|
__inline
|
|
VOID
|
|
Ext2SetFlag(PULONG Flags, ULONG FlagBit)
|
|
{
|
|
ULONG _ret = InterlockedOr(Flags, FlagBit);
|
|
ASSERT(*Flags == (_ret | FlagBit));
|
|
}
|
|
|
|
#ifdef __REACTOS__
|
|
static
|
|
#endif
|
|
__inline
|
|
VOID
|
|
Ext2ClearFlag(PULONG Flags, ULONG FlagBit)
|
|
{
|
|
ULONG _ret = InterlockedAnd(Flags, ~FlagBit);
|
|
ASSERT(*Flags == (_ret & (~FlagBit)));
|
|
}
|
|
|
|
#else
|
|
|
|
#define SetLongFlag(_F,_SF) InterlockedOr(&(_F), (ULONG)(_SF))
|
|
#define ClearLongFlag(_F,_SF) InterlockedAnd(&(_F), ~((ULONG)(_SF)))
|
|
|
|
#endif /* release */
|
|
|
|
#define Ext2RaiseStatus(IRPCONTEXT,STATUS) { \
|
|
(IRPCONTEXT)->ExceptionCode = (STATUS); \
|
|
ExRaiseStatus((STATUS)); \
|
|
}
|
|
|
|
#define Ext2NormalizeAndRaiseStatus(IRPCONTEXT,STATUS) { \
|
|
(IRPCONTEXT)->ExceptionCode = STATUS; \
|
|
if ((STATUS) == STATUS_VERIFY_REQUIRED) { ExRaiseStatus((STATUS)); } \
|
|
ExRaiseStatus(FsRtlNormalizeNtstatus((STATUS),STATUS_UNEXPECTED_IO_ERROR)); \
|
|
}
|
|
|
|
//
|
|
// Define IsWritingToEof for write (append) operations
|
|
//
|
|
|
|
#define FILE_WRITE_TO_END_OF_FILE 0xffffffff
|
|
|
|
#define IsWritingToEof(Pos) (((Pos).LowPart == FILE_WRITE_TO_END_OF_FILE) && \
|
|
((Pos).HighPart == -1 ))
|
|
|
|
#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)
|
|
|
|
//
|
|
// Pool Tags
|
|
//
|
|
|
|
#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'
|
|
|
|
//
|
|
// Bug Check Codes Definitions
|
|
//
|
|
|
|
#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 ); }
|
|
|
|
|
|
/* Ext2 file system definions *******************************************/
|
|
|
|
//
|
|
// The second extended file system magic number
|
|
//
|
|
|
|
#define EXT2_SUPER_MAGIC 0xEF53
|
|
|
|
#define EXT2_MIN_BLOCK 1024
|
|
#define EXT2_MIN_FRAG 1024
|
|
#define EXT2_MAX_USER_BLKSIZE 65536
|
|
//
|
|
// Inode flags (Linux uses octad number, but why ? strange!!!)
|
|
//
|
|
|
|
#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)
|
|
|
|
|
|
/*
|
|
* We need 8-bytes aligned for all the sturctures
|
|
* It's a must for all ERESOURCE allocations
|
|
*/
|
|
|
|
//
|
|
// Ext2Fsd Driver Definitions
|
|
//
|
|
|
|
//
|
|
// EXT2_IDENTIFIER_TYPE
|
|
//
|
|
// Identifiers used to mark the structures
|
|
//
|
|
|
|
typedef enum _EXT2_IDENTIFIER_TYPE {
|
|
#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;
|
|
|
|
//
|
|
// EXT2_IDENTIFIER
|
|
//
|
|
// Header used to mark the structures
|
|
//
|
|
typedef struct _EXT2_IDENTIFIER {
|
|
EXT2_IDENTIFIER_TYPE Type;
|
|
ULONG Size;
|
|
} EXT2_IDENTIFIER, *PEXT2_IDENTIFIER;
|
|
|
|
|
|
#define NodeType(Ptr) (*((EXT2_IDENTIFIER_TYPE *)(Ptr)))
|
|
|
|
typedef struct _EXT2_MCB EXT2_MCB, *PEXT2_MCB;
|
|
|
|
|
|
typedef PVOID PBCB;
|
|
|
|
//
|
|
|
|
//
|
|
// EXT2_GLOBAL_DATA
|
|
//
|
|
// Data that is not specific to a mounted volume
|
|
//
|
|
|
|
typedef VOID (NTAPI *EXT2_REAPER_RELEASE)(PVOID);
|
|
|
|
typedef struct _EXT2_REAPER {
|
|
PETHREAD Thread;
|
|
KEVENT Engine;
|
|
KEVENT Wait;
|
|
EXT2_REAPER_RELEASE Free;
|
|
ULONG Flags;
|
|
} EXT2_REAPER, *PEXT2_REAPER;
|
|
|
|
#define EXT2_REAPER_FLAG_STOP (1 << 0)
|
|
|
|
typedef struct _EXT2_GLOBAL {
|
|
|
|
/* Identifier for this structure */
|
|
EXT2_IDENTIFIER Identifier;
|
|
|
|
/* Syncronization primitive for this structure */
|
|
ERESOURCE Resource;
|
|
|
|
/* Global flags for the driver: I put it since
|
|
FastIoDispatch isn't 8bytes aligned. */
|
|
ULONG Flags;
|
|
|
|
/* Table of pointers to the fast I/O entry points */
|
|
FAST_IO_DISPATCH FastIoDispatch;
|
|
|
|
/* Filter callbacks */
|
|
FS_FILTER_CALLBACKS FilterCallbacks;
|
|
|
|
/* Table of pointers to the Cache Manager callbacks */
|
|
CACHE_MANAGER_CALLBACKS CacheManagerCallbacks;
|
|
CACHE_MANAGER_CALLBACKS CacheManagerNoOpCallbacks;
|
|
|
|
/* Pointer to the driver object */
|
|
PDRIVER_OBJECT DriverObject;
|
|
|
|
/* Pointer to the disk device object */
|
|
PDEVICE_OBJECT DiskdevObject;
|
|
|
|
/* Pointer to the cdrom device object */
|
|
PDEVICE_OBJECT CdromdevObject;
|
|
|
|
/* List of mounted volumes */
|
|
LIST_ENTRY VcbList;
|
|
|
|
/* Cleaning thread related: resource cleaner */
|
|
EXT2_REAPER FcbReaper;
|
|
EXT2_REAPER McbReaper;
|
|
EXT2_REAPER bhReaper;
|
|
|
|
/* Look Aside table of IRP_CONTEXT, FCB, MCB, CCB */
|
|
NPAGED_LOOKASIDE_LIST Ext2IrpContextLookasideList;
|
|
NPAGED_LOOKASIDE_LIST Ext2FcbLookasideList;
|
|
NPAGED_LOOKASIDE_LIST Ext2CcbLookasideList;
|
|
NPAGED_LOOKASIDE_LIST Ext2McbLookasideList;
|
|
NPAGED_LOOKASIDE_LIST Ext2ExtLookasideList;
|
|
NPAGED_LOOKASIDE_LIST Ext2DentryLookasideList;
|
|
USHORT MaxDepth;
|
|
|
|
/* User specified global codepage name */
|
|
struct {
|
|
WCHAR PageName[CODEPAGE_MAXLEN];
|
|
UCHAR AnsiName[CODEPAGE_MAXLEN];
|
|
struct nls_table * PageTable;
|
|
} Codepage;
|
|
|
|
/* global hiding patterns */
|
|
WCHAR wHidingPrefix[HIDINGPAT_LEN];
|
|
WCHAR wHidingSuffix[HIDINGPAT_LEN];
|
|
BOOLEAN bHidingPrefix;
|
|
CHAR sHidingPrefix[HIDINGPAT_LEN];
|
|
BOOLEAN bHidingSuffix;
|
|
CHAR sHidingSuffix[HIDINGPAT_LEN];
|
|
|
|
/* Registery path */
|
|
UNICODE_STRING RegistryPath;
|
|
|
|
/* global memory and i/o statistics and memory allocations
|
|
of various sturctures */
|
|
|
|
EXT2_PERF_STATISTICS_V2 PerfStat;
|
|
|
|
} EXT2_GLOBAL, *PEXT2_GLOBAL;
|
|
|
|
//
|
|
// Flags for EXT2_GLOBAL_DATA
|
|
//
|
|
|
|
#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
|
|
|
|
//
|
|
// Glboal Ext2Fsd Memory Block
|
|
//
|
|
|
|
extern PEXT2_GLOBAL Ext2Global;
|
|
|
|
//
|
|
// memory allocation statistics
|
|
//
|
|
|
|
|
|
#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))
|
|
|
|
//
|
|
// Driver Extension define
|
|
//
|
|
|
|
#define IsExt2FsDevice(DO) ((DO == Ext2Global->DiskdevObject) || \
|
|
(DO == Ext2Global->CdromdevObject) )
|
|
|
|
#ifdef _WIN2K_TARGET_
|
|
#define FSRTL_ADVANCED_FCB_HEADER FSRTL_COMMON_FCB_HEADER
|
|
#endif
|
|
|
|
typedef struct _EXT2_FCBVCB {
|
|
|
|
// Command header for Vcb and Fcb
|
|
FSRTL_ADVANCED_FCB_HEADER Header;
|
|
|
|
#ifndef _WIN2K_TARGET_
|
|
FAST_MUTEX Mutex;
|
|
#endif
|
|
|
|
// Ext2Fsd identifier
|
|
EXT2_IDENTIFIER Identifier;
|
|
|
|
|
|
// Locking resources
|
|
ERESOURCE MainResource;
|
|
ERESOURCE PagingIoResource;
|
|
|
|
} EXT2_FCBVCB, *PEXT2_FCBVCB;
|
|
|
|
//
|
|
// EXT2_VCB Volume Control Block
|
|
//
|
|
// Data that represents a mounted logical volume
|
|
// It is allocated as the device extension of the volume device object
|
|
//
|
|
typedef struct _EXT2_VCB {
|
|
|
|
/* Common header */
|
|
EXT2_FCBVCB;
|
|
|
|
// Resource for metadata (inode)
|
|
ERESOURCE MetaInode;
|
|
|
|
// Resource for metadata (block)
|
|
ERESOURCE MetaBlock;
|
|
|
|
// Resource for Mcb (Meta data control block)
|
|
ERESOURCE McbLock;
|
|
|
|
// List of FCBs for open files on this volume
|
|
ERESOURCE FcbLock;
|
|
LIST_ENTRY FcbList;
|
|
ULONG FcbCount;
|
|
|
|
// Mcb list
|
|
ULONG NumOfMcb;
|
|
LIST_ENTRY McbList;
|
|
|
|
// Entry of Mcb Tree (Root Node)
|
|
PEXT2_MCB McbTree;
|
|
|
|
// Link list to Global
|
|
LIST_ENTRY Next;
|
|
|
|
// Section objects
|
|
SECTION_OBJECT_POINTERS SectionObject;
|
|
|
|
// Dirty Mcbs of modifications for volume stream
|
|
LARGE_MCB Extents;
|
|
|
|
|
|
// Share Access for the file object
|
|
SHARE_ACCESS ShareAccess;
|
|
|
|
// Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLOSE
|
|
// for both files on this volume and open instances of the
|
|
// volume itself.
|
|
ULONG ReferenceCount; /* total ref count */
|
|
ULONG OpenHandleCount; /* all handles */
|
|
|
|
ULONG OpenVolumeCount; /* volume handle */
|
|
|
|
// Disk change count
|
|
ULONG ChangeCount;
|
|
|
|
// Pointer to the VPB in the target device object
|
|
PVPB Vpb;
|
|
PVPB Vpb2;
|
|
|
|
// The FileObject of Volume used to lock the volume
|
|
PFILE_OBJECT LockFile;
|
|
|
|
// List of IRPs pending on directory change notify requests
|
|
LIST_ENTRY NotifyList;
|
|
|
|
// Pointer to syncronization primitive for this list
|
|
PNOTIFY_SYNC NotifySync;
|
|
|
|
// This volumes device object
|
|
PDEVICE_OBJECT DeviceObject;
|
|
|
|
// The physical device object (the disk)
|
|
PDEVICE_OBJECT TargetDeviceObject;
|
|
|
|
// The physical device object (the disk)
|
|
PDEVICE_OBJECT RealDevice;
|
|
|
|
// Information about the physical device object
|
|
DISK_GEOMETRY DiskGeometry;
|
|
PARTITION_INFORMATION PartitionInformation;
|
|
|
|
BOOLEAN IsExt3fs;
|
|
PEXT2_SUPER_BLOCK SuperBlock;
|
|
|
|
// Block / Cluster size
|
|
ULONG BlockSize;
|
|
|
|
// Sector size in bits
|
|
ULONG SectorBits;
|
|
|
|
// Minimal i/o size: min(PageSize, BlockSize)
|
|
ULONGLONG IoUnitSize;
|
|
|
|
// Bits of aligned size
|
|
ULONG IoUnitBits;
|
|
|
|
// Inode size
|
|
ULONG InodeSize;
|
|
|
|
// Inode lookaside list
|
|
NPAGED_LOOKASIDE_LIST InodeLookasideList;
|
|
|
|
// Flags for the volume
|
|
ULONG Flags;
|
|
|
|
// Streaming File Object
|
|
PFILE_OBJECT Volume;
|
|
|
|
// User specified codepage name per volume
|
|
struct {
|
|
UCHAR AnsiName[CODEPAGE_MAXLEN];
|
|
struct nls_table * PageTable;
|
|
} Codepage;
|
|
|
|
/* patterns to hiding files */
|
|
BOOLEAN bHidingPrefix;
|
|
CHAR sHidingPrefix[HIDINGPAT_LEN];
|
|
BOOLEAN bHidingSuffix;
|
|
CHAR sHidingSuffix[HIDINGPAT_LEN];
|
|
|
|
/* User to impersanate */
|
|
uid_t uid;
|
|
gid_t gid;
|
|
|
|
/* User to act as */
|
|
uid_t euid;
|
|
gid_t egid;
|
|
|
|
/* mountpoint: symlink to DesDevices */
|
|
UCHAR DrvLetter;
|
|
|
|
struct block_device bd;
|
|
struct super_block sb;
|
|
struct ext3_sb_info sbi;
|
|
|
|
/* Maximum file size in blocks ... */
|
|
ULONG max_blocks_per_layer[EXT2_BLOCK_TYPES];
|
|
ULONG max_data_blocks;
|
|
loff_t max_bitmap_bytes;
|
|
loff_t max_bytes;
|
|
} EXT2_VCB, *PEXT2_VCB;
|
|
|
|
//
|
|
// Flags for EXT2_VCB
|
|
//
|
|
#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) (IsFlagOn((Vcb)->Flags, VCB_READ_ONLY) || \
|
|
IsFlagOn((Vcb)->Flags, VCB_RO_COMPAT_READ_ONLY) || \
|
|
IsFlagOn((Vcb)->Flags, VCB_WRITE_PROTECTED))
|
|
|
|
|
|
#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())
|
|
//
|
|
// EXT2_FCB File Control Block
|
|
//
|
|
// Data that represents an open file
|
|
// There is a single instance of the FCB for every open file
|
|
//
|
|
typedef struct _EXT2_FCB {
|
|
|
|
/* Common header */
|
|
EXT2_FCBVCB;
|
|
|
|
// List of FCBs for this volume
|
|
LIST_ENTRY Next;
|
|
LARGE_INTEGER TsDrop; /* drop time */
|
|
|
|
SECTION_OBJECT_POINTERS SectionObject;
|
|
|
|
// Share Access for the file object
|
|
SHARE_ACCESS ShareAccess;
|
|
|
|
// List of byte-range locks for this file
|
|
FILE_LOCK FileLockAnchor;
|
|
|
|
// oplock information management structure
|
|
OPLOCK Oplock;
|
|
|
|
// Lazy writer thread context
|
|
PETHREAD LazyWriterThread;
|
|
|
|
// Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP
|
|
ULONG OpenHandleCount;
|
|
|
|
// Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLOSE
|
|
ULONG ReferenceCount;
|
|
|
|
// Incremented on IRP_MJ_CREATE, decremented on IRP_MJ_CLEANUP
|
|
// But only for Files with FO_NO_INTERMEDIATE_BUFFERING flag
|
|
ULONG NonCachedOpenCount;
|
|
|
|
// Flags for the FCB
|
|
ULONG Flags;
|
|
|
|
// Pointer to the inode
|
|
struct inode *Inode;
|
|
|
|
// Vcb
|
|
PEXT2_VCB Vcb;
|
|
|
|
// Mcb Node ...
|
|
PEXT2_MCB Mcb;
|
|
|
|
} EXT2_FCB, *PEXT2_FCB;
|
|
|
|
//
|
|
// Flags for EXT2_FCB
|
|
//
|
|
|
|
#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
|
|
|
|
//
|
|
// Mcb Node
|
|
//
|
|
|
|
struct _EXT2_MCB {
|
|
|
|
// Identifier for this structure
|
|
EXT2_IDENTIFIER Identifier;
|
|
|
|
// Flags
|
|
ULONG Flags;
|
|
|
|
// Link List Info
|
|
PEXT2_MCB Parent; // Parent
|
|
PEXT2_MCB Next; // Siblings
|
|
|
|
union {
|
|
PEXT2_MCB Child; // Children Mcb nodes
|
|
PEXT2_MCB Target; // Target Mcb of symlink
|
|
};
|
|
|
|
// Mcb Node Info
|
|
|
|
// -> Fcb
|
|
PEXT2_FCB Fcb;
|
|
|
|
// Short name
|
|
UNICODE_STRING ShortName;
|
|
|
|
// Full name with path
|
|
UNICODE_STRING FullName;
|
|
|
|
// File attribute
|
|
ULONG FileAttr;
|
|
|
|
// reference count
|
|
ULONG Refercount;
|
|
|
|
// Extents zone
|
|
LARGE_MCB Extents;
|
|
|
|
// Metablocks
|
|
LARGE_MCB MetaExts;
|
|
|
|
// Time stamps
|
|
LARGE_INTEGER CreationTime;
|
|
LARGE_INTEGER LastWriteTime;
|
|
LARGE_INTEGER ChangeTime;
|
|
LARGE_INTEGER LastAccessTime;
|
|
|
|
// List Link to Vcb->McbList
|
|
LIST_ENTRY Link;
|
|
|
|
|
|
|
|
struct inode Inode;
|
|
struct dentry *de;
|
|
};
|
|
|
|
//
|
|
// Flags for MCB
|
|
//
|
|
#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))
|
|
|
|
/*
|
|
* routines for reference count management
|
|
*/
|
|
|
|
#define Ext2ReferXcb(_C) InterlockedIncrement(_C)
|
|
#define Ext2DerefXcb(_C) DEC_OBJ_CNT(_C)
|
|
|
|
#ifdef __REACTOS__
|
|
static
|
|
#endif
|
|
__inline ULONG DEC_OBJ_CNT(PULONG _C) {
|
|
if (*_C <= 0) {
|
|
DbgBreak();
|
|
}
|
|
return InterlockedDecrement(_C);
|
|
}
|
|
|
|
#if EXT2_DEBUG
|
|
VOID
|
|
Ext2TraceMcb(PCHAR fn, USHORT lc, USHORT add, PEXT2_MCB Mcb);
|
|
#define Ext2ReferMcb(Mcb) Ext2TraceMcb(__FUNCTION__, __LINE__, TRUE, Mcb)
|
|
#define Ext2DerefMcb(Mcb) Ext2TraceMcb(__FUNCTION__, __LINE__, FALSE, Mcb)
|
|
#else
|
|
#define Ext2ReferMcb(Mcb) Ext2ReferXcb(&Mcb->Refercount)
|
|
#define Ext2DerefMcb(Mcb) Ext2DerefXcb(&Mcb->Refercount)
|
|
#endif
|
|
|
|
//
|
|
// EXT2_CCB Context Control Block
|
|
//
|
|
// Data that represents one instance of an open file
|
|
// There is one instance of the CCB for every instance of an open file
|
|
//
|
|
typedef struct _EXT2_CCB {
|
|
|
|
// Identifier for this structure
|
|
EXT2_IDENTIFIER Identifier;
|
|
|
|
// Flags
|
|
ULONG Flags;
|
|
|
|
// Mcb of it's symbol link
|
|
PEXT2_MCB SymLink;
|
|
|
|
// State that may need to be maintained
|
|
UNICODE_STRING DirectorySearchPattern;
|
|
|
|
/* Open handle control block */
|
|
struct file filp;
|
|
|
|
/* The EA index we are on */
|
|
ULONG EaIndex;
|
|
|
|
} EXT2_CCB, *PEXT2_CCB;
|
|
|
|
//
|
|
// Flags for CCB
|
|
//
|
|
|
|
#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
|
|
|
|
//
|
|
// EXT2_IRP_CONTEXT
|
|
//
|
|
// Used to pass information about a request between the drivers functions
|
|
//
|
|
typedef struct ext2_icb {
|
|
|
|
// Identifier for this structure
|
|
EXT2_IDENTIFIER Identifier;
|
|
|
|
// Pointer to the IRP this request describes
|
|
PIRP Irp;
|
|
|
|
// Flags
|
|
ULONG Flags;
|
|
|
|
// The major and minor function code for the request
|
|
UCHAR MajorFunction;
|
|
UCHAR MinorFunction;
|
|
|
|
// The device object
|
|
PDEVICE_OBJECT DeviceObject;
|
|
|
|
// The real device object
|
|
PDEVICE_OBJECT RealDevice;
|
|
|
|
// The file object
|
|
PFILE_OBJECT FileObject;
|
|
|
|
PEXT2_FCB Fcb;
|
|
PEXT2_CCB Ccb;
|
|
|
|
// If the request is top level
|
|
BOOLEAN IsTopLevel;
|
|
|
|
// Used if the request needs to be queued for later processing
|
|
WORK_QUEUE_ITEM WorkQueueItem;
|
|
|
|
// If an exception is currently in progress
|
|
BOOLEAN ExceptionInProgress;
|
|
|
|
// The exception code when an exception is in progress
|
|
NTSTATUS ExceptionCode;
|
|
|
|
} EXT2_IRP_CONTEXT, *PEXT2_IRP_CONTEXT;
|
|
|
|
|
|
#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))
|
|
|
|
//
|
|
// EXT2_ALLOC_HEADER
|
|
//
|
|
// In the checked version of the driver this header is put in the beginning of
|
|
// every memory allocation
|
|
//
|
|
typedef struct _EXT2_ALLOC_HEADER {
|
|
EXT2_IDENTIFIER Identifier;
|
|
} EXT2_ALLOC_HEADER, *PEXT2_ALLOC_HEADER;
|
|
|
|
typedef struct _FCB_LIST_ENTRY {
|
|
PEXT2_FCB Fcb;
|
|
LIST_ENTRY Next;
|
|
} FCB_LIST_ENTRY, *PFCB_LIST_ENTRY;
|
|
|
|
|
|
// Block Description List
|
|
typedef struct _EXT2_EXTENT {
|
|
LONGLONG Lba;
|
|
ULONG Offset;
|
|
ULONG Length;
|
|
PIRP Irp;
|
|
struct _EXT2_EXTENT * Next;
|
|
} EXT2_EXTENT, *PEXT2_EXTENT;
|
|
|
|
|
|
/* FUNCTIONS DECLARATION *****************************************************/
|
|
|
|
// Include this so we don't need the latest WDK to build the driver.
|
|
#ifndef FSCTL_GET_RETRIEVAL_POINTER_BASE
|
|
#define FSCTL_GET_RETRIEVAL_POINTER_BASE CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 141, METHOD_BUFFERED, FILE_ANY_ACCESS) // RETRIEVAL_POINTER_BASE
|
|
#endif
|
|
|
|
#ifndef FILE_SUPPORTS_EXTENDED_ATTRIBUTES
|
|
#define FILE_SUPPORTS_EXTENDED_ATTRIBUTES 0x00800000
|
|
#endif
|
|
|
|
//
|
|
// The following macro is used to determine if an FSD thread can block
|
|
// for I/O or wait for a resource. It returns TRUE if the thread can
|
|
// block and FALSE otherwise. This attribute can then be used to call
|
|
// the FSD & FSP common work routine with the proper wait value.
|
|
//
|
|
|
|
#define CanExt2Wait(IRP) IoIsOperationSynchronous(Irp)
|
|
|
|
//
|
|
// memory allocation statistics
|
|
//
|
|
|
|
#ifdef __REACTOS__
|
|
static
|
|
#endif
|
|
__inline
|
|
VOID
|
|
Ext2TraceMemory(BOOLEAN _n, int _i, PVOID _p, LONG _s)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
#ifdef __REACTOS__
|
|
static
|
|
#endif
|
|
__inline
|
|
VOID
|
|
Ext2TraceIrpContext(BOOLEAN _n, PEXT2_IRP_CONTEXT IrpContext)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
typedef struct _EXT2_FILLDIR_CONTEXT {
|
|
PEXT2_IRP_CONTEXT efc_irp;
|
|
PUCHAR efc_buf;
|
|
ULONG efc_size;
|
|
ULONG efc_start;
|
|
ULONG efc_prev;
|
|
NTSTATUS efc_status;
|
|
FILE_INFORMATION_CLASS efc_fi;
|
|
BOOLEAN efc_single;
|
|
} EXT2_FILLDIR_CONTEXT, *PEXT2_FILLDIR_CONTEXT;
|
|
|
|
//
|
|
// Access.c
|
|
//
|
|
|
|
|
|
int Ext2CheckInodeAccess(PEXT2_VCB Vcb, struct inode *in, int attempt);
|
|
int Ext2CheckFileAccess (PEXT2_VCB Vcb, PEXT2_MCB Mcb, int attempt);
|
|
|
|
//
|
|
// Block.c
|
|
//
|
|
|
|
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);
|
|
|
|
|
|
//
|
|
// Cleanup.c
|
|
//
|
|
|
|
NTSTATUS
|
|
Ext2Cleanup (IN PEXT2_IRP_CONTEXT IrpContext);
|
|
|
|
//
|
|
// Close.c
|
|
//
|
|
|
|
NTSTATUS
|
|
Ext2Close (IN PEXT2_IRP_CONTEXT IrpContext);
|
|
|
|
VOID
|
|
Ext2QueueCloseRequest (IN PEXT2_IRP_CONTEXT IrpContext);
|
|
|
|
VOID NTAPI
|
|
Ext2DeQueueCloseRequest (IN PVOID Context);
|
|
|
|
//
|
|
// Cmcb.c
|
|
//
|
|
|
|
BOOLEAN NTAPI
|
|
Ext2AcquireForLazyWrite (
|
|
IN PVOID Context,
|
|
IN BOOLEAN Wait );
|
|
VOID NTAPI
|
|
Ext2ReleaseFromLazyWrite (IN PVOID Context);
|
|
|
|
BOOLEAN NTAPI
|
|
Ext2AcquireForReadAhead (
|
|
IN PVOID Context,
|
|
IN BOOLEAN Wait );
|
|
|
|
VOID NTAPI
|
|
Ext2ReleaseFromReadAhead (IN PVOID Context);
|
|
|
|
BOOLEAN NTAPI
|
|
Ext2NoOpAcquire (
|
|
IN PVOID Fcb,
|
|
IN BOOLEAN Wait );
|
|
|
|
VOID NTAPI
|
|
Ext2NoOpRelease (IN PVOID Fcb);
|
|
|
|
//
|
|
// Create.c
|
|
//
|
|
|
|
|
|
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
|
|
);
|
|
|
|
#define EXT2_LOOKUP_FLAG_MASK (0xFF00000)
|
|
#define EXT2_LOOKUP_NOT_FOLLOW (0x8000000)
|
|
|
|
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
|
|
);
|
|
|
|
//
|
|
// Debug.c
|
|
//
|
|
|
|
/* debug levels */
|
|
#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)
|
|
|
|
#if EXT2_DEBUG
|
|
extern ULONG DebugFilter;
|
|
|
|
VOID
|
|
__cdecl
|
|
Ext2NiPrintf(
|
|
PCHAR DebugMessage,
|
|
...
|
|
);
|
|
|
|
#define DEBUG(_DL, arg) do {if ((_DL) & DebugFilter) Ext2Printf arg;} while(0)
|
|
#define DEBUGNI(_DL, arg) do {if ((_DL) & DebugFilter) Ext2NiPrintf arg;} while(0)
|
|
|
|
#define Ext2CompleteRequest(Irp, bPrint, PriorityBoost) \
|
|
Ext2DbgPrintComplete(Irp, bPrint); \
|
|
IoCompleteRequest(Irp, PriorityBoost)
|
|
|
|
#else
|
|
|
|
#define DEBUG(_DL, arg) do {if ((_DL) & DL_ERR) DbgPrint arg;} while(0)
|
|
|
|
#define Ext2CompleteRequest(Irp, bPrint, PriorityBoost) \
|
|
IoCompleteRequest(Irp, PriorityBoost)
|
|
|
|
#endif // EXT2_DEBUG
|
|
|
|
VOID
|
|
__cdecl
|
|
Ext2Printf(
|
|
PCHAR DebugMessage,
|
|
...
|
|
);
|
|
|
|
extern ULONG ProcessNameOffset;
|
|
|
|
#define Ext2GetCurrentProcessName() ( \
|
|
(PUCHAR) PsGetCurrentProcess() + ProcessNameOffset \
|
|
)
|
|
|
|
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
|
|
);
|
|
|
|
//
|
|
// Devctl.c
|
|
//
|
|
|
|
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);
|
|
|
|
//
|
|
// Dirctl.c
|
|
//
|
|
|
|
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
|
|
);
|
|
|
|
//
|
|
// Dispatch.c
|
|
//
|
|
|
|
VOID NTAPI
|
|
Ext2OplockComplete (
|
|
IN PVOID Context,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
VOID NTAPI
|
|
Ext2LockIrp (
|
|
IN PVOID Context,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
Ext2QueueRequest (IN PEXT2_IRP_CONTEXT IrpContext);
|
|
|
|
VOID NTAPI
|
|
Ext2DeQueueRequest (IN PVOID Context);
|
|
|
|
NTSTATUS
|
|
Ext2DispatchRequest (IN PEXT2_IRP_CONTEXT IrpContext);
|
|
|
|
NTSTATUS NTAPI
|
|
Ext2BuildRequest (
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
//
|
|
// ea.c
|
|
//
|
|
|
|
NTSTATUS
|
|
Ext2QueryEa(
|
|
IN PEXT2_IRP_CONTEXT IrpContext
|
|
);
|
|
|
|
BOOLEAN
|
|
Ext2IsEaNameValid(
|
|
IN OEM_STRING Name
|
|
);
|
|
|
|
NTSTATUS
|
|
Ext2SetEa(
|
|
IN PEXT2_IRP_CONTEXT IrpContext
|
|
);
|
|
|
|
|
|
//
|
|
// Except.c
|
|
//
|
|
|
|
NTSTATUS
|
|
Ext2ExceptionFilter (
|
|
IN PEXT2_IRP_CONTEXT IrpContext,
|
|
IN PEXCEPTION_POINTERS ExceptionPointer
|
|
);
|
|
|
|
NTSTATUS
|
|
Ext2ExceptionHandler (IN PEXT2_IRP_CONTEXT IrpContext);
|
|
|
|
|
|
//
|
|
// Extents.c
|
|
//
|
|
|
|
|
|
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
|
|
);
|
|
|
|
|
|
//
|
|
// generic.c
|
|
//
|
|
|
|
static inline ext3_fsblk_t ext3_blocks_count(struct ext3_super_block *es)
|
|
{
|
|
return ((ext3_fsblk_t)le32_to_cpu(es->s_blocks_count_hi) << 32) |
|
|
le32_to_cpu(es->s_blocks_count);
|
|
}
|
|
|
|
static inline ext3_fsblk_t ext3_r_blocks_count(struct ext3_super_block *es)
|
|
{
|
|
return ((ext3_fsblk_t)le32_to_cpu(es->s_r_blocks_count_hi) << 32) |
|
|
le32_to_cpu(es->s_r_blocks_count);
|
|
}
|
|
|
|
static inline ext3_fsblk_t ext3_free_blocks_count(struct ext3_super_block *es)
|
|
{
|
|
return ((ext3_fsblk_t)le32_to_cpu(es->s_free_blocks_count_hi) << 32) |
|
|
le32_to_cpu(es->s_free_blocks_count);
|
|
}
|
|
|
|
static inline void ext3_blocks_count_set(struct ext3_super_block *es,
|
|
ext3_fsblk_t blk)
|
|
{
|
|
es->s_blocks_count = cpu_to_le32((u32)blk);
|
|
es->s_blocks_count_hi = cpu_to_le32(blk >> 32);
|
|
}
|
|
|
|
static inline void ext3_free_blocks_count_set(struct ext3_super_block *es,
|
|
ext3_fsblk_t blk)
|
|
{
|
|
es->s_free_blocks_count = cpu_to_le32((u32)blk);
|
|
es->s_free_blocks_count_hi = cpu_to_le32(blk >> 32);
|
|
}
|
|
|
|
static inline void ext3_r_blocks_count_set(struct ext3_super_block *es,
|
|
ext3_fsblk_t blk)
|
|
{
|
|
es->s_r_blocks_count = cpu_to_le32((u32)blk);
|
|
es->s_r_blocks_count_hi = cpu_to_le32(blk >> 32);
|
|
}
|
|
|
|
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);
|
|
struct ext4_group_desc * ext4_get_group_desc(struct super_block *sb,
|
|
ext4_group_t block_group, struct buffer_head **bh);
|
|
int ext4_check_descriptors(struct super_block *sb);
|
|
|
|
//
|
|
// Fastio.c
|
|
//
|
|
|
|
FAST_IO_POSSIBLE
|
|
Ext2IsFastIoPossible(
|
|
IN PEXT2_FCB Fcb
|
|
);
|
|
|
|
BOOLEAN NTAPI
|
|
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 NTAPI
|
|
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 NTAPI
|
|
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 NTAPI
|
|
Ext2FastIoQueryBasicInfo (
|
|
IN PFILE_OBJECT FileObject,
|
|
IN BOOLEAN Wait,
|
|
OUT PFILE_BASIC_INFORMATION Buffer,
|
|
OUT PIO_STATUS_BLOCK IoStatus,
|
|
IN PDEVICE_OBJECT DeviceObject);
|
|
|
|
BOOLEAN NTAPI
|
|
Ext2FastIoQueryStandardInfo (
|
|
IN PFILE_OBJECT FileObject,
|
|
IN BOOLEAN Wait,
|
|
OUT PFILE_STANDARD_INFORMATION Buffer,
|
|
OUT PIO_STATUS_BLOCK IoStatus,
|
|
IN PDEVICE_OBJECT DeviceObject);
|
|
|
|
BOOLEAN NTAPI
|
|
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 NTAPI
|
|
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 NTAPI
|
|
Ext2FastIoUnlockAll (
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PEPROCESS Process,
|
|
OUT PIO_STATUS_BLOCK IoStatus,
|
|
IN PDEVICE_OBJECT DeviceObject
|
|
);
|
|
|
|
BOOLEAN NTAPI
|
|
Ext2FastIoUnlockAllByKey (
|
|
IN PFILE_OBJECT FileObject,
|
|
#ifdef __REACTOS__
|
|
IN PVOID Process,
|
|
#else
|
|
IN PEPROCESS Process,
|
|
#endif
|
|
IN ULONG Key,
|
|
OUT PIO_STATUS_BLOCK IoStatus,
|
|
IN PDEVICE_OBJECT DeviceObject
|
|
);
|
|
|
|
|
|
BOOLEAN NTAPI
|
|
Ext2FastIoQueryNetworkOpenInfo (
|
|
IN PFILE_OBJECT FileObject,
|
|
IN BOOLEAN Wait,
|
|
OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
|
|
OUT PIO_STATUS_BLOCK IoStatus,
|
|
IN PDEVICE_OBJECT DeviceObject );
|
|
|
|
BOOLEAN NTAPI
|
|
Ext2FastIoQueryNetworkOpenInfo (
|
|
IN PFILE_OBJECT FileObject,
|
|
IN BOOLEAN Wait,
|
|
OUT PFILE_NETWORK_OPEN_INFORMATION Buffer,
|
|
OUT PIO_STATUS_BLOCK IoStatus,
|
|
IN PDEVICE_OBJECT DeviceObject);
|
|
|
|
VOID
|
|
NTAPI
|
|
Ext2AcquireForCreateSection (
|
|
IN PFILE_OBJECT FileObject
|
|
);
|
|
|
|
VOID
|
|
NTAPI
|
|
Ext2ReleaseForCreateSection (
|
|
IN PFILE_OBJECT FileObject
|
|
);
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
Ext2AcquireFileForModWrite (
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PLARGE_INTEGER EndingOffset,
|
|
OUT PERESOURCE *ResourceToRelease,
|
|
IN PDEVICE_OBJECT DeviceObject
|
|
);
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
Ext2ReleaseFileForModWrite (
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PERESOURCE ResourceToRelease,
|
|
IN PDEVICE_OBJECT DeviceObject
|
|
);
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
Ext2AcquireFileForCcFlush (
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PDEVICE_OBJECT DeviceObject
|
|
);
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
Ext2ReleaseFileForCcFlush (
|
|
IN PFILE_OBJECT FileObject,
|
|
IN PDEVICE_OBJECT DeviceObject
|
|
);
|
|
|
|
|
|
NTSTATUS
|
|
NTAPI
|
|
Ext2PreAcquireForCreateSection(
|
|
IN PFS_FILTER_CALLBACK_DATA cd,
|
|
OUT PVOID *cc
|
|
);
|
|
|
|
//
|
|
// FileInfo.c
|
|
//
|
|
|
|
|
|
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
|
|
);
|
|
|
|
|
|
//
|
|
// Flush.c
|
|
//
|
|
|
|
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);
|
|
|
|
|
|
//
|
|
// Fsctl.c
|
|
//
|
|
|
|
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
|
|
);
|
|
|
|
//
|
|
// MountPoint process workitem
|
|
//
|
|
|
|
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);
|
|
|
|
//
|
|
// HTree.c
|
|
//
|
|
|
|
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, ...);
|
|
#define ext3_error ext3_warning
|
|
#define ext4_error ext3_error
|
|
|
|
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);
|
|
|
|
typedef int (*filldir_t)(void *, const char *, int, unsigned long, __u32, unsigned);
|
|
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);
|
|
#if !defined(__REACTOS__) || (defined(_MSC_VER) && !defined(__clang__))
|
|
/* FIXME: Inspect the clang-cl code path */
|
|
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);
|
|
#endif
|
|
|
|
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);
|
|
|
|
//
|
|
// Init.c
|
|
//
|
|
|
|
NTSTATUS
|
|
Ext2QueryGlobalParameters(IN PUNICODE_STRING RegistryPath);
|
|
BOOLEAN
|
|
Ext2QueryRegistrySettings(IN PUNICODE_STRING RegistryPath);
|
|
|
|
VOID NTAPI
|
|
DriverUnload (IN PDRIVER_OBJECT DriverObject);
|
|
|
|
//
|
|
// Indirect.c
|
|
//
|
|
|
|
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
|
|
);
|
|
|
|
|
|
//
|
|
// linux.c: linux lib implemenation
|
|
//
|
|
|
|
int
|
|
ext2_init_linux();
|
|
|
|
void
|
|
ext2_destroy_linux();
|
|
|
|
|
|
//
|
|
// Lock.c
|
|
//
|
|
|
|
NTSTATUS
|
|
Ext2LockControl (IN PEXT2_IRP_CONTEXT IrpContext);
|
|
|
|
|
|
//
|
|
// Memory.c
|
|
//
|
|
|
|
VOID
|
|
NTAPI
|
|
Ext2FcbReaperThread(
|
|
PVOID Context
|
|
);
|
|
|
|
VOID
|
|
NTAPI
|
|
Ext2McbReaperThread(
|
|
PVOID Context
|
|
);
|
|
|
|
VOID
|
|
NTAPI
|
|
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 NTAPI
|
|
Ext2ReaperThread(
|
|
PVOID Context
|
|
);
|
|
|
|
NTSTATUS
|
|
Ext2StartReaper(PEXT2_REAPER, EXT2_REAPER_RELEASE);
|
|
VOID
|
|
NTAPI
|
|
Ext2StopReaper(PEXT2_REAPER Reaper);
|
|
|
|
//
|
|
// Misc.c
|
|
//
|
|
|
|
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);
|
|
//
|
|
// nls/nls_rtl.c
|
|
//
|
|
|
|
int
|
|
Ext2LoadAllNls();
|
|
|
|
VOID
|
|
Ext2UnloadAllNls();
|
|
|
|
//
|
|
// Pnp.c
|
|
//
|
|
|
|
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 );
|
|
|
|
|
|
//
|
|
// Read.c
|
|
//
|
|
|
|
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);
|
|
|
|
|
|
//
|
|
// ext3\recover.c
|
|
//
|
|
|
|
PEXT2_MCB
|
|
Ext2LoadInternalJournal(
|
|
PEXT2_VCB Vcb,
|
|
ULONG jNo
|
|
);
|
|
|
|
INT
|
|
Ext2CheckJournal(
|
|
PEXT2_VCB Vcb,
|
|
PULONG jNo
|
|
);
|
|
|
|
INT
|
|
Ext2RecoverJournal(
|
|
PEXT2_IRP_CONTEXT IrpContext,
|
|
PEXT2_VCB Vcb
|
|
);
|
|
|
|
//
|
|
// Shutdown.c
|
|
//
|
|
|
|
|
|
NTSTATUS
|
|
Ext2ShutDown (IN PEXT2_IRP_CONTEXT IrpContext);
|
|
|
|
|
|
//
|
|
// Volinfo.c
|
|
//
|
|
|
|
NTSTATUS
|
|
Ext2QueryVolumeInformation (IN PEXT2_IRP_CONTEXT IrpContext);
|
|
|
|
NTSTATUS
|
|
Ext2SetVolumeInformation (IN PEXT2_IRP_CONTEXT IrpContext);
|
|
|
|
//
|
|
// Write.c
|
|
//
|
|
|
|
typedef struct _EXT2_RW_CONTEXT {
|
|
PIRP MasterIrp;
|
|
KEVENT Event;
|
|
ULONG Blocks;
|
|
ULONG Length;
|
|
PERESOURCE Resource;
|
|
ERESOURCE_THREAD ThreadId;
|
|
PFILE_OBJECT FileObject;
|
|
ULONG Flags;
|
|
BOOLEAN Wait;
|
|
|
|
} EXT2_RW_CONTEXT, *PEXT2_RW_CONTEXT;
|
|
|
|
#define EXT2_RW_CONTEXT_WRITE 1
|
|
|
|
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);
|
|
|
|
#endif /* _EXT2_HEADER_ */
|