/* SPDX-License-Identifier: GPL-2.0 */ /* * Copyright 1996, 1997, 1998 Hans Reiser, see reiserfs/README for * licensing and copyright details */ #include <linux/reiserfs_fs.h> #include <linux/slab.h> #include <linux/interrupt.h> #include <linux/sched.h> #include <linux/bug.h> #include <linux/workqueue.h> #include <asm/unaligned.h> #include <linux/bitops.h> #include <linux/proc_fs.h> #include <linux/buffer_head.h> /* the 32 bit compat definitions with int argument */ #define REISERFS_IOC32_UNPACK … #define REISERFS_IOC32_GETVERSION … #define REISERFS_IOC32_SETVERSION … struct reiserfs_journal_list; /* bitmasks for i_flags field in reiserfs-specific part of inode */ reiserfs_inode_flags; struct reiserfs_inode_info { … }; reiserfs_super_block_flags; /* * struct reiserfs_super_block accessors/mutators since this is a disk * structure, it will always be in little endian format. */ #define sb_block_count(sbp) … #define set_sb_block_count(sbp,v) … #define sb_free_blocks(sbp) … #define set_sb_free_blocks(sbp,v) … #define sb_root_block(sbp) … #define set_sb_root_block(sbp,v) … #define sb_jp_journal_1st_block(sbp) … #define set_sb_jp_journal_1st_block(sbp,v) … #define sb_jp_journal_dev(sbp) … #define set_sb_jp_journal_dev(sbp,v) … #define sb_jp_journal_size(sbp) … #define set_sb_jp_journal_size(sbp,v) … #define sb_jp_journal_trans_max(sbp) … #define set_sb_jp_journal_trans_max(sbp,v) … #define sb_jp_journal_magic(sbp) … #define set_sb_jp_journal_magic(sbp,v) … #define sb_jp_journal_max_batch(sbp) … #define set_sb_jp_journal_max_batch(sbp,v) … #define sb_jp_jourmal_max_commit_age(sbp) … #define set_sb_jp_journal_max_commit_age(sbp,v) … #define sb_blocksize(sbp) … #define set_sb_blocksize(sbp,v) … #define sb_oid_maxsize(sbp) … #define set_sb_oid_maxsize(sbp,v) … #define sb_oid_cursize(sbp) … #define set_sb_oid_cursize(sbp,v) … #define sb_umount_state(sbp) … #define set_sb_umount_state(sbp,v) … #define sb_fs_state(sbp) … #define set_sb_fs_state(sbp,v) … #define sb_hash_function_code(sbp) … #define set_sb_hash_function_code(sbp,v) … #define sb_tree_height(sbp) … #define set_sb_tree_height(sbp,v) … #define sb_bmap_nr(sbp) … #define set_sb_bmap_nr(sbp,v) … #define sb_version(sbp) … #define set_sb_version(sbp,v) … #define sb_mnt_count(sbp) … #define set_sb_mnt_count(sbp, v) … #define sb_reserved_for_journal(sbp) … #define set_sb_reserved_for_journal(sbp,v) … /* LOGGING -- */ /* * These all interelate for performance. * * If the journal block count is smaller than n transactions, you lose speed. * I don't know what n is yet, I'm guessing 8-16. * * typical transaction size depends on the application, how often fsync is * called, and how many metadata blocks you dirty in a 30 second period. * The more small files (<16k) you use, the larger your transactions will * be. * * If your journal fills faster than dirty buffers get flushed to disk, it * must flush them before allowing the journal to wrap, which slows things * down. If you need high speed meta data updates, the journal should be * big enough to prevent wrapping before dirty meta blocks get to disk. * * If the batch max is smaller than the transaction max, you'll waste space * at the end of the journal because journal_end sets the next transaction * to start at 0 if the next transaction has any chance of wrapping. * * The large the batch max age, the better the speed, and the more meta * data changes you'll lose after a crash. */ /* don't mess with these for a while */ /* we have a node size define somewhere in reiserfs_fs.h. -Hans */ #define JOURNAL_BLOCK_SIZE … #define JOURNAL_MAX_CNODE … #define JOURNAL_HASH_SIZE … /* number of copies of the bitmaps to have floating. Must be >= 2 */ #define JOURNAL_NUM_BITMAPS … /* * One of these for every block in every transaction * Each one is in two hash tables. First, a hash of the current transaction, * and after journal_end, a hash of all the in memory transactions. * next and prev are used by the current transaction (journal_hash). * hnext and hprev are used by journal_list_hash. If a block is in more * than one transaction, the journal_list_hash links it in multiple times. * This allows flush_journal_list to remove just the cnode belonging to a * given transaction. */ struct reiserfs_journal_cnode { … }; struct reiserfs_bitmap_node { … }; struct reiserfs_list_bitmap { … }; /* * one of these for each transaction. The most important part here is the * j_realblock. this list of cnodes is used to hash all the blocks in all * the commits, to mark all the real buffer heads dirty once all the commits * hit the disk, and to make sure every real block in a transaction is on * disk before allowing the log area to be overwritten */ struct reiserfs_journal_list { … }; struct reiserfs_journal { … }; enum journal_state_bits { … }; /* ick. magic string to find desc blocks in the journal */ #define JOURNAL_DESC_MAGIC … hashf_t; struct reiserfs_bitmap_info { … }; struct proc_dir_entry; #if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO ) stat_cnt_t; reiserfs_proc_info_data_t; #else typedef struct reiserfs_proc_info_data { } reiserfs_proc_info_data_t; #endif /* Number of quota types we support */ #define REISERFS_MAXQUOTAS … /* reiserfs union of in-core super block data */ struct reiserfs_sb_info { … }; /* Definitions of reiserfs on-disk properties: */ #define REISERFS_3_5 … #define REISERFS_3_6 … #define REISERFS_OLD_FORMAT … /* Mount options */ enum reiserfs_mount_options { … }; #define reiserfs_r5_hash(s) … #define reiserfs_rupasov_hash(s) … #define reiserfs_tea_hash(s) … #define reiserfs_hash_detect(s) … #define reiserfs_no_border(s) … #define reiserfs_no_unhashed_relocation(s) … #define reiserfs_hashed_relocation(s) … #define reiserfs_test4(s) … #define have_large_tails(s) … #define have_small_tails(s) … #define replay_only(s) … #define reiserfs_attrs(s) … #define old_format_only(s) … #define convert_reiserfs(s) … #define reiserfs_data_log(s) … #define reiserfs_data_ordered(s) … #define reiserfs_data_writeback(s) … #define reiserfs_xattrs_user(s) … #define reiserfs_posixacl(s) … #define reiserfs_expose_privroot(s) … #define reiserfs_xattrs_optional(s) … #define reiserfs_barrier_none(s) … #define reiserfs_barrier_flush(s) … #define reiserfs_error_panic(s) … #define reiserfs_error_ro(s) … void reiserfs_file_buffer(struct buffer_head *bh, int list); extern struct file_system_type reiserfs_fs_type; int reiserfs_resize(struct super_block *, unsigned long); #define CARRY_ON … #define SCHEDULE_OCCURRED … #define SB_BUFFER_WITH_SB(s) … #define SB_JOURNAL(s) … #define SB_JOURNAL_1st_RESERVED_BLOCK(s) … #define SB_JOURNAL_LEN_FREE(s) … #define SB_AP_BITMAP(s) … #define SB_DISK_JOURNAL_HEAD(s) … #define reiserfs_is_journal_aborted(journal) … static inline int __reiserfs_is_journal_aborted(struct reiserfs_journal *journal) { … } /* * Locking primitives. The write lock is a per superblock * special mutex that has properties close to the Big Kernel Lock * which was used in the previous locking scheme. */ void reiserfs_write_lock(struct super_block *s); void reiserfs_write_unlock(struct super_block *s); int __must_check reiserfs_write_unlock_nested(struct super_block *s); void reiserfs_write_lock_nested(struct super_block *s, int depth); #ifdef CONFIG_REISERFS_CHECK void reiserfs_lock_check_recursive(struct super_block *s); #else static inline void reiserfs_lock_check_recursive(struct super_block *s) { } #endif /* * Several mutexes depend on the write lock. * However sometimes we want to relax the write lock while we hold * these mutexes, according to the release/reacquire on schedule() * properties of the Bkl that were used. * Reiserfs performances and locking were based on this scheme. * Now that the write lock is a mutex and not the bkl anymore, doing so * may result in a deadlock: * * A acquire write_lock * A acquire j_commit_mutex * A release write_lock and wait for something * B acquire write_lock * B can't acquire j_commit_mutex and sleep * A can't acquire write lock anymore * deadlock * * What we do here is avoiding such deadlock by playing the same game * than the Bkl: if we can't acquire a mutex that depends on the write lock, * we release the write lock, wait a bit and then retry. * * The mutexes concerned by this hack are: * - The commit mutex of a journal list * - The flush mutex * - The journal lock * - The inode mutex */ static inline void reiserfs_mutex_lock_safe(struct mutex *m, struct super_block *s) { … } static inline void reiserfs_mutex_lock_nested_safe(struct mutex *m, unsigned int subclass, struct super_block *s) { … } static inline void reiserfs_down_read_safe(struct rw_semaphore *sem, struct super_block *s) { … } /* * When we schedule, we usually want to also release the write lock, * according to the previous bkl based locking scheme of reiserfs. */ static inline void reiserfs_cond_resched(struct super_block *s) { … } struct fid; /* * 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. */ #define USE_INODE_GENERATION_COUNTER #define REISERFS_PREALLOCATE #define DISPLACE_NEW_PACKING_LOCALITIES #define PREALLOCATION_SIZE … /* n must be power of 2 */ #define _ROUND_UP(x,n) … /* * to be ok for alpha and others we have to align structures to 8 byte * boundary. * FIXME: do not change 4 by anything else: there is code which relies on that */ #define ROUND_UP(x) … /* * debug levels. Right now, CONFIG_REISERFS_CHECK means print all debug * messages. */ #define REISERFS_DEBUG_CODE … void __reiserfs_warning(struct super_block *s, const char *id, const char *func, const char *fmt, ...); #define reiserfs_warning(s, id, fmt, args...) … /* assertions handling */ /* always check a condition and panic if it's false. */ #define __RASSERT(cond, scond, format, args...) … #define RASSERT(cond, format, args...) … #if defined( CONFIG_REISERFS_CHECK ) #define RFALSE(cond, format, args...) … #else #define RFALSE … #endif #define CONSTF … /* * Disk Data Structures */ /*************************************************************************** * SUPER BLOCK * ***************************************************************************/ /* * Structure of super block on disk, a version of which in RAM is often * accessed as REISERFS_SB(s)->s_rs. The version in RAM is part of a larger * structure containing fields never written to disk. */ #define UNSET_HASH … #define TEA_HASH … #define YURA_HASH … #define R5_HASH … #define DEFAULT_HASH … struct journal_params { … }; /* this is the super from 3.5.X, where X >= 10 */ struct reiserfs_super_block_v1 { … } __attribute__ ((packed)); #define SB_SIZE_V1 … /* this is the on disk super block */ struct reiserfs_super_block { … } __attribute__ ((packed)); #define SB_SIZE … #define REISERFS_VERSION_1 … #define REISERFS_VERSION_2 … /* on-disk super block fields converted to cpu form */ #define SB_DISK_SUPER_BLOCK(s) … #define SB_V1_DISK_SUPER_BLOCK(s) … #define SB_BLOCKSIZE(s) … #define SB_BLOCK_COUNT(s) … #define SB_FREE_BLOCKS(s) … #define SB_REISERFS_MAGIC(s) … #define SB_ROOT_BLOCK(s) … #define SB_TREE_HEIGHT(s) … #define SB_REISERFS_STATE(s) … #define SB_VERSION(s) … #define SB_BMAP_NR(s) … #define PUT_SB_BLOCK_COUNT(s, val) … #define PUT_SB_FREE_BLOCKS(s, val) … #define PUT_SB_ROOT_BLOCK(s, val) … #define PUT_SB_TREE_HEIGHT(s, val) … #define PUT_SB_REISERFS_STATE(s, val) … #define PUT_SB_VERSION(s, val) … #define PUT_SB_BMAP_NR(s, val) … #define SB_ONDISK_JP(s) … #define SB_ONDISK_JOURNAL_SIZE(s) … #define SB_ONDISK_JOURNAL_1st_BLOCK(s) … #define SB_ONDISK_JOURNAL_DEVICE(s) … #define SB_ONDISK_RESERVED_FOR_JOURNAL(s) … #define is_block_in_log_or_reserved_area(s, block) … 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 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 the largest block size on any * platform, or code will break. -Hans */ #define REISERFS_DISK_OFFSET_IN_BYTES … #define REISERFS_FIRST_BLOCK … #define REISERFS_JOURNAL_OFFSET_IN_BYTES … /* the spot for the super in versions 3.5 - 3.5.10 (inclusive) */ #define REISERFS_OLD_DISK_OFFSET_IN_BYTES … /* reiserfs internal error code (used by search_by_key and fix_nodes)) */ #define CARRY_ON … #define REPEAT_SEARCH … #define IO_ERROR … #define NO_DISK_SPACE … #define NO_BALANCING_NEEDED … #define NO_MORE_UNUSED_CONTIGUOUS_BLOCKS … #define QUOTA_EXCEEDED … b_blocknr_t; unp_t; struct unfm_nodeinfo { … }; /* there are two formats of keys: 3.5 and 3.6 */ #define KEY_FORMAT_3_5 … #define KEY_FORMAT_3_6 … /* there are two stat datas */ #define STAT_DATA_V1 … #define STAT_DATA_V2 … static inline struct reiserfs_inode_info *REISERFS_I(const struct inode *inode) { … } static inline struct reiserfs_sb_info *REISERFS_SB(const struct super_block *sb) { … } /* * Don't trust REISERFS_SB(sb)->s_bmap_nr, it's a u16 * which overflows on large file systems. */ static inline __u32 reiserfs_bmap_count(struct super_block *sb) { … } static inline int bmap_would_wrap(unsigned bmap_nr) { … } extern const struct xattr_handler * const reiserfs_xattr_handlers[]; /* * this says about version of key of all items (but stat data) the * object consists of */ #define get_inode_item_key_version( inode ) … #define set_inode_item_key_version( inode, version ) … #define get_inode_sd_version(inode) … #define set_inode_sd_version(inode, version) … /* * This is an aggressive tail suppression policy, I am hoping it * improves our benchmarks. The principle behind it is that percentage * space saving is what matters, not absolute space saving. This is * non-intuitive, but it helps to understand it if you consider that the * cost to access 4 blocks is not much more than the cost to access 1 * block, if you have to do a seek and rotate. A tail risks a * non-linear disk access that is significant as a percentage of total * time cost for a 4 block file and saves an amount of space that is * less significant as a percentage of space, or so goes the hypothesis. * -Hans */ #define STORE_TAIL_IN_UNFM_S1(n_file_size,n_tail_size,n_block_size) … /* * Another strategy for tails, this one means only create a tail if all the * file would fit into one DIRECT item. * Primary intention for this one is to increase performance by decreasing * seeking. */ #define STORE_TAIL_IN_UNFM_S2(n_file_size,n_tail_size,n_block_size) … /* * values for s_umount_state field */ #define REISERFS_VALID_FS … #define REISERFS_ERROR_FS … /* * there are 5 item types currently */ #define TYPE_STAT_DATA … #define TYPE_INDIRECT … #define TYPE_DIRECT … #define TYPE_DIRENTRY … #define TYPE_MAXTYPE … #define TYPE_ANY … /*************************************************************************** * KEY & ITEM HEAD * ***************************************************************************/ /* * directories use this key as well as old files */ struct offset_v1 { … } __attribute__ ((packed)); struct offset_v2 { … } __attribute__ ((packed)); static inline __u16 offset_v2_k_type(const struct offset_v2 *v2) { … } static inline void set_offset_v2_k_type(struct offset_v2 *v2, int type) { … } static inline loff_t offset_v2_k_offset(const struct offset_v2 *v2) { … } static inline void set_offset_v2_k_offset(struct offset_v2 *v2, loff_t offset) { … } /* * Key of an item determines its location in the S+tree, and * is composed of 4 components */ struct reiserfs_key { … } __attribute__ ((packed)); struct in_core_key { … }; struct cpu_key { … }; /* * 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 … #define REISERFS_SHORT_KEY_LEN … /* The result of the key compare */ #define FIRST_GREATER … #define SECOND_GREATER … #define KEYS_IDENTICAL … #define KEY_FOUND … #define KEY_NOT_FOUND … #define KEY_SIZE … /* return values for search_by_key and clones */ #define ITEM_FOUND … #define ITEM_NOT_FOUND … #define ENTRY_FOUND … #define ENTRY_NOT_FOUND … #define DIRECTORY_NOT_FOUND … #define REGULAR_FILE_FOUND … #define DIRECTORY_FOUND … #define BYTE_FOUND … #define BYTE_NOT_FOUND … #define FILE_NOT_FOUND … #define POSITION_FOUND … #define POSITION_NOT_FOUND … /* return values for reiserfs_find_entry and search_by_entry_key */ #define NAME_FOUND … #define NAME_NOT_FOUND … #define GOTO_PREVIOUS_ITEM … #define NAME_FOUND_INVISIBLE … /* * 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 { … } __attribute__ ((packed)); /* size of item header */ #define IH_SIZE … #define ih_free_space(ih) … #define ih_version(ih) … #define ih_entry_count(ih) … #define ih_location(ih) … #define ih_item_len(ih) … #define put_ih_free_space(ih, val) … #define put_ih_version(ih, val) … #define put_ih_entry_count(ih, val) … #define put_ih_location(ih, val) … #define put_ih_item_len(ih, val) … #define unreachable_item(ih) … #define get_ih_free_space(ih) … #define set_ih_free_space(ih,val) … /* * 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 __u32, i is the index into the array, v is the value * to store there. */ #define get_block_num(p, i) … #define put_block_num(p, i, v) … /* * in old version uniqueness field shows key type */ #define V1_SD_UNIQUENESS … #define V1_INDIRECT_UNIQUENESS … #define V1_DIRECT_UNIQUENESS … #define V1_DIRENTRY_UNIQUENESS … #define V1_ANY_UNIQUENESS … /* here are conversion routines */ static inline int uniqueness2type(__u32 uniqueness) CONSTF; static inline int uniqueness2type(__u32 uniqueness) { … } static inline __u32 type2uniqueness(int type) CONSTF; static inline __u32 type2uniqueness(int type) { … } /* * 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 loff_t le_key_k_offset(int version, const struct reiserfs_key *key) { … } static inline loff_t le_ih_k_offset(const struct item_head *ih) { … } static inline loff_t le_key_k_type(int version, const struct reiserfs_key *key) { … } static inline loff_t le_ih_k_type(const struct item_head *ih) { … } static inline void set_le_key_k_offset(int version, struct reiserfs_key *key, loff_t offset) { … } static inline void add_le_key_k_offset(int version, struct reiserfs_key *key, loff_t offset) { … } static inline void add_le_ih_k_offset(struct item_head *ih, loff_t offset) { … } static inline void set_le_ih_k_offset(struct item_head *ih, loff_t offset) { … } static inline void set_le_key_k_type(int version, struct reiserfs_key *key, int type) { … } static inline void set_le_ih_k_type(struct item_head *ih, int type) { … } static inline int is_direntry_le_key(int version, struct reiserfs_key *key) { … } static inline int is_direct_le_key(int version, struct reiserfs_key *key) { … } static inline int is_indirect_le_key(int version, struct reiserfs_key *key) { … } static inline int is_statdata_le_key(int version, struct reiserfs_key *key) { … } /* item header has version. */ static inline int is_direntry_le_ih(struct item_head *ih) { … } static inline int is_direct_le_ih(struct item_head *ih) { … } static inline int is_indirect_le_ih(struct item_head *ih) { … } static inline int is_statdata_le_ih(struct item_head *ih) { … } /* key is pointer to cpu key, result is cpu */ static inline loff_t cpu_key_k_offset(const struct cpu_key *key) { … } static inline loff_t cpu_key_k_type(const struct cpu_key *key) { … } static inline void set_cpu_key_k_offset(struct cpu_key *key, loff_t offset) { … } static inline void set_cpu_key_k_type(struct cpu_key *key, int type) { … } static inline void cpu_key_k_offset_dec(struct cpu_key *key) { … } #define is_direntry_cpu_key(key) … #define is_direct_cpu_key(key) … #define is_indirect_cpu_key(key) … #define is_statdata_cpu_key(key) … /* are these used ? */ #define is_direntry_cpu_ih(ih) … #define is_direct_cpu_ih(ih) … #define is_indirect_cpu_ih(ih) … #define is_statdata_cpu_ih(ih) … #define I_K_KEY_IN_ITEM(ih, key, n_blocksize) … /* maximal length of item */ #define MAX_ITEM_LEN(block_size) … #define MIN_ITEM_LEN … /* object identifier for root dir */ #define REISERFS_ROOT_OBJECTID … #define REISERFS_ROOT_PARENT_OBJECTID … extern struct reiserfs_key root_key; /* * Picture represents a leaf of the S+tree * ______________________________________________________ * | | Array of | | | * |Block | Object-Item | F r e e | Objects- | * | head | Headers | S p a c e | Items | * |______|_______________|___________________|___________| */ /* * 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 { … }; #define BLKH_SIZE … #define blkh_level(p_blkh) … #define blkh_nr_item(p_blkh) … #define blkh_free_space(p_blkh) … #define blkh_reserved(p_blkh) … #define set_blkh_level(p_blkh,val) … #define set_blkh_nr_item(p_blkh,val) … #define set_blkh_free_space(p_blkh,val) … #define set_blkh_reserved(p_blkh,val) … #define blkh_right_delim_key(p_blkh) … #define set_blkh_right_delim_key(p_blkh,val) … /* values for blk_level field of the struct block_head */ /* * 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 */ #define FREE_LEVEL … #define DISK_LEAF_NODE_LEVEL … /* * Given the buffer head of a formatted node, resolve to the * block head of that node. */ #define B_BLK_HEAD(bh) … /* Number of items that are in buffer. */ #define B_NR_ITEMS(bh) … #define B_LEVEL(bh) … #define B_FREE_SPACE(bh) … #define PUT_B_NR_ITEMS(bh, val) … #define PUT_B_LEVEL(bh, val) … #define PUT_B_FREE_SPACE(bh, val) … /* Get right delimiting key. -- little endian */ #define B_PRIGHT_DELIM_KEY(bh) … /* Does the buffer contain a disk leaf. */ #define B_IS_ITEMS_LEVEL(bh) … /* Does the buffer contain a disk internal node */ #define B_IS_KEYS_LEVEL(bh) … /*************************************************************************** * STAT DATA * ***************************************************************************/ /* * old stat data is 32 bytes long. We are going to distinguish new one by * different size */ struct stat_data_v1 { … } __attribute__ ((packed)); #define SD_V1_SIZE … #define stat_data_v1(ih) … #define sd_v1_mode(sdp) … #define set_sd_v1_mode(sdp,v) … #define sd_v1_nlink(sdp) … #define set_sd_v1_nlink(sdp,v) … #define sd_v1_uid(sdp) … #define set_sd_v1_uid(sdp,v) … #define sd_v1_gid(sdp) … #define set_sd_v1_gid(sdp,v) … #define sd_v1_size(sdp) … #define set_sd_v1_size(sdp,v) … #define sd_v1_atime(sdp) … #define set_sd_v1_atime(sdp,v) … #define sd_v1_mtime(sdp) … #define set_sd_v1_mtime(sdp,v) … #define sd_v1_ctime(sdp) … #define set_sd_v1_ctime(sdp,v) … #define sd_v1_rdev(sdp) … #define set_sd_v1_rdev(sdp,v) … #define sd_v1_blocks(sdp) … #define set_sd_v1_blocks(sdp,v) … #define sd_v1_first_direct_byte(sdp) … #define set_sd_v1_first_direct_byte(sdp,v) … /* inode flags stored in sd_attrs (nee sd_reserved) */ /* * we want common flags to have the same values as in ext2, * so chattr(1) will work without problems */ #define REISERFS_IMMUTABLE_FL … #define REISERFS_APPEND_FL … #define REISERFS_SYNC_FL … #define REISERFS_NOATIME_FL … #define REISERFS_NODUMP_FL … #define REISERFS_SECRM_FL … #define REISERFS_UNRM_FL … #define REISERFS_COMPR_FL … #define REISERFS_NOTAIL_FL … /* persistent flags that file inherits from the parent directory */ #define REISERFS_INHERIT_MASK … /* * Stat Data on disk (reiserfs version of UFS disk inode minus the * address blocks) */ struct stat_data { … } __attribute__ ((packed)); /* this is 44 bytes long */ #define SD_SIZE … #define SD_V2_SIZE … #define stat_data_v2(ih) … #define sd_v2_mode(sdp) … #define set_sd_v2_mode(sdp,v) … /* sd_reserved */ /* set_sd_reserved */ #define sd_v2_nlink(sdp) … #define set_sd_v2_nlink(sdp,v) … #define sd_v2_size(sdp) … #define set_sd_v2_size(sdp,v) … #define sd_v2_uid(sdp) … #define set_sd_v2_uid(sdp,v) … #define sd_v2_gid(sdp) … #define set_sd_v2_gid(sdp,v) … #define sd_v2_atime(sdp) … #define set_sd_v2_atime(sdp,v) … #define sd_v2_mtime(sdp) … #define set_sd_v2_mtime(sdp,v) … #define sd_v2_ctime(sdp) … #define set_sd_v2_ctime(sdp,v) … #define sd_v2_blocks(sdp) … #define set_sd_v2_blocks(sdp,v) … #define sd_v2_rdev(sdp) … #define set_sd_v2_rdev(sdp,v) … #define sd_v2_generation(sdp) … #define set_sd_v2_generation(sdp,v) … #define sd_v2_attrs(sdp) … #define set_sd_v2_attrs(sdp,v) … /*************************************************************************** * DIRECTORY STRUCTURE * ***************************************************************************/ /* * Picture represents the structure of directory items * ________________________________________________ * | Array of | | | | | | * | directory |N-1| N-2 | .... | 1st |0th| * | entry headers | | | | | | * |_______________|___|_____|________|_______|___| * <---- directory entries ------> * * First directory item has k_offset component 1. We store "." and ".." * in one item, always, we never split "." and ".." into differing * items. This makes, among other things, the code for removing * directories simpler. */ #define SD_OFFSET … #define SD_UNIQUENESS … #define DOT_OFFSET … #define DOT_DOT_OFFSET … #define DIRENTRY_UNIQUENESS … #define FIRST_ITEM_OFFSET … /* * Q: How to get key of object pointed to by entry from entry? * * A: Each directory entry has its header. This header has deh_dir_id * and deh_objectid fields, those are key of object, entry points to */ /* * NOT IMPLEMENTED: * Directory will someday contain stat data of object */ struct reiserfs_de_head { … } __attribute__ ((packed)); #define DEH_SIZE … #define deh_offset(p_deh) … #define deh_dir_id(p_deh) … #define deh_objectid(p_deh) … #define deh_location(p_deh) … #define deh_state(p_deh) … #define put_deh_offset(p_deh,v) … #define put_deh_dir_id(p_deh,v) … #define put_deh_objectid(p_deh,v) … #define put_deh_location(p_deh,v) … #define put_deh_state(p_deh,v) … /* empty directory contains two entries "." and ".." and their headers */ #define EMPTY_DIR_SIZE … /* old format directories have this size when empty */ #define EMPTY_DIR_SIZE_V1 … #define DEH_Statdata … #define DEH_Visible … /* 64 bit systems (and the S/390) need to be aligned explicitly -jdm */ #if BITS_PER_LONG == 64 || defined(__s390__) || defined(__hppa__) #define ADDR_UNALIGNED_BITS … #endif /* * These are only used to manipulate deh_state. * Because of this, we'll use the ext2_ bit routines, * since they are little endian */ #ifdef ADDR_UNALIGNED_BITS #define aligned_address(addr) … #define unaligned_offset(addr) … #define set_bit_unaligned(nr, addr) … #define clear_bit_unaligned(nr, addr) … #define test_bit_unaligned(nr, addr) … #else #define set_bit_unaligned … #define clear_bit_unaligned … #define test_bit_unaligned … #endif #define mark_de_with_sd(deh) … #define mark_de_without_sd(deh) … #define mark_de_visible(deh) … #define mark_de_hidden(deh) … #define de_with_sd(deh) … #define de_visible(deh) … #define de_hidden(deh) … extern void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid, __le32 par_dirid, __le32 par_objid); extern void make_empty_dir_item(char *body, __le32 dirid, __le32 objid, __le32 par_dirid, __le32 par_objid); /* two entries per block (at least) */ #define REISERFS_MAX_NAME(block_size) … /* * 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 { … }; /* * these defines are useful when a particular member of * a reiserfs_dir_entry is needed */ /* pointer to file name, stored in entry */ #define B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh) … /* length of name */ #define I_DEH_N_ENTRY_FILE_NAME_LENGTH(ih,deh,entry_num) … /* hash value occupies bits from 7 up to 30 */ #define GET_HASH_VALUE(offset) … /* generation number occupies 7 bits starting from 0 up to 6 */ #define GET_GENERATION_NUMBER(offset) … #define MAX_GENERATION_NUMBER … #define SET_GENERATION_NUMBER(offset,gen_number) … /* * Picture represents an internal node of the reiserfs tree * ______________________________________________________ * | | Array of | Array of | Free | * |block | keys | pointers | space | * | head | N | N+1 | | * |______|_______________|___________________|___________| */ /*************************************************************************** * DISK CHILD * ***************************************************************************/ /* * Disk child pointer: * The pointer from an internal node of the tree to a node that is on disk. */ struct disk_child { … }; #define DC_SIZE … #define dc_block_number(dc_p) … #define dc_size(dc_p) … #define put_dc_block_number(dc_p, val) … #define put_dc_size(dc_p, val) … /* Get disk child by buffer header and position in the tree node. */ #define B_N_CHILD(bh, n_pos) … /* Get disk child number by buffer header and position in the tree node. */ #define B_N_CHILD_NUM(bh, n_pos) … #define PUT_B_N_CHILD_NUM(bh, n_pos, val) … /* maximal value of field child_size in structure disk_child */ /* child size is the combined size of all items and their headers */ #define MAX_CHILD_SIZE(bh) … /* amount of used space in buffer (not including block head) */ #define B_CHILD_SIZE(cur) … /* max and min number of keys in internal node */ #define MAX_NR_KEY(bh) … #define MIN_NR_KEY(bh) … /*************************************************************************** * PATH STRUCTURES AND DEFINES * ***************************************************************************/ /* * search_by_key fills up the path from the root to the leaf as it descends * the tree looking for the key. It uses reiserfs_bread to try to find * buffers in the cache given their block number. If it does not find * them in the cache it reads them from disk. For each node search_by_key * finds using reiserfs_bread it then uses bin_search to look through that * node. bin_search will find the position of the block_number of the next * node if it is looking through an internal node. If it is looking through * a leaf node bin_search will find the position of the item which has key * either equal to given key, or which is the maximal key less than the * given key. */ struct path_element { … }; /* * maximal height of a tree. don't change this without * changing JOURNAL_PER_BALANCE_CNT */ #define MAX_HEIGHT … /* Must be equals MAX_HEIGHT + FIRST_PATH_ELEMENT_OFFSET */ #define EXTENDED_MAX_HEIGHT … /* Must be equal to at least 2. */ #define FIRST_PATH_ELEMENT_OFFSET … /* Must be equal to FIRST_PATH_ELEMENT_OFFSET - 1 */ #define ILLEGAL_PATH_ELEMENT_OFFSET … /* this MUST be MAX_HEIGHT + 1. See about FEB below */ #define MAX_FEB_SIZE … /* * 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 search_by_key and the comments * in it, especially about decrement_counters_in_path(), to understand * this structure. * * Paths make the code so much harder to work with and debug.... An * enormous number of bugs are due to them, and trying to write or modify * code that uses them just makes my head hurt. They are based on an * excessive effort to avoid disturbing the precious VFS code.:-( The * gods only know how we are going to SMP the code that uses them. * znodes are the way! */ #define PATH_READA … #define PATH_READA_BACK … struct treepath { … }; #define pos_in_item(path) … #define INITIALIZE_PATH(var) … /* Get path element by path and path position. */ #define PATH_OFFSET_PELEMENT(path, n_offset) … /* Get buffer header at the path by path and path position. */ #define PATH_OFFSET_PBUFFER(path, n_offset) … /* Get position in the element at the path by path and path position. */ #define PATH_OFFSET_POSITION(path, n_offset) … #define PATH_PLAST_BUFFER(path) … /* * you know, to the person who didn't write this the macro name does not * at first suggest what it does. Maybe POSITION_FROM_PATH_END? Or * maybe we should just focus on dumping paths... -Hans */ #define PATH_LAST_POSITION(path) … /* * in do_balance leaf has h == 0 in contrast with path structure, * where root has level == 0. That is why we need these defines */ /* tb->S[h] */ #define PATH_H_PBUFFER(path, h) … /* tb->F[h] or tb->S[0]->b_parent */ #define PATH_H_PPARENT(path, h) … #define PATH_H_POSITION(path, h) … /* tb->S[h]->b_item_order */ #define PATH_H_B_ITEM_ORDER(path, h) … #define PATH_H_PATH_OFFSET(path, n_h) … static inline void *reiserfs_node_data(const struct buffer_head *bh) { … } /* get key from internal node */ static inline struct reiserfs_key *internal_key(struct buffer_head *bh, int item_num) { … } /* get the item header from leaf node */ static inline struct item_head *item_head(const struct buffer_head *bh, int item_num) { … } /* get the key from leaf node */ static inline struct reiserfs_key *leaf_key(const struct buffer_head *bh, int item_num) { … } static inline void *ih_item_body(const struct buffer_head *bh, const struct item_head *ih) { … } /* get item body from leaf node */ static inline void *item_body(const struct buffer_head *bh, int item_num) { … } static inline struct item_head *tp_item_head(const struct treepath *path) { … } static inline void *tp_item_body(const struct treepath *path) { … } #define get_last_bh(path) … #define get_item_pos(path) … #define item_moved(ih,path) … #define path_changed(ih,path) … /* array of the entry headers */ /* get item body */ #define B_I_DEH(bh, 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 buffer_head *bh, const struct item_head *ih, int pos_in_item) { … } /*************************************************************************** * MISC * ***************************************************************************/ /* Size of pointer to the unformatted node. */ #define UNFM_P_SIZE … #define UNFM_P_SHIFT … /* in in-core inode key is stored on le form */ #define INODE_PKEY(inode) … #define MAX_UL_INT … #define MAX_INT … #define MAX_US_INT … // reiserfs version 2 has max offset 60 bits. Version 1 - 32 bit offset static inline loff_t max_reiserfs_offset(struct inode *inode) { … } #define MAX_KEY_OBJECTID … #define MAX_B_NUM … #define MAX_FC_NUM … /* the purpose is to detect overflow of an unsigned short */ #define REISERFS_LINK_MAX … /* * The following defines are used in reiserfs_insert_item * and reiserfs_append_item */ #define REISERFS_KERNEL_MEM … #define REISERFS_USER_MEM … #define fs_generation(s) … #define get_generation(s) … #define FILESYSTEM_CHANGED_TB(tb) … #define __fs_changed(gen,s) … #define fs_changed(gen,s) … /*************************************************************************** * FIXATE NODES * ***************************************************************************/ #define VI_TYPE_LEFT_MERGEABLE … #define VI_TYPE_RIGHT_MERGEABLE … /* * 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 { … }; struct virtual_node { … }; /* used by directory items when creating virtual nodes */ struct direntry_uarea { … } __attribute__ ((packed)); /*************************************************************************** * TREE BALANCE * ***************************************************************************/ /* * This temporary structure is used in tree balance algorithms, and * constructed as we go to the extent that its various parts are * needed. It contains arrays of nodes that can potentially be * involved in the balancing of node S, and parameters that define how * each of the nodes must be balanced. Note that in these algorithms * for balancing the worst case is to need to balance the current node * S and the left and right neighbors and all of their parents plus * create a new node. We implement S1 balancing for the leaf nodes * and S0 balancing for the internal nodes (S1 and S0 are defined in * our papers.) */ /* size of the array of buffers to free at end of do_balance */ #define MAX_FREE_BLOCK … /* maximum number of FEB blocknrs on a single level */ #define MAX_AMOUNT_NEEDED … /* someday somebody will prefix every field in this struct with tb_ */ struct tree_balance { … }; /* These are modes of balancing */ /* When inserting an item. */ #define M_INSERT … /* * When inserting into (directories only) or appending onto an already * existent item. */ #define M_PASTE … /* When deleting an item. */ #define M_DELETE … /* When truncating an item or removing an entry from a (directory) item. */ #define M_CUT … /* used when balancing on leaf level skipped (in reiserfsck) */ #define M_INTERNAL … /* * When further balancing is not needed, then do_balance does not need * to be called. */ #define M_SKIP_BALANCING … #define M_CONVERT … /* modes of leaf_move_items */ #define LEAF_FROM_S_TO_L … #define LEAF_FROM_S_TO_R … #define LEAF_FROM_R_TO_L … #define LEAF_FROM_L_TO_R … #define LEAF_FROM_S_TO_SNEW … #define FIRST_TO_LAST … #define LAST_TO_FIRST … /* * used in do_balance for passing parent of node information that has * been gotten from tb struct */ struct buffer_info { … }; static inline struct super_block *sb_from_tb(struct tree_balance *tb) { … } static inline struct super_block *sb_from_bi(struct buffer_info *bi) { … } /* * there are 4 types of items: stat data, directory item, indirect, direct. * +-------------------+------------+--------------+------------+ * | | k_offset | k_uniqueness | mergeable? | * +-------------------+------------+--------------+------------+ * | stat data | 0 | 0 | no | * +-------------------+------------+--------------+------------+ * | 1st directory item| DOT_OFFSET | DIRENTRY_ .. | no | * | non 1st directory | hash value | UNIQUENESS | yes | * | item | | | | * +-------------------+------------+--------------+------------+ * | indirect item | offset + 1 |TYPE_INDIRECT | [1] | * +-------------------+------------+--------------+------------+ * | direct item | offset + 1 |TYPE_DIRECT | [2] | * +-------------------+------------+--------------+------------+ * * [1] if this is not the first indirect item of the object * [2] if this is not the first direct item of the object */ struct item_operations { … }; extern struct item_operations *item_ops[TYPE_ANY + 1]; #define op_bytes_number(ih,bsize) … #define op_is_left_mergeable(key,bsize) … #define op_print_item(ih,item) … #define op_check_item(ih,item) … #define op_create_vi(vn,vi,is_affected,insert_size) … #define op_check_left(vi,free,start_skip,end_skip) … #define op_check_right(vi,free) … #define op_part_size(vi,from,to) … #define op_unit_num(vi) … #define op_print_vi(vi) … #define COMP_SHORT_KEYS … /* number of blocks pointed to by the indirect item */ #define I_UNFM_NUM(ih) … /* * the used space within the unformatted node corresponding * to pos within the item pointed to by ih */ #define I_POS_UNFM_SIZE(ih,pos,size) … /* * number of bytes contained by the direct item or the * unformatted nodes the indirect item points to */ /* following defines use reiserfs buffer header and item header */ /* get stat-data */ #define B_I_STAT_DATA(bh, ih) … /* this is 3976 for size==4096 */ #define MAX_DIRECT_ITEM_LEN(size) … /* * indirect items consist of entries which contain blocknrs, pos * indicates which entry, and B_I_POS_UNFM_POINTER resolves to the * blocknr contained by the entry pos points to */ #define B_I_POS_UNFM_POINTER(bh, ih, pos) … #define PUT_B_I_POS_UNFM_POINTER(bh, ih, pos, val) … struct reiserfs_iget_args { … }; /*************************************************************************** * FUNCTION DECLARATIONS * ***************************************************************************/ #define get_journal_desc_magic(bh) … #define journal_trans_half(blocksize) … /* journal.c see journal.c for all the comments here */ /* first block written in a commit. */ struct reiserfs_journal_desc { … }; #define get_desc_trans_id(d) … #define get_desc_trans_len(d) … #define get_desc_mount_id(d) … #define set_desc_trans_id(d,val) … #define set_desc_trans_len(d,val) … #define set_desc_mount_id(d,val) … /* last block written in a commit */ struct reiserfs_journal_commit { … }; #define get_commit_trans_id(c) … #define get_commit_trans_len(c) … #define get_commit_mount_id(c) … #define set_commit_trans_id(c,val) … #define set_commit_trans_len(c,val) … /* * 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 { … }; /* biggest tunable defines are right here */ #define JOURNAL_BLOCK_COUNT … /* biggest possible single transaction, don't change for now (8/3/99) */ #define JOURNAL_TRANS_MAX_DEFAULT … #define JOURNAL_TRANS_MIN_DEFAULT … /* * max blocks to batch into one transaction, * don't make this any bigger than 900 */ #define JOURNAL_MAX_BATCH_DEFAULT … #define JOURNAL_MIN_RATIO … #define JOURNAL_MAX_COMMIT_AGE … #define JOURNAL_MAX_TRANS_AGE … #define JOURNAL_PER_BALANCE_CNT … #define JOURNAL_BLOCKS_PER_OBJECT(sb) … #ifdef CONFIG_QUOTA #define REISERFS_QUOTA_OPTS … /* We need to update data and inode (atime) */ #define REISERFS_QUOTA_TRANS_BLOCKS(s) … /* 1 balancing, 1 bitmap, 1 data per write + stat data update */ #define REISERFS_QUOTA_INIT_BLOCKS(s) … /* same as with INIT */ #define REISERFS_QUOTA_DEL_BLOCKS(s) … #else #define REISERFS_QUOTA_TRANS_BLOCKS … #define REISERFS_QUOTA_INIT_BLOCKS … #define REISERFS_QUOTA_DEL_BLOCKS … #endif /* * both of these can be as low as 1, or as high as you want. The min is the * number of 4k bitmap nodes preallocated on mount. New nodes are allocated * as needed, and released when transactions are committed. On release, if * the current number of nodes is > max, the node is freed, otherwise, * it is put on a free list for faster use later. */ #define REISERFS_MIN_BITMAP_NODES … #define REISERFS_MAX_BITMAP_NODES … /* these are based on journal hash size of 8192 */ #define JBH_HASH_SHIFT … #define JBH_HASH_MASK … #define _jhashfn(sb,block) … #define journal_hash(t,sb,block) … /* We need these to make journal.c code more readable */ #define journal_find_get_block(s, block) … #define journal_getblk(s, block) … #define journal_bread(s, block) … enum reiserfs_bh_state_bits { … }; BUFFER_FNS(JDirty, journaled); TAS_BUFFER_FNS(JDirty, journaled); BUFFER_FNS(JDirty_wait, journal_dirty); TAS_BUFFER_FNS(JDirty_wait, journal_dirty); BUFFER_FNS(JNew, journal_new); TAS_BUFFER_FNS(JNew, journal_new); BUFFER_FNS(JPrepared, journal_prepared); TAS_BUFFER_FNS(JPrepared, journal_prepared); BUFFER_FNS(JRestore_dirty, journal_restore_dirty); TAS_BUFFER_FNS(JRestore_dirty, journal_restore_dirty); BUFFER_FNS(JTest, journal_test); TAS_BUFFER_FNS(JTest, journal_test); /* transaction handle which is passed around for all journal calls */ struct reiserfs_transaction_handle { … }; /* * used to keep track of ordered and tail writes, attached to the buffer * head through b_journal_head. */ struct reiserfs_jh { … }; void reiserfs_free_jh(struct buffer_head *bh); int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh); int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh); int journal_mark_dirty(struct reiserfs_transaction_handle *, struct buffer_head *bh); static inline int reiserfs_file_data_log(struct inode *inode) { … } static inline int reiserfs_transaction_running(struct super_block *s) { … } static inline int reiserfs_transaction_free_space(struct reiserfs_transaction_handle *th) { … } struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct super_block *, int count); int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *); void reiserfs_vfs_truncate_file(struct inode *inode); int reiserfs_commit_page(struct inode *inode, struct page *page, unsigned from, unsigned to); void reiserfs_flush_old_commits(struct super_block *); int reiserfs_commit_for_inode(struct inode *); int reiserfs_inode_needs_commit(struct inode *); void reiserfs_update_inode_transaction(struct inode *); void reiserfs_wait_on_write_block(struct super_block *s); void reiserfs_block_writes(struct reiserfs_transaction_handle *th); void reiserfs_allow_writes(struct super_block *s); void reiserfs_check_lock_depth(struct super_block *s, char *caller); int reiserfs_prepare_for_journal(struct super_block *, struct buffer_head *bh, int wait); void reiserfs_restore_prepared_buffer(struct super_block *, struct buffer_head *bh); int journal_init(struct super_block *, const char *j_dev_name, int old_format, unsigned int); int journal_release(struct reiserfs_transaction_handle *, struct super_block *); int journal_release_error(struct reiserfs_transaction_handle *, struct super_block *); int journal_end(struct reiserfs_transaction_handle *); int journal_end_sync(struct reiserfs_transaction_handle *); int journal_mark_freed(struct reiserfs_transaction_handle *, struct super_block *, b_blocknr_t blocknr); int journal_transaction_should_end(struct reiserfs_transaction_handle *, int); int reiserfs_in_journal(struct super_block *sb, unsigned int bmap_nr, int bit_nr, int searchall, b_blocknr_t *next); int journal_begin(struct reiserfs_transaction_handle *, struct super_block *sb, unsigned long); int journal_join_abort(struct reiserfs_transaction_handle *, struct super_block *sb); void reiserfs_abort_journal(struct super_block *sb, int errno); void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...); int reiserfs_allocate_list_bitmaps(struct super_block *s, struct reiserfs_list_bitmap *, unsigned int); void reiserfs_schedule_old_flush(struct super_block *s); void reiserfs_cancel_old_flush(struct super_block *s); void add_save_link(struct reiserfs_transaction_handle *th, struct inode *inode, int truncate); int remove_save_link(struct inode *inode, int truncate); /* objectid.c */ __u32 reiserfs_get_unused_objectid(struct reiserfs_transaction_handle *th); void reiserfs_release_objectid(struct reiserfs_transaction_handle *th, __u32 objectid_to_release); int reiserfs_convert_objectid_map_v1(struct super_block *); /* stree.c */ int B_IS_IN_TREE(const struct buffer_head *); extern void copy_item_head(struct item_head *to, const struct item_head *from); /* first key is in cpu form, second - le */ extern int comp_short_keys(const struct reiserfs_key *le_key, const struct cpu_key *cpu_key); extern void le_key2cpu_key(struct cpu_key *to, const struct reiserfs_key *from); /* both are in le form */ extern int comp_le_keys(const struct reiserfs_key *, const struct reiserfs_key *); extern int comp_short_le_keys(const struct reiserfs_key *, const struct reiserfs_key *); /* * get key version from on disk key - kludge */ static inline int le_key_version(const struct reiserfs_key *key) { … } static inline void copy_key(struct reiserfs_key *to, const struct reiserfs_key *from) { … } int comp_items(const struct item_head *stored_ih, const struct treepath *path); const struct reiserfs_key *get_rkey(const struct treepath *chk_path, const struct super_block *sb); int search_by_key(struct super_block *, const struct cpu_key *, struct treepath *, int); #define search_item(s,key,path) … int search_for_position_by_key(struct super_block *sb, const struct cpu_key *cpu_key, struct treepath *search_path); extern void decrement_bcount(struct buffer_head *bh); void decrement_counters_in_path(struct treepath *search_path); void pathrelse(struct treepath *search_path); int reiserfs_check_path(struct treepath *p); void pathrelse_and_restore(struct super_block *s, struct treepath *search_path); int reiserfs_insert_item(struct reiserfs_transaction_handle *th, struct treepath *path, const struct cpu_key *key, struct item_head *ih, struct inode *inode, const char *body); int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th, struct treepath *path, const struct cpu_key *key, struct inode *inode, const char *body, int paste_size); int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th, struct treepath *path, struct cpu_key *key, struct inode *inode, struct page *page, loff_t new_file_size); int reiserfs_delete_item(struct reiserfs_transaction_handle *th, struct treepath *path, const struct cpu_key *key, struct inode *inode, struct buffer_head *un_bh); void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th, struct inode *inode, struct reiserfs_key *key); int reiserfs_delete_object(struct reiserfs_transaction_handle *th, struct inode *inode); int reiserfs_do_truncate(struct reiserfs_transaction_handle *th, struct inode *inode, struct page *, int update_timestamps); #define i_block_size(inode) … #define file_size(inode) … #define tail_size(inode) … #define tail_has_to_be_packed(inode) … void padd_item(char *item, int total_length, int length); /* inode.c */ /* args for the create parameter of reiserfs_get_block */ #define GET_BLOCK_NO_CREATE … #define GET_BLOCK_CREATE … #define GET_BLOCK_NO_HOLE … #define GET_BLOCK_READ_DIRECT … #define GET_BLOCK_NO_IMUX … #define GET_BLOCK_NO_DANGLE … void reiserfs_read_locked_inode(struct inode *inode, struct reiserfs_iget_args *args); int reiserfs_find_actor(struct inode *inode, void *p); int reiserfs_init_locked_inode(struct inode *inode, void *p); void reiserfs_evict_inode(struct inode *inode); int reiserfs_write_inode(struct inode *inode, struct writeback_control *wbc); int reiserfs_get_block(struct inode *inode, sector_t block, struct buffer_head *bh_result, int create); struct dentry *reiserfs_fh_to_dentry(struct super_block *sb, struct fid *fid, int fh_len, int fh_type); struct dentry *reiserfs_fh_to_parent(struct super_block *sb, struct fid *fid, int fh_len, int fh_type); int reiserfs_encode_fh(struct inode *inode, __u32 * data, int *lenp, struct inode *parent); int reiserfs_truncate_file(struct inode *, int update_timestamps); void make_cpu_key(struct cpu_key *cpu_key, struct inode *inode, loff_t offset, int type, int key_length); void make_le_item_head(struct item_head *ih, const struct cpu_key *key, int version, loff_t offset, int type, int length, int entry_count); struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key); struct reiserfs_security_handle; int reiserfs_new_inode(struct reiserfs_transaction_handle *th, struct inode *dir, umode_t mode, const char *symname, loff_t i_size, struct dentry *dentry, struct inode *inode, struct reiserfs_security_handle *security); void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th, struct inode *inode, loff_t size); static inline void reiserfs_update_sd(struct reiserfs_transaction_handle *th, struct inode *inode) { … } void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode); int reiserfs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, struct iattr *attr); int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len); /* namei.c */ void reiserfs_init_priv_inode(struct inode *inode); void set_de_name_and_namelen(struct reiserfs_dir_entry *de); int search_by_entry_key(struct super_block *sb, const struct cpu_key *key, struct treepath *path, struct reiserfs_dir_entry *de); struct dentry *reiserfs_get_parent(struct dentry *); #ifdef CONFIG_REISERFS_PROC_INFO int reiserfs_proc_info_init(struct super_block *sb); int reiserfs_proc_info_done(struct super_block *sb); int reiserfs_proc_info_global_init(void); int reiserfs_proc_info_global_done(void); #define PROC_EXP( e ) … #define __PINFO( sb ) … #define PROC_INFO_MAX( sb, field, value ) … #define PROC_INFO_INC( sb, field ) … #define PROC_INFO_ADD( sb, field, val ) … #define PROC_INFO_BH_STAT( sb, bh, level ) … #else static inline int reiserfs_proc_info_init(struct super_block *sb) { return 0; } static inline int reiserfs_proc_info_done(struct super_block *sb) { return 0; } static inline int reiserfs_proc_info_global_init(void) { return 0; } static inline int reiserfs_proc_info_global_done(void) { return 0; } #define PROC_EXP … #define VOID_V … #define PROC_INFO_MAX … #define PROC_INFO_INC … #define PROC_INFO_ADD … #define PROC_INFO_BH_STAT … #endif /* dir.c */ extern const struct inode_operations reiserfs_dir_inode_operations; extern const struct inode_operations reiserfs_symlink_inode_operations; extern const struct inode_operations reiserfs_special_inode_operations; extern const struct file_operations reiserfs_dir_operations; int reiserfs_readdir_inode(struct inode *, struct dir_context *); /* tail_conversion.c */ int direct2indirect(struct reiserfs_transaction_handle *, struct inode *, struct treepath *, struct buffer_head *, loff_t); int indirect2direct(struct reiserfs_transaction_handle *, struct inode *, struct page *, struct treepath *, const struct cpu_key *, loff_t, char *); void reiserfs_unmap_buffer(struct buffer_head *); /* file.c */ extern const struct inode_operations reiserfs_file_inode_operations; extern const struct inode_operations reiserfs_priv_file_inode_operations; extern const struct file_operations reiserfs_file_operations; extern const struct address_space_operations reiserfs_address_space_operations; /* fix_nodes.c */ int fix_nodes(int n_op_mode, struct tree_balance *tb, struct item_head *ins_ih, const void *); void unfix_nodes(struct tree_balance *); /* prints.c */ void __reiserfs_panic(struct super_block *s, const char *id, const char *function, const char *fmt, ...) __attribute__ ((noreturn)); #define reiserfs_panic(s, id, fmt, args...) … void __reiserfs_error(struct super_block *s, const char *id, const char *function, const char *fmt, ...); #define reiserfs_error(s, id, fmt, args...) … void reiserfs_info(struct super_block *s, const char *fmt, ...); void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...); void print_indirect_item(struct buffer_head *bh, int item_num); void store_print_tb(struct tree_balance *tb); void print_cur_tb(char *mes); void print_de(struct reiserfs_dir_entry *de); void print_bi(struct buffer_info *bi, char *mes); #define PRINT_LEAF_ITEMS … #define PRINT_DIRECTORY_ITEMS … #define PRINT_DIRECT_ITEMS … void print_block(struct buffer_head *bh, ...); void print_bmap(struct super_block *s, int silent); void print_bmap_block(int i, char *data, int size, int silent); /*void print_super_block (struct super_block * s, char * mes);*/ void print_objectid_map(struct super_block *s); void print_block_head(struct buffer_head *bh, char *mes); void check_leaf(struct buffer_head *bh); void check_internal(struct buffer_head *bh); void print_statistics(struct super_block *s); char *reiserfs_hashname(int code); /* lbalance.c */ int leaf_move_items(int shift_mode, struct tree_balance *tb, int mov_num, int mov_bytes, struct buffer_head *Snew); int leaf_shift_left(struct tree_balance *tb, int shift_num, int shift_bytes); int leaf_shift_right(struct tree_balance *tb, int shift_num, int shift_bytes); void leaf_delete_items(struct buffer_info *cur_bi, int last_first, int first, int del_num, int del_bytes); void leaf_insert_into_buf(struct buffer_info *bi, int before, struct item_head * const inserted_item_ih, const char * const inserted_item_body, int zeros_number); void leaf_paste_in_buffer(struct buffer_info *bi, int pasted_item_num, int pos_in_item, int paste_size, const char * const body, int zeros_number); void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num, int pos_in_item, int cut_size); void leaf_paste_entries(struct buffer_info *bi, int item_num, int before, int new_entry_count, struct reiserfs_de_head *new_dehs, const char *records, int paste_size); /* ibalance.c */ int balance_internal(struct tree_balance *, int, int, struct item_head *, struct buffer_head **); /* do_balance.c */ void do_balance_mark_leaf_dirty(struct tree_balance *tb, struct buffer_head *bh, int flag); #define do_balance_mark_internal_dirty … #define do_balance_mark_sb_dirty … void do_balance(struct tree_balance *tb, struct item_head *ih, const char *body, int flag); void reiserfs_invalidate_buffer(struct tree_balance *tb, struct buffer_head *bh); int get_left_neighbor_position(struct tree_balance *tb, int h); int get_right_neighbor_position(struct tree_balance *tb, int h); void replace_key(struct tree_balance *tb, struct buffer_head *, int, struct buffer_head *, int); void make_empty_node(struct buffer_info *); struct buffer_head *get_FEB(struct tree_balance *); /* bitmap.c */ /* * structure contains hints for block allocator, and it is a container for * arguments, such as node, search path, transaction_handle, etc. */ struct __reiserfs_blocknr_hint { … }; reiserfs_blocknr_hint_t; int reiserfs_parse_alloc_options(struct super_block *, char *); void reiserfs_init_alloc_options(struct super_block *s); /* * given a directory, this will tell you what packing locality * to use for a new object underneat it. The locality is returned * in disk byte order (le). */ __le32 reiserfs_choose_packing(struct inode *dir); void show_alloc_options(struct seq_file *seq, struct super_block *s); int reiserfs_init_bitmap_cache(struct super_block *sb); void reiserfs_free_bitmap_cache(struct super_block *sb); void reiserfs_cache_bitmap_metadata(struct super_block *sb, struct buffer_head *bh, struct reiserfs_bitmap_info *info); struct buffer_head *reiserfs_read_bitmap_block(struct super_block *sb, unsigned int bitmap); int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value); void reiserfs_free_block(struct reiserfs_transaction_handle *th, struct inode *, b_blocknr_t, int for_unformatted); int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *, b_blocknr_t *, int, int); static inline int reiserfs_new_form_blocknrs(struct tree_balance *tb, b_blocknr_t * new_blocknrs, int amount_needed) { … } static inline int reiserfs_new_unf_blocknrs(struct reiserfs_transaction_handle *th, struct inode *inode, b_blocknr_t * new_blocknrs, struct treepath *path, sector_t block) { … } #ifdef REISERFS_PREALLOCATE static inline int reiserfs_new_unf_blocknrs2(struct reiserfs_transaction_handle *th, struct inode *inode, b_blocknr_t * new_blocknrs, struct treepath *path, sector_t block) { … } void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th, struct inode *inode); void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th); #endif /* hashes.c */ __u32 keyed_hash(const signed char *msg, int len); __u32 yura_hash(const signed char *msg, int len); __u32 r5_hash(const signed char *msg, int len); #define reiserfs_set_le_bit … #define reiserfs_test_and_set_le_bit … #define reiserfs_clear_le_bit … #define reiserfs_test_and_clear_le_bit … #define reiserfs_test_le_bit … #define reiserfs_find_next_zero_le_bit … /* * sometimes reiserfs_truncate may require to allocate few new blocks * to perform indirect2direct conversion. People probably used to * think, that truncate should work without problems on a filesystem * without free disk space. They may complain that they can not * truncate due to lack of free disk space. This spare space allows us * to not worry about it. 500 is probably too much, but it should be * absolutely safe */ #define SPARE_SPACE … /* prototypes from ioctl.c */ int reiserfs_fileattr_get(struct dentry *dentry, struct fileattr *fa); int reiserfs_fileattr_set(struct mnt_idmap *idmap, struct dentry *dentry, struct fileattr *fa); long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg); long reiserfs_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg); int reiserfs_unpack(struct inode *inode);
Codebase Browser
linux