开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
reiserfs_fs_sb.h
资源名称：arm_cross-3.4.4.tar.gz　[点击查看]
上传用户：szlgq88
上传日期：2009-04-28
资源大小：48287k
文件大小：22k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

reiserfs_fs_sb.h：源码内容
  1. /* Copyright 1996-2000 Hans Reiser, see reiserfs/README for licensing
  2.  * and copyright details */
  4. #ifndef _LINUX_REISER_FS_SB
  5. #define _LINUX_REISER_FS_SB
  7. #ifdef __KERNEL__
  8. #include <linux/workqueue.h>
  9. #include <linux/rwsem.h>
  10. #endif
  12. typedef enum {
  13. reiserfs_attrs_cleared = 0x00000001,
  14. } reiserfs_super_block_flags;
  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))
  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))
  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))
  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))
  81. /* LOGGING -- */
  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. */
  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 */
  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. */
  119. struct 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. };
  131. struct reiserfs_bitmap_node {
  132. int id;
  133. char *data;
  134. struct list_head list;
  135. };
  137. struct reiserfs_list_bitmap {
  138. struct reiserfs_journal_list *journal_list;
  139. struct reiserfs_bitmap_node **bitmaps;
  140. };
  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 */
  148. struct 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;
  165. /* time ordered list of all transactions we haven't tried to flush yet */
  166. struct list_head j_working_list;
  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. };
  175. struct 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 */
  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 */
  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;
  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 */
  206. int j_cnode_used; /* number of cnodes on the used list */
  207. int j_cnode_free; /* number of cnodes on the free list */
  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 */
  215. struct reiserfs_journal_cnode *j_cnode_free_list;
  216. struct reiserfs_journal_cnode *j_cnode_free_orig; /* orig pointer returned from vmalloc */
  218. struct reiserfs_journal_list *j_current_jl;
  219. int j_free_bitmap_nodes;
  220. int j_used_bitmap_nodes;
  222. int j_num_lists; /* total number of active transactions */
  223. int j_num_work_lists; /* number that need attention from kreiserfsd */
  225. /* debugging to make sure things are flushed in order */
  226. int j_last_flush_id;
  228. /* debugging to make sure things are committed in order */
  229. int j_last_commit_id;
  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 */
  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;
  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;
  249. int j_errno;
  251. /* when flushing ordered buffers, throttle new ordered writers */
  252. struct work_struct j_work;
  253. atomic_t j_async_throttle;
  254. };
  256. enum journal_state_bits {
  257. J_WRITERS_BLOCKED = 1, /* set when new writers not allowed */
  258. J_WRITERS_QUEUED, /* set when log is full due to too many writers */
  259. J_ABORTED, /* set when log is aborted */
  260. };
  262. #define JOURNAL_DESC_MAGIC "ReIsErLB" /* ick.  magic string to find desc blocks in the journal */
  264. typedef __u32(*hashf_t) (const signed char *, int);
  266. struct reiserfs_bitmap_info {
  267. // FIXME: Won't work with block sizes > 8K
  268. __u16 first_zero_hint;
  269. __u16 free_count;
  270. struct buffer_head *bh; /* the actual bitmap */
  271. };
  273. struct proc_dir_entry;
  275. #if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
  276. typedef unsigned long int stat_cnt_t;
  277. typedef struct reiserfs_proc_info_data {
  278. spinlock_t lock;
  279. int exiting;
  280. int max_hash_collisions;
  282. stat_cnt_t breads;
  283. stat_cnt_t bread_miss;
  284. stat_cnt_t search_by_key;
  285. stat_cnt_t search_by_key_fs_changed;
  286. stat_cnt_t search_by_key_restarted;
  288. stat_cnt_t insert_item_restarted;
  289. stat_cnt_t paste_into_item_restarted;
  290. stat_cnt_t cut_from_item_restarted;
  291. stat_cnt_t delete_solid_item_restarted;
  292. stat_cnt_t delete_item_restarted;
  294. stat_cnt_t leaked_oid;
  295. stat_cnt_t leaves_removable;
  297. /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */
  298. stat_cnt_t balance_at[5]; /* XXX */
  299. /* sbk == search_by_key */
  300. stat_cnt_t sbk_read_at[5]; /* XXX */
  301. stat_cnt_t sbk_fs_changed[5];
  302. stat_cnt_t sbk_restarted[5];
  303. stat_cnt_t items_at[5]; /* XXX */
  304. stat_cnt_t free_at[5]; /* XXX */
  305. stat_cnt_t can_node_be_removed[5]; /* XXX */
  306. long int lnum[5]; /* XXX */
  307. long int rnum[5]; /* XXX */
  308. long int lbytes[5]; /* XXX */
  309. long int rbytes[5]; /* XXX */
  310. stat_cnt_t get_neighbors[5];
  311. stat_cnt_t get_neighbors_restart[5];
  312. stat_cnt_t need_l_neighbor[5];
  313. stat_cnt_t need_r_neighbor[5];
  315. stat_cnt_t free_block;
  316. struct __scan_bitmap_stats {
  317. stat_cnt_t call;
  318. stat_cnt_t wait;
  319. stat_cnt_t bmap;
  320. stat_cnt_t retry;
  321. stat_cnt_t in_journal_hint;
  322. stat_cnt_t in_journal_nohint;
  323. stat_cnt_t stolen;
  324. } scan_bitmap;
  325. struct __journal_stats {
  326. stat_cnt_t in_journal;
  327. stat_cnt_t in_journal_bitmap;
  328. stat_cnt_t in_journal_reusable;
  329. stat_cnt_t lock_journal;
  330. stat_cnt_t lock_journal_wait;
  331. stat_cnt_t journal_being;
  332. stat_cnt_t journal_relock_writers;
  333. stat_cnt_t journal_relock_wcount;
  334. stat_cnt_t mark_dirty;
  335. stat_cnt_t mark_dirty_already;
  336. stat_cnt_t mark_dirty_notjournal;
  337. stat_cnt_t restore_prepared;
  338. stat_cnt_t prepare;
  339. stat_cnt_t prepare_retry;
  340. } journal;
  341. } reiserfs_proc_info_data_t;
  342. #else
  343. typedef struct reiserfs_proc_info_data {
  344. } reiserfs_proc_info_data_t;
  345. #endif
  347. /* reiserfs union of in-core super block data */
  348. struct reiserfs_sb_info {
  349. struct buffer_head *s_sbh; /* Buffer containing the super block */
  350. /* both the comment and the choice of
  351.    name are unclear for s_rs -Hans */
  352. struct reiserfs_super_block *s_rs; /* Pointer to the super block in the buffer */
  353. struct reiserfs_bitmap_info *s_ap_bitmap;
  354. struct reiserfs_journal *s_journal; /* pointer to journal information */
  355. unsigned short s_mount_state; /* reiserfs state (valid, invalid) */
  357. /* Comment? -Hans */
  358. void (*end_io_handler) (struct buffer_head *, int);
  359. hashf_t s_hash_function; /* pointer to function which is used
  360.    to sort names in directory. Set on
  361.    mount */
  362. unsigned long s_mount_opt; /* reiserfs's mount options are set
  363.    here (currently - NOTAIL, NOLOG,
  364.    REPLAYONLY) */
  366. struct { /* This is a structure that describes block allocator options */
  367. unsigned long bits; /* Bitfield for enable/disable kind of options */
  368. unsigned long large_file_size; /* size started from which we consider file to be a large one(in blocks) */
  369. int border; /* percentage of disk, border takes */
  370. int preallocmin; /* Minimal file size (in blocks) starting from which we do preallocations */
  371. int preallocsize; /* Number of blocks we try to prealloc when file
  372.    reaches preallocmin size (in blocks) or
  373.    prealloc_list is empty. */
  374. } s_alloc_options;
  376. /* Comment? -Hans */
  377. wait_queue_head_t s_wait;
  378. /* To be obsoleted soon by per buffer seals.. -Hans */
  379. atomic_t s_generation_counter; // increased by one every time the
  380. // tree gets re-balanced
  381. unsigned long s_properties; /* File system properties. Currently holds
  382.    on-disk FS format */
  384. /* session statistics */
  385. int s_kmallocs;
  386. int s_disk_reads;
  387. int s_disk_writes;
  388. int s_fix_nodes;
  389. int s_do_balance;
  390. int s_unneeded_left_neighbor;
  391. int s_good_search_by_key_reada;
  392. int s_bmaps;
  393. int s_bmaps_without_search;
  394. int s_direct2indirect;
  395. int s_indirect2direct;
  396. /* set up when it's ok for reiserfs_read_inode2() to read from
  397.    disk inode with nlink==0. Currently this is only used during
  398.    finish_unfinished() processing at mount time */
  399. int s_is_unlinked_ok;
  400. reiserfs_proc_info_data_t s_proc_info_data;
  401. struct proc_dir_entry *procdir;
  402. int reserved_blocks; /* amount of blocks reserved for further allocations */
  403. spinlock_t bitmap_lock; /* this lock on now only used to protect reserved_blocks variable */
  404. struct dentry *priv_root; /* root of /.reiserfs_priv */
  405. struct dentry *xattr_root; /* root of /.reiserfs_priv/.xa */
  406. struct rw_semaphore xattr_dir_sem;
  408. int j_errno;
  409. #ifdef CONFIG_QUOTA
  410. char *s_qf_names[MAXQUOTAS];
  411. int s_jquota_fmt;
  412. #endif
  413. };
  415. /* Definitions of reiserfs on-disk properties: */
  416. #define REISERFS_3_5 0
  417. #define REISERFS_3_6 1
  419. enum 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 */
  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 hases 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 */
  443. REISERFS_DATA_LOG,
  444. REISERFS_DATA_ORDERED,
  445. REISERFS_DATA_WRITEBACK,
  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) */
  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,
  461. /* Actions on error */
  462. REISERFS_ERROR_PANIC,
  463. REISERFS_ERROR_RO,
  464. REISERFS_ERROR_CONTINUE,
  466. REISERFS_QUOTA, /* Some quota option specified */
  468. REISERFS_TEST1,
  469. REISERFS_TEST2,
  470. REISERFS_TEST3,
  471. REISERFS_TEST4,
  472. REISERFS_UNSUPPORTED_OPT,
  473. };
  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))
  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))
  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))
  503. void reiserfs_file_buffer(struct buffer_head *bh, int list);
  504. extern struct file_system_type reiserfs_fs_type;
  505. int reiserfs_resize(struct super_block *, unsigned long);
  507. #define CARRY_ON                0
  508. #define SCHEDULE_OCCURRED       1
  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)
  516. #define SB_DISK_JOURNAL_HEAD(s) (SB_JOURNAL(s)->j_header_bh->)
  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.  */
  521. static inline char *reiserfs_bdevname(struct super_block *s)
  522. {
  523. return (s == NULL) ? "Null superblock" : s->s_id;
  524. }
  526. #define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal)))
  527. static inline int __reiserfs_is_journal_aborted(struct reiserfs_journal
  528. *journal)
  529. {
  530. return test_bit(J_ABORTED, &journal->j_state);
  531. }
  533. #endif /* _LINUX_REISER_FS_SB */