reiserfs_fs.h

reiserfsprogs-3.6.19.tar.gz 源码 给有需要的人！

/*
 * Copyright 1996-2004 by Hans Reiser, licensing governed by 
 * reiserfsprogs/README
 */

/*
 *  Reiser File System constants and structures
 */

/* in reading the #defines, it may help to understand that they employ the
   following abbreviations:

   B = Buffer
   I = Item header
   H = Height within the tree (should be changed to LEV)
   N = Number of the item in the node
   STAT = stat data
   DEH = Directory Entry Header
   EC = Entry Count
   E = Entry number
   UL = Unsigned Long
   BLKH = BLocK Header
   UNFM = UNForMatted node
   DC = Disk Child
   P = Path

   These #defines are named by concatenating these abbreviations, where first
   comes the arguments, and last comes the return value, of the macro.

*/

#ifndef REISERFSPROGS_FS_H
#define REISERFSPRIGS_FS_H 

#ifndef NO_EXTERN_INLINE
# define extern_inline extern inline
#else
# define extern_inline
#endif

#include <asm/unaligned.h>

#ifndef get_unaligned
#if defined(__ppc__) || defined(ppc) || defined(__ppc) || \
    defined(__PPC) || defined(powerpc) || defined(__powerpc__)
#	define get_unaligned(ptr)	(*(ptr))
#	define put_unaligned(val,ptr)	((void)(*(ptr) = (val)))
#endif
#endif

#define get_leXX(xx,p,field)	(le##xx##_to_cpu ((p)->field))
#define set_leXX(xx,p,field,val) do { (p)->field = cpu_to_le##xx(val); } while (0)

#define get_le16(p,field)	get_leXX (16, p, field)
#define set_le16(p,field,val)	set_leXX (16, p, field, val)

#define get_le32(p,field)	get_leXX (32, p, field)
#define set_le32(p,field,val)	set_leXX (32, p, field, val)

#define get_le64(p,field)	get_leXX (64, p, field)
#define set_le64(p,field,val)	set_leXX (64, p, field, val)



/***************************************************************************/
/*                             SUPER BLOCK                                 */
/***************************************************************************/

#define UNSET_HASH 0 // read_super will guess about, what hash names
                     // in directories were sorted with
#define TEA_HASH  1
#define YURA_HASH 2
#define R5_HASH   3
#define DEFAULT_HASH R5_HASH


/* super block of prejournalled version */
struct reiserfs_super_block_v0
{
    __u32 s_block_count;
    __u32 s_free_blocks;
    __u32 s_root_block;
    __u16 s_blocksize;
    __u16 s_oid_maxsize;
    __u16 s_oid_cursize;
    __u16 s_state;
    char s_magic[16];
    __u16 s_tree_height;
    __u16 s_bmap_nr;
    __u16 s_reserved;
};


struct journal_params {
    __u32 jp_journal_1st_block;	/* where does journal start from on its
                                   device */
    __u32 jp_journal_dev;	/* journal device st_rdev */
    __u32 jp_journal_size;	/* size of the journal on FS creation. used to
				   make sure they don't overflow it */
    __u32 jp_journal_trans_max;	/* max number of blocks in a transaction.  */
    __u32 jp_journal_magic; 	/* random value made on fs creation (this was
				   sb_journal_block_count) */
    __u32 jp_journal_max_batch;	/* max number of blocks to batch into a trans */
    __u32 jp_journal_max_commit_age;      /* in seconds, how old can an async commit be */
    __u32 jp_journal_max_trans_age;       /* in seconds, how old can a transaction be */
};


#define get_jp_journal_1st_block(jp)	 get_le32 (jp, jp_journal_1st_block)
#define set_jp_journal_1st_block(jp,val) set_le32 (jp, jp_journal_1st_block, val)

#define get_jp_journal_dev(jp)		get_le32 (jp, jp_journal_dev)
#define set_jp_journal_dev(jp,val)	set_le32 (jp, jp_journal_dev, val)

#define get_jp_journal_size(jp)		get_le32 (jp, jp_journal_size)
#define set_jp_journal_size(jp,val)	set_le32 (jp, jp_journal_size, val)

#define get_jp_journal_max_trans_len(jp)	get_le32 (jp, jp_journal_trans_max)
#define set_jp_journal_max_trans_len(jp,val)	set_le32 (jp, jp_journal_trans_max, val)

#define get_jp_journal_magic(jp)	get_le32 (jp, jp_journal_magic)
#define set_jp_journal_magic(jp,val)	set_le32 (jp, jp_journal_magic, val)

#define NEED_TUNE 0xffffffff

#define get_jp_journal_max_batch(jp)	get_le32 (jp, jp_journal_max_batch)
#define set_jp_journal_max_batch(jp,val)	set_le32 (jp, jp_journal_max_batch, val)

#define get_jp_journal_max_commit_age(jp)	get_le32 (jp, jp_journal_max_commit_age)
#define set_jp_journal_max_commit_age(jp,val)	set_le32 (jp, jp_journal_max_commit_age, val)

#define get_jp_journal_max_trans_age(jp)	get_le32 (jp, jp_journal_max_commit_age)
#define set_jp_journal_max_trans_age(jp,val)	set_le32 (jp, jp_journal_max_commit_age, val)


/* this is the super from 3.5.X */
struct reiserfs_super_block_v1
{
    __u32 sb_block_count; 	/* 0 number of block on data device */
    __u32 sb_free_blocks; 	/* 4 free blocks count */
    __u32 sb_root_block;        /* 8 root of the tree */

    struct journal_params sb_journal; /* 12 */

    __u16 sb_blocksize;         /* 44 */
    __u16 sb_oid_maxsize;	/* 46 max size of object id array, see
				   get_objectid() commentary */
    __u16 sb_oid_cursize; 	/* 48 current size of object id array */
    __u16 sb_umount_state;	/* 50 this is set to 1 when filesystem was
				   umounted, to 2 - when not */
    
    char s_magic[10]; 		/* 52 reiserfs magic string indicates that
				   file system is reiserfs: "ReIsErFs" or
				   "ReIsEr2Fs" or "ReIsEr3Fs" */
    __u16 sb_fs_state; 		/* 62 it is set to used by fsck to mark which phase of
				   rebuilding is done (used for fsck debugging) */
    __u32 sb_hash_function_code;/* 64 code of fuction which was/is/will be
				   used to sort names in a directory. See
				   codes in above */
    __u16 sb_tree_height;	/* 68 height of filesytem tree. Tree
				   consisting of only one root block has 2
				   here */
    __u16 sb_bmap_nr;     	/* 70 amount of bitmap blocks needed to
				   address each block of file system */
    __u16 sb_version; 		/* 72 this field is only reliable on
				   filesystem with non-standard journal */
    __u16 sb_reserved_for_journal;  /* 74 size in blocks of journal area on
				       main device, we need to keep after
				       non-standard journal relocation */
};

#define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1)) /* 76 bytes */

#define sb_jp(sb) (&((sb)->s_v1.sb_journal))

/* values for sb_version field of struct reiserfs_super_block. sb_version is
   only reliable on filesystem with non-standard journal */
#define REISERFS_FORMAT_3_5 0
#define REISERFS_FORMAT_3_6 2
#define REISERFS_FORMAT_UNKNOWN -1
                                   

/* values for sb_mount_state field */
#define FS_CLEANLY_UMOUNTED    1 /* this was REISERFS_VALID_FS */
#define FS_NOT_CLEANLY_UMOUNTED    2 /* this was REISERFS_ERROR. It
                                              means that filesystem was not
                                              cleanly unmounted */

/* Structure of super block on disk */
struct reiserfs_super_block
{
/*  0 */    struct reiserfs_super_block_v1 s_v1;
/* 76 */     __u32 sb_inode_generation; 
/* 80 */     __u32 s_flags;                /* Right now used only by inode-attributes, if enabled */
/* 84 */    unsigned char s_uuid[16];      /* filesystem unique identifier */
/*100 */    unsigned char s_label[16];     /* filesystem volume label */
/*116 */    char s_unused[88] ;            /* zero filled by mkreiserfs and reiserfs_convert_objectid_map_v1()
                                            * so any additions must be updated there as well. */ 
/*204*/
} __attribute__ ((__packed__));;

typedef enum {
  reiserfs_attrs_cleared       = 0x00000001,
} reiserfs_super_block_flags;



#define SB_SIZE (sizeof(struct reiserfs_super_block)) /* 204 bytes */

/* set/get fields of super block with these defines */
#define get_sb_block_count(sb)		get_le32 (sb, s_v1.sb_block_count)
#define set_sb_block_count(sb,val)	set_le32 (sb, s_v1.sb_block_count, val)

#define get_sb_free_blocks(sb)		get_le32 (sb, s_v1.sb_free_blocks)
#define set_sb_free_blocks(sb,val)	set_le32 (sb, s_v1.sb_free_blocks, val)

#define get_sb_root_block(sb)		get_le32 (sb,s_v1.sb_root_block)
#define set_sb_root_block(sb,val)	set_le32 (sb, s_v1.sb_root_block, val)

#if 0
#define get_sb_mount_id(sb)		get_le32 (sb,s_v1.sb_mountid)
#define set_sb_mount_id(sb,val)		set_le32 (sb, s_v1.sb_mountid, val)

#define get_sb_journal_magic(sb)	get_le32 (sb, s_v1.sb_journal_magic)
#define set_sb_journal_magic(sb,val)	set_le32 (sb, s_v1.sb_journal_magic, val)
#endif

#define get_sb_block_size(sb)		get_le16 (sb, s_v1.sb_blocksize)
#define set_sb_block_size(sb,val)	set_le16 (sb, s_v1.sb_blocksize, val)

#define get_sb_oid_maxsize(sb)		get_le16 (sb, s_v1.sb_oid_maxsize)
#define set_sb_oid_maxsize(sb,val)	set_le16 (sb, s_v1.sb_oid_maxsize, val)

#define get_sb_oid_cursize(sb)		get_le16 (sb, s_v1.sb_oid_cursize)
#define set_sb_oid_cursize(sb,val)	set_le16 (sb, s_v1.sb_oid_cursize, val)

#define get_sb_umount_state(sb)		get_le16 (sb, s_v1.sb_umount_state)
#define set_sb_umount_state(sb,val)	set_le16 (sb, s_v1.sb_umount_state, val)

#define get_sb_fs_state(sb)		get_le16 (sb, s_v1.sb_fs_state)
#define set_sb_fs_state(sb,flag)	set_le16 (sb, s_v1.sb_fs_state, flag)

#define get_sb_hash_code(sb)		get_le32 (sb, s_v1.sb_hash_function_code)
#define set_sb_hash_code(sb,val)	set_le32 (sb, s_v1.sb_hash_function_code, val)

#define get_sb_tree_height(sb)		get_le16 (sb, s_v1.sb_tree_height)
#define set_sb_tree_height(sb,val)	set_le16 (sb, s_v1.sb_tree_height, val)

#define get_sb_bmap_nr(sb)		get_le16 (sb, s_v1.sb_bmap_nr)
#define set_sb_bmap_nr(sb,val)		set_le16 (sb, s_v1.sb_bmap_nr, val)

#define get_sb_version(sb)		get_le16 (sb, s_v1.sb_version)
#define set_sb_version(sb,val)		set_le16 (sb, s_v1.sb_version, val)

#define get_sb_reserved_for_journal(sb)		get_le16 (sb, s_v1.sb_reserved_for_journal)
#define set_sb_reserved_for_journal(sb,val)	set_le16 (sb, s_v1.sb_reserved_for_journal, val)

#define get_sb_v2_inode_generation(sb)		get_le32 (sb, sb_inode_generation)
#define set_sb_v2_inode_generation(sb,val)	set_le32 (sb, sb_inode_generation, val)

#define get_sb_v2_flags(sb)		get_le32 (sb, s_flags)
#define set_sb_v2_flags(sb, val)	set_le32 (sb, s_flags, val)

#define get_sb_v2_flag(sb, flag)       (get_le32 (sb, s_flags) & flag)
#define set_sb_v2_flag(sb, flag)	set_le32 (sb, s_flags, get_le32 (sb, s_flags) | flag)
#define clear_sb_v2_flag(sb, flag)	set_le32 (sb, s_flags, get_le32 (sb, s_flags) & ~(flag))

/*
#define journal_is_relocated(sb)        get_jp_journal_dev(sb_jp (sb))
*/

/* these are possible values for sb_fs_state */
#define FS_CONSISTENT   0x0	    /* this is set by mkreiserfs and by reiserfsck */
#define FS_ERROR	0x1	    /* this is set by the kernel when fsck is wanted. */
#define FS_FATAL	0x2	    /* this is set by fsck when fatal corruption is found */
#define IO_ERROR	0x4	    /* this is set by kernel when io error occures */
#define PASS_0_DONE     0xfa02	    /* set by fsck when pass-by-pass (-d),
				       FS_FATAL flag included */
#define PASS_1_DONE     0xfb02	    /* set by fsck when pass-by-pass (-d),
                                       FS_FATAL flag included */
#define TREE_IS_BUILT   0xfc02	    /* set by fsck when pass-by-pass (-d),
                                       FS_FATAL flag included */
#define SEMANTIC_DONE   0xfd02	    /* set by fsck when pass-by-pass (-d),
                                       FS_FATAL flag included */
#define LOST_FOUND_DONE 0xfe02	    /* set by fsck when pass-by-pass (-d),
                                       FS_FATAL flag included */

/* struct stat_data* access macros */
/* v1 */
#define sd_v1_mode(sd)                 (le16_to_cpu((sd)->sd_mode))
#define set_sd_v1_mode(sd,n)           ((sd)->sd_mode = cpu_to_le16((n)))
#define sd_v1_nlink(sd)                (le16_to_cpu((sd)->sd_nlink))
#define set_sd_v1_nlink(sd,n)          ((sd)->sd_nlink = cpu_to_le16((n))) 
#define sd_v1_uid(sd)                  (le16_to_cpu((sd)->sd_uid))
#define set_sd_v1_uid(sd,n)            ((sd)->sd_uid = cpu_to_le16((n)))
#define sd_v1_gid(sd)                  (le16_to_cpu((sd)->sd_gid))
#define set_sd_v1_gid(sd,n)            ((sd)->sd_gid = cpu_to_le16((n)))
#define sd_v1_size(sd)                 (le32_to_cpu((sd)->sd_size))
#define set_sd_v1_size(sd,n)           ((sd)->sd_size = cpu_to_le32((n)))
#define sd_v1_atime(sd)                (le32_to_cpu((sd)->sd_atime))
#define set_sd_v1_atime(sd,n)          ((sd)->sd_atime = cpu_to_le32((n)))
#define sd_v1_mtime(sd)                (le32_to_cpu((sd)->sd_mtime))
#define set_sd_v1_mtime(sd,n)          ((sd)->sd_mtime = cpu_to_le32((n)))
#define sd_v1_ctime(sd)                (le32_to_cpu((sd)->sd_ctime))
#define set_sd_v1_ctime(sd,n)          ((sd)->sd_ctime = cpu_to_le32((n)))
#define sd_v1_blocks(sd)               (le32_to_cpu((sd)->u.sd_blocks))
#define set_sd_v1_blocks(sd,n)         ((sd)->u.sd_blocks = cpu_to_le32((n)))
#define sd_v1_rdev(sd)                 (le32_to_cpu((sd)->u.sd_rdev))
#define set_sd_v1_rdev(sd,n)           ((sd)->u.sd_rdev = cpu_to_le32((n)))
#define sd_v1_first_direct_byte(sd)    (le32_to_cpu((sd)->sd_first_direct_byte))