4078 lines · 140.8 KB · C
RawDownload
// SPDX-License-Identifier: GPL-2.0/* *  ext4.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 _EXT4_H#define _EXT4_H #include <linux/refcount.h>#include <linux/types.h>#include <linux/blkdev.h>#include <linux/magic.h>#include <linux/jbd2.h>#include <linux/quota.h>#include <linux/rwsem.h>#include <linux/rbtree.h>#include <linux/seqlock.h>#include <linux/mutex.h>#include <linux/timer.h>#include <linux/sched/signal.h>#include <linux/blockgroup_lock.h>#include <linux/percpu_counter.h>#include <linux/ratelimit.h>#include <linux/crc32c.h>#include <linux/falloc.h>#include <linux/percpu-rwsem.h>#include <linux/fiemap.h>#ifdef __KERNEL__#include <linux/compat.h>#endif#include <uapi/linux/ext4.h> #include <linux/fscrypt.h>#include <linux/fsverity.h> #include <linux/compiler.h> /* * The fourth extended filesystem constants/structures */ /* * with AGGRESSIVE_CHECK allocator runs consistency checks over * structures. these checks slow things down a lot */#define AGGRESSIVE_CHECK__ /* * with DOUBLE_CHECK defined mballoc creates persistent in-core * bitmaps, maintains and uses them to check for double allocations */#define DOUBLE_CHECK__ /* * Define EXT4FS_DEBUG to produce debug messages */#undef EXT4FS_DEBUG /* * Debug code */#ifdef EXT4FS_DEBUG#define ext4_debug(f, a...)						\	do {								\		printk(KERN_DEBUG "EXT4-fs DEBUG (%s, %d): %s:",	\			__FILE__, __LINE__, __func__);			\		printk(KERN_DEBUG f, ## a);				\	} while (0)#else#define ext4_debug(fmt, ...)	no_printk(fmt, ##__VA_ARGS__)#endif  /*  * Turn on EXT_DEBUG to enable ext4_ext_show_path/leaf/move in extents.c  */#define EXT_DEBUG__ /* * Dynamic printk for controlled extents debugging. */#ifdef CONFIG_EXT4_DEBUG#define ext_debug(ino, fmt, ...)					\	pr_debug("[%s/%d] EXT4-fs (%s): ino %llu: (%s, %d): %s:" fmt,	\		 current->comm, task_pid_nr(current),			\		 ino->i_sb->s_id, ino->i_ino, __FILE__, __LINE__,	\		 __func__, ##__VA_ARGS__)#else#define ext_debug(ino, fmt, ...)	no_printk(fmt, ##__VA_ARGS__)#endif #define ASSERT(assert)						\do {									\	if (unlikely(!(assert))) {					\		printk(KERN_EMERG					\		       "Assertion failure in %s() at %s:%d: '%s'\n",	\		       __func__, __FILE__, __LINE__, #assert);		\		BUG();							\	}								\} while (0) /* data type for block offset of block group */typedef int ext4_grpblk_t; /* data type for filesystem-wide blocks number */typedef unsigned long long ext4_fsblk_t; /* data type for file logical block number */typedef __u32 ext4_lblk_t; /* data type for block group number */typedef unsigned int ext4_group_t; enum SHIFT_DIRECTION {	SHIFT_LEFT = 0,	SHIFT_RIGHT,}; /* * For each criteria, mballoc has slightly different way of finding * the required blocks nad usually, higher the criteria the slower the * allocation.  We start at lower criterias and keep falling back to * higher ones if we are not able to find any blocks.  Lower (earlier) * criteria are faster. */enum criteria {	/*	 * Used when number of blocks needed is a power of 2. This	 * doesn't trigger any disk IO except prefetch and is the	 * fastest criteria.	 */	CR_POWER2_ALIGNED, 	/*	 * Tries to lookup in-memory data structures to find the most	 * suitable group that satisfies goal request. No disk IO	 * except block prefetch.	 */	CR_GOAL_LEN_FAST,         /*	 * Same as CR_GOAL_LEN_FAST but is allowed to reduce the goal         * length to the best available length for faster allocation.	 */	CR_BEST_AVAIL_LEN, 	/*	 * Reads each block group sequentially, performing disk IO if	 * necessary, to find suitable block group. Tries to	 * allocate goal length but might trim the request if nothing	 * is found after enough tries.	 */	CR_GOAL_LEN_SLOW, 	/*	 * Finds the first free set of blocks and allocates	 * those. This is only used in rare cases when	 * CR_GOAL_LEN_SLOW also fails to allocate anything.	 */	CR_ANY_FREE, 	/*	 * Number of criterias defined.	 */	EXT4_MB_NUM_CRS}; /* * Flags used in mballoc's allocation_context flags field. * * Also used to show what's going on for debugging purposes when the * flag field is exported via the traceport interface */ /* prefer goal again. length */#define EXT4_MB_HINT_MERGE		0x0001/* first blocks in the file */#define EXT4_MB_HINT_FIRST		0x0008/* data is being allocated */#define EXT4_MB_HINT_DATA		0x0020/* don't preallocate (for tails) */#define EXT4_MB_HINT_NOPREALLOC		0x0040/* allocate for locality group */#define EXT4_MB_HINT_GROUP_ALLOC	0x0080/* allocate goal blocks or none */#define EXT4_MB_HINT_GOAL_ONLY		0x0100/* goal is meaningful */#define EXT4_MB_HINT_TRY_GOAL		0x0200/* blocks already pre-reserved by delayed allocation */#define EXT4_MB_DELALLOC_RESERVED	0x0400/* We are doing stream allocation */#define EXT4_MB_STREAM_ALLOC		0x0800/* Use reserved root blocks if needed */#define EXT4_MB_USE_ROOT_BLOCKS		0x1000/* Use blocks from reserved pool */#define EXT4_MB_USE_RESERVED		0x2000/* Do strict check for free blocks while retrying block allocation */#define EXT4_MB_STRICT_CHECK		0x4000 struct ext4_allocation_request {	/* target inode for block we're allocating */	struct inode *inode;	/* how many blocks we want to allocate */	unsigned int len;	/* logical block in target inode */	ext4_lblk_t logical;	/* the closest logical allocated block to the left */	ext4_lblk_t lleft;	/* the closest logical allocated block to the right */	ext4_lblk_t lright;	/* phys. target (a hint) */	ext4_fsblk_t goal;	/* phys. block for the closest logical allocated block to the left */	ext4_fsblk_t pleft;	/* phys. block for the closest logical allocated block to the right */	ext4_fsblk_t pright;	/* flags. see above EXT4_MB_HINT_* */	unsigned int flags;}; /* * Logical to physical block mapping, used by ext4_map_blocks() * * This structure is used to pass requests into ext4_map_blocks() as * well as to store the information returned by ext4_map_blocks().  It * takes less room on the stack than a struct buffer_head. */#define EXT4_MAP_NEW		BIT(BH_New)#define EXT4_MAP_MAPPED		BIT(BH_Mapped)#define EXT4_MAP_UNWRITTEN	BIT(BH_Unwritten)#define EXT4_MAP_BOUNDARY	BIT(BH_Boundary)#define EXT4_MAP_DELAYED	BIT(BH_Delay)/* * This is for use in ext4_map_query_blocks() for a special case where we can * have a physically and logically contiguous blocks split across two leaf * nodes instead of a single extent. This is required in case of atomic writes * to know whether the returned extent is last in leaf. If yes, then lookup for * next in leaf block in ext4_map_query_blocks_next_in_leaf(). * - This is never going to be added to any buffer head state. * - We use the next available bit after BH_BITMAP_UPTODATE. */#define EXT4_MAP_QUERY_LAST_IN_LEAF	BIT(BH_BITMAP_UPTODATE + 1)#define EXT4_MAP_FLAGS		(EXT4_MAP_NEW | EXT4_MAP_MAPPED |\				 EXT4_MAP_UNWRITTEN | EXT4_MAP_BOUNDARY |\				 EXT4_MAP_DELAYED | EXT4_MAP_QUERY_LAST_IN_LEAF) struct ext4_map_blocks {	ext4_fsblk_t m_pblk;	ext4_lblk_t m_lblk;	unsigned int m_len;	unsigned int m_flags;	u64 m_seq;}; /* * Block validity checking, system zone rbtree. */struct ext4_system_blocks {	struct rb_root root;	struct rcu_head rcu;}; /* * Flags for ext4_io_end->flags */#define EXT4_IO_END_UNWRITTEN	0x0001#define EXT4_IO_END_FAILED	0x0002 #define EXT4_IO_END_DEFER_COMPLETION (EXT4_IO_END_UNWRITTEN | EXT4_IO_END_FAILED) struct ext4_io_end_vec {	struct list_head list;		/* list of io_end_vec */	loff_t offset;			/* offset in the file */	ssize_t size;			/* size of the extent */}; /* * For converting unwritten extents on a work queue. 'handle' is used for * buffered writeback. */typedef struct ext4_io_end {	struct list_head	list;		/* per-file finished IO list */	handle_t		*handle;	/* handle reserved for extent						 * conversion */	struct inode		*inode;		/* file being written to */	struct bio		*bio;		/* Linked list of completed						 * bios covering the extent */	unsigned int		flag;		/* unwritten or not */	refcount_t		count;		/* reference counter */	struct list_head	list_vec;	/* list of ext4_io_end_vec */} ext4_io_end_t; struct ext4_io_submit {	struct writeback_control *io_wbc;	struct bio		*io_bio;	ext4_io_end_t		*io_end;	sector_t		io_next_block;}; /* * Special inodes numbers */#define	EXT4_BAD_INO		 1	/* Bad blocks inode */#define EXT4_ROOT_INO		 2	/* Root inode */#define EXT4_USR_QUOTA_INO	 3	/* User quota inode */#define EXT4_GRP_QUOTA_INO	 4	/* Group quota inode */#define EXT4_BOOT_LOADER_INO	 5	/* Boot loader inode */#define EXT4_UNDEL_DIR_INO	 6	/* Undelete directory inode */#define EXT4_RESIZE_INO		 7	/* Reserved group descriptors inode */#define EXT4_JOURNAL_INO	 8	/* Journal inode */ /* First non-reserved inode for old ext4 filesystems */#define EXT4_GOOD_OLD_FIRST_INO	11 /* * Maximal count of links to a file */#define EXT4_LINK_MAX		65000 /* * Macro-instructions used to manage several block sizes */#define EXT4_MIN_BLOCK_SIZE		1024#define	EXT4_MAX_BLOCK_SIZE		65536#define EXT4_MIN_BLOCK_LOG_SIZE		10#define EXT4_MAX_BLOCK_LOG_SIZE		16#define EXT4_MAX_CLUSTER_LOG_SIZE	28#ifdef __KERNEL__# define EXT4_BLOCK_SIZE(s)		((s)->s_blocksize)#else# define EXT4_BLOCK_SIZE(s)		(EXT4_MIN_BLOCK_SIZE << (s)->s_log_block_size)#endif#define	EXT4_ADDR_PER_BLOCK(s)		(EXT4_BLOCK_SIZE(s) / sizeof(__u32))#define EXT4_CLUSTER_SIZE(s)		(EXT4_BLOCK_SIZE(s) << \					 EXT4_SB(s)->s_cluster_bits)#ifdef __KERNEL__# define EXT4_BLOCK_SIZE_BITS(s)	((s)->s_blocksize_bits)# define EXT4_CLUSTER_BITS(s)		(EXT4_SB(s)->s_cluster_bits)#else# define EXT4_BLOCK_SIZE_BITS(s)	((s)->s_log_block_size + 10)#endif#ifdef __KERNEL__#define	EXT4_ADDR_PER_BLOCK_BITS(s)	(EXT4_SB(s)->s_addr_per_block_bits)#define EXT4_INODE_SIZE(s)		(EXT4_SB(s)->s_inode_size)#define EXT4_FIRST_INO(s)		(EXT4_SB(s)->s_first_ino)#else#define EXT4_INODE_SIZE(s)	(((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? \				 EXT4_GOOD_OLD_INODE_SIZE : \				 (s)->s_inode_size)#define EXT4_FIRST_INO(s)	(((s)->s_rev_level == EXT4_GOOD_OLD_REV) ? \				 EXT4_GOOD_OLD_FIRST_INO : \				 (s)->s_first_ino)#endif#define EXT4_BLOCK_ALIGN(size, blkbits)		ALIGN((size), (1 << (blkbits)))#define EXT4_MAX_BLOCKS(size, offset, blkbits) \	((EXT4_BLOCK_ALIGN(size + offset, blkbits) >> blkbits) - (offset >> \								  blkbits))#define EXT4_B_TO_LBLK(inode, offset) \	(round_up((offset), i_blocksize(inode)) >> (inode)->i_blkbits)#define EXT4_LBLK_TO_B(inode, lblk) ((loff_t)(lblk) << (inode)->i_blkbits) /* Translate a block number to a page index */#define EXT4_LBLK_TO_PG(inode, lblk)	(EXT4_LBLK_TO_B((inode), (lblk)) >> \					 PAGE_SHIFT)/* Translate a page index to a block number */#define EXT4_PG_TO_LBLK(inode, pnum)	(((loff_t)(pnum) << PAGE_SHIFT) >> \					 (inode)->i_blkbits)/* Translate a block number to a cluster number */#define EXT4_B2C(sbi, blk)	((blk) >> (sbi)->s_cluster_bits)/* Translate a cluster number to a block number */#define EXT4_C2B(sbi, cluster)	((cluster) << (sbi)->s_cluster_bits)/* Translate # of blks to # of clusters */#define EXT4_NUM_B2C(sbi, blks)	(((blks) + (sbi)->s_cluster_ratio - 1) >> \				 (sbi)->s_cluster_bits)/* Mask out the low bits to get the starting block of the cluster */#define EXT4_PBLK_CMASK(s, pblk) ((pblk) &				\				  ~((ext4_fsblk_t) (s)->s_cluster_ratio - 1))#define EXT4_LBLK_CMASK(s, lblk) ((lblk) &				\				  ~((ext4_lblk_t) (s)->s_cluster_ratio - 1))/* Fill in the low bits to get the last block of the cluster */#define EXT4_LBLK_CFILL(sbi, lblk) ((lblk) |				\				    ((ext4_lblk_t) (sbi)->s_cluster_ratio - 1))/* Get the cluster offset */#define EXT4_PBLK_COFF(s, pblk) ((pblk) &				\				 ((ext4_fsblk_t) (s)->s_cluster_ratio - 1))#define EXT4_LBLK_COFF(s, lblk) ((lblk) &				\				 ((ext4_lblk_t) (s)->s_cluster_ratio - 1)) /* * Structure of a blocks group descriptor */struct ext4_group_desc{	__le32	bg_block_bitmap_lo;	/* Blocks bitmap block */	__le32	bg_inode_bitmap_lo;	/* Inodes bitmap block */	__le32	bg_inode_table_lo;	/* Inodes table block */	__le16	bg_free_blocks_count_lo;/* Free blocks count */	__le16	bg_free_inodes_count_lo;/* Free inodes count */	__le16	bg_used_dirs_count_lo;	/* Directories count */	__le16	bg_flags;		/* EXT4_BG_flags (INODE_UNINIT, etc) */	__le32  bg_exclude_bitmap_lo;   /* Exclude bitmap for snapshots */	__le16  bg_block_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+bbitmap) LE */	__le16  bg_inode_bitmap_csum_lo;/* crc32c(s_uuid+grp_num+ibitmap) LE */	__le16  bg_itable_unused_lo;	/* Unused inodes count */	__le16  bg_checksum;		/* crc16(sb_uuid+group+desc) */	__le32	bg_block_bitmap_hi;	/* Blocks bitmap block MSB */	__le32	bg_inode_bitmap_hi;	/* Inodes bitmap block MSB */	__le32	bg_inode_table_hi;	/* Inodes table block MSB */	__le16	bg_free_blocks_count_hi;/* Free blocks count MSB */	__le16	bg_free_inodes_count_hi;/* Free inodes count MSB */	__le16	bg_used_dirs_count_hi;	/* Directories count MSB */	__le16  bg_itable_unused_hi;    /* Unused inodes count MSB */	__le32  bg_exclude_bitmap_hi;   /* Exclude bitmap block MSB */	__le16  bg_block_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+bbitmap) BE */	__le16  bg_inode_bitmap_csum_hi;/* crc32c(s_uuid+grp_num+ibitmap) BE */	__u32   bg_reserved;}; #define EXT4_BG_INODE_BITMAP_CSUM_HI_END	\	(offsetof(struct ext4_group_desc, bg_inode_bitmap_csum_hi) + \	 sizeof(__le16))#define EXT4_BG_BLOCK_BITMAP_CSUM_HI_END	\	(offsetof(struct ext4_group_desc, bg_block_bitmap_csum_hi) + \	 sizeof(__le16)) /* * Structure of a flex block group info */ struct flex_groups {	atomic64_t	free_clusters;	atomic_t	free_inodes;	atomic_t	used_dirs;}; #define EXT4_BG_INODE_UNINIT	0x0001 /* Inode table/bitmap not in use */#define EXT4_BG_BLOCK_UNINIT	0x0002 /* Block bitmap not in use */#define EXT4_BG_INODE_ZEROED	0x0004 /* On-disk itable initialized to zero */ /* * Macro-instructions used to manage group descriptors */#define EXT4_MIN_DESC_SIZE		32#define EXT4_MIN_DESC_SIZE_64BIT	64#define	EXT4_MAX_DESC_SIZE		EXT4_MIN_BLOCK_SIZE#define EXT4_DESC_SIZE(s)		(EXT4_SB(s)->s_desc_size)#ifdef __KERNEL__# define EXT4_BLOCKS_PER_GROUP(s)	(EXT4_SB(s)->s_blocks_per_group)# define EXT4_CLUSTERS_PER_GROUP(s)	(EXT4_SB(s)->s_clusters_per_group)# define EXT4_DESC_PER_BLOCK(s)		(EXT4_SB(s)->s_desc_per_block)# define EXT4_INODES_PER_GROUP(s)	(EXT4_SB(s)->s_inodes_per_group)# define EXT4_DESC_PER_BLOCK_BITS(s)	(EXT4_SB(s)->s_desc_per_block_bits)#else# define EXT4_BLOCKS_PER_GROUP(s)	((s)->s_blocks_per_group)# define EXT4_DESC_PER_BLOCK(s)		(EXT4_BLOCK_SIZE(s) / EXT4_DESC_SIZE(s))# define EXT4_INODES_PER_GROUP(s)	((s)->s_inodes_per_group)#endif /* * Constants relative to the data blocks */#define	EXT4_NDIR_BLOCKS		12#define	EXT4_IND_BLOCK			EXT4_NDIR_BLOCKS#define	EXT4_DIND_BLOCK			(EXT4_IND_BLOCK + 1)#define	EXT4_TIND_BLOCK			(EXT4_DIND_BLOCK + 1)#define	EXT4_N_BLOCKS			(EXT4_TIND_BLOCK + 1) /* * Inode flags */#define	EXT4_SECRM_FL			0x00000001 /* Secure deletion */#define	EXT4_UNRM_FL			0x00000002 /* Undelete */#define	EXT4_COMPR_FL			0x00000004 /* Compress file */#define EXT4_SYNC_FL			0x00000008 /* Synchronous updates */#define EXT4_IMMUTABLE_FL		0x00000010 /* Immutable file */#define EXT4_APPEND_FL			0x00000020 /* writes to file may only append */#define EXT4_NODUMP_FL			0x00000040 /* do not dump file */#define EXT4_NOATIME_FL			0x00000080 /* do not update atime *//* Reserved for compression usage... */#define EXT4_DIRTY_FL			0x00000100#define EXT4_COMPRBLK_FL		0x00000200 /* One or more compressed clusters */#define EXT4_NOCOMPR_FL			0x00000400 /* Don't compress */	/* nb: was previously EXT2_ECOMPR_FL */#define EXT4_ENCRYPT_FL			0x00000800 /* encrypted file *//* End compression flags --- maybe not all used */#define EXT4_INDEX_FL			0x00001000 /* hash-indexed directory */#define EXT4_IMAGIC_FL			0x00002000 /* AFS directory */#define EXT4_JOURNAL_DATA_FL		0x00004000 /* file data should be journaled */#define EXT4_NOTAIL_FL			0x00008000 /* file tail should not be merged */#define EXT4_DIRSYNC_FL			0x00010000 /* dirsync behaviour (directories only) */

Lines 1–500 of 4078.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t