2005-06-18 17:10:50 +00:00
|
|
|
/*-
|
|
|
|
* Copyright 2000 Hans Reiser
|
|
|
|
* See README for licensing and copyright details
|
|
|
|
*
|
2012-01-15 13:23:18 +00:00
|
|
|
* Ported to FreeBSD by Jean-Sébastien Pédron <jspedron@club-internet.fr>
|
2005-06-18 17:10:50 +00:00
|
|
|
*
|
|
|
|
* $FreeBSD$
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef _GNU_REISERFS_REISERFS_FS_H
|
|
|
|
#define _GNU_REISERFS_REISERFS_FS_H
|
|
|
|
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/endian.h>
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/mount.h>
|
|
|
|
#include <sys/namei.h>
|
2006-11-06 13:42:10 +00:00
|
|
|
#include <sys/priv.h>
|
2005-06-18 17:10:50 +00:00
|
|
|
#include <sys/proc.h>
|
|
|
|
#include <sys/vnode.h>
|
|
|
|
#include <sys/unistd.h>
|
|
|
|
|
|
|
|
#include <sys/bio.h>
|
|
|
|
#include <sys/buf.h>
|
|
|
|
#include <sys/conf.h>
|
|
|
|
#include <sys/fcntl.h>
|
|
|
|
#include <sys/syslog.h>
|
|
|
|
|
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/dirent.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
//#include <sys/mutex.h>
|
|
|
|
|
|
|
|
#include <sys/ctype.h>
|
|
|
|
#include <sys/bitstring.h>
|
|
|
|
|
|
|
|
#include <geom/geom.h>
|
|
|
|
#include <geom/geom_vfs.h>
|
|
|
|
|
|
|
|
#include <gnu/fs/reiserfs/reiserfs_mount.h>
|
|
|
|
#include <gnu/fs/reiserfs/reiserfs_fs_sb.h>
|
|
|
|
#include <gnu/fs/reiserfs/reiserfs_fs_i.h>
|
|
|
|
|
|
|
|
/* n must be power of 2 */
|
|
|
|
#define _ROUND_UP(x, n) (((x) + (n) - 1u) & ~((n) - 1u))
|
|
|
|
|
|
|
|
/* To be ok for alpha and others we have to align structures to 8 byte
|
|
|
|
* boundary. */
|
|
|
|
#define ROUND_UP(x) _ROUND_UP(x, 8LL)
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Global variables
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
extern struct vop_vector reiserfs_vnodeops;
|
|
|
|
extern struct vop_vector reiserfs_specops;
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Super block
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
#define REISERFS_BSIZE 1024
|
|
|
|
|
|
|
|
/* ReiserFS leaves the first 64k unused, so that partition labels have
|
|
|
|
* enough space. If someone wants to write a fancy bootloader that needs
|
|
|
|
* more than 64k, let us know, and this will be increased in size.
|
|
|
|
* This number must be larger than than the largest block size on any
|
|
|
|
* platform, or code will break. -Hans */
|
|
|
|
#define REISERFS_DISK_OFFSET 64
|
|
|
|
#define REISERFS_DISK_OFFSET_IN_BYTES \
|
|
|
|
((REISERFS_DISK_OFFSET) * (REISERFS_BSIZE))
|
|
|
|
|
|
|
|
/* The spot for the super in versions 3.5 - 3.5.10 (inclusive) */
|
|
|
|
#define REISERFS_OLD_DISK_OFFSET 8
|
|
|
|
#define REISERFS_OLD_DISK_OFFSET_IN_BYTES \
|
|
|
|
((REISERFS_OLD_DISK_OFFSET) * (REISERFS_BSIZE))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Structure of a super block on disk, a version of which in RAM is
|
|
|
|
* often accessed as REISERFS_SB(s)->r_rs. The version in RAM is part of
|
|
|
|
* a larger structure containing fields never written to disk.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#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
|
|
|
|
|
|
|
|
struct journal_params {
|
|
|
|
uint32_t jp_journal_1st_block; /* Where does journal start
|
|
|
|
from on its device */
|
|
|
|
uint32_t jp_journal_dev; /* Journal device st_rdev */
|
|
|
|
uint32_t jp_journal_size; /* Size of the journal */
|
|
|
|
uint32_t jp_journal_trans_max; /* Max number of blocks in
|
|
|
|
a transaction */
|
|
|
|
uint32_t jp_journal_magic; /* Random value made on
|
|
|
|
fs creation (this was
|
|
|
|
sb_journal_block_count) */
|
|
|
|
uint32_t jp_journal_max_batch; /* Max number of blocks to
|
|
|
|
batch into a
|
|
|
|
transaction */
|
|
|
|
uint32_t jp_journal_max_commit_age; /* In seconds, how old can
|
|
|
|
an async commit be */
|
|
|
|
uint32_t jp_journal_max_trans_age; /* In seconds, how old a
|
|
|
|
transaction be */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct reiserfs_super_block_v1 {
|
|
|
|
uint32_t s_block_count; /* Blocks count */
|
|
|
|
uint32_t s_free_blocks; /* Free blocks count */
|
|
|
|
uint32_t s_root_block; /* Root block number */
|
|
|
|
|
|
|
|
struct journal_params s_journal;
|
|
|
|
|
|
|
|
uint16_t s_blocksize;
|
|
|
|
uint16_t s_oid_maxsize;
|
|
|
|
uint16_t s_oid_cursize;
|
|
|
|
uint16_t s_umount_state;
|
|
|
|
|
|
|
|
char s_magic[10];
|
|
|
|
|
|
|
|
uint16_t s_fs_state;
|
|
|
|
uint32_t s_hash_function_code;
|
|
|
|
uint16_t s_tree_height;
|
|
|
|
uint16_t s_bmap_nr;
|
|
|
|
uint16_t s_version;
|
|
|
|
uint16_t s_reserved_for_journal;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
#define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1))
|
|
|
|
|
|
|
|
struct reiserfs_super_block {
|
|
|
|
struct reiserfs_super_block_v1 s_v1;
|
|
|
|
uint32_t s_inode_generation;
|
|
|
|
uint32_t s_flags;
|
|
|
|
unsigned char s_uuid[16];
|
|
|
|
unsigned char s_label[16];
|
|
|
|
char s_unused[88];
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
#define SB_SIZE (sizeof(struct reiserfs_super_block))
|
|
|
|
|
|
|
|
#define REISERFS_VERSION_1 0
|
|
|
|
#define REISERFS_VERSION_2 2
|
|
|
|
|
|
|
|
#define REISERFS_SB(sbi) (sbi)
|
|
|
|
#define SB_DISK_SUPER_BLOCK(sbi) (REISERFS_SB(sbi)->s_rs)
|
|
|
|
#define SB_V1_DISK_SUPER_BLOCK(sbi) (&(SB_DISK_SUPER_BLOCK(sbi)->s_v1))
|
|
|
|
|
|
|
|
#define SB_BLOCKSIZE(sbi) \
|
|
|
|
le32toh((SB_V1_DISK_SUPER_BLOCK(sbi)->s_blocksize))
|
|
|
|
#define SB_BLOCK_COUNT(sbi) \
|
|
|
|
le32toh((SB_V1_DISK_SUPER_BLOCK(sbi)->s_block_count))
|
|
|
|
#define SB_FREE_BLOCKS(s) \
|
|
|
|
le32toh((SB_V1_DISK_SUPER_BLOCK(sbi)->s_free_blocks))
|
|
|
|
|
|
|
|
#define SB_REISERFS_MAGIC(sbi) \
|
|
|
|
(SB_V1_DISK_SUPER_BLOCK(sbi)->s_magic)
|
|
|
|
|
|
|
|
#define SB_ROOT_BLOCK(sbi) \
|
|
|
|
le32toh((SB_V1_DISK_SUPER_BLOCK(sbi)->s_root_block))
|
|
|
|
|
|
|
|
#define SB_TREE_HEIGHT(sbi) \
|
|
|
|
le16toh((SB_V1_DISK_SUPER_BLOCK(sbi)->s_tree_height))
|
|
|
|
|
|
|
|
#define SB_REISERFS_STATE(sbi) \
|
|
|
|
le16toh((SB_V1_DISK_SUPER_BLOCK(sbi)->s_umount_state))
|
|
|
|
|
|
|
|
#define SB_VERSION(sbi) le16toh((SB_V1_DISK_SUPER_BLOCK(sbi)->s_version))
|
|
|
|
#define SB_BMAP_NR(sbi) le16toh((SB_V1_DISK_SUPER_BLOCK(sbi)->s_bmap_nr))
|
|
|
|
|
|
|
|
#define REISERFS_SUPER_MAGIC_STRING "ReIsErFs"
|
|
|
|
#define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs"
|
|
|
|
#define REISER2FS_JR_SUPER_MAGIC_STRING "ReIsEr3Fs"
|
|
|
|
|
|
|
|
extern const char reiserfs_3_5_magic_string[];
|
|
|
|
extern const char reiserfs_3_6_magic_string[];
|
|
|
|
extern const char reiserfs_jr_magic_string[];
|
|
|
|
|
|
|
|
int is_reiserfs_3_5(struct reiserfs_super_block *rs);
|
|
|
|
int is_reiserfs_3_6(struct reiserfs_super_block *rs);
|
|
|
|
int is_reiserfs_jr(struct reiserfs_super_block *rs);
|
|
|
|
|
|
|
|
/* ReiserFS internal error code (used by search_by_key and fix_nodes) */
|
|
|
|
#define IO_ERROR -2
|
|
|
|
|
|
|
|
typedef uint32_t b_blocknr_t;
|
|
|
|
typedef uint32_t unp_t;
|
|
|
|
|
|
|
|
struct unfm_nodeinfo {
|
|
|
|
unp_t unfm_nodenum;
|
|
|
|
unsigned short unfm_freespace;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* There are two formats of keys: 3.5 and 3.6 */
|
|
|
|
#define KEY_FORMAT_3_5 0
|
|
|
|
#define KEY_FORMAT_3_6 1
|
|
|
|
|
|
|
|
/* There are two stat datas */
|
|
|
|
#define STAT_DATA_V1 0
|
|
|
|
#define STAT_DATA_V2 1
|
|
|
|
|
|
|
|
#define REISERFS_I(ip) (ip)
|
|
|
|
|
|
|
|
#define get_inode_item_key_version(ip) \
|
|
|
|
((REISERFS_I(ip)->i_flags & i_item_key_version_mask) ? \
|
|
|
|
KEY_FORMAT_3_6 : KEY_FORMAT_3_5)
|
|
|
|
|
|
|
|
#define set_inode_item_key_version(ip, version) ({ \
|
|
|
|
if ((version) == KEY_FORMAT_3_6) \
|
|
|
|
REISERFS_I(ip)->i_flags |= i_item_key_version_mask; \
|
|
|
|
else \
|
|
|
|
REISERFS_I(ip)->i_flags &= ~i_item_key_version_mask; \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define get_inode_sd_version(ip) \
|
|
|
|
((REISERFS_I(ip)->i_flags & i_stat_data_version_mask) ? \
|
|
|
|
STAT_DATA_V2 : STAT_DATA_V1)
|
|
|
|
|
|
|
|
#define set_inode_sd_version(inode, version) ({ \
|
|
|
|
if((version) == STAT_DATA_V2) \
|
|
|
|
REISERFS_I(ip)->i_flags |= i_stat_data_version_mask; \
|
|
|
|
else \
|
|
|
|
REISERFS_I(ip)->i_flags &= ~i_stat_data_version_mask; \
|
|
|
|
})
|
|
|
|
|
|
|
|
/* Values for s_umount_state field */
|
|
|
|
#define REISERFS_VALID_FS 1
|
|
|
|
#define REISERFS_ERROR_FS 2
|
|
|
|
|
|
|
|
/* There are 5 item types currently */
|
|
|
|
#define TYPE_STAT_DATA 0
|
|
|
|
#define TYPE_INDIRECT 1
|
|
|
|
#define TYPE_DIRECT 2
|
|
|
|
#define TYPE_DIRENTRY 3
|
|
|
|
#define TYPE_MAXTYPE 3
|
|
|
|
#define TYPE_ANY 15
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Key & item head
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
struct offset_v1 {
|
|
|
|
uint32_t k_offset;
|
|
|
|
uint32_t k_uniqueness;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
struct offset_v2 {
|
|
|
|
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
|
/* little endian version */
|
|
|
|
uint64_t k_offset:60;
|
|
|
|
uint64_t k_type:4;
|
|
|
|
#else
|
|
|
|
/* big endian version */
|
|
|
|
uint64_t k_type:4;
|
|
|
|
uint64_t k_offset:60;
|
|
|
|
#endif
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
#if (BYTE_ORDER == BIG_ENDIAN)
|
|
|
|
typedef union {
|
|
|
|
struct offset_v2 offset_v2;
|
|
|
|
uint64_t linear;
|
|
|
|
} __packed offset_v2_esafe_overlay;
|
|
|
|
|
|
|
|
static inline uint16_t
|
|
|
|
offset_v2_k_type(const struct offset_v2 *v2)
|
|
|
|
{
|
|
|
|
|
|
|
|
offset_v2_esafe_overlay tmp = *(const offset_v2_esafe_overlay *)v2;
|
|
|
|
tmp.linear = le64toh(tmp.linear);
|
|
|
|
return ((tmp.offset_v2.k_type <= TYPE_MAXTYPE) ?
|
|
|
|
tmp.offset_v2.k_type : TYPE_ANY);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
set_offset_v2_k_type(struct offset_v2 *v2, int type)
|
|
|
|
{
|
|
|
|
|
|
|
|
offset_v2_esafe_overlay *tmp = (offset_v2_esafe_overlay *)v2;
|
|
|
|
tmp->linear = le64toh(tmp->linear);
|
|
|
|
tmp->offset_v2.k_type = type;
|
|
|
|
tmp->linear = htole64(tmp->linear);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline off_t
|
|
|
|
offset_v2_k_offset(const struct offset_v2 *v2)
|
|
|
|
{
|
|
|
|
|
|
|
|
offset_v2_esafe_overlay tmp = *(const offset_v2_esafe_overlay *)v2;
|
|
|
|
tmp.linear = le64toh(tmp.linear);
|
|
|
|
return (tmp.offset_v2.k_offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
set_offset_v2_k_offset(struct offset_v2 *v2, off_t offset)
|
|
|
|
{
|
|
|
|
|
|
|
|
offset_v2_esafe_overlay *tmp = (offset_v2_esafe_overlay *)v2;
|
|
|
|
tmp->linear = le64toh(tmp->linear);
|
|
|
|
tmp->offset_v2.k_offset = offset;
|
|
|
|
tmp->linear = htole64(tmp->linear);
|
|
|
|
}
|
|
|
|
#else /* BYTE_ORDER != BIG_ENDIAN */
|
|
|
|
#define offset_v2_k_type(v2) ((v2)->k_type)
|
|
|
|
#define set_offset_v2_k_type(v2, val) (offset_v2_k_type(v2) = (val))
|
|
|
|
#define offset_v2_k_offset(v2) ((v2)->k_offset)
|
|
|
|
#define set_offset_v2_k_offset(v2, val) (offset_v2_k_offset(v2) = (val))
|
|
|
|
#endif /* BYTE_ORDER == BIG_ENDIAN */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Key of an item determines its location in the S+tree, and
|
|
|
|
* is composed of 4 components
|
|
|
|
*/
|
|
|
|
struct key {
|
|
|
|
uint32_t k_dir_id; /* Packing locality: by default parent
|
|
|
|
directory object id */
|
|
|
|
uint32_t k_objectid; /* Object identifier */
|
|
|
|
union {
|
|
|
|
struct offset_v1 k_offset_v1;
|
|
|
|
struct offset_v2 k_offset_v2;
|
|
|
|
} __packed u;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
struct cpu_key {
|
|
|
|
struct key on_disk_key;
|
|
|
|
int version;
|
|
|
|
int key_length; /* 3 in all cases but direct2indirect
|
|
|
|
and indirect2direct conversion */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Our function for comparing keys can compare keys of different
|
|
|
|
* lengths. It takes as a parameter the length of the keys it is to
|
|
|
|
* compare. These defines are used in determining what is to be passed
|
|
|
|
* to it as that parameter.
|
|
|
|
*/
|
|
|
|
#define REISERFS_FULL_KEY_LEN 4
|
|
|
|
#define REISERFS_SHORT_KEY_LEN 2
|
|
|
|
|
|
|
|
#define KEY_SIZE (sizeof(struct key))
|
|
|
|
#define SHORT_KEY_SIZE (sizeof(uint32_t) + sizeof(uint32_t))
|
|
|
|
|
|
|
|
/* Return values for search_by_key and clones */
|
|
|
|
#define ITEM_FOUND 1
|
|
|
|
#define ITEM_NOT_FOUND 0
|
|
|
|
#define ENTRY_FOUND 1
|
|
|
|
#define ENTRY_NOT_FOUND 0
|
|
|
|
#define DIRECTORY_NOT_FOUND -1
|
|
|
|
#define REGULAR_FILE_FOUND -2
|
|
|
|
#define DIRECTORY_FOUND -3
|
|
|
|
#define BYTE_FOUND 1
|
|
|
|
#define BYTE_NOT_FOUND 0
|
|
|
|
#define FILE_NOT_FOUND -1
|
|
|
|
|
|
|
|
#define POSITION_FOUND 1
|
|
|
|
#define POSITION_NOT_FOUND 0
|
|
|
|
|
|
|
|
/* Return values for reiserfs_find_entry and search_by_entry_key */
|
|
|
|
#define NAME_FOUND 1
|
|
|
|
#define NAME_NOT_FOUND 0
|
|
|
|
#define GOTO_PREVIOUS_ITEM 2
|
|
|
|
#define NAME_FOUND_INVISIBLE 3
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Everything in the filesystem is stored as a set of items. The item
|
|
|
|
* head contains the key of the item, its free space (for indirect
|
|
|
|
* items) and specifies the location of the item itself within the
|
|
|
|
* block.
|
|
|
|
*/
|
|
|
|
struct item_head {
|
|
|
|
/*
|
|
|
|
* Everything in the tree is found by searching for it based on
|
|
|
|
* its key.
|
|
|
|
*/
|
|
|
|
struct key ih_key;
|
|
|
|
union {
|
|
|
|
/*
|
|
|
|
* The free space in the last unformatted node of an
|
|
|
|
* indirect item if this is an indirect 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.
|
|
|
|
*/
|
|
|
|
uint16_t ih_free_space_reserved;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If this is a directory item, this field equals the number of
|
|
|
|
* directory entries in the directory item.
|
|
|
|
*/
|
|
|
|
uint16_t ih_entry_count;
|
|
|
|
} __packed u;
|
|
|
|
uint16_t ih_item_len; /* Total size of the item body */
|
|
|
|
uint16_t ih_item_location; /* An offset to the item body within
|
|
|
|
the block */
|
|
|
|
uint16_t ih_version; /* 0 for all old items, 2 for new
|
|
|
|
ones. Highest bit is set by fsck
|
|
|
|
temporary, cleaned after all
|
|
|
|
done */
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* Size of item header */
|
|
|
|
#define IH_SIZE (sizeof(struct item_head))
|
|
|
|
|
|
|
|
#define ih_free_space(ih) le16toh((ih)->u.ih_free_space_reserved)
|
|
|
|
#define ih_version(ih) le16toh((ih)->ih_version)
|
|
|
|
#define ih_entry_count(ih) le16toh((ih)->u.ih_entry_count)
|
|
|
|
#define ih_location(ih) le16toh((ih)->ih_item_location)
|
|
|
|
#define ih_item_len(ih) le16toh((ih)->ih_item_len)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These operate on indirect items, where you've got an array of ints at
|
|
|
|
* a possibly unaligned location. These are a noop on IA32.
|
|
|
|
*
|
|
|
|
* p is the array of uint32_t, i is the index into the array, v is the
|
|
|
|
* value to store there.
|
|
|
|
*/
|
|
|
|
#define get_unaligned(ptr) \
|
|
|
|
({ __typeof__(*(ptr)) __tmp; \
|
|
|
|
memcpy(&__tmp, (ptr), sizeof(*(ptr))); __tmp; })
|
|
|
|
|
|
|
|
#define put_unaligned(val, ptr) \
|
|
|
|
({ __typeof__(*(ptr)) __tmp = (val); \
|
|
|
|
memcpy((ptr), &__tmp, sizeof(*(ptr))); \
|
|
|
|
(void)0; })
|
|
|
|
|
|
|
|
#define get_block_num(p, i) le32toh(get_unaligned((p) + (i)))
|
|
|
|
#define put_block_num(p, i, v) put_unaligned(htole32(v), (p) + (i))
|
|
|
|
|
|
|
|
/* In old version uniqueness field shows key type */
|
|
|
|
#define V1_SD_UNIQUENESS 0
|
|
|
|
#define V1_INDIRECT_UNIQUENESS 0xfffffffe
|
|
|
|
#define V1_DIRECT_UNIQUENESS 0xffffffff
|
|
|
|
#define V1_DIRENTRY_UNIQUENESS 500
|
|
|
|
#define V1_ANY_UNIQUENESS 555
|
|
|
|
|
|
|
|
/* Here are conversion routines */
|
|
|
|
static inline int uniqueness2type(uint32_t uniqueness);
|
|
|
|
static inline uint32_t type2uniqueness(int type);
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
uniqueness2type(uint32_t uniqueness)
|
|
|
|
{
|
|
|
|
|
|
|
|
switch ((int)uniqueness) {
|
|
|
|
case V1_SD_UNIQUENESS:
|
|
|
|
return (TYPE_STAT_DATA);
|
|
|
|
case V1_INDIRECT_UNIQUENESS:
|
|
|
|
return (TYPE_INDIRECT);
|
|
|
|
case V1_DIRECT_UNIQUENESS:
|
|
|
|
return (TYPE_DIRECT);
|
|
|
|
case V1_DIRENTRY_UNIQUENESS:
|
|
|
|
return (TYPE_DIRENTRY);
|
|
|
|
default:
|
|
|
|
log(LOG_NOTICE, "reiserfs: unknown uniqueness (%u)\n",
|
|
|
|
uniqueness);
|
|
|
|
case V1_ANY_UNIQUENESS:
|
|
|
|
return (TYPE_ANY);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline uint32_t
|
|
|
|
type2uniqueness(int type)
|
|
|
|
{
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case TYPE_STAT_DATA:
|
|
|
|
return (V1_SD_UNIQUENESS);
|
|
|
|
case TYPE_INDIRECT:
|
|
|
|
return (V1_INDIRECT_UNIQUENESS);
|
|
|
|
case TYPE_DIRECT:
|
|
|
|
return (V1_DIRECT_UNIQUENESS);
|
|
|
|
case TYPE_DIRENTRY:
|
|
|
|
return (V1_DIRENTRY_UNIQUENESS);
|
|
|
|
default:
|
|
|
|
log(LOG_NOTICE, "reiserfs: unknown type (%u)\n", type);
|
|
|
|
case TYPE_ANY:
|
|
|
|
return (V1_ANY_UNIQUENESS);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Key is pointer to on disk key which is stored in le, result is cpu,
|
|
|
|
* there is no way to get version of object from key, so, provide
|
|
|
|
* version to these defines.
|
|
|
|
*/
|
|
|
|
static inline off_t
|
|
|
|
le_key_k_offset(int version, const struct key *key)
|
|
|
|
{
|
|
|
|
|
|
|
|
return ((version == KEY_FORMAT_3_5) ?
|
|
|
|
le32toh(key->u.k_offset_v1.k_offset) :
|
|
|
|
offset_v2_k_offset(&(key->u.k_offset_v2)));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline off_t
|
|
|
|
le_ih_k_offset(const struct item_head *ih)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (le_key_k_offset(ih_version(ih), &(ih->ih_key)));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline off_t
|
|
|
|
le_key_k_type(int version, const struct key *key)
|
|
|
|
{
|
|
|
|
|
|
|
|
return ((version == KEY_FORMAT_3_5) ?
|
|
|
|
uniqueness2type(le32toh(key->u.k_offset_v1.k_uniqueness)) :
|
|
|
|
offset_v2_k_type(&(key->u.k_offset_v2)));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline off_t
|
|
|
|
le_ih_k_type(const struct item_head *ih)
|
|
|
|
{
|
|
|
|
return (le_key_k_type(ih_version(ih), &(ih->ih_key)));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
set_le_key_k_offset(int version, struct key *key, off_t offset)
|
|
|
|
{
|
|
|
|
|
|
|
|
(version == KEY_FORMAT_3_5) ?
|
|
|
|
(key->u.k_offset_v1.k_offset = htole32(offset)) :
|
|
|
|
(set_offset_v2_k_offset(&(key->u.k_offset_v2), offset));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
set_le_ih_k_offset(struct item_head *ih, off_t offset)
|
|
|
|
{
|
|
|
|
|
|
|
|
set_le_key_k_offset(ih_version(ih), &(ih->ih_key), offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
set_le_key_k_type(int version, struct key *key, int type)
|
|
|
|
{
|
|
|
|
|
|
|
|
(version == KEY_FORMAT_3_5) ?
|
|
|
|
(key->u.k_offset_v1.k_uniqueness =
|
|
|
|
htole32(type2uniqueness(type))) :
|
|
|
|
(set_offset_v2_k_type(&(key->u.k_offset_v2), type));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
set_le_ih_k_type(struct item_head *ih, int type)
|
|
|
|
{
|
|
|
|
|
|
|
|
set_le_key_k_type(ih_version(ih), &(ih->ih_key), type);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define is_direntry_le_key(version, key) \
|
|
|
|
(le_key_k_type(version, key) == TYPE_DIRENTRY)
|
|
|
|
#define is_direct_le_key(version, key) \
|
|
|
|
(le_key_k_type(version, key) == TYPE_DIRECT)
|
|
|
|
#define is_indirect_le_key(version, key) \
|
|
|
|
(le_key_k_type(version, key) == TYPE_INDIRECT)
|
|
|
|
#define is_statdata_le_key(version, key) \
|
|
|
|
(le_key_k_type(version, key) == TYPE_STAT_DATA)
|
|
|
|
|
|
|
|
/* Item header has version. */
|
|
|
|
#define is_direntry_le_ih(ih) \
|
|
|
|
is_direntry_le_key(ih_version(ih), &((ih)->ih_key))
|
|
|
|
#define is_direct_le_ih(ih) \
|
|
|
|
is_direct_le_key(ih_version(ih), &((ih)->ih_key))
|
|
|
|
#define is_indirect_le_ih(ih) \
|
|
|
|
is_indirect_le_key(ih_version(ih), &((ih)->ih_key))
|
|
|
|
#define is_statdata_le_ih(ih) \
|
|
|
|
is_statdata_le_key(ih_version(ih), &((ih)->ih_key))
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
set_cpu_key_k_offset(struct cpu_key *key, off_t offset)
|
|
|
|
{
|
|
|
|
|
|
|
|
(key->version == KEY_FORMAT_3_5) ?
|
|
|
|
(key->on_disk_key.u.k_offset_v1.k_offset = offset) :
|
|
|
|
(key->on_disk_key.u.k_offset_v2.k_offset = offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
set_cpu_key_k_type(struct cpu_key *key, int type)
|
|
|
|
{
|
|
|
|
|
|
|
|
(key->version == KEY_FORMAT_3_5) ?
|
|
|
|
(key->on_disk_key.u.k_offset_v1.k_uniqueness =
|
|
|
|
type2uniqueness(type)):
|
|
|
|
(key->on_disk_key.u.k_offset_v2.k_type = type);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define is_direntry_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRENTRY)
|
|
|
|
#define is_direct_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRECT)
|
|
|
|
#define is_indirect_cpu_key(key) (cpu_key_k_type (key) == TYPE_INDIRECT)
|
|
|
|
#define is_statdata_cpu_key(key) (cpu_key_k_type (key) == TYPE_STAT_DATA)
|
|
|
|
|
|
|
|
/* Maximal length of item */
|
|
|
|
#define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE)
|
|
|
|
#define MIN_ITEM_LEN 1
|
|
|
|
|
|
|
|
/* Object identifier for root dir */
|
|
|
|
#define REISERFS_ROOT_OBJECTID 2
|
|
|
|
#define REISERFS_ROOT_PARENT_OBJECTID 1
|
|
|
|
|
|
|
|
/* key is pointer to cpu key, result is cpu */
|
|
|
|
static inline off_t
|
|
|
|
cpu_key_k_offset(const struct cpu_key *key)
|
|
|
|
{
|
|
|
|
|
|
|
|
return ((key->version == KEY_FORMAT_3_5) ?
|
|
|
|
key->on_disk_key.u.k_offset_v1.k_offset :
|
|
|
|
key->on_disk_key.u.k_offset_v2.k_offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline off_t
|
|
|
|
cpu_key_k_type(const struct cpu_key *key)
|
|
|
|
{
|
|
|
|
|
|
|
|
return ((key->version == KEY_FORMAT_3_5) ?
|
|
|
|
uniqueness2type(key->on_disk_key.u.k_offset_v1.k_uniqueness) :
|
|
|
|
key->on_disk_key.u.k_offset_v2.k_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Header of a disk block. More precisely, header of a formatted leaf
|
|
|
|
* or internal node, and not the header of an unformatted node.
|
|
|
|
*/
|
|
|
|
struct block_head {
|
|
|
|
uint16_t blk_level; /* Level of a block in the
|
|
|
|
tree. */
|
|
|
|
uint16_t blk_nr_item; /* Number of keys/items in a
|
|
|
|
block. */
|
|
|
|
uint16_t blk_free_space; /* Block free space in bytes. */
|
|
|
|
uint16_t blk_reserved; /* Dump this in v4/planA */
|
|
|
|
struct key blk_right_delim_key; /* Kept only for compatibility */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define BLKH_SIZE (sizeof(struct block_head))
|
|
|
|
#define blkh_level(p_blkh) (le16toh((p_blkh)->blk_level))
|
|
|
|
#define blkh_nr_item(p_blkh) (le16toh((p_blkh)->blk_nr_item))
|
|
|
|
#define blkh_free_space(p_blkh) (le16toh((p_blkh)->blk_free_space))
|
|
|
|
|
|
|
|
#define FREE_LEVEL 0 /* When node gets removed from the tree its
|
|
|
|
blk_level is set to FREE_LEVEL. It is then
|
|
|
|
used to see whether the node is still in the
|
|
|
|
tree */
|
|
|
|
|
|
|
|
/* Values for blk_level field of the struct block_head */
|
|
|
|
#define DISK_LEAF_NODE_LEVEL 1 /* Leaf node level.*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Given the buffer head of a formatted node, resolve to the block head
|
|
|
|
* of that node.
|
|
|
|
*/
|
|
|
|
#define B_BLK_HEAD(p_s_bp) ((struct block_head *)((p_s_bp)->b_data))
|
|
|
|
#define B_NR_ITEMS(p_s_bp) (blkh_nr_item(B_BLK_HEAD(p_s_bp)))
|
|
|
|
#define B_LEVEL(p_s_bp) (blkh_level(B_BLK_HEAD(p_s_bp)))
|
|
|
|
#define B_FREE_SPACE(p_s_bp) (blkh_free_space(B_BLK_HEAD(p_s_bp)))
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Stat data
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Old stat data is 32 bytes long. We are going to distinguish new one
|
|
|
|
* by different size.
|
|
|
|
*/
|
|
|
|
struct stat_data_v1 {
|
|
|
|
uint16_t sd_mode; /* File type, permissions */
|
|
|
|
uint16_t sd_nlink; /* Number of hard links */
|
|
|
|
uint16_t sd_uid; /* Owner */
|
|
|
|
uint16_t sd_gid; /* Group */
|
|
|
|
uint32_t sd_size; /* File size */
|
|
|
|
uint32_t sd_atime; /* Time of last access */
|
|
|
|
uint32_t sd_mtime; /* Time file was last modified */
|
|
|
|
uint32_t sd_ctime; /* Time inode (stat data) was last changed
|
|
|
|
(except changes to sd_atime and
|
|
|
|
sd_mtime) */
|
|
|
|
union {
|
|
|
|
uint32_t sd_rdev;
|
|
|
|
uint32_t sd_blocks; /* Number of blocks file uses */
|
|
|
|
} __packed u;
|
|
|
|
uint32_t sd_first_direct_byte; /* First byte of file which is
|
|
|
|
stored in a direct item:
|
|
|
|
except that if it equals 1
|
|
|
|
it is a symlink and if it
|
|
|
|
equals ~(uint32_t)0 there
|
|
|
|
is no direct item. The
|
|
|
|
existence of this field
|
|
|
|
really grates on me. Let's
|
|
|
|
replace it with a macro based
|
|
|
|
on sd_size and our tail
|
|
|
|
suppression policy. Someday.
|
|
|
|
-Hans */
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
#define SD_V1_SIZE (sizeof(struct stat_data_v1))
|
|
|
|
#define stat_data_v1(ih) (ih_version (ih) == KEY_FORMAT_3_5)
|
|
|
|
#define sd_v1_mode(sdp) (le16toh((sdp)->sd_mode))
|
|
|
|
#define set_sd_v1_mode(sdp, v) ((sdp)->sd_mode = htole16(v))
|
|
|
|
#define sd_v1_nlink(sdp) (le16toh((sdp)->sd_nlink))
|
|
|
|
#define set_sd_v1_nlink(sdp, v) ((sdp)->sd_nlink = htole16(v))
|
|
|
|
#define sd_v1_uid(sdp) (le16toh((sdp)->sd_uid))
|
|
|
|
#define set_sd_v1_uid(sdp, v) ((sdp)->sd_uid = htole16(v))
|
|
|
|
#define sd_v1_gid(sdp) (le16toh((sdp)->sd_gid))
|
|
|
|
#define set_sd_v1_gid(sdp, v) ((sdp)->sd_gid = htole16(v))
|
|
|
|
#define sd_v1_size(sdp) (le32toh((sdp)->sd_size))
|
|
|
|
#define set_sd_v1_size(sdp, v) ((sdp)->sd_size = htole32(v))
|
|
|
|
#define sd_v1_atime(sdp) (le32toh((sdp)->sd_atime))
|
|
|
|
#define set_sd_v1_atime(sdp, v) ((sdp)->sd_atime = htole32(v))
|
|
|
|
#define sd_v1_mtime(sdp) (le32toh((sdp)->sd_mtime))
|
|
|
|
#define set_sd_v1_mtime(sdp, v) ((sdp)->sd_mtime = htole32(v))
|
|
|
|
#define sd_v1_ctime(sdp) (le32toh((sdp)->sd_ctime))
|
|
|
|
#define set_sd_v1_ctime(sdp, v) ((sdp)->sd_ctime = htole32(v))
|
|
|
|
#define sd_v1_rdev(sdp) (le32toh((sdp)->u.sd_rdev))
|
|
|
|
#define set_sd_v1_rdev(sdp, v) ((sdp)->u.sd_rdev = htole32(v))
|
|
|
|
#define sd_v1_blocks(sdp) (le32toh((sdp)->u.sd_blocks))
|
|
|
|
#define set_sd_v1_blocks(sdp, v) ((sdp)->u.sd_blocks = htole32(v))
|
|
|
|
#define sd_v1_first_direct_byte(sdp) \
|
|
|
|
(le32toh((sdp)->sd_first_direct_byte))
|
|
|
|
#define set_sd_v1_first_direct_byte(sdp, v) \
|
|
|
|
((sdp)->sd_first_direct_byte = htole32(v))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We want common flags to have the same values as in ext2,
|
|
|
|
* so chattr(1) will work without problems
|
|
|
|
*/
|
2010-01-14 14:30:54 +00:00
|
|
|
#include <fs/ext2fs/ext2fs.h>
|
|
|
|
#include <fs/ext2fs/ext2_dinode.h>
|
|
|
|
#define REISERFS_IMMUTABLE_FL EXT2_IMMUTABLE
|
|
|
|
#define REISERFS_APPEND_FL EXT2_APPEND
|
|
|
|
#define REISERFS_SYNC_FL EXT2_SYNC
|
|
|
|
#define REISERFS_NOATIME_FL EXT2_NOATIME
|
|
|
|
#define REISERFS_NODUMP_FL EXT2_NODUMP
|
|
|
|
#define REISERFS_SECRM_FL EXT2_SECRM
|
|
|
|
#define REISERFS_UNRM_FL EXT2_UNRM
|
|
|
|
#define REISERFS_COMPR_FL EXT2_COMPR
|
2005-06-18 17:10:50 +00:00
|
|
|
#define REISERFS_NOTAIL_FL EXT2_NOTAIL_FL
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Stat Data on disk (reiserfs version of UFS disk inode minus the
|
|
|
|
* address blocks)
|
|
|
|
*/
|
|
|
|
struct stat_data {
|
|
|
|
uint16_t sd_mode; /* File type, permissions */
|
|
|
|
uint16_t sd_attrs; /* Persistent inode flags */
|
|
|
|
uint32_t sd_nlink; /* Number of hard links */
|
|
|
|
uint64_t sd_size; /* File size */
|
|
|
|
uint32_t sd_uid; /* Owner */
|
|
|
|
uint32_t sd_gid; /* Group */
|
|
|
|
uint32_t sd_atime; /* Time of last access */
|
|
|
|
uint32_t sd_mtime; /* Time file was last modified */
|
|
|
|
uint32_t sd_ctime; /* Time inode (stat data) was last changed
|
|
|
|
(except changes to sd_atime and
|
|
|
|
sd_mtime) */
|
|
|
|
uint32_t sd_blocks;
|
|
|
|
union {
|
|
|
|
uint32_t sd_rdev;
|
|
|
|
uint32_t sd_generation;
|
|
|
|
//uint32_t sd_first_direct_byte;
|
|
|
|
/*
|
|
|
|
* First byte of file which is stored in a
|
|
|
|
* direct item: except that if it equals 1
|
|
|
|
* it is a symlink and if it equals
|
|
|
|
* ~(uint32_t)0 there is no direct item. The
|
|
|
|
* existence of this field really grates
|
|
|
|
* on me. Let's replace it with a macro
|
|
|
|
* based on sd_size and our tail
|
|
|
|
* suppression policy?
|
|
|
|
*/
|
|
|
|
} __packed u;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* This is 44 bytes long */
|
|
|
|
#define SD_SIZE (sizeof(struct stat_data))
|
|
|
|
#define SD_V2_SIZE SD_SIZE
|
|
|
|
#define stat_data_v2(ih) (ih_version (ih) == KEY_FORMAT_3_6)
|
|
|
|
#define sd_v2_mode(sdp) (le16toh((sdp)->sd_mode))
|
|
|
|
#define set_sd_v2_mode(sdp, v) ((sdp)->sd_mode = htole16(v))
|
|
|
|
/* sd_reserved */
|
|
|
|
/* set_sd_reserved */
|
|
|
|
#define sd_v2_nlink(sdp) (le32toh((sdp)->sd_nlink))
|
|
|
|
#define set_sd_v2_nlink(sdp, v) ((sdp)->sd_nlink = htole32(v))
|
|
|
|
#define sd_v2_size(sdp) (le64toh((sdp)->sd_size))
|
|
|
|
#define set_sd_v2_size(sdp, v) ((sdp)->sd_size = cpu_to_le64(v))
|
|
|
|
#define sd_v2_uid(sdp) (le32toh((sdp)->sd_uid))
|
|
|
|
#define set_sd_v2_uid(sdp, v) ((sdp)->sd_uid = htole32(v))
|
|
|
|
#define sd_v2_gid(sdp) (le32toh((sdp)->sd_gid))
|
|
|
|
#define set_sd_v2_gid(sdp, v) ((sdp)->sd_gid = htole32(v))
|
|
|
|
#define sd_v2_atime(sdp) (le32toh((sdp)->sd_atime))
|
|
|
|
#define set_sd_v2_atime(sdp, v) ((sdp)->sd_atime = htole32(v))
|
|
|
|
#define sd_v2_mtime(sdp) (le32toh((sdp)->sd_mtime))
|
|
|
|
#define set_sd_v2_mtime(sdp, v) ((sdp)->sd_mtime = htole32(v))
|
|
|
|
#define sd_v2_ctime(sdp) (le32toh((sdp)->sd_ctime))
|
|
|
|
#define set_sd_v2_ctime(sdp, v) ((sdp)->sd_ctime = htole32(v))
|
|
|
|
#define sd_v2_blocks(sdp) (le32toh((sdp)->sd_blocks))
|
|
|
|
#define set_sd_v2_blocks(sdp, v) ((sdp)->sd_blocks = htole32(v))
|
|
|
|
#define sd_v2_rdev(sdp) (le32toh((sdp)->u.sd_rdev))
|
|
|
|
#define set_sd_v2_rdev(sdp, v) ((sdp)->u.sd_rdev = htole32(v))
|
|
|
|
#define sd_v2_generation(sdp) (le32toh((sdp)->u.sd_generation))
|
|
|
|
#define set_sd_v2_generation(sdp, v) ((sdp)->u.sd_generation = htole32(v))
|
|
|
|
#define sd_v2_attrs(sdp) (le16toh((sdp)->sd_attrs))
|
|
|
|
#define set_sd_v2_attrs(sdp, v) ((sdp)->sd_attrs = htole16(v))
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Directory structure
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
#define SD_OFFSET 0
|
|
|
|
#define SD_UNIQUENESS 0
|
|
|
|
#define DOT_OFFSET 1
|
|
|
|
#define DOT_DOT_OFFSET 2
|
|
|
|
#define DIRENTRY_UNIQUENESS 500
|
|
|
|
|
|
|
|
#define FIRST_ITEM_OFFSET 1
|
|
|
|
|
|
|
|
struct reiserfs_de_head {
|
|
|
|
uint32_t deh_offset; /* Third component of the directory
|
|
|
|
entry key */
|
|
|
|
uint32_t deh_dir_id; /* Objectid of the parent directory of
|
|
|
|
the object, that is referenced by
|
|
|
|
directory entry */
|
|
|
|
uint32_t deh_objectid; /* Objectid of the object, that is
|
|
|
|
referenced by directory entry */
|
|
|
|
uint16_t deh_location; /* Offset of name in the whole item */
|
|
|
|
uint16_t deh_state; /* Whether 1) entry contains stat data
|
|
|
|
(for future), and 2) whether entry
|
|
|
|
is hidden (unlinked) */
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
#define DEH_SIZE sizeof(struct reiserfs_de_head)
|
|
|
|
#define deh_offset(p_deh) (le32toh((p_deh)->deh_offset))
|
|
|
|
#define deh_dir_id(p_deh) (le32toh((p_deh)->deh_dir_id))
|
|
|
|
#define deh_objectid(p_deh) (le32toh((p_deh)->deh_objectid))
|
|
|
|
#define deh_location(p_deh) (le16toh((p_deh)->deh_location))
|
|
|
|
#define deh_state(p_deh) (le16toh((p_deh)->deh_state))
|
|
|
|
|
|
|
|
#define put_deh_offset(p_deh, v) ((p_deh)->deh_offset = htole32((v)))
|
|
|
|
#define put_deh_dir_id(p_deh, v) ((p_deh)->deh_dir_id = htole32((v)))
|
|
|
|
#define put_deh_objectid(p_deh, v) ((p_deh)->deh_objectid = htole32((v)))
|
|
|
|
#define put_deh_location(p_deh, v) ((p_deh)->deh_location = htole16((v)))
|
|
|
|
#define put_deh_state(p_deh, v) ((p_deh)->deh_state = htole16((v)))
|
|
|
|
|
|
|
|
/* Empty directory contains two entries "." and ".." and their headers */
|
|
|
|
#define EMPTY_DIR_SIZE \
|
|
|
|
(DEH_SIZE * 2 + ROUND_UP(strlen(".")) + ROUND_UP(strlen("..")))
|
|
|
|
|
|
|
|
/* Old format directories have this size when empty */
|
|
|
|
#define EMPTY_DIR_SIZE_V1 (DEH_SIZE * 2 + 3)
|
|
|
|
|
|
|
|
#define DEH_Statdata 0 /* Not used now */
|
|
|
|
#define DEH_Visible 2
|
|
|
|
|
2005-06-21 10:11:13 +00:00
|
|
|
/* Macro to map Linux' *_bit function to bitstring.h macros */
|
|
|
|
#define set_bit(bit, name) bit_set((bitstr_t *)name, bit)
|
|
|
|
#define clear_bit(bit, name) bit_clear((bitstr_t *)name, bit)
|
|
|
|
#define test_bit(bit, name) bit_test((bitstr_t *)name, bit)
|
2005-06-18 17:10:50 +00:00
|
|
|
|
2005-06-21 10:11:13 +00:00
|
|
|
#define set_bit_unaligned(bit, name) set_bit(bit, name)
|
|
|
|
#define clear_bit_unaligned(bit, name) clear_bit(bit, name)
|
|
|
|
#define test_bit_unaligned(bit, name) test_bit(bit, name)
|
2005-06-18 17:10:50 +00:00
|
|
|
|
|
|
|
#define mark_de_with_sd(deh) \
|
|
|
|
set_bit_unaligned(DEH_Statdata, &((deh)->deh_state))
|
|
|
|
#define mark_de_without_sd(deh) \
|
|
|
|
clear_bit_unaligned(DEH_Statdata, &((deh)->deh_state))
|
|
|
|
#define mark_de_visible(deh) \
|
|
|
|
set_bit_unaligned (DEH_Visible, &((deh)->deh_state))
|
|
|
|
#define mark_de_hidden(deh) \
|
|
|
|
clear_bit_unaligned (DEH_Visible, &((deh)->deh_state))
|
|
|
|
|
|
|
|
#define de_with_sd(deh) \
|
|
|
|
test_bit_unaligned(DEH_Statdata, &((deh)->deh_state))
|
|
|
|
#define de_visible(deh) \
|
|
|
|
test_bit_unaligned(DEH_Visible, &((deh)->deh_state))
|
|
|
|
#define de_hidden(deh) \
|
|
|
|
!test_bit_unaligned(DEH_Visible, &((deh)->deh_state))
|
|
|
|
|
|
|
|
/* Two entries per block (at least) */
|
|
|
|
#define REISERFS_MAX_NAME(block_size) 255
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This structure is used for operations on directory entries. It is not
|
|
|
|
* a disk structure. When reiserfs_find_entry or search_by_entry_key
|
|
|
|
* find directory entry, they return filled reiserfs_dir_entry structure
|
|
|
|
*/
|
|
|
|
struct reiserfs_dir_entry {
|
|
|
|
struct buf *de_bp;
|
|
|
|
int de_item_num;
|
|
|
|
struct item_head *de_ih;
|
|
|
|
int de_entry_num;
|
|
|
|
struct reiserfs_de_head *de_deh;
|
|
|
|
int de_entrylen;
|
|
|
|
int de_namelen;
|
|
|
|
char *de_name;
|
|
|
|
char *de_gen_number_bit_string;
|
|
|
|
|
|
|
|
uint32_t de_dir_id;
|
|
|
|
uint32_t de_objectid;
|
|
|
|
|
|
|
|
struct cpu_key de_entry_key;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Pointer to file name, stored in entry */
|
|
|
|
#define B_I_DEH_ENTRY_FILE_NAME(bp, ih, deh) \
|
|
|
|
(B_I_PITEM(bp, ih) + deh_location(deh))
|
|
|
|
|
|
|
|
/* Length of name */
|
|
|
|
#define I_DEH_N_ENTRY_FILE_NAME_LENGTH(ih, deh, entry_num) \
|
|
|
|
(I_DEH_N_ENTRY_LENGTH(ih, deh, entry_num) - \
|
|
|
|
(de_with_sd(deh) ? SD_SIZE : 0))
|
|
|
|
|
|
|
|
/* Hash value occupies bits from 7 up to 30 */
|
|
|
|
#define GET_HASH_VALUE(offset) ((offset) & 0x7fffff80LL)
|
|
|
|
|
|
|
|
/* Generation number occupies 7 bits starting from 0 up to 6 */
|
|
|
|
#define GET_GENERATION_NUMBER(offset) ((offset) & 0x7fLL)
|
|
|
|
#define MAX_GENERATION_NUMBER 127
|
|
|
|
|
|
|
|
/* Get item body */
|
|
|
|
#define B_I_PITEM(bp, ih) ((bp)->b_data + ih_location(ih))
|
|
|
|
#define B_I_DEH(bp, ih) ((struct reiserfs_de_head *)(B_I_PITEM(bp, ih)))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Length of the directory entry in directory item. This define
|
|
|
|
* calculates length of i-th directory entry using directory entry
|
|
|
|
* locations from dir entry head. When it calculates length of 0-th
|
|
|
|
* directory entry, it uses length of whole item in place of entry
|
|
|
|
* location of the non-existent following entry in the calculation. See
|
|
|
|
* picture above.
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
entry_length (const struct buf *bp, const struct item_head *ih,
|
|
|
|
int pos_in_item)
|
|
|
|
{
|
|
|
|
struct reiserfs_de_head *deh;
|
|
|
|
|
|
|
|
deh = B_I_DEH(bp, ih) + pos_in_item;
|
|
|
|
if (pos_in_item)
|
|
|
|
return (deh_location(deh - 1) - deh_location(deh));
|
|
|
|
|
|
|
|
return (ih_item_len(ih) - deh_location(deh));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Number of entries in the directory item, depends on ENTRY_COUNT
|
|
|
|
* being at the start of directory dynamic data.
|
|
|
|
*/
|
|
|
|
#define I_ENTRY_COUNT(ih) (ih_entry_count((ih)))
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Disk child
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disk child pointer: The pointer from an internal node of the tree
|
|
|
|
* to a node that is on disk.
|
|
|
|
*/
|
|
|
|
struct disk_child {
|
|
|
|
uint32_t dc_block_number; /* Disk child's block number. */
|
|
|
|
uint16_t dc_size; /* Disk child's used space. */
|
|
|
|
uint16_t dc_reserved;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define DC_SIZE (sizeof(struct disk_child))
|
|
|
|
#define dc_block_number(dc_p) (le32toh((dc_p)->dc_block_number))
|
|
|
|
#define dc_size(dc_p) (le16toh((dc_p)->dc_size))
|
|
|
|
#define put_dc_block_number(dc_p, val) \
|
|
|
|
do { (dc_p)->dc_block_number = htole32(val); } while (0)
|
|
|
|
#define put_dc_size(dc_p, val) \
|
|
|
|
do { (dc_p)->dc_size = htole16(val); } while (0)
|
|
|
|
|
|
|
|
/* Get disk child by buffer header and position in the tree node. */
|
|
|
|
#define B_N_CHILD(p_s_bp, n_pos) \
|
|
|
|
((struct disk_child *)((p_s_bp)->b_data + BLKH_SIZE + \
|
|
|
|
B_NR_ITEMS(p_s_bp) * KEY_SIZE + \
|
|
|
|
DC_SIZE * (n_pos)))
|
|
|
|
|
|
|
|
/* Get disk child number by buffer header and position in the tree node. */
|
|
|
|
#define B_N_CHILD_NUM(p_s_bp, n_pos) \
|
|
|
|
(dc_block_number(B_N_CHILD(p_s_bp, n_pos)))
|
|
|
|
#define PUT_B_N_CHILD_NUM(p_s_bp, n_pos, val) \
|
|
|
|
(put_dc_block_number(B_N_CHILD(p_s_bp, n_pos), val))
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Path structures and defines
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
struct path_element {
|
|
|
|
struct buf *pe_buffer; /* Pointer to the buffer at the path in
|
|
|
|
the tree. */
|
|
|
|
int pe_position; /* Position in the tree node which is
|
|
|
|
placed in the buffer above. */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define MAX_HEIGHT 5 /* Maximal height of a tree. Don't
|
|
|
|
change this without changing
|
|
|
|
JOURNAL_PER_BALANCE_CNT */
|
|
|
|
#define EXTENDED_MAX_HEIGHT 7 /* Must be equals MAX_HEIGHT +
|
|
|
|
FIRST_PATH_ELEMENT_OFFSET */
|
|
|
|
#define FIRST_PATH_ELEMENT_OFFSET 2 /* Must be equal to at least 2. */
|
|
|
|
#define ILLEGAL_PATH_ELEMENT_OFFSET 1 /* Must be equal to
|
|
|
|
FIRST_PATH_ELEMENT_OFFSET - 1 */
|
|
|
|
#define MAX_FEB_SIZE 6 /* This MUST be MAX_HEIGHT + 1.
|
|
|
|
See about FEB below */
|
|
|
|
|
|
|
|
struct path {
|
|
|
|
/* Length of the array below. */
|
|
|
|
int path_length;
|
|
|
|
/* Array of the path element */
|
|
|
|
struct path_element path_elements[EXTENDED_MAX_HEIGHT];
|
|
|
|
int pos_in_item;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define pos_in_item(path) ((path)->pos_in_item)
|
|
|
|
|
2005-12-04 09:57:09 +00:00
|
|
|
#ifdef __amd64__
|
|
|
|
/* To workaround a bug in gcc. He generates a call to memset() which
|
|
|
|
* is a inline function; this causes a compile time error. */
|
|
|
|
#define INITIALIZE_PATH(var) \
|
|
|
|
struct path var; \
|
|
|
|
bzero(&var, sizeof(var)); \
|
|
|
|
var.path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
|
|
|
|
#else
|
2005-06-18 17:10:50 +00:00
|
|
|
#define INITIALIZE_PATH(var) \
|
|
|
|
struct path var = { ILLEGAL_PATH_ELEMENT_OFFSET, }
|
2005-12-04 09:57:09 +00:00
|
|
|
#endif
|
2005-06-18 17:10:50 +00:00
|
|
|
|
|
|
|
/* Get path element by path and path position. */
|
|
|
|
#define PATH_OFFSET_PELEMENT(p_s_path, n_offset) \
|
|
|
|
((p_s_path)->path_elements + (n_offset))
|
|
|
|
|
|
|
|
/* Get buffer header at the path by path and path position. */
|
|
|
|
#define PATH_OFFSET_PBUFFER(p_s_path, n_offset) \
|
|
|
|
(PATH_OFFSET_PELEMENT(p_s_path, n_offset)->pe_buffer)
|
|
|
|
|
|
|
|
/* Get position in the element at the path by path and path position. */
|
|
|
|
#define PATH_OFFSET_POSITION(p_s_path, n_offset) \
|
|
|
|
(PATH_OFFSET_PELEMENT(p_s_path, n_offset)->pe_position)
|
|
|
|
|
|
|
|
#define PATH_PLAST_BUFFER(p_s_path) \
|
|
|
|
(PATH_OFFSET_PBUFFER((p_s_path), (p_s_path)->path_length))
|
|
|
|
|
|
|
|
#define PATH_LAST_POSITION(p_s_path) \
|
|
|
|
(PATH_OFFSET_POSITION((p_s_path), (p_s_path)->path_length))
|
|
|
|
|
|
|
|
#define PATH_PITEM_HEAD(p_s_path) \
|
|
|
|
B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_path), PATH_LAST_POSITION(p_s_path))
|
|
|
|
|
|
|
|
#define get_last_bp(path) PATH_PLAST_BUFFER(path)
|
|
|
|
#define get_ih(path) PATH_PITEM_HEAD(path)
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Misc.
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* Size of pointer to the unformatted node. */
|
|
|
|
#define UNFM_P_SIZE (sizeof(unp_t))
|
|
|
|
#define UNFM_P_SHIFT 2
|
|
|
|
|
|
|
|
/* In in-core inode key is stored on le form */
|
|
|
|
#define INODE_PKEY(ip) ((struct key *)(REISERFS_I(ip)->i_key))
|
|
|
|
|
|
|
|
#define MAX_UL_INT 0xffffffff
|
|
|
|
#define MAX_INT 0x7ffffff
|
|
|
|
#define MAX_US_INT 0xffff
|
|
|
|
|
|
|
|
/* The purpose is to detect overflow of an unsigned short */
|
|
|
|
#define REISERFS_LINK_MAX (MAX_US_INT - 1000)
|
|
|
|
|
|
|
|
#define fs_generation(sbi) (REISERFS_SB(sbi)->s_generation_counter)
|
|
|
|
#define get_generation(sbi) (fs_generation(sbi))
|
|
|
|
|
|
|
|
#define __fs_changed(gen, sbi) (gen != get_generation (sbi))
|
|
|
|
/*#define fs_changed(gen, sbi) ({ cond_resched(); \
|
|
|
|
__fs_changed(gen, sbi); })*/
|
|
|
|
#define fs_changed(gen, sbi) (__fs_changed(gen, sbi))
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Fixate node
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To make any changes in the tree we always first find node, that
|
|
|
|
* contains item to be changed/deleted or place to insert a new item.
|
|
|
|
* We call this node S. To do balancing we need to decide what we will
|
|
|
|
* shift to left/right neighbor, or to a new node, where new item will
|
|
|
|
* be etc. To make this analysis simpler we build virtual node. Virtual
|
|
|
|
* node is an array of items, that will replace items of node S. (For
|
|
|
|
* instance if we are going to delete an item, virtual node does not
|
|
|
|
* contain it). Virtual node keeps information about item sizes and
|
|
|
|
* types, mergeability of first and last items, sizes of all entries in
|
|
|
|
* directory item. We use this array of items when calculating what we
|
|
|
|
* can shift to neighbors and how many nodes we have to have if we do
|
|
|
|
* not any shiftings, if we shift to left/right neighbor or to both.
|
|
|
|
*/
|
|
|
|
struct virtual_item {
|
|
|
|
int vi_index; /* Index in the array of item
|
|
|
|
operations */
|
|
|
|
unsigned short vi_type; /* Left/right mergeability */
|
|
|
|
unsigned short vi_item_len; /* Length of item that it will
|
|
|
|
have after balancing */
|
|
|
|
struct item_head *vi_ih;
|
|
|
|
const char *vi_item; /* Body of item (old or new) */
|
|
|
|
const void *vi_new_data; /* 0 always but paste mode */
|
|
|
|
void *vi_uarea; /* Item specific area */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct virtual_node {
|
|
|
|
char *vn_free_ptr; /* This is a pointer to the free space
|
|
|
|
in the buffer */
|
|
|
|
unsigned short vn_nr_item; /* Number of items in virtual node */
|
|
|
|
short vn_size; /* Size of node , that node would have
|
|
|
|
if it has unlimited size and no
|
|
|
|
balancing is performed */
|
|
|
|
short vn_mode; /* Mode of balancing (paste, insert,
|
|
|
|
delete, cut) */
|
|
|
|
short vn_affected_item_num;
|
|
|
|
short vn_pos_in_item;
|
|
|
|
struct item_head *vn_ins_ih; /* Item header of inserted item, 0 for
|
|
|
|
other modes */
|
|
|
|
const void *vn_data;
|
|
|
|
struct virtual_item *vn_vi; /* Array of items (including a new one,
|
|
|
|
excluding item to be deleted) */
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Used by directory items when creating virtual nodes */
|
|
|
|
struct direntry_uarea {
|
|
|
|
int flags;
|
|
|
|
uint16_t entry_count;
|
|
|
|
uint16_t entry_sizes[1];
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Tree balance
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
struct reiserfs_iget_args {
|
|
|
|
uint32_t objectid;
|
|
|
|
uint32_t dirid;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct item_operations {
|
|
|
|
int (*bytes_number)(struct item_head * ih, int block_size);
|
|
|
|
void (*decrement_key)(struct cpu_key *);
|
|
|
|
int (*is_left_mergeable)(struct key * ih, unsigned long bsize);
|
|
|
|
void (*print_item)(struct item_head *, char * item);
|
|
|
|
void (*check_item)(struct item_head *, char * item);
|
|
|
|
|
|
|
|
int (*create_vi)(struct virtual_node * vn,
|
|
|
|
struct virtual_item * vi, int is_affected, int insert_size);
|
|
|
|
int (*check_left)(struct virtual_item * vi, int free,
|
|
|
|
int start_skip, int end_skip);
|
|
|
|
int (*check_right)(struct virtual_item * vi, int free);
|
|
|
|
int (*part_size)(struct virtual_item * vi, int from, int to);
|
|
|
|
int (*unit_num)(struct virtual_item * vi);
|
|
|
|
void (*print_vi)(struct virtual_item * vi);
|
|
|
|
};
|
|
|
|
|
|
|
|
extern struct item_operations *item_ops[TYPE_ANY + 1];
|
|
|
|
|
|
|
|
#define op_bytes_number(ih, bsize) \
|
|
|
|
item_ops[le_ih_k_type(ih)]->bytes_number(ih, bsize)
|
|
|
|
|
|
|
|
#define COMP_KEYS comp_keys
|
|
|
|
#define COMP_SHORT_KEYS comp_short_keys
|
|
|
|
|
|
|
|
/* Get the item header */
|
|
|
|
#define B_N_PITEM_HEAD(bp, item_num) \
|
|
|
|
((struct item_head *)((bp)->b_data + BLKH_SIZE) + (item_num))
|
|
|
|
|
|
|
|
/* Get key */
|
|
|
|
#define B_N_PDELIM_KEY(bp, item_num) \
|
|
|
|
((struct key *)((bp)->b_data + BLKH_SIZE) + (item_num))
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------
|
|
|
|
* Function declarations
|
|
|
|
* -------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* reiserfs_stree.c */
|
|
|
|
int B_IS_IN_TREE(const struct buf *p_s_bp);
|
|
|
|
|
|
|
|
extern void copy_item_head(struct item_head * p_v_to,
|
|
|
|
const struct item_head * p_v_from);
|
|
|
|
|
|
|
|
extern int comp_keys(const struct key *le_key,
|
|
|
|
const struct cpu_key *cpu_key);
|
|
|
|
extern int comp_short_keys(const struct key *le_key,
|
|
|
|
const struct cpu_key *cpu_key);
|
|
|
|
|
|
|
|
extern int comp_le_keys(const struct key *, const struct key *);
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
le_key_version(const struct key *key)
|
|
|
|
{
|
|
|
|
int type;
|
|
|
|
|
|
|
|
type = offset_v2_k_type(&(key->u.k_offset_v2));
|
|
|
|
if (type != TYPE_DIRECT && type != TYPE_INDIRECT &&
|
|
|
|
type != TYPE_DIRENTRY)
|
|
|
|
return (KEY_FORMAT_3_5);
|
|
|
|
|
|
|
|
return (KEY_FORMAT_3_6);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
copy_key(struct key *to, const struct key *from)
|
|
|
|
{
|
|
|
|
|
|
|
|
memcpy(to, from, KEY_SIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct key *get_lkey(const struct path *p_s_chk_path,
|
|
|
|
const struct reiserfs_sb_info *p_s_sbi);
|
|
|
|
const struct key *get_rkey(const struct path *p_s_chk_path,
|
|
|
|
const struct reiserfs_sb_info *p_s_sbi);
|
2009-03-08 06:14:33 +00:00
|
|
|
int bin_search(const void * p_v_key, const void * p_v_base,
|
2005-06-18 17:10:50 +00:00
|
|
|
int p_n_num, int p_n_width, int * p_n_pos);
|
|
|
|
|
|
|
|
void pathrelse(struct path *p_s_search_path);
|
|
|
|
int reiserfs_check_path(struct path *p);
|
|
|
|
|
|
|
|
int search_by_key(struct reiserfs_sb_info *p_s_sbi,
|
|
|
|
const struct cpu_key *p_s_key,
|
|
|
|
struct path *p_s_search_path,
|
|
|
|
int n_stop_level);
|
|
|
|
#define search_item(sbi, key, path) \
|
|
|
|
search_by_key(sbi, key, path, DISK_LEAF_NODE_LEVEL)
|
|
|
|
int search_for_position_by_key(struct reiserfs_sb_info *p_s_sbi,
|
|
|
|
const struct cpu_key *p_s_cpu_key,
|
|
|
|
struct path *p_s_search_path);
|
|
|
|
void decrement_counters_in_path(struct path *p_s_search_path);
|
|
|
|
|
|
|
|
/* reiserfs_inode.c */
|
|
|
|
vop_read_t reiserfs_read;
|
|
|
|
vop_inactive_t reiserfs_inactive;
|
|
|
|
vop_reclaim_t reiserfs_reclaim;
|
|
|
|
|
|
|
|
int reiserfs_get_block(struct reiserfs_node *ip, long block,
|
|
|
|
off_t offset, struct uio *uio);
|
|
|
|
|
|
|
|
void make_cpu_key(struct cpu_key *cpu_key, struct reiserfs_node *ip,
|
|
|
|
off_t offset, int type, int key_length);
|
|
|
|
|
|
|
|
void reiserfs_read_locked_inode(struct reiserfs_node *ip,
|
|
|
|
struct reiserfs_iget_args *args);
|
|
|
|
int reiserfs_iget(struct mount *mp, const struct cpu_key *key,
|
|
|
|
struct vnode **vpp, struct thread *td);
|
|
|
|
|
|
|
|
void sd_attrs_to_i_attrs(uint16_t sd_attrs, struct reiserfs_node *ip);
|
|
|
|
void i_attrs_to_sd_attrs(struct reiserfs_node *ip, uint16_t *sd_attrs);
|
|
|
|
|
|
|
|
/* reiserfs_namei.c */
|
|
|
|
vop_readdir_t reiserfs_readdir;
|
|
|
|
vop_cachedlookup_t reiserfs_lookup;
|
|
|
|
|
|
|
|
void set_de_name_and_namelen(struct reiserfs_dir_entry * de);
|
|
|
|
int search_by_entry_key(struct reiserfs_sb_info *sbi,
|
|
|
|
const struct cpu_key *key, struct path *path,
|
|
|
|
struct reiserfs_dir_entry *de);
|
|
|
|
|
|
|
|
/* reiserfs_prints.c */
|
|
|
|
char *reiserfs_hashname(int code);
|
|
|
|
void reiserfs_dump_buffer(caddr_t buf, off_t len);
|
|
|
|
|
|
|
|
#if defined(REISERFS_DEBUG)
|
|
|
|
#define reiserfs_log(lvl, fmt, ...) \
|
|
|
|
log(lvl, "ReiserFS/%s: " fmt, __func__, ## __VA_ARGS__)
|
|
|
|
#elif defined (REISERFS_DEBUG_CONS)
|
|
|
|
#define reiserfs_log(lvl, fmt, ...) \
|
|
|
|
printf("%s:%d: " fmt, __func__, __LINE__, ## __VA_ARGS__)
|
|
|
|
#else
|
|
|
|
#define reiserfs_log(lvl, fmt, ...)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define reiserfs_log_0(lvl, fmt, ...) \
|
|
|
|
printf("%s:%d: " fmt, __func__, __LINE__, ## __VA_ARGS__)
|
|
|
|
|
|
|
|
/* reiserfs_hashes.c */
|
|
|
|
uint32_t keyed_hash(const signed char *msg, int len);
|
|
|
|
uint32_t yura_hash(const signed char *msg, int len);
|
|
|
|
uint32_t r5_hash(const signed char *msg, int len);
|
|
|
|
|
|
|
|
#define reiserfs_test_le_bit test_bit
|
|
|
|
|
|
|
|
#endif /* !defined _GNU_REISERFS_REISERFS_FS_H */
|