298 lines
9.6 KiB
C
298 lines
9.6 KiB
C
/*
|
|
* Copyright 2000-2004 by Hans Reiser, licensing governed by
|
|
* reiserfsprogs/README
|
|
*/
|
|
|
|
#ifndef REISERFS_TYPES_H
|
|
#define REISERFS_TYPES_H
|
|
|
|
#include "misc/types.h"
|
|
#include "misc/swab.h"
|
|
|
|
struct reiserfs_bitmap {
|
|
unsigned long bm_byte_size;
|
|
unsigned long bm_bit_size;
|
|
char * bm_map;
|
|
unsigned long bm_set_bits;
|
|
int bm_dirty; /* used for fetched bitmap */
|
|
unsigned long bm_first_zero;
|
|
};
|
|
|
|
typedef struct reiserfs_bitmap reiserfs_bitmap_t;
|
|
|
|
|
|
typedef struct reiserfs_bh reiserfs_bh_t;
|
|
|
|
struct reiserfs_bh {
|
|
unsigned long b_blocknr;
|
|
int b_dev;
|
|
unsigned long b_size;
|
|
char * b_data;
|
|
unsigned long b_state;
|
|
unsigned int b_count;
|
|
unsigned int b_list ;
|
|
void (*b_start_io) (unsigned long);
|
|
void (*b_end_io)(reiserfs_bh_t *bh, int uptodate);
|
|
|
|
reiserfs_bh_t * b_next;
|
|
reiserfs_bh_t * b_prev;
|
|
reiserfs_bh_t * b_hash_next;
|
|
reiserfs_bh_t * b_hash_prev;
|
|
};
|
|
|
|
|
|
/* magic string to find desc blocks in the journal */
|
|
#define JOURNAL_DESC_MAGIC "ReIsErLB"
|
|
|
|
struct reiserfs_journal_param {
|
|
/* where does journal start from on its device */
|
|
__u32 jp_start;
|
|
/* journal device st_rdev */
|
|
__u32 jp_dev;
|
|
/* size of the journal on FS creation. used to make sure
|
|
they don't overflow it */
|
|
__u32 jp_size;
|
|
/* max number of blocks in a transaction. */
|
|
__u32 jp_tlen;
|
|
/* random value made on fs creation (this was sb_journal_block_count) */
|
|
__u32 jp_magic;
|
|
/* max number of blocks to batch into a trans */
|
|
__u32 jp_max_batch;
|
|
/* in seconds, how old can an async commit be */
|
|
__u32 jp_commit_age;
|
|
/* in seconds, how old can a transaction be */
|
|
__u32 jp_trans_age;
|
|
};
|
|
|
|
typedef struct reiserfs_journal_param reiserfs_journal_param_t;
|
|
|
|
/* this header block gets written whenever a transaction is considered fully
|
|
** flushed, and is more recent than the last fully flushed transaction. fully
|
|
** flushed means all the log blocks and all the real blocks are on disk, and
|
|
** this transaction does not need to be replayed. */
|
|
struct reiserfs_journal_header {
|
|
/* id of last fully flushed transaction */
|
|
__u32 jh_last_flush_trans_id ;
|
|
/* offset in the log of where to start replay after a crash */
|
|
__u32 jh_flush_offset ;
|
|
|
|
__u32 jh_mount_id ;
|
|
|
|
reiserfs_journal_param_t jh_journal;
|
|
|
|
/* the mount id of the fs during the last reiserfsck --check. */
|
|
__u32 jh_last_check_mount_id;
|
|
};
|
|
|
|
/* 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 */
|
|
|
|
reiserfs_journal_param_t 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 */
|
|
};
|
|
|
|
typedef struct reiserfs_super_block_v1 reiserfs_sb_v1_t;
|
|
|
|
/* Structure of super block on disk */
|
|
struct reiserfs_super_block {
|
|
/* 0 */ reiserfs_sb_v1_t s_v1;
|
|
/* 76 */ __u32 sb_inode_generation;
|
|
/* Right now used only by inode-attributes, if enabled */
|
|
/* 80 */ __u32 s_flags;
|
|
/* filesystem unique identifier */
|
|
/* 84 */ unsigned char s_uuid[16];
|
|
/* filesystem volume label */
|
|
/*100 */ unsigned char s_label[16];
|
|
/* zero filled by mkreiserfs and reiserfs_convert_objectid_map_v1()
|
|
* so any additions must be updated there as well. */
|
|
/*116 */ char s_unused[88];
|
|
/*204*/
|
|
} __attribute__ ((__packed__));;
|
|
|
|
typedef struct reiserfs_super_block reiserfs_sb_t;
|
|
|
|
typedef __u32 (*hashf_t) (const char *, int);
|
|
|
|
typedef struct reiserfs_filsys reiserfs_filsys_t;
|
|
|
|
struct reiserfs_filsys {
|
|
unsigned int fs_blocksize;
|
|
int fs_format; /* on-disk format version */
|
|
hashf_t hash; /* pointer to function which is used to sort
|
|
names in directory. It is set by
|
|
reiserfs_fs_open if it is set in the super
|
|
block, otherwise it is set by first
|
|
reiserfs_hash_correct */
|
|
|
|
char fs_file_name[4096]; /* file name of underlying device */
|
|
int fs_dev; /* descriptor of opened block device file */
|
|
reiserfs_bh_t * fs_super_bh; /* buffer containing super block */
|
|
reiserfs_sb_t * fs_ondisk_sb; /* pointer to its b_data */
|
|
|
|
|
|
reiserfs_bitmap_t * fs_bitmap2; /* ondisk bitmap after
|
|
reiserfs_bitmap_open */
|
|
|
|
|
|
/* opened journal fields */
|
|
char fs_j_file_name[4096]; /* file name of relocated journal device */
|
|
int fs_journal_dev; /* descriptor of opened journal device */
|
|
reiserfs_bh_t * fs_jh_bh; /* buffer containing journal header */
|
|
|
|
/* badblocks */
|
|
reiserfs_bitmap_t * fs_badblocks_bm;
|
|
|
|
int fs_dirt;
|
|
int fs_flags;
|
|
void * fs_vp;
|
|
int (*block_allocator) (reiserfs_filsys_t * fs,
|
|
unsigned long * free_blocknrs,
|
|
unsigned long start, int amount_needed);
|
|
int (*block_deallocator) (reiserfs_filsys_t * fs, unsigned long block);
|
|
|
|
__u16 lost_format;
|
|
};
|
|
|
|
|
|
#define REISERFS_TREE_HEIGHT_MAX 6
|
|
#define REISERFS_PATH_OFFINIT 2
|
|
#define REISERFS_PATH_OFFILL 1
|
|
#define REISERFS_PATH_MAX (REISERFS_TREE_HEIGHT_MAX + \
|
|
REISERFS_PATH_OFFINIT)
|
|
|
|
struct reiserfs_path_element {
|
|
/* Pointer to the buffer at the path in the tree. */
|
|
reiserfs_bh_t * pe_buffer;
|
|
|
|
/* Position in the tree node which is placed in the buffer above. */
|
|
int pe_position;
|
|
};
|
|
|
|
typedef struct reiserfs_path_element reiserfs_path_element_t;
|
|
|
|
|
|
/* We need to keep track of who the ancestors of nodes are. When we
|
|
perform a search we record which nodes were visited while
|
|
descending the tree looking for the node we searched for. This list
|
|
of nodes is called the path. This information is used while
|
|
performing balancing. Note that this path information may become
|
|
invalid, and this means we must check it when using it to see if it
|
|
is still valid. You'll need to read reiserfs_tree_search_item and the
|
|
comments in it, especially about decrement_counters_in_path(),
|
|
to understand this structure. */
|
|
struct reiserfs_path {
|
|
/* Length of the array above. */
|
|
unsigned int path_length;
|
|
|
|
/* Array of the path elements. */
|
|
reiserfs_path_element_t path_elements[REISERFS_PATH_MAX];
|
|
|
|
int pos_in_item;
|
|
};
|
|
|
|
typedef struct reiserfs_path reiserfs_path_t;
|
|
|
|
struct reiserfs_koff_v1 {
|
|
__u32 k_offset;
|
|
__u32 k_uniqueness;
|
|
} __attribute__ ((__packed__));
|
|
|
|
struct reiserfs_koff_v2 {
|
|
#if __BYTE_ORDER == __LITTLE_ENDIAN
|
|
__u64 k_offset:60;
|
|
__u64 k_type: 4;
|
|
#elif __BYTE_ORDER == __BIG_ENDIAN
|
|
__u64 k_type: 4;
|
|
__u64 k_offset:60;
|
|
#else
|
|
# error "nuxi/pdp-endian archs are not supported"
|
|
#endif
|
|
} __attribute__ ((__packed__));
|
|
|
|
/* Key of the object determines object's location in the tree,
|
|
composed of 4 components */
|
|
struct reiserfs_key {
|
|
/* packing locality: by default parent directory object id */
|
|
__u32 k2_dir_id;
|
|
|
|
/* object identifier */
|
|
__u32 k2_objectid;
|
|
|
|
union {
|
|
struct reiserfs_koff_v1 k2_offset_v1;
|
|
struct reiserfs_koff_v2 k2_offset_v2;
|
|
} __attribute__ ((__packed__)) u;
|
|
} __attribute__ ((__packed__));
|
|
|
|
typedef struct reiserfs_key reiserfs_key_t;
|
|
|
|
/* Everything in the filesystem is stored as a set of items. The item head
|
|
contains the key of the item, its free space (for extent items) and
|
|
specifies the location of the item itself within the block. */
|
|
|
|
struct reiserfs_ih {
|
|
reiserfs_key_t ih_key; /* Everything in the tree is found by searching for it
|
|
based on its key.*/
|
|
|
|
union {
|
|
__u16 ih2_free_space; /* The free space in the last unformatted node
|
|
of an extent item if this is an extent
|
|
item. This equals 0xFFFF iff this is a direct
|
|
item or stat data item. Note that the key, not
|
|
this field, is used to determine the item
|
|
type, and thus which field this union
|
|
contains. */
|
|
__u16 ih2_entry_count; /* Iff this is a directory item, this field
|
|
equals the number of directory entries in
|
|
the directory item. */
|
|
} __attribute__ ((__packed__)) u;
|
|
__u16 ih2_item_len; /* total size of the item body */
|
|
__u16 ih2_item_location; /* an offset to the item body within the
|
|
block */
|
|
|
|
__u16 ih_format; /* key format is stored in bits 0-11 of this item
|
|
flags are stored in bits 12-15 */
|
|
#if 0
|
|
struct {
|
|
__u16 key_format : 12; /* KEY_FORMAT_1 or KEY_FORMAT_2. This is not
|
|
necessary, but we have space, let use it */
|
|
__u16 flags : 4; /* fsck set here its flag (reachable/unreachable) */
|
|
} __attribute__ ((__packed__)) ih2_format;
|
|
#endif
|
|
} __attribute__ ((__packed__));
|
|
|
|
typedef struct reiserfs_ih reiserfs_ih_t;
|
|
|
|
typedef int (*unfm_func_t) (reiserfs_filsys_t *, __u32);
|
|
|
|
#endif
|