mirror of
https://github.com/RGBCube/serenity
synced 2025-07-25 18:37:35 +00:00
Kernel: Split the Ext2FileSystem.{cpp,h} files into smaller components
This commit is contained in:
parent
1c91881a1d
commit
3cc0d60141
15 changed files with 845 additions and 802 deletions
735
Kernel/FileSystem/Ext2FS/Definitions.h
Normal file
735
Kernel/FileSystem/Ext2FS/Definitions.h
Normal file
|
@ -0,0 +1,735 @@
|
|||
/*
|
||||
* linux/include/linux/ext2_fs.h
|
||||
*
|
||||
* Copyright (C) 1992, 1993, 1994, 1995
|
||||
* Remy Card (card@masi.ibp.fr)
|
||||
* Laboratoire MASI - Institut Blaise Pascal
|
||||
* Universite Pierre et Marie Curie (Paris VI)
|
||||
*
|
||||
* from
|
||||
*
|
||||
* linux/include/linux/minix_fs.h
|
||||
*
|
||||
* Copyright (C) 1991, 1992 Linus Torvalds
|
||||
*/
|
||||
|
||||
#ifndef _LINUX_EXT2_FS_H
|
||||
#define _LINUX_EXT2_FS_H
|
||||
|
||||
static constexpr size_t max_block_size = 4096;
|
||||
|
||||
#include "ext2_types.h" /* Changed from linux/types.h */
|
||||
|
||||
/*
|
||||
* The second extended filesystem constants/structures
|
||||
*/
|
||||
|
||||
/*
|
||||
* Define EXT2_PREALLOCATE to preallocate data blocks for expanding files
|
||||
*/
|
||||
#define EXT2_PREALLOCATE
|
||||
#define EXT2_DEFAULT_PREALLOC_BLOCKS 8
|
||||
|
||||
/*
|
||||
* The second extended file system version
|
||||
*/
|
||||
#define EXT2FS_DATE "95/08/09"
|
||||
#define EXT2FS_VERSION "0.5b"
|
||||
|
||||
/*
|
||||
* Special inode numbers
|
||||
*/
|
||||
#define EXT2_BAD_INO 1 /* Bad blocks inode */
|
||||
#define EXT2_ROOT_INO 2 /* Root inode */
|
||||
#define EXT2_ACL_IDX_INO 3 /* ACL inode */
|
||||
#define EXT2_ACL_DATA_INO 4 /* ACL inode */
|
||||
#define EXT2_BOOT_LOADER_INO 5 /* Boot loader inode */
|
||||
#define EXT2_UNDEL_DIR_INO 6 /* Undelete directory inode */
|
||||
#define EXT2_RESIZE_INO 7 /* Reserved group descriptors inode */
|
||||
#define EXT2_JOURNAL_INO 8 /* Journal inode */
|
||||
|
||||
/* First non-reserved inode for old ext2 filesystems */
|
||||
#define EXT2_GOOD_OLD_FIRST_INO 11
|
||||
|
||||
/*
|
||||
* The second extended file system magic number
|
||||
*/
|
||||
#define EXT2_SUPER_MAGIC 0xEF53
|
||||
|
||||
#ifdef __KERNEL__
|
||||
# define EXT2_SB(sb) (&((sb)->u.ext2_sb))
|
||||
#else
|
||||
/* Assume that user mode programs are passing in an ext2fs superblock, not
|
||||
* a kernel struct super_block. This will allow us to call the feature-test
|
||||
* macros from user land. */
|
||||
# define EXT2_SB(sb) (sb)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Maximal count of links to a file
|
||||
*/
|
||||
#define EXT2_LINK_MAX 65000
|
||||
|
||||
/*
|
||||
* Macro-instructions used to manage several block sizes
|
||||
*/
|
||||
#define EXT2_MIN_BLOCK_LOG_SIZE 10 /* 1024 */
|
||||
#define EXT2_MAX_BLOCK_LOG_SIZE 16 /* 65536 */
|
||||
#define EXT2_MIN_BLOCK_SIZE (1 << EXT2_MIN_BLOCK_LOG_SIZE)
|
||||
#define EXT2_MAX_BLOCK_SIZE (1 << EXT2_MAX_BLOCK_LOG_SIZE)
|
||||
#ifdef __KERNEL__
|
||||
# define EXT2_BLOCK_SIZE(s) ((s)->s_blocksize)
|
||||
# define EXT2_BLOCK_SIZE_BITS(s) ((s)->s_blocksize_bits)
|
||||
# define EXT2_ADDR_PER_BLOCK_BITS(s) (EXT2_SB(s)->addr_per_block_bits)
|
||||
# define EXT2_INODE_SIZE(s) (EXT2_SB(s)->s_inode_size)
|
||||
# define EXT2_FIRST_INO(s) (EXT2_SB(s)->s_first_ino)
|
||||
#else
|
||||
# define EXT2_BLOCK_SIZE(s) (EXT2_MIN_BLOCK_SIZE << (s)->s_log_block_size)
|
||||
# define EXT2_BLOCK_SIZE_BITS(s) ((s)->s_log_block_size + 10)
|
||||
# define EXT2_INODE_SIZE(s) (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? EXT2_GOOD_OLD_INODE_SIZE : (s)->s_inode_size)
|
||||
# define EXT2_FIRST_INO(s) (((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? EXT2_GOOD_OLD_FIRST_INO : (s)->s_first_ino)
|
||||
#endif
|
||||
#define EXT2_ADDR_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / sizeof(__u32))
|
||||
|
||||
/*
|
||||
* Macro-instructions used to manage fragments
|
||||
*/
|
||||
#define EXT2_MIN_FRAG_SIZE EXT2_MIN_BLOCK_SIZE
|
||||
#define EXT2_MAX_FRAG_SIZE EXT2_MAX_BLOCK_SIZE
|
||||
#define EXT2_MIN_FRAG_LOG_SIZE EXT2_MIN_BLOCK_LOG_SIZE
|
||||
#ifdef __KERNEL__
|
||||
# define EXT2_FRAG_SIZE(s) (EXT2_SB(s)->s_frag_size)
|
||||
# define EXT2_FRAGS_PER_BLOCK(s) (EXT2_SB(s)->s_frags_per_block)
|
||||
#else
|
||||
# define EXT2_FRAG_SIZE(s) (EXT2_MIN_FRAG_SIZE << (s)->s_log_frag_size)
|
||||
# define EXT2_FRAGS_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / EXT2_FRAG_SIZE(s))
|
||||
#endif
|
||||
|
||||
/*
|
||||
* ACL structures
|
||||
*/
|
||||
struct ext2_acl_header /* Header of Access Control Lists */
|
||||
{
|
||||
__u32 aclh_size;
|
||||
__u32 aclh_file_count;
|
||||
__u32 aclh_acle_count;
|
||||
__u32 aclh_first_acle;
|
||||
};
|
||||
|
||||
struct ext2_acl_entry /* Access Control List Entry */
|
||||
{
|
||||
__u32 acle_size;
|
||||
__u16 acle_perms; /* Access permissions */
|
||||
__u16 acle_type; /* Type of entry */
|
||||
__u16 acle_tag; /* User or group identity */
|
||||
__u16 acle_pad1;
|
||||
__u32 acle_next; /* Pointer on next entry for the */
|
||||
/* same inode or on next free entry */
|
||||
};
|
||||
|
||||
/*
|
||||
* Structure of a blocks group descriptor
|
||||
*/
|
||||
struct ext2_group_desc {
|
||||
__u32 bg_block_bitmap; /* Blocks bitmap block */
|
||||
__u32 bg_inode_bitmap; /* Inodes bitmap block */
|
||||
__u32 bg_inode_table; /* Inodes table block */
|
||||
__u16 bg_free_blocks_count; /* Free blocks count */
|
||||
__u16 bg_free_inodes_count; /* Free inodes count */
|
||||
__u16 bg_used_dirs_count; /* Directories count */
|
||||
__u16 bg_flags;
|
||||
__u32 bg_reserved[2];
|
||||
__u16 bg_itable_unused; /* Unused inodes count */
|
||||
__u16 bg_checksum; /* crc16(s_uuid+group_num+group_desc)*/
|
||||
};
|
||||
|
||||
struct ext4_group_desc {
|
||||
__u32 bg_block_bitmap; /* Blocks bitmap block */
|
||||
__u32 bg_inode_bitmap; /* Inodes bitmap block */
|
||||
__u32 bg_inode_table; /* Inodes table block */
|
||||
__u16 bg_free_blocks_count; /* Free blocks count */
|
||||
__u16 bg_free_inodes_count; /* Free inodes count */
|
||||
__u16 bg_used_dirs_count; /* Directories count */
|
||||
__u16 bg_flags;
|
||||
__u32 bg_reserved[2];
|
||||
__u16 bg_itable_unused; /* Unused inodes count */
|
||||
__u16 bg_checksum; /* crc16(s_uuid+group_num+group_desc)*/
|
||||
__u32 bg_block_bitmap_hi; /* Blocks bitmap block MSB */
|
||||
__u32 bg_inode_bitmap_hi; /* Inodes bitmap block MSB */
|
||||
__u32 bg_inode_table_hi; /* Inodes table block MSB */
|
||||
__u16 bg_free_blocks_count_hi; /* Free blocks count MSB */
|
||||
__u16 bg_free_inodes_count_hi; /* Free inodes count MSB */
|
||||
__u16 bg_used_dirs_count_hi; /* Directories count MSB */
|
||||
__u16 bg_pad;
|
||||
__u32 bg_reserved2[3];
|
||||
};
|
||||
|
||||
#define EXT2_BG_INODE_UNINIT 0x0001 /* Inode table/bitmap not initialized */
|
||||
#define EXT2_BG_BLOCK_UNINIT 0x0002 /* Block bitmap not initialized */
|
||||
#define EXT2_BG_INODE_ZEROED 0x0004 /* On-disk itable initialized to zero */
|
||||
|
||||
/*
|
||||
* Data structures used by the directory indexing feature
|
||||
*
|
||||
* Note: all of the multibyte integer fields are little endian.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Note: dx_root_info is laid out so that if it should somehow get
|
||||
* overlaid by a dirent the two low bits of the hash version will be
|
||||
* zero. Therefore, the hash version mod 4 should never be 0.
|
||||
* Sincerely, the paranoia department.
|
||||
*/
|
||||
struct ext2_dx_root_info {
|
||||
__u32 reserved_zero;
|
||||
__u8 hash_version; /* 0 now, 1 at release */
|
||||
__u8 info_length; /* 8 */
|
||||
__u8 indirect_levels;
|
||||
__u8 unused_flags;
|
||||
};
|
||||
|
||||
#define EXT2_HASH_LEGACY 0
|
||||
#define EXT2_HASH_HALF_MD4 1
|
||||
#define EXT2_HASH_TEA 2
|
||||
#define EXT2_HASH_LEGACY_UNSIGNED 3 /* reserved for userspace lib */
|
||||
#define EXT2_HASH_HALF_MD4_UNSIGNED 4 /* reserved for userspace lib */
|
||||
#define EXT2_HASH_TEA_UNSIGNED 5 /* reserved for userspace lib */
|
||||
|
||||
#define EXT2_HASH_FLAG_INCOMPAT 0x1
|
||||
|
||||
struct ext2_dx_entry {
|
||||
__u32 hash;
|
||||
__u32 block;
|
||||
};
|
||||
|
||||
struct ext2_dx_countlimit {
|
||||
__u16 limit;
|
||||
__u16 count;
|
||||
};
|
||||
|
||||
/*
|
||||
* Macro-instructions used to manage group descriptors
|
||||
*/
|
||||
#define EXT2_MIN_DESC_SIZE 32
|
||||
#define EXT2_MIN_DESC_SIZE_64BIT 64
|
||||
#define EXT2_MAX_DESC_SIZE EXT2_MIN_BLOCK_SIZE
|
||||
#define EXT2_DESC_SIZE(s) \
|
||||
((EXT2_SB(s)->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) ? (s)->s_desc_size : EXT2_MIN_DESC_SIZE)
|
||||
|
||||
#define EXT2_BLOCKS_PER_GROUP(s) (EXT2_SB(s)->s_blocks_per_group)
|
||||
#define EXT2_INODES_PER_GROUP(s) (EXT2_SB(s)->s_inodes_per_group)
|
||||
#define EXT2_INODES_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / EXT2_INODE_SIZE(s))
|
||||
/* limits imposed by 16-bit value gd_free_{blocks,inode}_count */
|
||||
#define EXT2_MAX_BLOCKS_PER_GROUP(s) ((1 << 16) - 8)
|
||||
#define EXT2_MAX_INODES_PER_GROUP(s) ((1 << 16) - EXT2_INODES_PER_BLOCK(s))
|
||||
#ifdef __KERNEL__
|
||||
# define EXT2_DESC_PER_BLOCK(s) (EXT2_SB(s)->s_desc_per_block)
|
||||
# define EXT2_DESC_PER_BLOCK_BITS(s) (EXT2_SB(s)->s_desc_per_block_bits)
|
||||
#else
|
||||
# define EXT2_DESC_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s) / EXT2_DESC_SIZE(s))
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Constants relative to the data blocks
|
||||
*/
|
||||
#define EXT2_NDIR_BLOCKS 12
|
||||
#define EXT2_IND_BLOCK EXT2_NDIR_BLOCKS
|
||||
#define EXT2_DIND_BLOCK (EXT2_IND_BLOCK + 1)
|
||||
#define EXT2_TIND_BLOCK (EXT2_DIND_BLOCK + 1)
|
||||
#define EXT2_N_BLOCKS (EXT2_TIND_BLOCK + 1)
|
||||
|
||||
/*
|
||||
* Inode flags
|
||||
*/
|
||||
#define EXT2_SECRM_FL 0x00000001 /* Secure deletion */
|
||||
#define EXT2_UNRM_FL 0x00000002 /* Undelete */
|
||||
#define EXT2_COMPR_FL 0x00000004 /* Compress file */
|
||||
#define EXT2_SYNC_FL 0x00000008 /* Synchronous updates */
|
||||
#define EXT2_IMMUTABLE_FL 0x00000010 /* Immutable file */
|
||||
#define EXT2_APPEND_FL 0x00000020 /* writes to file may only append */
|
||||
#define EXT2_NODUMP_FL 0x00000040 /* do not dump file */
|
||||
#define EXT2_NOATIME_FL 0x00000080 /* do not update atime */
|
||||
/* Reserved for compression usage... */
|
||||
#define EXT2_DIRTY_FL 0x00000100
|
||||
#define EXT2_COMPRBLK_FL 0x00000200 /* One or more compressed clusters */
|
||||
#define EXT2_NOCOMPR_FL 0x00000400 /* Access raw compressed data */
|
||||
#define EXT2_ECOMPR_FL 0x00000800 /* Compression error */
|
||||
/* End compression flags --- maybe not all used */
|
||||
#define EXT2_BTREE_FL 0x00001000 /* btree format dir */
|
||||
#define EXT2_INDEX_FL 0x00001000 /* hash-indexed directory */
|
||||
#define EXT2_IMAGIC_FL 0x00002000
|
||||
#define EXT3_JOURNAL_DATA_FL 0x00004000 /* file data should be journaled */
|
||||
#define EXT2_NOTAIL_FL 0x00008000 /* file tail should not be merged */
|
||||
#define EXT2_DIRSYNC_FL 0x00010000 /* Synchronous directory modifications */
|
||||
#define EXT2_TOPDIR_FL 0x00020000 /* Top of directory hierarchies*/
|
||||
#define EXT4_HUGE_FILE_FL 0x00040000 /* Set to each huge file */
|
||||
#define EXT4_EXTENTS_FL 0x00080000 /* Inode uses extents */
|
||||
#define EXT2_RESERVED_FL 0x80000000 /* reserved for ext2 lib */
|
||||
|
||||
#define EXT2_FL_USER_VISIBLE 0x000BDFFF /* User visible flags */
|
||||
#define EXT2_FL_USER_MODIFIABLE 0x000080FF /* User modifiable flags */
|
||||
|
||||
/*
|
||||
* ioctl commands
|
||||
*/
|
||||
|
||||
/* Used for online resize */
|
||||
struct ext2_new_group_input {
|
||||
__u32 group; /* Group number for this data */
|
||||
__u32 block_bitmap; /* Absolute block number of block bitmap */
|
||||
__u32 inode_bitmap; /* Absolute block number of inode bitmap */
|
||||
__u32 inode_table; /* Absolute block number of inode table start */
|
||||
__u32 blocks_count; /* Total number of blocks in this group */
|
||||
__u16 reserved_blocks; /* Number of reserved blocks in this group */
|
||||
__u16 unused; /* Number of reserved GDT blocks in group */
|
||||
};
|
||||
|
||||
struct ext4_new_group_input {
|
||||
__u32 group; /* Group number for this data */
|
||||
__u64 block_bitmap; /* Absolute block number of block bitmap */
|
||||
__u64 inode_bitmap; /* Absolute block number of inode bitmap */
|
||||
__u64 inode_table; /* Absolute block number of inode table start */
|
||||
__u32 blocks_count; /* Total number of blocks in this group */
|
||||
__u16 reserved_blocks; /* Number of reserved blocks in this group */
|
||||
__u16 unused;
|
||||
};
|
||||
|
||||
#ifdef __GNU__ /* Needed for the Hurd */
|
||||
# define _IOT_ext2_new_group_input _IOT(_IOTS(__u32), 5, _IOTS(__u16), 2, 0, 0)
|
||||
#endif
|
||||
|
||||
#define EXT2_IOC_GETFLAGS _IOR('f', 1, long)
|
||||
#define EXT2_IOC_SETFLAGS _IOW('f', 2, long)
|
||||
#define EXT2_IOC_GETVERSION _IOR('v', 1, long)
|
||||
#define EXT2_IOC_SETVERSION _IOW('v', 2, long)
|
||||
#define EXT2_IOC_GETVERSION_NEW _IOR('f', 3, long)
|
||||
#define EXT2_IOC_SETVERSION_NEW _IOW('f', 4, long)
|
||||
#define EXT2_IOC_GROUP_EXTEND _IOW('f', 7, unsigned long)
|
||||
#define EXT2_IOC_GROUP_ADD _IOW('f', 8, struct ext2_new_group_input)
|
||||
#define EXT4_IOC_GROUP_ADD _IOW('f', 8, struct ext4_new_group_input)
|
||||
|
||||
/*
|
||||
* Structure of an inode on the disk
|
||||
*/
|
||||
struct ext2_inode {
|
||||
__u16 i_mode; /* File mode */
|
||||
__u16 i_uid; /* Low 16 bits of Owner Uid */
|
||||
__u32 i_size; /* Size in bytes */
|
||||
__u32 i_atime; /* Access time */
|
||||
__u32 i_ctime; /* Inode change time */
|
||||
__u32 i_mtime; /* Modification time */
|
||||
__u32 i_dtime; /* Deletion Time */
|
||||
__u16 i_gid; /* Low 16 bits of Group Id */
|
||||
__u16 i_links_count; /* Links count */
|
||||
__u32 i_blocks; /* Blocks count */
|
||||
__u32 i_flags; /* File flags */
|
||||
union {
|
||||
struct {
|
||||
__u32 l_i_version; /* was l_i_reserved1 */
|
||||
} linux1;
|
||||
struct {
|
||||
__u32 h_i_translator;
|
||||
} hurd1;
|
||||
} osd1; /* OS dependent 1 */
|
||||
__u32 i_block[EXT2_N_BLOCKS]; /* Pointers to blocks */
|
||||
__u32 i_generation; /* File version (for NFS) */
|
||||
__u32 i_file_acl; /* File ACL */
|
||||
__u32 i_dir_acl; /* Directory ACL */
|
||||
__u32 i_faddr; /* Fragment address */
|
||||
union {
|
||||
struct {
|
||||
__u16 l_i_blocks_hi;
|
||||
__u16 l_i_file_acl_high;
|
||||
__u16 l_i_uid_high; /* these 2 fields */
|
||||
__u16 l_i_gid_high; /* were reserved2[0] */
|
||||
__u32 l_i_reserved2;
|
||||
} linux2;
|
||||
struct {
|
||||
__u8 h_i_frag; /* Fragment number */
|
||||
__u8 h_i_fsize; /* Fragment size */
|
||||
__u16 h_i_mode_high;
|
||||
__u16 h_i_uid_high;
|
||||
__u16 h_i_gid_high;
|
||||
__u32 h_i_author;
|
||||
} hurd2;
|
||||
} osd2; /* OS dependent 2 */
|
||||
};
|
||||
|
||||
/*
|
||||
* Permanent part of an large inode on the disk
|
||||
*/
|
||||
struct ext2_inode_large {
|
||||
__u16 i_mode; /* File mode */
|
||||
__u16 i_uid; /* Low 16 bits of Owner Uid */
|
||||
__u32 i_size; /* Size in bytes */
|
||||
__u32 i_atime; /* Access time */
|
||||
__u32 i_ctime; /* Inode Change time */
|
||||
__u32 i_mtime; /* Modification time */
|
||||
__u32 i_dtime; /* Deletion Time */
|
||||
__u16 i_gid; /* Low 16 bits of Group Id */
|
||||
__u16 i_links_count; /* Links count */
|
||||
__u32 i_blocks; /* Blocks count */
|
||||
__u32 i_flags; /* File flags */
|
||||
union {
|
||||
struct {
|
||||
__u32 l_i_version; /* was l_i_reserved1 */
|
||||
} linux1;
|
||||
struct {
|
||||
__u32 h_i_translator;
|
||||
} hurd1;
|
||||
} osd1; /* OS dependent 1 */
|
||||
__u32 i_block[EXT2_N_BLOCKS]; /* Pointers to blocks */
|
||||
__u32 i_generation; /* File version (for NFS) */
|
||||
__u32 i_file_acl; /* File ACL */
|
||||
__u32 i_dir_acl; /* Directory ACL */
|
||||
__u32 i_faddr; /* Fragment address */
|
||||
union {
|
||||
struct {
|
||||
__u16 l_i_blocks_hi;
|
||||
__u16 l_i_file_acl_high;
|
||||
__u16 l_i_uid_high; /* these 2 fields */
|
||||
__u16 l_i_gid_high; /* were reserved2[0] */
|
||||
__u32 l_i_reserved2;
|
||||
} linux2;
|
||||
struct {
|
||||
__u8 h_i_frag; /* Fragment number */
|
||||
__u8 h_i_fsize; /* Fragment size */
|
||||
__u16 h_i_mode_high;
|
||||
__u16 h_i_uid_high;
|
||||
__u16 h_i_gid_high;
|
||||
__u32 h_i_author;
|
||||
} hurd2;
|
||||
} osd2; /* OS dependent 2 */
|
||||
__u16 i_extra_isize;
|
||||
__u16 i_pad1;
|
||||
__u32 i_ctime_extra; /* extra Change time (nsec << 2 | epoch) */
|
||||
__u32 i_mtime_extra; /* extra Modification time (nsec << 2 | epoch) */
|
||||
__u32 i_atime_extra; /* extra Access time (nsec << 2 | epoch) */
|
||||
__u32 i_crtime; /* File creation time */
|
||||
__u32 i_crtime_extra; /* extra File creation time (nsec << 2 | epoch)*/
|
||||
__u32 i_version_hi; /* high 32 bits for 64-bit version */
|
||||
};
|
||||
|
||||
#define i_size_high i_dir_acl
|
||||
|
||||
#if defined(__KERNEL__) || defined(__linux__)
|
||||
# define i_reserved1 osd1.linux1.l_i_reserved1
|
||||
# define i_frag osd2.linux2.l_i_frag
|
||||
# define i_fsize osd2.linux2.l_i_fsize
|
||||
# define i_uid_low i_uid
|
||||
# define i_gid_low i_gid
|
||||
# define i_uid_high osd2.linux2.l_i_uid_high
|
||||
# define i_gid_high osd2.linux2.l_i_gid_high
|
||||
# define i_reserved2 osd2.linux2.l_i_reserved2
|
||||
#else
|
||||
# if defined(__GNU__)
|
||||
|
||||
# define i_translator osd1.hurd1.h_i_translator
|
||||
# define i_frag osd2.hurd2.h_i_frag;
|
||||
# define i_fsize osd2.hurd2.h_i_fsize;
|
||||
# define i_uid_high osd2.hurd2.h_i_uid_high
|
||||
# define i_gid_high osd2.hurd2.h_i_gid_high
|
||||
# define i_author osd2.hurd2.h_i_author
|
||||
|
||||
# endif /* __GNU__ */
|
||||
#endif /* defined(__KERNEL__) || defined(__linux__) */
|
||||
|
||||
#define inode_uid(inode) ((inode).i_uid | (inode).osd2.linux2.l_i_uid_high << 16)
|
||||
#define inode_gid(inode) ((inode).i_gid | (inode).osd2.linux2.l_i_gid_high << 16)
|
||||
#define ext2fs_set_i_uid_high(inode, x) ((inode).osd2.linux2.l_i_uid_high = (x))
|
||||
#define ext2fs_set_i_gid_high(inode, x) ((inode).osd2.linux2.l_i_gid_high = (x))
|
||||
|
||||
/*
|
||||
* File system states
|
||||
*/
|
||||
#define EXT2_VALID_FS 0x0001 /* Unmounted cleanly */
|
||||
#define EXT2_ERROR_FS 0x0002 /* Errors detected */
|
||||
#define EXT3_ORPHAN_FS 0x0004 /* Orphans being recovered */
|
||||
|
||||
/*
|
||||
* Misc. filesystem flags
|
||||
*/
|
||||
#define EXT2_FLAGS_SIGNED_HASH 0x0001 /* Signed dirhash in use */
|
||||
#define EXT2_FLAGS_UNSIGNED_HASH 0x0002 /* Unsigned dirhash in use */
|
||||
#define EXT2_FLAGS_TEST_FILESYS 0x0004 /* OK for use on development code */
|
||||
|
||||
/*
|
||||
* Mount flags
|
||||
*/
|
||||
#define EXT2_MOUNT_CHECK 0x0001 /* Do mount-time checks */
|
||||
#define EXT2_MOUNT_GRPID 0x0004 /* Create files with directory's group */
|
||||
#define EXT2_MOUNT_DEBUG 0x0008 /* Some debugging messages */
|
||||
#define EXT2_MOUNT_ERRORS_CONT 0x0010 /* Continue on errors */
|
||||
#define EXT2_MOUNT_ERRORS_RO 0x0020 /* Remount fs ro on errors */
|
||||
#define EXT2_MOUNT_ERRORS_PANIC 0x0040 /* Panic on errors */
|
||||
#define EXT2_MOUNT_MINIX_DF 0x0080 /* Mimics the Minix statfs */
|
||||
#define EXT2_MOUNT_NO_UID32 0x0200 /* Disable 32-bit UIDs */
|
||||
|
||||
#define clear_opt(o, opt) o &= ~EXT2_MOUNT_##opt
|
||||
#define set_opt(o, opt) o |= EXT2_MOUNT_##opt
|
||||
#define test_opt(sb, opt) (EXT2_SB(sb)->s_mount_opt & EXT2_MOUNT_##opt)
|
||||
/*
|
||||
* Maximal mount counts between two filesystem checks
|
||||
*/
|
||||
#define EXT2_DFL_MAX_MNT_COUNT 20 /* Allow 20 mounts */
|
||||
#define EXT2_DFL_CHECKINTERVAL 0 /* Don't use interval check */
|
||||
|
||||
/*
|
||||
* Behavior when detecting errors
|
||||
*/
|
||||
#define EXT2_ERRORS_CONTINUE 1 /* Continue execution */
|
||||
#define EXT2_ERRORS_RO 2 /* Remount fs read-only */
|
||||
#define EXT2_ERRORS_PANIC 3 /* Panic */
|
||||
#define EXT2_ERRORS_DEFAULT EXT2_ERRORS_CONTINUE
|
||||
|
||||
/*
|
||||
* Structure of the super block
|
||||
*/
|
||||
struct ext2_super_block {
|
||||
__u32 s_inodes_count; /* Inodes count */
|
||||
__u32 s_blocks_count; /* Blocks count */
|
||||
__u32 s_r_blocks_count; /* Reserved blocks count */
|
||||
__u32 s_free_blocks_count; /* Free blocks count */
|
||||
__u32 s_free_inodes_count; /* Free inodes count */
|
||||
__u32 s_first_data_block; /* First Data Block */
|
||||
__u32 s_log_block_size; /* Block size */
|
||||
__s32 s_log_frag_size; /* Fragment size */
|
||||
__u32 s_blocks_per_group; /* # Blocks per group */
|
||||
__u32 s_frags_per_group; /* # Fragments per group */
|
||||
__u32 s_inodes_per_group; /* # Inodes per group */
|
||||
__u32 s_mtime; /* Mount time */
|
||||
__u32 s_wtime; /* Write time */
|
||||
__u16 s_mnt_count; /* Mount count */
|
||||
__s16 s_max_mnt_count; /* Maximal mount count */
|
||||
__u16 s_magic; /* Magic signature */
|
||||
__u16 s_state; /* File system state */
|
||||
__u16 s_errors; /* Behavior when detecting errors */
|
||||
__u16 s_minor_rev_level; /* minor revision level */
|
||||
__u32 s_lastcheck; /* time of last check */
|
||||
__u32 s_checkinterval; /* max. time between checks */
|
||||
__u32 s_creator_os; /* OS */
|
||||
__u32 s_rev_level; /* Revision level */
|
||||
__u16 s_def_resuid; /* Default uid for reserved blocks */
|
||||
__u16 s_def_resgid; /* Default gid for reserved blocks */
|
||||
/*
|
||||
* These fields are for EXT2_DYNAMIC_REV superblocks only.
|
||||
*
|
||||
* Note: the difference between the compatible feature set and
|
||||
* the incompatible feature set is that if there is a bit set
|
||||
* in the incompatible feature set that the kernel doesn't
|
||||
* know about, it should refuse to mount the filesystem.
|
||||
*
|
||||
* e2fsck's requirements are more strict; if it doesn't know
|
||||
* about a feature in either the compatible or incompatible
|
||||
* feature set, it must abort and not try to meddle with
|
||||
* things it doesn't understand...
|
||||
*/
|
||||
__u32 s_first_ino; /* First non-reserved inode */
|
||||
__u16 s_inode_size; /* size of inode structure */
|
||||
__u16 s_block_group_nr; /* block group # of this superblock */
|
||||
__u32 s_feature_compat; /* compatible feature set */
|
||||
__u32 s_feature_incompat; /* incompatible feature set */
|
||||
__u32 s_feature_ro_compat; /* readonly-compatible feature set */
|
||||
__u8 s_uuid[16]; /* 128-bit uuid for volume */
|
||||
char s_volume_name[16]; /* volume name */
|
||||
char s_last_mounted[64]; /* directory where last mounted */
|
||||
__u32 s_algorithm_usage_bitmap; /* For compression */
|
||||
/*
|
||||
* Performance hints. Directory preallocation should only
|
||||
* happen if the EXT2_FEATURE_COMPAT_DIR_PREALLOC flag is on.
|
||||
*/
|
||||
__u8 s_prealloc_blocks; /* Nr of blocks to try to preallocate*/
|
||||
__u8 s_prealloc_dir_blocks; /* Nr to preallocate for dirs */
|
||||
__u16 s_reserved_gdt_blocks; /* Per group table for online growth */
|
||||
/*
|
||||
* Journaling support valid if EXT2_FEATURE_COMPAT_HAS_JOURNAL set.
|
||||
*/
|
||||
__u8 s_journal_uuid[16]; /* uuid of journal superblock */
|
||||
__u32 s_journal_inum; /* inode number of journal file */
|
||||
__u32 s_journal_dev; /* device number of journal file */
|
||||
__u32 s_last_orphan; /* start of list of inodes to delete */
|
||||
__u32 s_hash_seed[4]; /* HTREE hash seed */
|
||||
__u8 s_def_hash_version; /* Default hash version to use */
|
||||
__u8 s_jnl_backup_type; /* Default type of journal backup */
|
||||
__u16 s_desc_size; /* Group desc. size: INCOMPAT_64BIT */
|
||||
__u32 s_default_mount_opts;
|
||||
__u32 s_first_meta_bg; /* First metablock group */
|
||||
__u32 s_mkfs_time; /* When the filesystem was created */
|
||||
__u32 s_jnl_blocks[17]; /* Backup of the journal inode */
|
||||
__u32 s_blocks_count_hi; /* Blocks count high 32bits */
|
||||
__u32 s_r_blocks_count_hi; /* Reserved blocks count high 32 bits*/
|
||||
__u32 s_free_blocks_hi; /* Free blocks count */
|
||||
__u16 s_min_extra_isize; /* All inodes have at least # bytes */
|
||||
__u16 s_want_extra_isize; /* New inodes should reserve # bytes */
|
||||
__u32 s_flags; /* Miscellaneous flags */
|
||||
__u16 s_raid_stride; /* RAID stride */
|
||||
__u16 s_mmp_interval; /* # seconds to wait in MMP checking */
|
||||
__u64 s_mmp_block; /* Block for multi-mount protection */
|
||||
__u32 s_raid_stripe_width; /* blocks on all data disks (N*stride)*/
|
||||
__u8 s_log_groups_per_flex; /* FLEX_BG group size */
|
||||
__u8 s_reserved_char_pad;
|
||||
__u16 s_reserved_pad; /* Padding to next 32bits */
|
||||
__u32 s_reserved[162]; /* Padding to the end of the block */
|
||||
};
|
||||
|
||||
/*
|
||||
* Codes for operating systems
|
||||
*/
|
||||
#define EXT2_OS_LINUX 0
|
||||
#define EXT2_OS_HURD 1
|
||||
#define EXT2_OBSO_OS_MASIX 2
|
||||
#define EXT2_OS_FREEBSD 3
|
||||
#define EXT2_OS_LITES 4
|
||||
|
||||
/*
|
||||
* Revision levels
|
||||
*/
|
||||
#define EXT2_GOOD_OLD_REV 0 /* The good old (original) format */
|
||||
#define EXT2_DYNAMIC_REV 1 /* V2 format w/ dynamic inode sizes */
|
||||
|
||||
#define EXT2_CURRENT_REV EXT2_GOOD_OLD_REV
|
||||
#define EXT2_MAX_SUPP_REV EXT2_DYNAMIC_REV
|
||||
|
||||
#define EXT2_GOOD_OLD_INODE_SIZE 128
|
||||
|
||||
/*
|
||||
* Journal inode backup types
|
||||
*/
|
||||
#define EXT3_JNL_BACKUP_BLOCKS 1
|
||||
|
||||
/*
|
||||
* Feature set definitions
|
||||
*/
|
||||
|
||||
#define EXT2_HAS_COMPAT_FEATURE(sb, mask) \
|
||||
(EXT2_SB(sb)->s_feature_compat & (mask))
|
||||
#define EXT2_HAS_RO_COMPAT_FEATURE(sb, mask) \
|
||||
(EXT2_SB(sb)->s_feature_ro_compat & (mask))
|
||||
#define EXT2_HAS_INCOMPAT_FEATURE(sb, mask) \
|
||||
(EXT2_SB(sb)->s_feature_incompat & (mask))
|
||||
|
||||
#define EXT2_FEATURE_COMPAT_DIR_PREALLOC 0x0001
|
||||
#define EXT2_FEATURE_COMPAT_IMAGIC_INODES 0x0002
|
||||
#define EXT3_FEATURE_COMPAT_HAS_JOURNAL 0x0004
|
||||
#define EXT2_FEATURE_COMPAT_EXT_ATTR 0x0008
|
||||
#define EXT2_FEATURE_COMPAT_RESIZE_INODE 0x0010
|
||||
#define EXT2_FEATURE_COMPAT_DIR_INDEX 0x0020
|
||||
#define EXT2_FEATURE_COMPAT_LAZY_BG 0x0040
|
||||
|
||||
#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER 0x0001
|
||||
#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE 0x0002
|
||||
/* #define EXT2_FEATURE_RO_COMPAT_BTREE_DIR 0x0004 not used */
|
||||
#define EXT4_FEATURE_RO_COMPAT_HUGE_FILE 0x0008
|
||||
#define EXT4_FEATURE_RO_COMPAT_GDT_CSUM 0x0010
|
||||
#define EXT4_FEATURE_RO_COMPAT_DIR_NLINK 0x0020
|
||||
#define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE 0x0040
|
||||
|
||||
#define EXT2_FEATURE_INCOMPAT_COMPRESSION 0x0001
|
||||
#define EXT2_FEATURE_INCOMPAT_FILETYPE 0x0002
|
||||
#define EXT3_FEATURE_INCOMPAT_RECOVER 0x0004 /* Needs recovery */
|
||||
#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV 0x0008 /* Journal device */
|
||||
#define EXT2_FEATURE_INCOMPAT_META_BG 0x0010
|
||||
#define EXT3_FEATURE_INCOMPAT_EXTENTS 0x0040
|
||||
#define EXT4_FEATURE_INCOMPAT_64BIT 0x0080
|
||||
#define EXT4_FEATURE_INCOMPAT_MMP 0x0100
|
||||
#define EXT4_FEATURE_INCOMPAT_FLEX_BG 0x0200
|
||||
|
||||
#define EXT2_FEATURE_COMPAT_SUPP 0
|
||||
#define EXT2_FEATURE_INCOMPAT_SUPP (EXT2_FEATURE_INCOMPAT_FILETYPE)
|
||||
#define EXT2_FEATURE_RO_COMPAT_SUPP (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER | EXT2_FEATURE_RO_COMPAT_LARGE_FILE | EXT4_FEATURE_RO_COMPAT_DIR_NLINK | EXT2_FEATURE_RO_COMPAT_BTREE_DIR)
|
||||
|
||||
/*
|
||||
* Default values for user and/or group using reserved blocks
|
||||
*/
|
||||
#define EXT2_DEF_RESUID 0
|
||||
#define EXT2_DEF_RESGID 0
|
||||
|
||||
/*
|
||||
* Default mount options
|
||||
*/
|
||||
#define EXT2_DEFM_DEBUG 0x0001
|
||||
#define EXT2_DEFM_BSDGROUPS 0x0002
|
||||
#define EXT2_DEFM_XATTR_USER 0x0004
|
||||
#define EXT2_DEFM_ACL 0x0008
|
||||
#define EXT2_DEFM_UID16 0x0010
|
||||
#define EXT3_DEFM_JMODE 0x0060
|
||||
#define EXT3_DEFM_JMODE_DATA 0x0020
|
||||
#define EXT3_DEFM_JMODE_ORDERED 0x0040
|
||||
#define EXT3_DEFM_JMODE_WBACK 0x0060
|
||||
|
||||
/*
|
||||
* Structure of a directory entry
|
||||
*/
|
||||
#define EXT2_NAME_LEN 255
|
||||
|
||||
struct ext2_dir_entry {
|
||||
__u32 inode; /* Inode number */
|
||||
__u16 rec_len; /* Directory entry length */
|
||||
__u16 name_len; /* Name length */
|
||||
char name[EXT2_NAME_LEN]; /* Filename */
|
||||
};
|
||||
|
||||
/*
|
||||
* The new version of the directory entry. Since EXT2 structures are
|
||||
* stored in intel byte order, and the name_len field could never be
|
||||
* bigger than 255 chars, it's safe to reclaim the extra byte for the
|
||||
* file_type field.
|
||||
*/
|
||||
struct ext2_dir_entry_2 {
|
||||
__u32 inode; /* Inode number */
|
||||
__u16 rec_len; /* Directory entry length */
|
||||
__u8 name_len; /* Name length */
|
||||
__u8 file_type;
|
||||
char name[EXT2_NAME_LEN]; /* Filename */
|
||||
};
|
||||
|
||||
/*
|
||||
* Ext2 directory file types. Only the low 3 bits are used. The
|
||||
* other bits are reserved for now.
|
||||
*/
|
||||
#define EXT2_FT_UNKNOWN 0
|
||||
#define EXT2_FT_REG_FILE 1
|
||||
#define EXT2_FT_DIR 2
|
||||
#define EXT2_FT_CHRDEV 3
|
||||
#define EXT2_FT_BLKDEV 4
|
||||
#define EXT2_FT_FIFO 5
|
||||
#define EXT2_FT_SOCK 6
|
||||
#define EXT2_FT_SYMLINK 7
|
||||
|
||||
#define EXT2_FT_MAX 8
|
||||
|
||||
/*
|
||||
* EXT2_DIR_PAD defines the directory entries boundaries
|
||||
*
|
||||
* NOTE: It must be a multiple of 4
|
||||
*/
|
||||
#define EXT2_DIR_PAD 4
|
||||
#define EXT2_DIR_ROUND (EXT2_DIR_PAD - 1)
|
||||
#define EXT2_DIR_REC_LEN(name_len) (((name_len) + 8 + EXT2_DIR_ROUND) & ~EXT2_DIR_ROUND)
|
||||
|
||||
/*
|
||||
* This structure will be used for multiple mount protection. It will be
|
||||
* written into the block number saved in the s_mmp_block field in the
|
||||
* superblock.
|
||||
*/
|
||||
#define EXT2_MMP_MAGIC 0x004D4D50 /* ASCII for MMP */
|
||||
#define EXT2_MMP_CLEAN 0xFF4D4D50 /* Value of mmp_seq for clean unmount */
|
||||
#define EXT2_MMP_FSCK_ON 0xE24D4D50 /* Value of mmp_seq when being fscked */
|
||||
|
||||
struct mmp_struct {
|
||||
__u32 mmp_magic;
|
||||
__u32 mmp_seq;
|
||||
__u64 mmp_time;
|
||||
char mmp_nodename[64];
|
||||
char mmp_bdevname[32];
|
||||
__u16 mmp_interval;
|
||||
__u16 mmp_pad1;
|
||||
__u32 mmp_pad2;
|
||||
};
|
||||
|
||||
/*
|
||||
* Interval in number of seconds to update the MMP sequence number.
|
||||
*/
|
||||
#define EXT2_MMP_DEF_INTERVAL 5
|
||||
|
||||
#endif /* _LINUX_EXT2_FS_H */
|
23
Kernel/FileSystem/Ext2FS/DirectoryEntry.h
Normal file
23
Kernel/FileSystem/Ext2FS/DirectoryEntry.h
Normal file
|
@ -0,0 +1,23 @@
|
|||
/*
|
||||
* Copyright (c) 2022, Liav A. <liavalb@hotmail.co.il>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <AK/OwnPtr.h>
|
||||
#include <AK/Types.h>
|
||||
#include <Kernel/FileSystem/Inode.h>
|
||||
#include <Kernel/KString.h>
|
||||
|
||||
namespace Kernel {
|
||||
|
||||
struct Ext2FSDirectoryEntry {
|
||||
NonnullOwnPtr<KString> name;
|
||||
InodeIndex inode_index { 0 };
|
||||
u8 file_type { 0 };
|
||||
u16 record_length { 0 };
|
||||
};
|
||||
|
||||
}
|
697
Kernel/FileSystem/Ext2FS/FileSystem.cpp
Normal file
697
Kernel/FileSystem/Ext2FS/FileSystem.cpp
Normal file
|
@ -0,0 +1,697 @@
|
|||
/*
|
||||
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
||||
* Copyright (c) 2021, sin-ack <sin-ack@protonmail.com>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#include <Kernel/Debug.h>
|
||||
#include <Kernel/FileSystem/Ext2FS/FileSystem.h>
|
||||
#include <Kernel/FileSystem/Ext2FS/Inode.h>
|
||||
#include <Kernel/Process.h>
|
||||
#include <Kernel/UnixTypes.h>
|
||||
|
||||
namespace Kernel {
|
||||
|
||||
ErrorOr<NonnullLockRefPtr<FileSystem>> Ext2FS::try_create(OpenFileDescription& file_description)
|
||||
{
|
||||
return TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) Ext2FS(file_description)));
|
||||
}
|
||||
|
||||
Ext2FS::Ext2FS(OpenFileDescription& file_description)
|
||||
: BlockBasedFileSystem(file_description)
|
||||
{
|
||||
}
|
||||
|
||||
Ext2FS::~Ext2FS() = default;
|
||||
|
||||
ErrorOr<void> Ext2FS::flush_super_block()
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
VERIFY((sizeof(ext2_super_block) % logical_block_size()) == 0);
|
||||
auto super_block_buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)&m_super_block);
|
||||
return raw_write_blocks(2, (sizeof(ext2_super_block) / logical_block_size()), super_block_buffer);
|
||||
}
|
||||
|
||||
ext2_group_desc const& Ext2FS::group_descriptor(GroupIndex group_index) const
|
||||
{
|
||||
// FIXME: Should this fail gracefully somehow?
|
||||
VERIFY(group_index <= m_block_group_count);
|
||||
VERIFY(group_index > 0);
|
||||
return block_group_descriptors()[group_index.value() - 1];
|
||||
}
|
||||
|
||||
bool Ext2FS::is_initialized_while_locked()
|
||||
{
|
||||
VERIFY(m_lock.is_locked());
|
||||
return !m_root_inode.is_null();
|
||||
}
|
||||
|
||||
ErrorOr<void> Ext2FS::initialize_while_locked()
|
||||
{
|
||||
VERIFY(m_lock.is_locked());
|
||||
VERIFY(!is_initialized_while_locked());
|
||||
|
||||
VERIFY((sizeof(ext2_super_block) % logical_block_size()) == 0);
|
||||
auto super_block_buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)&m_super_block);
|
||||
TRY(raw_read_blocks(2, (sizeof(ext2_super_block) / logical_block_size()), super_block_buffer));
|
||||
|
||||
auto const& super_block = this->super_block();
|
||||
if constexpr (EXT2_DEBUG) {
|
||||
dmesgln("Ext2FS: super block magic: {:04x} (super block size: {})", super_block.s_magic, sizeof(ext2_super_block));
|
||||
}
|
||||
if (super_block.s_magic != EXT2_SUPER_MAGIC) {
|
||||
dmesgln("Ext2FS: Bad super block magic");
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
if constexpr (EXT2_DEBUG) {
|
||||
dmesgln("Ext2FS: {} inodes, {} blocks", super_block.s_inodes_count, super_block.s_blocks_count);
|
||||
dmesgln("Ext2FS: Block size: {}", EXT2_BLOCK_SIZE(&super_block));
|
||||
dmesgln("Ext2FS: First data block: {}", super_block.s_first_data_block);
|
||||
dmesgln("Ext2FS: Inodes per block: {}", inodes_per_block());
|
||||
dmesgln("Ext2FS: Inodes per group: {}", inodes_per_group());
|
||||
dmesgln("Ext2FS: Free inodes: {}", super_block.s_free_inodes_count);
|
||||
dmesgln("Ext2FS: Descriptors per block: {}", EXT2_DESC_PER_BLOCK(&super_block));
|
||||
dmesgln("Ext2FS: Descriptor size: {}", EXT2_DESC_SIZE(&super_block));
|
||||
}
|
||||
|
||||
set_block_size(EXT2_BLOCK_SIZE(&super_block));
|
||||
set_fragment_size(EXT2_FRAG_SIZE(&super_block));
|
||||
|
||||
// Note: This depends on the block size being available.
|
||||
TRY(BlockBasedFileSystem::initialize_while_locked());
|
||||
|
||||
VERIFY(block_size() <= (int)max_block_size);
|
||||
|
||||
m_block_group_count = ceil_div(super_block.s_blocks_count, super_block.s_blocks_per_group);
|
||||
|
||||
if (m_block_group_count == 0) {
|
||||
dmesgln("Ext2FS: no block groups :(");
|
||||
return EINVAL;
|
||||
}
|
||||
|
||||
auto blocks_to_read = ceil_div(m_block_group_count * sizeof(ext2_group_desc), block_size());
|
||||
BlockIndex first_block_of_bgdt = block_size() == 1024 ? 2 : 1;
|
||||
m_cached_group_descriptor_table = TRY(KBuffer::try_create_with_size("Ext2FS: Block group descriptors"sv, block_size() * blocks_to_read, Memory::Region::Access::ReadWrite));
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(m_cached_group_descriptor_table->data());
|
||||
TRY(read_blocks(first_block_of_bgdt, blocks_to_read, buffer));
|
||||
|
||||
if constexpr (EXT2_DEBUG) {
|
||||
for (unsigned i = 1; i <= m_block_group_count; ++i) {
|
||||
auto const& group = group_descriptor(i);
|
||||
dbgln("Ext2FS: group[{}] ( block_bitmap: {}, inode_bitmap: {}, inode_table: {} )", i, group.bg_block_bitmap, group.bg_inode_bitmap, group.bg_inode_table);
|
||||
}
|
||||
}
|
||||
|
||||
m_root_inode = TRY(build_root_inode());
|
||||
return {};
|
||||
}
|
||||
|
||||
Inode& Ext2FS::root_inode()
|
||||
{
|
||||
return *m_root_inode;
|
||||
}
|
||||
|
||||
bool Ext2FS::find_block_containing_inode(InodeIndex inode, BlockIndex& block_index, unsigned& offset) const
|
||||
{
|
||||
auto const& super_block = this->super_block();
|
||||
|
||||
if (inode != EXT2_ROOT_INO && inode < EXT2_FIRST_INO(&super_block))
|
||||
return false;
|
||||
|
||||
if (inode > super_block.s_inodes_count)
|
||||
return false;
|
||||
|
||||
auto const& bgd = group_descriptor(group_index_from_inode(inode));
|
||||
|
||||
u64 full_offset = ((inode.value() - 1) % inodes_per_group()) * inode_size();
|
||||
block_index = bgd.bg_inode_table + (full_offset >> EXT2_BLOCK_SIZE_BITS(&super_block));
|
||||
offset = full_offset & (block_size() - 1);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
Ext2FS::BlockListShape Ext2FS::compute_block_list_shape(unsigned blocks) const
|
||||
{
|
||||
BlockListShape shape;
|
||||
unsigned const entries_per_block = EXT2_ADDR_PER_BLOCK(&super_block());
|
||||
unsigned blocks_remaining = blocks;
|
||||
|
||||
shape.direct_blocks = min((unsigned)EXT2_NDIR_BLOCKS, blocks_remaining);
|
||||
blocks_remaining -= shape.direct_blocks;
|
||||
if (!blocks_remaining)
|
||||
return shape;
|
||||
|
||||
shape.indirect_blocks = min(blocks_remaining, entries_per_block);
|
||||
shape.meta_blocks += 1;
|
||||
blocks_remaining -= shape.indirect_blocks;
|
||||
if (!blocks_remaining)
|
||||
return shape;
|
||||
|
||||
shape.doubly_indirect_blocks = min(blocks_remaining, entries_per_block * entries_per_block);
|
||||
shape.meta_blocks += 1;
|
||||
shape.meta_blocks += ceil_div(shape.doubly_indirect_blocks, entries_per_block);
|
||||
blocks_remaining -= shape.doubly_indirect_blocks;
|
||||
if (!blocks_remaining)
|
||||
return shape;
|
||||
|
||||
shape.triply_indirect_blocks = min(blocks_remaining, entries_per_block * entries_per_block * entries_per_block);
|
||||
shape.meta_blocks += 1;
|
||||
shape.meta_blocks += ceil_div(shape.triply_indirect_blocks, entries_per_block * entries_per_block);
|
||||
shape.meta_blocks += ceil_div(shape.triply_indirect_blocks, entries_per_block);
|
||||
blocks_remaining -= shape.triply_indirect_blocks;
|
||||
VERIFY(blocks_remaining == 0);
|
||||
return shape;
|
||||
}
|
||||
|
||||
u8 Ext2FS::internal_file_type_to_directory_entry_type(DirectoryEntryView const& entry) const
|
||||
{
|
||||
switch (entry.file_type) {
|
||||
case EXT2_FT_REG_FILE:
|
||||
return DT_REG;
|
||||
case EXT2_FT_DIR:
|
||||
return DT_DIR;
|
||||
case EXT2_FT_CHRDEV:
|
||||
return DT_CHR;
|
||||
case EXT2_FT_BLKDEV:
|
||||
return DT_BLK;
|
||||
case EXT2_FT_FIFO:
|
||||
return DT_FIFO;
|
||||
case EXT2_FT_SOCK:
|
||||
return DT_SOCK;
|
||||
case EXT2_FT_SYMLINK:
|
||||
return DT_LNK;
|
||||
default:
|
||||
return DT_UNKNOWN;
|
||||
}
|
||||
}
|
||||
|
||||
Ext2FS::FeaturesReadOnly Ext2FS::get_features_readonly() const
|
||||
{
|
||||
if (m_super_block.s_rev_level > 0)
|
||||
return static_cast<Ext2FS::FeaturesReadOnly>(m_super_block.s_feature_ro_compat);
|
||||
return Ext2FS::FeaturesReadOnly::None;
|
||||
}
|
||||
|
||||
u64 Ext2FS::inodes_per_block() const
|
||||
{
|
||||
return EXT2_INODES_PER_BLOCK(&super_block());
|
||||
}
|
||||
|
||||
u64 Ext2FS::inodes_per_group() const
|
||||
{
|
||||
return EXT2_INODES_PER_GROUP(&super_block());
|
||||
}
|
||||
|
||||
u64 Ext2FS::inode_size() const
|
||||
{
|
||||
return EXT2_INODE_SIZE(&super_block());
|
||||
}
|
||||
u64 Ext2FS::blocks_per_group() const
|
||||
{
|
||||
return EXT2_BLOCKS_PER_GROUP(&super_block());
|
||||
}
|
||||
|
||||
ErrorOr<void> Ext2FS::write_ext2_inode(InodeIndex inode, ext2_inode const& e2inode)
|
||||
{
|
||||
BlockIndex block_index;
|
||||
unsigned offset;
|
||||
if (!find_block_containing_inode(inode, block_index, offset))
|
||||
return EINVAL;
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(const_cast<u8*>((u8 const*)&e2inode));
|
||||
return write_block(block_index, buffer, inode_size(), offset);
|
||||
}
|
||||
|
||||
auto Ext2FS::allocate_blocks(GroupIndex preferred_group_index, size_t count) -> ErrorOr<Vector<BlockIndex>>
|
||||
{
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: allocate_blocks(preferred group: {}, count {})", preferred_group_index, count);
|
||||
if (count == 0)
|
||||
return Vector<BlockIndex> {};
|
||||
|
||||
Vector<BlockIndex> blocks;
|
||||
TRY(blocks.try_ensure_capacity(count));
|
||||
|
||||
MutexLocker locker(m_lock);
|
||||
auto group_index = preferred_group_index;
|
||||
|
||||
if (!group_descriptor(preferred_group_index).bg_free_blocks_count) {
|
||||
group_index = 1;
|
||||
}
|
||||
|
||||
while (blocks.size() < count) {
|
||||
bool found_a_group = false;
|
||||
if (group_descriptor(group_index).bg_free_blocks_count) {
|
||||
found_a_group = true;
|
||||
} else {
|
||||
if (group_index == preferred_group_index)
|
||||
group_index = 1;
|
||||
for (; group_index <= m_block_group_count; group_index = GroupIndex { group_index.value() + 1 }) {
|
||||
if (group_descriptor(group_index).bg_free_blocks_count) {
|
||||
found_a_group = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
VERIFY(found_a_group);
|
||||
auto const& bgd = group_descriptor(group_index);
|
||||
|
||||
auto* cached_bitmap = TRY(get_bitmap_block(bgd.bg_block_bitmap));
|
||||
|
||||
int blocks_in_group = min(blocks_per_group(), super_block().s_blocks_count);
|
||||
auto block_bitmap = cached_bitmap->bitmap(blocks_in_group);
|
||||
|
||||
BlockIndex first_block_in_group = (group_index.value() - 1) * blocks_per_group() + first_block_index().value();
|
||||
size_t free_region_size = 0;
|
||||
auto first_unset_bit_index = block_bitmap.find_longest_range_of_unset_bits(count - blocks.size(), free_region_size);
|
||||
VERIFY(first_unset_bit_index.has_value());
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: allocating free region of size: {} [{}]", free_region_size, group_index);
|
||||
for (size_t i = 0; i < free_region_size; ++i) {
|
||||
BlockIndex block_index = (first_unset_bit_index.value() + i) + first_block_in_group.value();
|
||||
TRY(set_block_allocation_state(block_index, true));
|
||||
blocks.unchecked_append(block_index);
|
||||
dbgln_if(EXT2_DEBUG, " allocated > {}", block_index);
|
||||
}
|
||||
}
|
||||
|
||||
VERIFY(blocks.size() == count);
|
||||
return blocks;
|
||||
}
|
||||
|
||||
ErrorOr<InodeIndex> Ext2FS::allocate_inode(GroupIndex preferred_group)
|
||||
{
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: allocate_inode(preferred_group: {})", preferred_group);
|
||||
MutexLocker locker(m_lock);
|
||||
|
||||
// FIXME: We shouldn't refuse to allocate an inode if there is no group that can house the whole thing.
|
||||
// In those cases we should just spread it across multiple groups.
|
||||
auto is_suitable_group = [this](auto group_index) {
|
||||
auto& bgd = group_descriptor(group_index);
|
||||
return bgd.bg_free_inodes_count && bgd.bg_free_blocks_count >= 1;
|
||||
};
|
||||
|
||||
GroupIndex group_index;
|
||||
if (preferred_group.value() && is_suitable_group(preferred_group)) {
|
||||
group_index = preferred_group;
|
||||
} else {
|
||||
for (unsigned i = 1; i <= m_block_group_count; ++i) {
|
||||
if (is_suitable_group(i)) {
|
||||
group_index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!group_index) {
|
||||
dmesgln("Ext2FS: allocate_inode: no suitable group found for new inode");
|
||||
return ENOSPC;
|
||||
}
|
||||
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: allocate_inode: found suitable group [{}] for new inode :^)", group_index);
|
||||
|
||||
auto const& bgd = group_descriptor(group_index);
|
||||
unsigned inodes_in_group = min(inodes_per_group(), super_block().s_inodes_count);
|
||||
InodeIndex first_inode_in_group = (group_index.value() - 1) * inodes_per_group() + 1;
|
||||
|
||||
auto* cached_bitmap = TRY(get_bitmap_block(bgd.bg_inode_bitmap));
|
||||
auto inode_bitmap = cached_bitmap->bitmap(inodes_in_group);
|
||||
for (size_t i = 0; i < inode_bitmap.size(); ++i) {
|
||||
if (inode_bitmap.get(i))
|
||||
continue;
|
||||
inode_bitmap.set(i, true);
|
||||
|
||||
auto inode_index = InodeIndex(first_inode_in_group.value() + i);
|
||||
|
||||
cached_bitmap->dirty = true;
|
||||
m_super_block.s_free_inodes_count--;
|
||||
m_super_block_dirty = true;
|
||||
const_cast<ext2_group_desc&>(bgd).bg_free_inodes_count--;
|
||||
m_block_group_descriptors_dirty = true;
|
||||
|
||||
// In case the inode cache had this cached as "non-existent", uncache that info.
|
||||
m_inode_cache.remove(inode_index.value());
|
||||
|
||||
return inode_index;
|
||||
}
|
||||
|
||||
dmesgln("Ext2FS: allocate_inode found no available inode, despite bgd claiming there are inodes :(");
|
||||
return EIO;
|
||||
}
|
||||
|
||||
Ext2FS::GroupIndex Ext2FS::group_index_from_block_index(BlockIndex block_index) const
|
||||
{
|
||||
if (!block_index)
|
||||
return 0;
|
||||
return (block_index.value() - 1) / blocks_per_group() + 1;
|
||||
}
|
||||
|
||||
auto Ext2FS::group_index_from_inode(InodeIndex inode) const -> GroupIndex
|
||||
{
|
||||
if (!inode)
|
||||
return 0;
|
||||
return (inode.value() - 1) / inodes_per_group() + 1;
|
||||
}
|
||||
|
||||
ErrorOr<bool> Ext2FS::get_inode_allocation_state(InodeIndex index) const
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
if (index == 0)
|
||||
return EINVAL;
|
||||
auto group_index = group_index_from_inode(index);
|
||||
auto const& bgd = group_descriptor(group_index);
|
||||
unsigned index_in_group = index.value() - ((group_index.value() - 1) * inodes_per_group());
|
||||
unsigned bit_index = (index_in_group - 1) % inodes_per_group();
|
||||
|
||||
auto* cached_bitmap = TRY(const_cast<Ext2FS&>(*this).get_bitmap_block(bgd.bg_inode_bitmap));
|
||||
return cached_bitmap->bitmap(inodes_per_group()).get(bit_index);
|
||||
}
|
||||
|
||||
ErrorOr<void> Ext2FS::update_bitmap_block(BlockIndex bitmap_block, size_t bit_index, bool new_state, u32& super_block_counter, u16& group_descriptor_counter)
|
||||
{
|
||||
auto* cached_bitmap = TRY(get_bitmap_block(bitmap_block));
|
||||
bool current_state = cached_bitmap->bitmap(blocks_per_group()).get(bit_index);
|
||||
if (current_state == new_state) {
|
||||
dbgln("Ext2FS: Bit {} in bitmap block {} had unexpected state {}", bit_index, bitmap_block, current_state);
|
||||
return EIO;
|
||||
}
|
||||
cached_bitmap->bitmap(blocks_per_group()).set(bit_index, new_state);
|
||||
cached_bitmap->dirty = true;
|
||||
|
||||
if (new_state) {
|
||||
--super_block_counter;
|
||||
--group_descriptor_counter;
|
||||
} else {
|
||||
++super_block_counter;
|
||||
++group_descriptor_counter;
|
||||
}
|
||||
|
||||
m_super_block_dirty = true;
|
||||
m_block_group_descriptors_dirty = true;
|
||||
return {};
|
||||
}
|
||||
|
||||
ErrorOr<void> Ext2FS::set_inode_allocation_state(InodeIndex inode_index, bool new_state)
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
auto group_index = group_index_from_inode(inode_index);
|
||||
unsigned index_in_group = inode_index.value() - ((group_index.value() - 1) * inodes_per_group());
|
||||
unsigned bit_index = (index_in_group - 1) % inodes_per_group();
|
||||
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: set_inode_allocation_state: Inode {} -> {}", inode_index, new_state);
|
||||
auto& bgd = const_cast<ext2_group_desc&>(group_descriptor(group_index));
|
||||
return update_bitmap_block(bgd.bg_inode_bitmap, bit_index, new_state, m_super_block.s_free_inodes_count, bgd.bg_free_inodes_count);
|
||||
}
|
||||
|
||||
Ext2FS::BlockIndex Ext2FS::first_block_index() const
|
||||
{
|
||||
return block_size() == 1024 ? 1 : 0;
|
||||
}
|
||||
|
||||
ErrorOr<Ext2FS::CachedBitmap*> Ext2FS::get_bitmap_block(BlockIndex bitmap_block_index)
|
||||
{
|
||||
for (auto& cached_bitmap : m_cached_bitmaps) {
|
||||
if (cached_bitmap->bitmap_block_index == bitmap_block_index)
|
||||
return cached_bitmap.ptr();
|
||||
}
|
||||
|
||||
auto block = TRY(KBuffer::try_create_with_size("Ext2FS: Cached bitmap block"sv, block_size(), Memory::Region::Access::ReadWrite));
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(block->data());
|
||||
TRY(read_block(bitmap_block_index, &buffer, block_size()));
|
||||
auto new_bitmap = TRY(adopt_nonnull_own_or_enomem(new (nothrow) CachedBitmap(bitmap_block_index, move(block))));
|
||||
TRY(m_cached_bitmaps.try_append(move(new_bitmap)));
|
||||
return m_cached_bitmaps.last().ptr();
|
||||
}
|
||||
|
||||
ErrorOr<void> Ext2FS::set_block_allocation_state(BlockIndex block_index, bool new_state)
|
||||
{
|
||||
VERIFY(block_index != 0);
|
||||
MutexLocker locker(m_lock);
|
||||
|
||||
auto group_index = group_index_from_block_index(block_index);
|
||||
unsigned index_in_group = (block_index.value() - first_block_index().value()) - ((group_index.value() - 1) * blocks_per_group());
|
||||
unsigned bit_index = index_in_group % blocks_per_group();
|
||||
auto& bgd = const_cast<ext2_group_desc&>(group_descriptor(group_index));
|
||||
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: Block {} state -> {} (in bitmap block {})", block_index, new_state, bgd.bg_block_bitmap);
|
||||
return update_bitmap_block(bgd.bg_block_bitmap, bit_index, new_state, m_super_block.s_free_blocks_count, bgd.bg_free_blocks_count);
|
||||
}
|
||||
|
||||
ErrorOr<NonnullLockRefPtr<Inode>> Ext2FS::create_directory(Ext2FSInode& parent_inode, StringView name, mode_t mode, UserID uid, GroupID gid)
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
VERIFY(is_directory(mode));
|
||||
|
||||
auto inode = TRY(create_inode(parent_inode, name, mode, 0, uid, gid));
|
||||
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: create_directory: created new directory named '{} with inode {}", name, inode->index());
|
||||
|
||||
Vector<Ext2FSDirectoryEntry> entries;
|
||||
auto current_directory_name = TRY(KString::try_create("."sv));
|
||||
TRY(entries.try_empend(move(current_directory_name), inode->index(), static_cast<u8>(EXT2_FT_DIR)));
|
||||
auto parent_directory_name = TRY(KString::try_create(".."sv));
|
||||
TRY(entries.try_empend(move(parent_directory_name), parent_inode.index(), static_cast<u8>(EXT2_FT_DIR)));
|
||||
|
||||
TRY(static_cast<Ext2FSInode&>(*inode).write_directory(entries));
|
||||
TRY(parent_inode.increment_link_count());
|
||||
|
||||
auto& bgd = const_cast<ext2_group_desc&>(group_descriptor(group_index_from_inode(inode->identifier().index())));
|
||||
++bgd.bg_used_dirs_count;
|
||||
m_block_group_descriptors_dirty = true;
|
||||
|
||||
return inode;
|
||||
}
|
||||
|
||||
ErrorOr<NonnullLockRefPtr<Inode>> Ext2FS::create_inode(Ext2FSInode& parent_inode, StringView name, mode_t mode, dev_t dev, UserID uid, GroupID gid)
|
||||
{
|
||||
if (name.length() > EXT2_NAME_LEN)
|
||||
return ENAMETOOLONG;
|
||||
|
||||
if (parent_inode.m_raw_inode.i_links_count == 0)
|
||||
return ENOENT;
|
||||
|
||||
ext2_inode e2inode {};
|
||||
auto now = kgettimeofday().to_truncated_seconds();
|
||||
e2inode.i_mode = mode;
|
||||
e2inode.i_uid = uid.value();
|
||||
e2inode.i_gid = gid.value();
|
||||
e2inode.i_size = 0;
|
||||
e2inode.i_atime = now;
|
||||
e2inode.i_ctime = now;
|
||||
e2inode.i_mtime = now;
|
||||
e2inode.i_dtime = 0;
|
||||
e2inode.i_flags = 0;
|
||||
|
||||
// For directories, add +1 link count for the "." entry in self.
|
||||
e2inode.i_links_count = is_directory(mode);
|
||||
|
||||
if (is_character_device(mode))
|
||||
e2inode.i_block[0] = dev;
|
||||
else if (is_block_device(mode))
|
||||
e2inode.i_block[1] = dev;
|
||||
|
||||
auto inode_id = TRY(allocate_inode());
|
||||
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: writing initial metadata for inode {}", inode_id.value());
|
||||
TRY(write_ext2_inode(inode_id, e2inode));
|
||||
|
||||
auto new_inode = TRY(get_inode({ fsid(), inode_id }));
|
||||
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS: Adding inode '{}' (mode {:o}) to parent directory {}", name, mode, parent_inode.index());
|
||||
TRY(parent_inode.add_child(*new_inode, name, mode));
|
||||
return new_inode;
|
||||
}
|
||||
|
||||
void Ext2FS::uncache_inode(InodeIndex index)
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
m_inode_cache.remove(index);
|
||||
}
|
||||
|
||||
unsigned Ext2FS::total_block_count() const
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
return super_block().s_blocks_count;
|
||||
}
|
||||
|
||||
unsigned Ext2FS::free_block_count() const
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
return super_block().s_free_blocks_count;
|
||||
}
|
||||
|
||||
unsigned Ext2FS::total_inode_count() const
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
return super_block().s_inodes_count;
|
||||
}
|
||||
|
||||
unsigned Ext2FS::free_inode_count() const
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
return super_block().s_free_inodes_count;
|
||||
}
|
||||
|
||||
ErrorOr<void> Ext2FS::prepare_to_clear_last_mount()
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
for (auto& it : m_inode_cache) {
|
||||
if (it.value->ref_count() > 1)
|
||||
return EBUSY;
|
||||
}
|
||||
|
||||
BlockBasedFileSystem::remove_disk_cache_before_last_unmount();
|
||||
m_inode_cache.clear();
|
||||
m_root_inode = nullptr;
|
||||
return {};
|
||||
}
|
||||
|
||||
ErrorOr<void> Ext2FS::free_inode(Ext2FSInode& inode)
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
VERIFY(inode.m_raw_inode.i_links_count == 0);
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS[{}]::free_inode(): Inode {} has no more links, time to delete!", fsid(), inode.index());
|
||||
|
||||
// Mark all blocks used by this inode as free.
|
||||
{
|
||||
auto blocks = TRY(inode.compute_block_list_with_meta_blocks());
|
||||
for (auto block_index : blocks) {
|
||||
VERIFY(block_index <= super_block().s_blocks_count);
|
||||
if (block_index.value())
|
||||
TRY(set_block_allocation_state(block_index, false));
|
||||
}
|
||||
}
|
||||
|
||||
// If the inode being freed is a directory, update block group directory counter.
|
||||
if (inode.is_directory()) {
|
||||
auto& bgd = const_cast<ext2_group_desc&>(group_descriptor(group_index_from_inode(inode.index())));
|
||||
--bgd.bg_used_dirs_count;
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS[{}]::free_inode(): Decremented bg_used_dirs_count to {} for inode {}", fsid(), bgd.bg_used_dirs_count, inode.index());
|
||||
m_block_group_descriptors_dirty = true;
|
||||
}
|
||||
|
||||
// NOTE: After this point, the inode metadata is wiped.
|
||||
memset(&inode.m_raw_inode, 0, sizeof(ext2_inode));
|
||||
inode.m_raw_inode.i_dtime = kgettimeofday().to_truncated_seconds();
|
||||
TRY(write_ext2_inode(inode.index(), inode.m_raw_inode));
|
||||
|
||||
// Mark the inode as free.
|
||||
TRY(set_inode_allocation_state(inode.index(), false));
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
void Ext2FS::flush_block_group_descriptor_table()
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
auto blocks_to_write = ceil_div(m_block_group_count * sizeof(ext2_group_desc), block_size());
|
||||
auto first_block_of_bgdt = block_size() == 1024 ? 2 : 1;
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer((u8*)block_group_descriptors());
|
||||
if (auto result = write_blocks(first_block_of_bgdt, blocks_to_write, buffer); result.is_error())
|
||||
dbgln("Ext2FS[{}]::flush_block_group_descriptor_table(): Failed to write blocks: {}", fsid(), result.error());
|
||||
}
|
||||
|
||||
void Ext2FS::flush_writes()
|
||||
{
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
if (m_super_block_dirty) {
|
||||
auto result = flush_super_block();
|
||||
if (result.is_error()) {
|
||||
dbgln("Ext2FS[{}]::flush_writes(): Failed to write superblock: {}", fsid(), result.error());
|
||||
// FIXME: We should handle this error.
|
||||
VERIFY_NOT_REACHED();
|
||||
}
|
||||
m_super_block_dirty = false;
|
||||
}
|
||||
if (m_block_group_descriptors_dirty) {
|
||||
flush_block_group_descriptor_table();
|
||||
m_block_group_descriptors_dirty = false;
|
||||
}
|
||||
for (auto& cached_bitmap : m_cached_bitmaps) {
|
||||
if (cached_bitmap->dirty) {
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(cached_bitmap->buffer->data());
|
||||
if (auto result = write_block(cached_bitmap->bitmap_block_index, buffer, block_size()); result.is_error()) {
|
||||
dbgln("Ext2FS[{}]::flush_writes(): Failed to write blocks: {}", fsid(), result.error());
|
||||
}
|
||||
cached_bitmap->dirty = false;
|
||||
dbgln_if(EXT2_DEBUG, "Ext2FS[{}]::flush_writes(): Flushed bitmap block {}", fsid(), cached_bitmap->bitmap_block_index);
|
||||
}
|
||||
}
|
||||
|
||||
// Uncache Inodes that are only kept alive by the index-to-inode lookup cache.
|
||||
// We don't uncache Inodes that are being watched by at least one InodeWatcher.
|
||||
|
||||
// FIXME: It would be better to keep a capped number of Inodes around.
|
||||
// The problem is that they are quite heavy objects, and use a lot of heap memory
|
||||
// for their (child name lookup) and (block list) caches.
|
||||
|
||||
m_inode_cache.remove_all_matching([](InodeIndex, LockRefPtr<Ext2FSInode> const& cached_inode) {
|
||||
// NOTE: If we're asked to look up an inode by number (via get_inode) and it turns out
|
||||
// to not exist, we remember the fact that it doesn't exist by caching a nullptr.
|
||||
// This seems like a reasonable time to uncache ideas about unknown inodes, so do that.
|
||||
if (cached_inode == nullptr)
|
||||
return true;
|
||||
|
||||
return cached_inode->ref_count() == 1 && !cached_inode->has_watchers();
|
||||
});
|
||||
}
|
||||
|
||||
BlockBasedFileSystem::flush_writes();
|
||||
}
|
||||
|
||||
ErrorOr<NonnullLockRefPtr<Ext2FSInode>> Ext2FS::build_root_inode() const
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
BlockIndex block_index;
|
||||
unsigned offset;
|
||||
if (!find_block_containing_inode(EXT2_ROOT_INO, block_index, offset))
|
||||
return EINVAL;
|
||||
|
||||
auto inode = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) Ext2FSInode(const_cast<Ext2FS&>(*this), EXT2_ROOT_INO)));
|
||||
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(&inode->m_raw_inode));
|
||||
TRY(read_block(block_index, &buffer, sizeof(ext2_inode), offset));
|
||||
return inode;
|
||||
}
|
||||
|
||||
ErrorOr<NonnullLockRefPtr<Inode>> Ext2FS::get_inode(InodeIdentifier inode) const
|
||||
{
|
||||
MutexLocker locker(m_lock);
|
||||
VERIFY(inode.fsid() == fsid());
|
||||
VERIFY(m_root_inode);
|
||||
|
||||
if (inode.index() == EXT2_ROOT_INO)
|
||||
return *m_root_inode;
|
||||
|
||||
{
|
||||
auto it = m_inode_cache.find(inode.index());
|
||||
if (it != m_inode_cache.end()) {
|
||||
if (!it->value)
|
||||
return ENOENT;
|
||||
return NonnullLockRefPtr<Inode> { *it->value };
|
||||
}
|
||||
}
|
||||
|
||||
auto inode_allocation_state = TRY(get_inode_allocation_state(inode.index()));
|
||||
|
||||
if (!inode_allocation_state) {
|
||||
TRY(m_inode_cache.try_set(inode.index(), nullptr));
|
||||
return ENOENT;
|
||||
}
|
||||
|
||||
BlockIndex block_index;
|
||||
unsigned offset;
|
||||
if (!find_block_containing_inode(inode.index(), block_index, offset))
|
||||
return EINVAL;
|
||||
|
||||
auto new_inode = TRY(adopt_nonnull_lock_ref_or_enomem(new (nothrow) Ext2FSInode(const_cast<Ext2FS&>(*this), inode.index())));
|
||||
|
||||
auto buffer = UserOrKernelBuffer::for_kernel_buffer(reinterpret_cast<u8*>(&new_inode->m_raw_inode));
|
||||
TRY(read_block(block_index, &buffer, sizeof(ext2_inode), offset));
|
||||
|
||||
TRY(m_inode_cache.try_set(inode.index(), new_inode));
|
||||
return new_inode;
|
||||
}
|
||||
|
||||
}
|
131
Kernel/FileSystem/Ext2FS/FileSystem.h
Normal file
131
Kernel/FileSystem/Ext2FS/FileSystem.h
Normal file
|
@ -0,0 +1,131 @@
|
|||
/*
|
||||
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <AK/Bitmap.h>
|
||||
#include <AK/HashMap.h>
|
||||
#include <Kernel/FileSystem/BlockBasedFileSystem.h>
|
||||
#include <Kernel/FileSystem/Ext2FS/Definitions.h>
|
||||
#include <Kernel/FileSystem/Inode.h>
|
||||
#include <Kernel/KBuffer.h>
|
||||
#include <Kernel/UnixTypes.h>
|
||||
|
||||
namespace Kernel {
|
||||
|
||||
class Ext2FSInode;
|
||||
|
||||
class Ext2FS final : public BlockBasedFileSystem {
|
||||
friend class Ext2FSInode;
|
||||
|
||||
public:
|
||||
enum class FeaturesReadOnly : u32 {
|
||||
None = 0,
|
||||
FileSize64bits = 1 << 1,
|
||||
};
|
||||
|
||||
static ErrorOr<NonnullLockRefPtr<FileSystem>> try_create(OpenFileDescription&);
|
||||
|
||||
virtual ~Ext2FS() override;
|
||||
|
||||
virtual unsigned total_block_count() const override;
|
||||
virtual unsigned free_block_count() const override;
|
||||
virtual unsigned total_inode_count() const override;
|
||||
virtual unsigned free_inode_count() const override;
|
||||
|
||||
virtual bool supports_watchers() const override { return true; }
|
||||
|
||||
virtual u8 internal_file_type_to_directory_entry_type(DirectoryEntryView const& entry) const override;
|
||||
|
||||
FeaturesReadOnly get_features_readonly() const;
|
||||
|
||||
virtual StringView class_name() const override { return "Ext2FS"sv; }
|
||||
virtual Inode& root_inode() override;
|
||||
|
||||
private:
|
||||
AK_TYPEDEF_DISTINCT_ORDERED_ID(unsigned, GroupIndex);
|
||||
|
||||
explicit Ext2FS(OpenFileDescription&);
|
||||
|
||||
ext2_super_block const& super_block() const { return m_super_block; }
|
||||
ext2_group_desc const& group_descriptor(GroupIndex) const;
|
||||
ext2_group_desc* block_group_descriptors() { return (ext2_group_desc*)m_cached_group_descriptor_table->data(); }
|
||||
ext2_group_desc const* block_group_descriptors() const { return (ext2_group_desc const*)m_cached_group_descriptor_table->data(); }
|
||||
void flush_block_group_descriptor_table();
|
||||
u64 inodes_per_block() const;
|
||||
u64 inodes_per_group() const;
|
||||
u64 blocks_per_group() const;
|
||||
u64 inode_size() const;
|
||||
|
||||
ErrorOr<NonnullLockRefPtr<Ext2FSInode>> build_root_inode() const;
|
||||
|
||||
ErrorOr<void> write_ext2_inode(InodeIndex, ext2_inode const&);
|
||||
bool find_block_containing_inode(InodeIndex, BlockIndex& block_index, unsigned& offset) const;
|
||||
|
||||
ErrorOr<void> flush_super_block();
|
||||
|
||||
virtual ErrorOr<void> initialize_while_locked() override;
|
||||
virtual bool is_initialized_while_locked() override;
|
||||
|
||||
virtual ErrorOr<void> prepare_to_clear_last_mount() override;
|
||||
ErrorOr<NonnullLockRefPtr<Inode>> get_inode(InodeIdentifier) const;
|
||||
ErrorOr<NonnullLockRefPtr<Inode>> create_inode(Ext2FSInode& parent_inode, StringView name, mode_t, dev_t, UserID, GroupID);
|
||||
ErrorOr<NonnullLockRefPtr<Inode>> create_directory(Ext2FSInode& parent_inode, StringView name, mode_t, UserID, GroupID);
|
||||
virtual void flush_writes() override;
|
||||
|
||||
BlockIndex first_block_index() const;
|
||||
ErrorOr<InodeIndex> allocate_inode(GroupIndex preferred_group = 0);
|
||||
ErrorOr<Vector<BlockIndex>> allocate_blocks(GroupIndex preferred_group_index, size_t count);
|
||||
GroupIndex group_index_from_inode(InodeIndex) const;
|
||||
GroupIndex group_index_from_block_index(BlockIndex) const;
|
||||
|
||||
ErrorOr<bool> get_inode_allocation_state(InodeIndex) const;
|
||||
ErrorOr<void> set_inode_allocation_state(InodeIndex, bool);
|
||||
ErrorOr<void> set_block_allocation_state(BlockIndex, bool);
|
||||
|
||||
void uncache_inode(InodeIndex);
|
||||
ErrorOr<void> free_inode(Ext2FSInode&);
|
||||
|
||||
struct BlockListShape {
|
||||
unsigned direct_blocks { 0 };
|
||||
unsigned indirect_blocks { 0 };
|
||||
unsigned doubly_indirect_blocks { 0 };
|
||||
unsigned triply_indirect_blocks { 0 };
|
||||
unsigned meta_blocks { 0 };
|
||||
};
|
||||
|
||||
BlockListShape compute_block_list_shape(unsigned blocks) const;
|
||||
|
||||
u64 m_block_group_count { 0 };
|
||||
|
||||
mutable ext2_super_block m_super_block {};
|
||||
mutable OwnPtr<KBuffer> m_cached_group_descriptor_table;
|
||||
|
||||
mutable HashMap<InodeIndex, LockRefPtr<Ext2FSInode>> m_inode_cache;
|
||||
|
||||
bool m_super_block_dirty { false };
|
||||
bool m_block_group_descriptors_dirty { false };
|
||||
|
||||
struct CachedBitmap {
|
||||
CachedBitmap(BlockIndex bi, NonnullOwnPtr<KBuffer> buf)
|
||||
: bitmap_block_index(bi)
|
||||
, buffer(move(buf))
|
||||
{
|
||||
}
|
||||
BlockIndex bitmap_block_index { 0 };
|
||||
bool dirty { false };
|
||||
NonnullOwnPtr<KBuffer> buffer;
|
||||
Bitmap bitmap(u32 blocks_per_group) { return Bitmap { buffer->data(), blocks_per_group }; }
|
||||
};
|
||||
|
||||
ErrorOr<CachedBitmap*> get_bitmap_block(BlockIndex);
|
||||
ErrorOr<void> update_bitmap_block(BlockIndex bitmap_block, size_t bit_index, bool new_state, u32& super_block_counter, u16& group_descriptor_counter);
|
||||
|
||||
Vector<OwnPtr<CachedBitmap>> m_cached_bitmaps;
|
||||
LockRefPtr<Ext2FSInode> m_root_inode;
|
||||
};
|
||||
|
||||
}
|
1029
Kernel/FileSystem/Ext2FS/Inode.cpp
Normal file
1029
Kernel/FileSystem/Ext2FS/Inode.cpp
Normal file
File diff suppressed because it is too large
Load diff
84
Kernel/FileSystem/Ext2FS/Inode.h
Normal file
84
Kernel/FileSystem/Ext2FS/Inode.h
Normal file
|
@ -0,0 +1,84 @@
|
|||
/*
|
||||
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <AK/HashMap.h>
|
||||
#include <Kernel/FileSystem/Ext2FS/Definitions.h>
|
||||
#include <Kernel/FileSystem/Ext2FS/DirectoryEntry.h>
|
||||
#include <Kernel/FileSystem/Ext2FS/FileSystem.h>
|
||||
#include <Kernel/FileSystem/Inode.h>
|
||||
#include <Kernel/UnixTypes.h>
|
||||
|
||||
namespace Kernel {
|
||||
|
||||
class Ext2FSInode final : public Inode {
|
||||
friend class Ext2FS;
|
||||
|
||||
public:
|
||||
virtual ~Ext2FSInode() override;
|
||||
|
||||
u64 size() const;
|
||||
bool is_symlink() const { return Kernel::is_symlink(m_raw_inode.i_mode); }
|
||||
bool is_directory() const { return Kernel::is_directory(m_raw_inode.i_mode); }
|
||||
|
||||
private:
|
||||
// ^Inode
|
||||
virtual ErrorOr<size_t> read_bytes_locked(off_t, size_t, UserOrKernelBuffer& buffer, OpenFileDescription*) const override;
|
||||
virtual InodeMetadata metadata() const override;
|
||||
virtual ErrorOr<void> traverse_as_directory(Function<ErrorOr<void>(FileSystem::DirectoryEntryView const&)>) const override;
|
||||
virtual ErrorOr<NonnullLockRefPtr<Inode>> lookup(StringView name) override;
|
||||
virtual ErrorOr<void> flush_metadata() override;
|
||||
virtual ErrorOr<size_t> write_bytes_locked(off_t, size_t, UserOrKernelBuffer const& data, OpenFileDescription*) override;
|
||||
virtual ErrorOr<NonnullLockRefPtr<Inode>> create_child(StringView name, mode_t, dev_t, UserID, GroupID) override;
|
||||
virtual ErrorOr<void> add_child(Inode& child, StringView name, mode_t) override;
|
||||
virtual ErrorOr<void> remove_child(StringView name) override;
|
||||
virtual ErrorOr<void> update_timestamps(Optional<time_t> atime, Optional<time_t> ctime, Optional<time_t> mtime) override;
|
||||
virtual ErrorOr<void> increment_link_count() override;
|
||||
virtual ErrorOr<void> decrement_link_count() override;
|
||||
virtual ErrorOr<void> chmod(mode_t) override;
|
||||
virtual ErrorOr<void> chown(UserID, GroupID) override;
|
||||
virtual ErrorOr<void> truncate(u64) override;
|
||||
virtual ErrorOr<int> get_block_address(int) override;
|
||||
|
||||
ErrorOr<void> write_directory(Vector<Ext2FSDirectoryEntry>&);
|
||||
ErrorOr<void> populate_lookup_cache();
|
||||
ErrorOr<void> resize(u64);
|
||||
ErrorOr<void> write_indirect_block(BlockBasedFileSystem::BlockIndex, Span<BlockBasedFileSystem::BlockIndex>);
|
||||
ErrorOr<void> grow_doubly_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, Span<BlockBasedFileSystem::BlockIndex>, Vector<BlockBasedFileSystem::BlockIndex>&, unsigned&);
|
||||
ErrorOr<void> shrink_doubly_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, size_t, unsigned&);
|
||||
ErrorOr<void> grow_triply_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, Span<BlockBasedFileSystem::BlockIndex>, Vector<BlockBasedFileSystem::BlockIndex>&, unsigned&);
|
||||
ErrorOr<void> shrink_triply_indirect_block(BlockBasedFileSystem::BlockIndex, size_t, size_t, unsigned&);
|
||||
ErrorOr<void> flush_block_list();
|
||||
|
||||
ErrorOr<void> compute_block_list_with_exclusive_locking();
|
||||
ErrorOr<Vector<BlockBasedFileSystem::BlockIndex>> compute_block_list() const;
|
||||
ErrorOr<Vector<BlockBasedFileSystem::BlockIndex>> compute_block_list_with_meta_blocks() const;
|
||||
ErrorOr<Vector<BlockBasedFileSystem::BlockIndex>> compute_block_list_impl(bool include_block_list_blocks) const;
|
||||
ErrorOr<Vector<BlockBasedFileSystem::BlockIndex>> compute_block_list_impl_internal(ext2_inode const&, bool include_block_list_blocks) const;
|
||||
|
||||
Ext2FS& fs();
|
||||
Ext2FS const& fs() const;
|
||||
Ext2FSInode(Ext2FS&, InodeIndex);
|
||||
|
||||
Vector<BlockBasedFileSystem::BlockIndex> m_block_list;
|
||||
HashMap<NonnullOwnPtr<KString>, InodeIndex> m_lookup_cache;
|
||||
ext2_inode m_raw_inode {};
|
||||
|
||||
Mutex m_block_list_lock { "BlockList"sv };
|
||||
};
|
||||
|
||||
inline Ext2FS& Ext2FSInode::fs()
|
||||
{
|
||||
return static_cast<Ext2FS&>(Inode::fs());
|
||||
}
|
||||
|
||||
inline Ext2FS const& Ext2FSInode::fs() const
|
||||
{
|
||||
return static_cast<Ext2FS const&>(Inode::fs());
|
||||
}
|
||||
|
||||
}
|
154
Kernel/FileSystem/Ext2FS/ext2_types.h
Normal file
154
Kernel/FileSystem/Ext2FS/ext2_types.h
Normal file
|
@ -0,0 +1,154 @@
|
|||
/*
|
||||
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
||||
*
|
||||
* SPDX-License-Identifier: BSD-2-Clause
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
/*
|
||||
* If linux/types.h is already been included, assume it has defined
|
||||
* everything we need. (cross fingers) Other header files may have
|
||||
* also defined the types that we need.
|
||||
*/
|
||||
#if (!defined(_LINUX_TYPES_H) && !defined(_BLKID_TYPES_H) && !defined(_EXT2_TYPES_H))
|
||||
# define _EXT2_TYPES_H
|
||||
|
||||
# define __S8_TYPEDEF __signed__ char
|
||||
# define __U8_TYPEDEF unsigned char
|
||||
# define __S16_TYPEDEF __signed__ short
|
||||
# define __U16_TYPEDEF unsigned short
|
||||
# define __S32_TYPEDEF __signed__ int
|
||||
# define __U32_TYPEDEF unsigned int
|
||||
# define __S64_TYPEDEF __signed__ long long
|
||||
# define __U64_TYPEDEF unsigned long long
|
||||
|
||||
# ifdef __U8_TYPEDEF
|
||||
typedef __U8_TYPEDEF __u8;
|
||||
# else
|
||||
typedef unsigned char __u8;
|
||||
# endif
|
||||
|
||||
# ifdef __S8_TYPEDEF
|
||||
typedef __S8_TYPEDEF __s8;
|
||||
# else
|
||||
typedef signed char __s8;
|
||||
# endif
|
||||
|
||||
# ifdef __U16_TYPEDEF
|
||||
typedef __U16_TYPEDEF __u16;
|
||||
# else
|
||||
# if (4 == 2)
|
||||
typedef unsigned int __u16;
|
||||
# else
|
||||
# if (2 == 2)
|
||||
typedef unsigned short __u16;
|
||||
# else
|
||||
? == error : undefined 16 bit type
|
||||
# endif /* SIZEOF_SHORT == 2 */
|
||||
# endif /* SIZEOF_INT == 2 */
|
||||
# endif /* __U16_TYPEDEF */
|
||||
|
||||
# ifdef __S16_TYPEDEF
|
||||
typedef __S16_TYPEDEF __s16;
|
||||
# else
|
||||
# if (4 == 2)
|
||||
typedef int __s16;
|
||||
# else
|
||||
# if (2 == 2)
|
||||
typedef short __s16;
|
||||
# else
|
||||
? == error
|
||||
: undefined 16 bit type
|
||||
# endif /* SIZEOF_SHORT == 2 */
|
||||
# endif /* SIZEOF_INT == 2 */
|
||||
# endif /* __S16_TYPEDEF */
|
||||
|
||||
# ifdef __U32_TYPEDEF
|
||||
typedef __U32_TYPEDEF __u32;
|
||||
# else
|
||||
# if (4 == 4)
|
||||
typedef unsigned int __u32;
|
||||
# else
|
||||
# if (4 == 4)
|
||||
typedef unsigned long __u32;
|
||||
# else
|
||||
# if (2 == 4)
|
||||
typedef unsigned short __u32;
|
||||
# else
|
||||
? == error
|
||||
: undefined 32 bit type
|
||||
# endif /* SIZEOF_SHORT == 4 */
|
||||
# endif /* SIZEOF_LONG == 4 */
|
||||
# endif /* SIZEOF_INT == 4 */
|
||||
# endif /* __U32_TYPEDEF */
|
||||
|
||||
# ifdef __S32_TYPEDEF
|
||||
typedef __S32_TYPEDEF __s32;
|
||||
# else
|
||||
# if (4 == 4)
|
||||
typedef int __s32;
|
||||
# else
|
||||
# if (4 == 4)
|
||||
typedef long __s32;
|
||||
# else
|
||||
# if (2 == 4)
|
||||
typedef short __s32;
|
||||
# else
|
||||
? == error
|
||||
: undefined 32 bit type
|
||||
# endif /* SIZEOF_SHORT == 4 */
|
||||
# endif /* SIZEOF_LONG == 4 */
|
||||
# endif /* SIZEOF_INT == 4 */
|
||||
# endif /* __S32_TYPEDEF */
|
||||
|
||||
# ifdef __U64_TYPEDEF
|
||||
typedef __U64_TYPEDEF __u64;
|
||||
# else
|
||||
# if (4 == 8)
|
||||
typedef unsigned int __u64;
|
||||
# else
|
||||
# if (4 == 8)
|
||||
typedef unsigned long __u64;
|
||||
# else
|
||||
# if (8 == 8)
|
||||
typedef unsigned long long __u64;
|
||||
# endif /* SIZEOF_LONG_LONG == 8 */
|
||||
# endif /* SIZEOF_LONG == 8 */
|
||||
# endif /* SIZEOF_INT == 8 */
|
||||
# endif /* __U64_TYPEDEF */
|
||||
|
||||
# ifdef __S64_TYPEDEF
|
||||
typedef __S64_TYPEDEF __s64;
|
||||
# else
|
||||
# if (4 == 8)
|
||||
typedef int __s64;
|
||||
# else
|
||||
# if (4 == 8)
|
||||
typedef long __s64;
|
||||
# else
|
||||
# if (8 == 8)
|
||||
# if defined(__GNUC__)
|
||||
typedef __signed__ long long __s64;
|
||||
# else
|
||||
typedef signed long long __s64;
|
||||
# endif /* __GNUC__ */
|
||||
# endif /* SIZEOF_LONG_LONG == 8 */
|
||||
# endif /* SIZEOF_LONG == 8 */
|
||||
# endif /* SIZEOF_INT == 8 */
|
||||
# endif /* __S64_TYPEDEF */
|
||||
|
||||
# undef __S8_TYPEDEF
|
||||
# undef __U8_TYPEDEF
|
||||
# undef __S16_TYPEDEF
|
||||
# undef __U16_TYPEDEF
|
||||
# undef __S32_TYPEDEF
|
||||
# undef __U32_TYPEDEF
|
||||
# undef __S64_TYPEDEF
|
||||
# undef __U64_TYPEDEF
|
||||
|
||||
#endif /* _*_TYPES_H */
|
||||
|
||||
/* These defines are needed for the public ext2fs.h header file */
|
||||
#define HAVE_SYS_TYPES_H 1
|
||||
#undef WORDS_BIGENDIAN
|
Loading…
Add table
Add a link
Reference in a new issue