reiserfs_fs_sb.h

This is a ReiserFs file system driver for Windows NT/2000/XP/Vista.

    // FIXME: Won't work with block sizes > 8K
    __u16  first_zero_hint;
    __u16  free_count;
    struct buffer_head *bh; /* the actual bitmap */
};

struct proc_dir_entry;

#if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
typedef unsigned long int stat_cnt_t;
typedef struct reiserfs_proc_info_data
{
  spinlock_t lock;
  int exiting;
  int max_hash_collisions;

  stat_cnt_t breads;
  stat_cnt_t bread_miss;
  stat_cnt_t search_by_key;
  stat_cnt_t search_by_key_fs_changed;
  stat_cnt_t search_by_key_restarted;

  stat_cnt_t insert_item_restarted;
  stat_cnt_t paste_into_item_restarted;
  stat_cnt_t cut_from_item_restarted;
  stat_cnt_t delete_solid_item_restarted;
  stat_cnt_t delete_item_restarted;

  stat_cnt_t leaked_oid;
  stat_cnt_t leaves_removable;

  /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */
  stat_cnt_t balance_at[ 5 ]; /* XXX */
  /* sbk == search_by_key */
  stat_cnt_t sbk_read_at[ 5 ]; /* XXX */
  stat_cnt_t sbk_fs_changed[ 5 ];
  stat_cnt_t sbk_restarted[ 5 ];
  stat_cnt_t items_at[ 5 ]; /* XXX */
  stat_cnt_t free_at[ 5 ]; /* XXX */
  stat_cnt_t can_node_be_removed[ 5 ]; /* XXX */
  long int lnum[ 5 ]; /* XXX */
  long int rnum[ 5 ]; /* XXX */
  long int lbytes[ 5 ]; /* XXX */
  long int rbytes[ 5 ]; /* XXX */
  stat_cnt_t get_neighbors[ 5 ];
  stat_cnt_t get_neighbors_restart[ 5 ];
  stat_cnt_t need_l_neighbor[ 5 ];
  stat_cnt_t need_r_neighbor[ 5 ];

  stat_cnt_t free_block;
  struct __scan_bitmap_stats {
	stat_cnt_t call;
	stat_cnt_t wait;
	stat_cnt_t bmap;
	stat_cnt_t retry;
	stat_cnt_t in_journal_hint;
	stat_cnt_t in_journal_nohint;
	stat_cnt_t stolen;
  } scan_bitmap;
  struct __journal_stats {
	stat_cnt_t in_journal;
	stat_cnt_t in_journal_bitmap;
	stat_cnt_t in_journal_reusable;
	stat_cnt_t lock_journal;
	stat_cnt_t lock_journal_wait;
	stat_cnt_t journal_being;
	stat_cnt_t journal_relock_writers;
	stat_cnt_t journal_relock_wcount;
	stat_cnt_t mark_dirty;
	stat_cnt_t mark_dirty_already;
	stat_cnt_t mark_dirty_notjournal;
	stat_cnt_t restore_prepared;
	stat_cnt_t prepare;
	stat_cnt_t prepare_retry;
  } journal;
} reiserfs_proc_info_data_t;
#else
typedef struct reiserfs_proc_info_data
{} reiserfs_proc_info_data_t;
#endif

/* reiserfs union of in-core super block data */
struct reiserfs_sb_info
{
    struct buffer_head * s_sbh;                   /* Buffer containing the super block */
				/* both the comment and the choice of
                                   name are unclear for s_rs -Hans */
    struct reiserfs_super_block * s_rs;           /* Pointer to the super block in the buffer */
    struct reiserfs_bitmap_info * s_ap_bitmap;
    struct reiserfs_journal *s_journal ;		/* pointer to journal information */
    unsigned short s_mount_state;                 /* reiserfs state (valid, invalid) */
  
				/* Comment? -Hans */
    void (*end_io_handler)(struct buffer_head *, int);
    hashf_t s_hash_function;	/* pointer to function which is used
                                   to sort names in directory. Set on
                                   mount */
    unsigned long s_mount_opt;	/* reiserfs's mount options are set
                                   here (currently - NOTAIL, NOLOG,
                                   REPLAYONLY) */

    struct {			/* This is a structure that describes block allocator options */
	unsigned long bits;	/* Bitfield for enable/disable kind of options */
	unsigned long large_file_size; /* size started from which we consider file to be a large one(in blocks) */
	int border;		/* percentage of disk, border takes */
	int preallocmin;	/* Minimal file size (in blocks) starting from which we do preallocations */
	int preallocsize;	/* Number of blocks we try to prealloc when file
				   reaches preallocmin size (in blocks) or
				   prealloc_list is empty. */
    } s_alloc_options;

				/* Comment? -Hans */
    wait_queue_head_t s_wait;
				/* To be obsoleted soon by per buffer seals.. -Hans */
    atomic_t s_generation_counter; // increased by one every time the
    // tree gets re-balanced
    unsigned long s_properties;    /* File system properties. Currently holds
				     on-disk FS format */
    
    /* session statistics */
    int s_kmallocs;
    int s_disk_reads;
    int s_disk_writes;
    int s_fix_nodes;
    int s_do_balance;
    int s_unneeded_left_neighbor;
    int s_good_search_by_key_reada;
    int s_bmaps;
    int s_bmaps_without_search;
    int s_direct2indirect;
    int s_indirect2direct;
	/* set up when it's ok for reiserfs_read_inode2() to read from
	   disk inode with nlink==0. Currently this is only used during
	   finish_unfinished() processing at mount time */
    int s_is_unlinked_ok;
    reiserfs_proc_info_data_t s_proc_info_data;
    struct proc_dir_entry *procdir;
    int reserved_blocks; /* amount of blocks reserved for further allocations */
    spinlock_t bitmap_lock; /* this lock on now only used to protect reserved_blocks variable */
    struct dentry *priv_root; /* root of /.reiserfs_priv */
    struct dentry *xattr_root; /* root of /.reiserfs_priv/.xa */
    struct rw_semaphore xattr_dir_sem;

    int j_errno;
#ifdef CONFIG_QUOTA
    char *s_qf_names[MAXQUOTAS];
    int s_jquota_fmt;
#endif
};

/* Definitions of reiserfs on-disk properties: */
#define REISERFS_3_5 0
#define REISERFS_3_6 1

enum reiserfs_mount_options {
/* Mount options */
    REISERFS_LARGETAIL,  /* large tails will be created in a session */
    REISERFS_SMALLTAIL,  /* small (for files less than block size) tails will be created in a session */
    REPLAYONLY, /* replay journal and return 0. Use by fsck */
    REISERFS_CONVERT,    /* -o conv: causes conversion of old
                                 format super block to the new
                                 format. If not specified - old
                                 partition will be dealt with in a
                                 manner of 3.5.x */

/* -o hash={tea, rupasov, r5, detect} is meant for properly mounting 
** reiserfs disks from 3.5.19 or earlier.  99% of the time, this option
** is not required.  If the normal autodection code can't determine which
** hash to use (because both hases had the same value for a file)
** use this option to force a specific hash.  It won't allow you to override
** the existing hash on the FS, so if you have a tea hash disk, and mount
** with -o hash=rupasov, the mount will fail.
*/
    FORCE_TEA_HASH,      /* try to force tea hash on mount */
    FORCE_RUPASOV_HASH,  /* try to force rupasov hash on mount */
    FORCE_R5_HASH,       /* try to force rupasov hash on mount */
    FORCE_HASH_DETECT,   /* try to detect hash function on mount */

    REISERFS_DATA_LOG,
    REISERFS_DATA_ORDERED,
    REISERFS_DATA_WRITEBACK,

/* used for testing experimental features, makes benchmarking new
   features with and without more convenient, should never be used by
   users in any code shipped to users (ideally) */

    REISERFS_NO_BORDER,
    REISERFS_NO_UNHASHED_RELOCATION,
    REISERFS_HASHED_RELOCATION,
    REISERFS_ATTRS,
    REISERFS_XATTRS,
    REISERFS_XATTRS_USER,
    REISERFS_POSIXACL,
    REISERFS_BARRIER_NONE,
    REISERFS_BARRIER_FLUSH,

    /* Actions on error */
    REISERFS_ERROR_PANIC,
    REISERFS_ERROR_RO,
    REISERFS_ERROR_CONTINUE,

    REISERFS_TEST1,
    REISERFS_TEST2,
    REISERFS_TEST3,
    REISERFS_TEST4,
    REISERFS_UNSUPPORTED_OPT,
};

#define reiserfs_r5_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_R5_HASH))
#define reiserfs_rupasov_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_RUPASOV_HASH))
#define reiserfs_tea_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_TEA_HASH))
#define reiserfs_hash_detect(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_HASH_DETECT))
#define reiserfs_no_border(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_BORDER))
#define reiserfs_no_unhashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_UNHASHED_RELOCATION))
#define reiserfs_hashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_HASHED_RELOCATION))
#define reiserfs_test4(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_TEST4))

#define have_large_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_LARGETAIL))
#define have_small_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_SMALLTAIL))
#define replay_only(s) (REISERFS_SB(s)->s_mount_opt & (1 << REPLAYONLY))
#define reiserfs_attrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ATTRS))
#define old_format_only(s) (REISERFS_SB(s)->s_properties & (1 << REISERFS_3_5))
#define convert_reiserfs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_CONVERT))
#define reiserfs_data_log(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_LOG))
#define reiserfs_data_ordered(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_ORDERED))
#define reiserfs_data_writeback(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_WRITEBACK))
#define reiserfs_xattrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS))
#define reiserfs_xattrs_user(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS_USER))
#define reiserfs_posixacl(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_POSIXACL))
#define reiserfs_xattrs_optional(s) (reiserfs_xattrs_user(s) || reiserfs_posixacl(s))
#define reiserfs_barrier_none(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_NONE))
#define reiserfs_barrier_flush(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_FLUSH))

#define reiserfs_error_panic(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_PANIC))
#define reiserfs_error_ro(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_RO))

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                0
#define SCHEDULE_OCCURRED       1


#define SB_BUFFER_WITH_SB(s) (REISERFS_SB(s)->s_sbh)
#define SB_JOURNAL(s) (REISERFS_SB(s)->s_journal)
#define SB_JOURNAL_1st_RESERVED_BLOCK(s) (SB_JOURNAL(s)->j_1st_reserved_block)
#define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free) 
#define SB_AP_BITMAP(s) (REISERFS_SB(s)->s_ap_bitmap)

#define SB_DISK_JOURNAL_HEAD(s) (SB_JOURNAL(s)->j_header_bh->)

/* A safe version of the "bdevname", which returns the "s_id" field of
 * a superblock or else "Null superblock" if the super block is NULL.
 */
static inline char *reiserfs_bdevname(struct super_block *s)
{
        return (s == NULL) ? "Null superblock" : s -> s_id;
}

#define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal)))
static inline int __reiserfs_is_journal_aborted (struct reiserfs_journal *journal)
{
    return test_bit (J_ABORTED, &journal->j_state);
}

#endif	/* _LINUX_REISER_FS_SB */