1/* Copyright 1996-2000 Hans Reiser, see reiserfs/README for licensing 2 * and copyright details */ 3 4#ifndef _LINUX_REISER_FS_SB 5#define _LINUX_REISER_FS_SB 6 7#ifdef __KERNEL__ 8#include <linux/workqueue.h> 9#include <linux/rwsem.h> 10#endif 11 12typedef enum { 13 reiserfs_attrs_cleared = 0x00000001, 14} reiserfs_super_block_flags; 15 16/* struct reiserfs_super_block accessors/mutators 17 * since this is a disk structure, it will always be in 18 * little endian format. */ 19#define sb_block_count(sbp) (le32_to_cpu((sbp)->s_v1.s_block_count)) 20#define set_sb_block_count(sbp,v) ((sbp)->s_v1.s_block_count = cpu_to_le32(v)) 21#define sb_free_blocks(sbp) (le32_to_cpu((sbp)->s_v1.s_free_blocks)) 22#define set_sb_free_blocks(sbp,v) ((sbp)->s_v1.s_free_blocks = cpu_to_le32(v)) 23#define sb_root_block(sbp) (le32_to_cpu((sbp)->s_v1.s_root_block)) 24#define set_sb_root_block(sbp,v) ((sbp)->s_v1.s_root_block = cpu_to_le32(v)) 25 26#define sb_jp_journal_1st_block(sbp) \ 27 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_1st_block)) 28#define set_sb_jp_journal_1st_block(sbp,v) \ 29 ((sbp)->s_v1.s_journal.jp_journal_1st_block = cpu_to_le32(v)) 30#define sb_jp_journal_dev(sbp) \ 31 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_dev)) 32#define set_sb_jp_journal_dev(sbp,v) \ 33 ((sbp)->s_v1.s_journal.jp_journal_dev = cpu_to_le32(v)) 34#define sb_jp_journal_size(sbp) \ 35 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_size)) 36#define set_sb_jp_journal_size(sbp,v) \ 37 ((sbp)->s_v1.s_journal.jp_journal_size = cpu_to_le32(v)) 38#define sb_jp_journal_trans_max(sbp) \ 39 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_trans_max)) 40#define set_sb_jp_journal_trans_max(sbp,v) \ 41 ((sbp)->s_v1.s_journal.jp_journal_trans_max = cpu_to_le32(v)) 42#define sb_jp_journal_magic(sbp) \ 43 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_magic)) 44#define set_sb_jp_journal_magic(sbp,v) \ 45 ((sbp)->s_v1.s_journal.jp_journal_magic = cpu_to_le32(v)) 46#define sb_jp_journal_max_batch(sbp) \ 47 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_batch)) 48#define set_sb_jp_journal_max_batch(sbp,v) \ 49 ((sbp)->s_v1.s_journal.jp_journal_max_batch = cpu_to_le32(v)) 50#define sb_jp_jourmal_max_commit_age(sbp) \ 51 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_commit_age)) 52#define set_sb_jp_journal_max_commit_age(sbp,v) \ 53 ((sbp)->s_v1.s_journal.jp_journal_max_commit_age = cpu_to_le32(v)) 54 55#define sb_blocksize(sbp) (le16_to_cpu((sbp)->s_v1.s_blocksize)) 56#define set_sb_blocksize(sbp,v) ((sbp)->s_v1.s_blocksize = cpu_to_le16(v)) 57#define sb_oid_maxsize(sbp) (le16_to_cpu((sbp)->s_v1.s_oid_maxsize)) 58#define set_sb_oid_maxsize(sbp,v) ((sbp)->s_v1.s_oid_maxsize = cpu_to_le16(v)) 59#define sb_oid_cursize(sbp) (le16_to_cpu((sbp)->s_v1.s_oid_cursize)) 60#define set_sb_oid_cursize(sbp,v) ((sbp)->s_v1.s_oid_cursize = cpu_to_le16(v)) 61#define sb_umount_state(sbp) (le16_to_cpu((sbp)->s_v1.s_umount_state)) 62#define set_sb_umount_state(sbp,v) ((sbp)->s_v1.s_umount_state = cpu_to_le16(v)) 63#define sb_fs_state(sbp) (le16_to_cpu((sbp)->s_v1.s_fs_state)) 64#define set_sb_fs_state(sbp,v) ((sbp)->s_v1.s_fs_state = cpu_to_le16(v)) 65#define sb_hash_function_code(sbp) \ 66 (le32_to_cpu((sbp)->s_v1.s_hash_function_code)) 67#define set_sb_hash_function_code(sbp,v) \ 68 ((sbp)->s_v1.s_hash_function_code = cpu_to_le32(v)) 69#define sb_tree_height(sbp) (le16_to_cpu((sbp)->s_v1.s_tree_height)) 70#define set_sb_tree_height(sbp,v) ((sbp)->s_v1.s_tree_height = cpu_to_le16(v)) 71#define sb_bmap_nr(sbp) (le16_to_cpu((sbp)->s_v1.s_bmap_nr)) 72#define set_sb_bmap_nr(sbp,v) ((sbp)->s_v1.s_bmap_nr = cpu_to_le16(v)) 73#define sb_version(sbp) (le16_to_cpu((sbp)->s_v1.s_version)) 74#define set_sb_version(sbp,v) ((sbp)->s_v1.s_version = cpu_to_le16(v)) 75 76#define sb_reserved_for_journal(sbp) \ 77 (le16_to_cpu((sbp)->s_v1.s_reserved_for_journal)) 78#define set_sb_reserved_for_journal(sbp,v) \ 79 ((sbp)->s_v1.s_reserved_for_journal = cpu_to_le16(v)) 80 81/* LOGGING -- */ 82 83/* These all interelate for performance. 84** 85** If the journal block count is smaller than n transactions, you lose speed. 86** I don't know what n is yet, I'm guessing 8-16. 87** 88** typical transaction size depends on the application, how often fsync is 89** called, and how many metadata blocks you dirty in a 30 second period. 90** The more small files (<16k) you use, the larger your transactions will 91** be. 92** 93** If your journal fills faster than dirty buffers get flushed to disk, it must flush them before allowing the journal 94** to wrap, which slows things down. If you need high speed meta data updates, the journal should be big enough 95** to prevent wrapping before dirty meta blocks get to disk. 96** 97** If the batch max is smaller than the transaction max, you'll waste space at the end of the journal 98** because journal_end sets the next transaction to start at 0 if the next transaction has any chance of wrapping. 99** 100** The large the batch max age, the better the speed, and the more meta data changes you'll lose after a crash. 101** 102*/ 103 104/* don't mess with these for a while */ 105 /* we have a node size define somewhere in reiserfs_fs.h. -Hans */ 106#define JOURNAL_BLOCK_SIZE 4096 /* BUG gotta get rid of this */ 107#define JOURNAL_MAX_CNODE 1500 /* max cnodes to allocate. */ 108#define JOURNAL_HASH_SIZE 8192 109#define JOURNAL_NUM_BITMAPS 5 /* number of copies of the bitmaps to have floating. Must be >= 2 */ 110 111/* One of these for every block in every transaction 112** Each one is in two hash tables. First, a hash of the current transaction, and after journal_end, a 113** hash of all the in memory transactions. 114** next and prev are used by the current transaction (journal_hash). 115** hnext and hprev are used by journal_list_hash. If a block is in more than one transaction, the journal_list_hash 116** links it in multiple times. This allows flush_journal_list to remove just the cnode belonging 117** to a given transaction. 118*/ 119struct reiserfs_journal_cnode { 120 struct buffer_head *bh; /* real buffer head */ 121 struct super_block *sb; /* dev of real buffer head */ 122 __u32 blocknr; /* block number of real buffer head, == 0 when buffer on disk */ 123 long state; 124 struct reiserfs_journal_list *jlist; /* journal list this cnode lives in */ 125 struct reiserfs_journal_cnode *next; /* next in transaction list */ 126 struct reiserfs_journal_cnode *prev; /* prev in transaction list */ 127 struct reiserfs_journal_cnode *hprev; /* prev in hash list */ 128 struct reiserfs_journal_cnode *hnext; /* next in hash list */ 129}; 130 131struct reiserfs_bitmap_node { 132 int id; 133 char *data; 134 struct list_head list; 135}; 136 137struct reiserfs_list_bitmap { 138 struct reiserfs_journal_list *journal_list; 139 struct reiserfs_bitmap_node **bitmaps; 140}; 141 142/* 143** one of these for each transaction. The most important part here is the j_realblock. 144** this list of cnodes is used to hash all the blocks in all the commits, to mark all the 145** real buffer heads dirty once all the commits hit the disk, 146** and to make sure every real block in a transaction is on disk before allowing the log area 147** to be overwritten */ 148struct reiserfs_journal_list { 149 unsigned long j_start; 150 unsigned long j_state; 151 unsigned long j_len; 152 atomic_t j_nonzerolen; 153 atomic_t j_commit_left; 154 atomic_t j_older_commits_done; /* all commits older than this on disk */ 155 struct semaphore j_commit_lock; 156 unsigned long j_trans_id; 157 time_t j_timestamp; 158 struct reiserfs_list_bitmap *j_list_bitmap; 159 struct buffer_head *j_commit_bh; /* commit buffer head */ 160 struct reiserfs_journal_cnode *j_realblock; 161 struct reiserfs_journal_cnode *j_freedlist; /* list of buffers that were freed during this trans. free each of these on flush */ 162 /* time ordered list of all active transactions */ 163 struct list_head j_list; 164 165 /* time ordered list of all transactions we haven't tried to flush yet */ 166 struct list_head j_working_list; 167 168 /* list of tail conversion targets in need of flush before commit */ 169 struct list_head j_tail_bh_list; 170 /* list of data=ordered buffers in need of flush before commit */ 171 struct list_head j_bh_list; 172 int j_refcount; 173}; 174 175struct reiserfs_journal { 176 struct buffer_head **j_ap_blocks; /* journal blocks on disk */ 177 struct reiserfs_journal_cnode *j_last; /* newest journal block */ 178 struct reiserfs_journal_cnode *j_first; /* oldest journal block. start here for traverse */ 179 180 struct file *j_dev_file; 181 struct block_device *j_dev_bd; 182 int j_1st_reserved_block; /* first block on s_dev of reserved area journal */ 183 184 long j_state; 185 unsigned long j_trans_id; 186 unsigned long j_mount_id; 187 unsigned long j_start; /* start of current waiting commit (index into j_ap_blocks) */ 188 unsigned long j_len; /* lenght of current waiting commit */ 189 unsigned long j_len_alloc; /* number of buffers requested by journal_begin() */ 190 atomic_t j_wcount; /* count of writers for current commit */ 191 unsigned long j_bcount; /* batch count. allows turning X transactions into 1 */ 192 unsigned long j_first_unflushed_offset; /* first unflushed transactions offset */ 193 unsigned long j_last_flush_trans_id; /* last fully flushed journal timestamp */ 194 struct buffer_head *j_header_bh; 195 196 time_t j_trans_start_time; /* time this transaction started */ 197 struct semaphore j_lock; 198 struct semaphore j_flush_sem; 199 wait_queue_head_t j_join_wait; /* wait for current transaction to finish before starting new one */ 200 atomic_t j_jlock; /* lock for j_join_wait */ 201 int j_list_bitmap_index; /* number of next list bitmap to use */ 202 int j_must_wait; /* no more journal begins allowed. MUST sleep on j_join_wait */ 203 int j_next_full_flush; /* next journal_end will flush all journal list */ 204 int j_next_async_flush; /* next journal_end will flush all async commits */ 205 206 int j_cnode_used; /* number of cnodes on the used list */ 207 int j_cnode_free; /* number of cnodes on the free list */ 208 209 unsigned int j_trans_max; /* max number of blocks in a transaction. */ 210 unsigned int j_max_batch; /* max number of blocks to batch into a trans */ 211 unsigned int j_max_commit_age; /* in seconds, how old can an async commit be */ 212 unsigned int j_max_trans_age; /* in seconds, how old can a transaction be */ 213 unsigned int j_default_max_commit_age; /* the default for the max commit age */ 214 215 struct reiserfs_journal_cnode *j_cnode_free_list; 216 struct reiserfs_journal_cnode *j_cnode_free_orig; /* orig pointer returned from vmalloc */ 217 218 struct reiserfs_journal_list *j_current_jl; 219 int j_free_bitmap_nodes; 220 int j_used_bitmap_nodes; 221 222 int j_num_lists; /* total number of active transactions */ 223 int j_num_work_lists; /* number that need attention from kreiserfsd */ 224 225 /* debugging to make sure things are flushed in order */ 226 int j_last_flush_id; 227 228 /* debugging to make sure things are committed in order */ 229 int j_last_commit_id; 230 231 struct list_head j_bitmap_nodes; 232 struct list_head j_dirty_buffers; 233 spinlock_t j_dirty_buffers_lock; /* protects j_dirty_buffers */ 234 235 /* list of all active transactions */ 236 struct list_head j_journal_list; 237 /* lists that haven't been touched by writeback attempts */ 238 struct list_head j_working_list; 239 240 struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS]; /* array of bitmaps to record the deleted blocks */ 241 struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE]; /* hash table for real buffer heads in current trans */ 242 struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE]; /* hash table for all the real buffer heads in all 243 the transactions */ 244 struct list_head j_prealloc_list; /* list of inodes which have preallocated blocks */ 245 int j_persistent_trans; 246 unsigned long j_max_trans_size; 247 unsigned long j_max_batch_size; 248 249 int j_errno; 250 251 /* when flushing ordered buffers, throttle new ordered writers */ 252 struct delayed_work j_work; 253 struct super_block *j_work_sb; 254 atomic_t j_async_throttle; 255}; 256 257enum journal_state_bits { 258 J_WRITERS_BLOCKED = 1, /* set when new writers not allowed */ 259 J_WRITERS_QUEUED, /* set when log is full due to too many writers */ 260 J_ABORTED, /* set when log is aborted */ 261}; 262 263#define JOURNAL_DESC_MAGIC "ReIsErLB" /* ick. magic string to find desc blocks in the journal */ 264 265typedef __u32(*hashf_t) (const signed char *, int); 266 267struct reiserfs_bitmap_info { 268 __u16 first_zero_hint; 269 __u16 free_count; 270}; 271 272struct proc_dir_entry; 273 274#if defined(CONFIG_PROC_FS) && defined(CONFIG_REISERFS_PROC_INFO) 275typedef unsigned long int stat_cnt_t; 276typedef struct reiserfs_proc_info_data { 277 spinlock_t lock; 278 int exiting; 279 int max_hash_collisions; 280 281 stat_cnt_t breads; 282 stat_cnt_t bread_miss; 283 stat_cnt_t search_by_key; 284 stat_cnt_t search_by_key_fs_changed; 285 stat_cnt_t search_by_key_restarted; 286 287 stat_cnt_t insert_item_restarted; 288 stat_cnt_t paste_into_item_restarted; 289 stat_cnt_t cut_from_item_restarted; 290 stat_cnt_t delete_solid_item_restarted; 291 stat_cnt_t delete_item_restarted; 292 293 stat_cnt_t leaked_oid; 294 stat_cnt_t leaves_removable; 295 296 /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */ 297 stat_cnt_t balance_at[5]; 298 /* sbk == search_by_key */ 299 stat_cnt_t sbk_read_at[5]; 300 stat_cnt_t sbk_fs_changed[5]; 301 stat_cnt_t sbk_restarted[5]; 302 stat_cnt_t items_at[5]; 303 stat_cnt_t free_at[5]; 304 stat_cnt_t can_node_be_removed[5]; 305 long int lnum[5]; 306 long int rnum[5]; 307 long int lbytes[5]; 308 long int rbytes[5]; 309 stat_cnt_t get_neighbors[5]; 310 stat_cnt_t get_neighbors_restart[5]; 311 stat_cnt_t need_l_neighbor[5]; 312 stat_cnt_t need_r_neighbor[5]; 313 314 stat_cnt_t free_block; 315 struct __scan_bitmap_stats { 316 stat_cnt_t call; 317 stat_cnt_t wait; 318 stat_cnt_t bmap; 319 stat_cnt_t retry; 320 stat_cnt_t in_journal_hint; 321 stat_cnt_t in_journal_nohint; 322 stat_cnt_t stolen; 323 } scan_bitmap; 324 struct __journal_stats { 325 stat_cnt_t in_journal; 326 stat_cnt_t in_journal_bitmap; 327 stat_cnt_t in_journal_reusable; 328 stat_cnt_t lock_journal; 329 stat_cnt_t lock_journal_wait; 330 stat_cnt_t journal_being; 331 stat_cnt_t journal_relock_writers; 332 stat_cnt_t journal_relock_wcount; 333 stat_cnt_t mark_dirty; 334 stat_cnt_t mark_dirty_already; 335 stat_cnt_t mark_dirty_notjournal; 336 stat_cnt_t restore_prepared; 337 stat_cnt_t prepare; 338 stat_cnt_t prepare_retry; 339 } journal; 340} reiserfs_proc_info_data_t; 341#else 342typedef struct reiserfs_proc_info_data { 343} reiserfs_proc_info_data_t; 344#endif 345 346/* reiserfs union of in-core super block data */ 347struct reiserfs_sb_info { 348 struct buffer_head *s_sbh; /* Buffer containing the super block */ 349 /* both the comment and the choice of 350 name are unclear for s_rs -Hans */ 351 struct reiserfs_super_block *s_rs; /* Pointer to the super block in the buffer */ 352 struct reiserfs_bitmap_info *s_ap_bitmap; 353 struct reiserfs_journal *s_journal; /* pointer to journal information */ 354 unsigned short s_mount_state; /* reiserfs state (valid, invalid) */ 355 356 /* Comment? -Hans */ 357 void (*end_io_handler) (struct buffer_head *, int); 358 hashf_t s_hash_function; /* pointer to function which is used 359 to sort names in directory. Set on 360 mount */ 361 unsigned long s_mount_opt; /* reiserfs's mount options are set 362 here (currently - NOTAIL, NOLOG, 363 REPLAYONLY) */ 364 365 struct { /* This is a structure that describes block allocator options */ 366 unsigned long bits; /* Bitfield for enable/disable kind of options */ 367 unsigned long large_file_size; /* size started from which we consider file to be a large one(in blocks) */ 368 int border; /* percentage of disk, border takes */ 369 int preallocmin; /* Minimal file size (in blocks) starting from which we do preallocations */ 370 int preallocsize; /* Number of blocks we try to prealloc when file 371 reaches preallocmin size (in blocks) or 372 prealloc_list is empty. */ 373 } s_alloc_options; 374 375 /* Comment? -Hans */ 376 wait_queue_head_t s_wait; 377 /* To be obsoleted soon by per buffer seals.. -Hans */ 378 atomic_t s_generation_counter; // increased by one every time the 379 // tree gets re-balanced 380 unsigned long s_properties; /* File system properties. Currently holds 381 on-disk FS format */ 382 383 /* session statistics */ 384 int s_disk_reads; 385 int s_disk_writes; 386 int s_fix_nodes; 387 int s_do_balance; 388 int s_unneeded_left_neighbor; 389 int s_good_search_by_key_reada; 390 int s_bmaps; 391 int s_bmaps_without_search; 392 int s_direct2indirect; 393 int s_indirect2direct; 394 /* set up when it's ok for reiserfs_read_inode2() to read from 395 disk inode with nlink==0. Currently this is only used during 396 finish_unfinished() processing at mount time */ 397 int s_is_unlinked_ok; 398 reiserfs_proc_info_data_t s_proc_info_data; 399 struct proc_dir_entry *procdir; 400 int reserved_blocks; /* amount of blocks reserved for further allocations */ 401 spinlock_t bitmap_lock; /* this lock on now only used to protect reserved_blocks variable */ 402 struct dentry *priv_root; /* root of /.reiserfs_priv */ 403#ifdef CONFIG_REISERFS_FS_XATTR 404 struct dentry *xattr_root; /* root of /.reiserfs_priv/.xa */ 405 struct rw_semaphore xattr_dir_sem; 406#endif 407 int j_errno; 408#ifdef CONFIG_QUOTA 409 char *s_qf_names[MAXQUOTAS]; 410 int s_jquota_fmt; 411#endif 412}; 413 414/* Definitions of reiserfs on-disk properties: */ 415#define REISERFS_3_5 0 416#define REISERFS_3_6 1 417#define REISERFS_OLD_FORMAT 2 418 419enum reiserfs_mount_options { 420/* Mount options */ 421 REISERFS_LARGETAIL, /* large tails will be created in a session */ 422 REISERFS_SMALLTAIL, /* small (for files less than block size) tails will be created in a session */ 423 REPLAYONLY, /* replay journal and return 0. Use by fsck */ 424 REISERFS_CONVERT, /* -o conv: causes conversion of old 425 format super block to the new 426 format. If not specified - old 427 partition will be dealt with in a 428 manner of 3.5.x */ 429 430/* -o hash={tea, rupasov, r5, detect} is meant for properly mounting 431** reiserfs disks from 3.5.19 or earlier. 99% of the time, this option 432** is not required. If the normal autodection code can't determine which 433** hash to use (because both hashes had the same value for a file) 434** use this option to force a specific hash. It won't allow you to override 435** the existing hash on the FS, so if you have a tea hash disk, and mount 436** with -o hash=rupasov, the mount will fail. 437*/ 438 FORCE_TEA_HASH, /* try to force tea hash on mount */ 439 FORCE_RUPASOV_HASH, /* try to force rupasov hash on mount */ 440 FORCE_R5_HASH, /* try to force rupasov hash on mount */ 441 FORCE_HASH_DETECT, /* try to detect hash function on mount */ 442 443 REISERFS_DATA_LOG, 444 REISERFS_DATA_ORDERED, 445 REISERFS_DATA_WRITEBACK, 446 447/* used for testing experimental features, makes benchmarking new 448 features with and without more convenient, should never be used by 449 users in any code shipped to users (ideally) */ 450 451 REISERFS_NO_BORDER, 452 REISERFS_NO_UNHASHED_RELOCATION, 453 REISERFS_HASHED_RELOCATION, 454 REISERFS_ATTRS, 455 REISERFS_XATTRS, 456 REISERFS_XATTRS_USER, 457 REISERFS_POSIXACL, 458 REISERFS_BARRIER_NONE, 459 REISERFS_BARRIER_FLUSH, 460 461 /* Actions on error */ 462 REISERFS_ERROR_PANIC, 463 REISERFS_ERROR_RO, 464 REISERFS_ERROR_CONTINUE, 465 466 REISERFS_QUOTA, /* Some quota option specified */ 467 468 REISERFS_TEST1, 469 REISERFS_TEST2, 470 REISERFS_TEST3, 471 REISERFS_TEST4, 472 REISERFS_UNSUPPORTED_OPT, 473}; 474 475#define reiserfs_r5_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_R5_HASH)) 476#define reiserfs_rupasov_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_RUPASOV_HASH)) 477#define reiserfs_tea_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_TEA_HASH)) 478#define reiserfs_hash_detect(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_HASH_DETECT)) 479#define reiserfs_no_border(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_BORDER)) 480#define reiserfs_no_unhashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_UNHASHED_RELOCATION)) 481#define reiserfs_hashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_HASHED_RELOCATION)) 482#define reiserfs_test4(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_TEST4)) 483 484#define have_large_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_LARGETAIL)) 485#define have_small_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_SMALLTAIL)) 486#define replay_only(s) (REISERFS_SB(s)->s_mount_opt & (1 << REPLAYONLY)) 487#define reiserfs_attrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ATTRS)) 488#define old_format_only(s) (REISERFS_SB(s)->s_properties & (1 << REISERFS_3_5)) 489#define convert_reiserfs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_CONVERT)) 490#define reiserfs_data_log(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_LOG)) 491#define reiserfs_data_ordered(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_ORDERED)) 492#define reiserfs_data_writeback(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_WRITEBACK)) 493#define reiserfs_xattrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS)) 494#define reiserfs_xattrs_user(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS_USER)) 495#define reiserfs_posixacl(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_POSIXACL)) 496#define reiserfs_xattrs_optional(s) (reiserfs_xattrs_user(s) || reiserfs_posixacl(s)) 497#define reiserfs_barrier_none(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_NONE)) 498#define reiserfs_barrier_flush(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_FLUSH)) 499 500#define reiserfs_error_panic(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_PANIC)) 501#define reiserfs_error_ro(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_RO)) 502 503void reiserfs_file_buffer(struct buffer_head *bh, int list); 504extern struct file_system_type reiserfs_fs_type; 505int reiserfs_resize(struct super_block *, unsigned long); 506 507#define CARRY_ON 0 508#define SCHEDULE_OCCURRED 1 509 510#define SB_BUFFER_WITH_SB(s) (REISERFS_SB(s)->s_sbh) 511#define SB_JOURNAL(s) (REISERFS_SB(s)->s_journal) 512#define SB_JOURNAL_1st_RESERVED_BLOCK(s) (SB_JOURNAL(s)->j_1st_reserved_block) 513#define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free) 514#define SB_AP_BITMAP(s) (REISERFS_SB(s)->s_ap_bitmap) 515 516#define SB_DISK_JOURNAL_HEAD(s) (SB_JOURNAL(s)->j_header_bh->) 517 518/* A safe version of the "bdevname", which returns the "s_id" field of 519 * a superblock or else "Null superblock" if the super block is NULL. 520 */ 521static inline char *reiserfs_bdevname(struct super_block *s) 522{ 523 return (s == NULL) ? "Null superblock" : s->s_id; 524} 525 526#define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal))) 527static inline int __reiserfs_is_journal_aborted(struct reiserfs_journal 528 *journal) 529{ 530 return test_bit(J_ABORTED, &journal->j_state); 531} 532 533#endif /* _LINUX_REISER_FS_SB */ 534