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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
reiserfs_fs_sb.h
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：25k
源码类别：

嵌入式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/tqueue.h>
  9. #endif
  11. //
  12. // super block's field values
  13. //
  14. /*#define REISERFS_VERSION 0 undistributed bitmap */
  15. /*#define REISERFS_VERSION 1 distributed bitmap and resizer*/
  16. #define REISERFS_VERSION_2 2 /* distributed bitmap, resizer, 64-bit, etc*/
  17. #define UNSET_HASH 0 // read_super will guess about, what hash names
  18.                      // in directories were sorted with
  19. #define TEA_HASH  1
  20. #define YURA_HASH 2
  21. #define R5_HASH   3
  22. #define DEFAULT_HASH R5_HASH
  24. /* this is the on disk super block */
  26. struct reiserfs_super_block
  27. {
  28.   __u32 s_block_count;
  29.   __u32 s_free_blocks;                  /* free blocks count    */
  30.   __u32 s_root_block;            /* root block number    */
  31.   __u32 s_journal_block;            /* journal block number    */
  32.   __u32 s_journal_dev;            /* journal device number  */
  34.   /* Since journal size is currently a #define in a header file, if 
  35.   ** someone creates a disk with a 16MB journal and moves it to a 
  36.   ** system with 32MB journal default, they will overflow their journal 
  37.   ** when they mount the disk.  s_orig_journal_size, plus some checks
  38.   ** while mounting (inside journal_init) prevent that from happening
  39.   */
  41. /* great comment Chris. Thanks.  -Hans */
  43.   __u32 s_orig_journal_size; 
  44.   __u32 s_journal_trans_max ;           /* max number of blocks in a transaction.  */
  45.   __u32 s_journal_block_count ;         /* total size of the journal. can change over time  */
  46.   __u32 s_journal_max_batch ;           /* max number of blocks to batch into a trans */
  47.   __u32 s_journal_max_commit_age ;      /* in seconds, how old can an async commit be */
  48.   __u32 s_journal_max_trans_age ;       /* in seconds, how old can a transaction be */
  49.   __u16 s_blocksize;                    /* block size           */
  50.   __u16 s_oid_maxsize; /* max size of object id array, see get_objectid() commentary  */
  51.   __u16 s_oid_cursize; /* current size of object id array */
  52.   __u16 s_state;                        /* valid or error       */
  53.   char s_magic[12];                     /* reiserfs magic string indicates that file system is reiserfs */
  54.   __u32 s_hash_function_code; /* indicate, what hash function is being use to sort names in a directory*/
  55.   __u16 s_tree_height;                  /* height of disk tree */
  56.   __u16 s_bmap_nr;                      /* amount of bitmap blocks needed to address each block of file system */
  57.   __u16 s_version; /* I'd prefer it if this was a string,
  58.                                    something like "3.6.4", and maybe
  59.                                    16 bytes long mostly unused. We
  60.                                    don't need to save bytes in the
  61.                                    superblock. -Hans */
  62.   __u16 s_reserved;
  63.   __u32 s_inode_generation;
  64.   char s_unused[124] ; /* zero filled by mkreiserfs */
  65. } __attribute__ ((__packed__));
  67. #define SB_SIZE (sizeof(struct reiserfs_super_block))
  68. /* struct reiserfs_super_block accessors/mutators
  69.  * since this is a disk structure, it will always be in 
  70.  * little endian format. */
  71. #define sb_block_count(sbp)           (le32_to_cpu((sbp)->s_block_count))
  72. #define set_sb_block_count(sbp,v)     ((sbp)->s_block_count = cpu_to_le32(v))
  73. #define sb_free_blocks(sbp)           (le32_to_cpu((sbp)->s_free_blocks))
  74. #define set_sb_free_blocks(sbp,v)     ((sbp)->s_free_blocks = cpu_to_le32(v))
  75. #define sb_root_block(sbp)            (le32_to_cpu((sbp)->s_root_block))
  76. #define set_sb_root_block(sbp,v)      ((sbp)->s_root_block = cpu_to_le32(v))
  77. #define sb_journal_block(sbp)         (le32_to_cpu((sbp)->s_journal_block))
  78. #define set_sb_journal_block(sbp,v)   ((sbp)->s_journal_block = cpu_to_le32(v))
  79. #define sb_journal_dev(sbp)           (le32_to_cpu((sbp)->s_journal_dev))
  80. #define set_sb_journal_dev(sbp,v)     ((sbp)->s_journal_dev = cpu_to_le32(v))
  81. #define sb_orig_journal_size(sbp)   (le32_to_cpu((sbp)->s_orig_journal_size))
  82. #define set_sb_orig_journal_size(sbp,v) 
  83.                             ((sbp)->s_orig_journal_size = cpu_to_le32(v))
  84. #define sb_journal_trans_max(sbp)     (le32_to_cpu((sbp)->s_journal_trans_max))
  85. #define set_journal_trans_max(sbp,v) 
  86.                             ((sbp)->s_journal_trans_max = cpu_to_le32(v))
  87. #define sb_journal_block_count(sbp)  (le32_to_cpu((sbp)->journal_block_count))
  88. #define sb_set_journal_block_count(sbp,v) 
  89.                             ((sbp)->s_journal_block_count = cpu_to_le32(v))
  90. #define sb_journal_max_batch(sbp)     (le32_to_cpu((sbp)->s_journal_max_batch))
  91. #define set_sb_journal_max_batch(sbp,v) 
  92.                             ((sbp)->s_journal_max_batch = cpu_to_le32(v))
  93. #define sb_jourmal_max_commit_age(sbp) 
  94.                             (le32_to_cpu((sbp)->s_journal_max_commit_age))
  95. #define set_sb_journal_max_commit_age(sbp,v) 
  96.                             ((sbp)->s_journal_max_commit_age = cpu_to_le32(v))
  97. #define sb_jourmal_max_trans_age(sbp) 
  98.                             (le32_to_cpu((sbp)->s_journal_max_trans_age))
  99. #define set_sb_journal_max_trans_age(sbp,v) 
  100.                             ((sbp)->s_journal_max_trans_age = cpu_to_le32(v))
  101. #define sb_blocksize(sbp)             (le16_to_cpu((sbp)->s_blocksize))
  102. #define set_sb_blocksize(sbp,v)       ((sbp)->s_blocksize = cpu_to_le16(v))
  103. #define sb_oid_maxsize(sbp)           (le16_to_cpu((sbp)->s_oid_maxsize))
  104. #define set_sb_oid_maxsize(sbp,v)     ((sbp)->s_oid_maxsize = cpu_to_le16(v))
  105. #define sb_oid_cursize(sbp)           (le16_to_cpu((sbp)->s_oid_cursize))
  106. #define set_sb_oid_cursize(sbp,v)     ((sbp)->s_oid_cursize = cpu_to_le16(v))
  107. #define sb_state(sbp)                 (le16_to_cpu((sbp)->s_state))
  108. #define set_sb_state(sbp,v)           ((sbp)->s_state = cpu_to_le16(v))
  109. #define sb_hash_function_code(sbp) 
  110.                             (le32_to_cpu((sbp)->s_hash_function_code))
  111. #define set_sb_hash_function_code(sbp,v) 
  112.                             ((sbp)->s_hash_function_code = cpu_to_le32(v))
  113. #define sb_tree_height(sbp)           (le16_to_cpu((sbp)->s_tree_height))
  114. #define set_sb_tree_height(sbp,v)     ((sbp)->s_tree_height = cpu_to_le16(v))
  115. #define sb_bmap_nr(sbp)               (le16_to_cpu((sbp)->s_bmap_nr))
  116. #define set_sb_bmap_nr(sbp,v)         ((sbp)->s_bmap_nr = cpu_to_le16(v))
  117. #define sb_version(sbp)               (le16_to_cpu((sbp)->s_version))
  118. #define set_sb_version(sbp,v)         ((sbp)->s_version = cpu_to_le16(v))
  120. /* this is the super from 3.5.X, where X >= 10 */
  121. struct reiserfs_super_block_v1
  122. {
  123.   __u32 s_block_count; /* blocks count         */
  124.   __u32 s_free_blocks;                  /* free blocks count    */
  125.   __u32 s_root_block;            /* root block number    */
  126.   __u32 s_journal_block;            /* journal block number    */
  127.   __u32 s_journal_dev;            /* journal device number  */
  128.   __u32 s_orig_journal_size;  /* size of the journal on FS creation.  used to make sure they don't overflow it */
  129.   __u32 s_journal_trans_max ;           /* max number of blocks in a transaction.  */
  130.   __u32 s_journal_block_count ;         /* total size of the journal. can change over time  */
  131.   __u32 s_journal_max_batch ;           /* max number of blocks to batch into a trans */
  132.   __u32 s_journal_max_commit_age ;      /* in seconds, how old can an async commit be */
  133.   __u32 s_journal_max_trans_age ;       /* in seconds, how old can a transaction be */
  134.   __u16 s_blocksize;                    /* block size           */
  135.   __u16 s_oid_maxsize; /* max size of object id array, see get_objectid() commentary  */
  136.   __u16 s_oid_cursize; /* current size of object id array */
  137.   __u16 s_state;                        /* valid or error       */
  138.   char s_magic[16];                     /* reiserfs magic string indicates that file system is reiserfs */
  139.   __u16 s_tree_height;                  /* height of disk tree */
  140.   __u16 s_bmap_nr;                      /* amount of bitmap blocks needed to address each block of file system */
  141.   __u32 s_reserved;
  142. } __attribute__ ((__packed__));
  144. #define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1))
  146. /* LOGGING -- */
  148. /* These all interelate for performance.  
  149. **
  150. ** If the journal block count is smaller than n transactions, you lose speed. 
  151. ** I don't know what n is yet, I'm guessing 8-16.
  152. **
  153. ** typical transaction size depends on the application, how often fsync is
  154. ** called, and how many metadata blocks you dirty in a 30 second period.  
  155. ** The more small files (<16k) you use, the larger your transactions will
  156. ** be.
  157. ** 
  158. ** If your journal fills faster than dirty buffers get flushed to disk, it must flush them before allowing the journal
  159. ** to wrap, which slows things down.  If you need high speed meta data updates, the journal should be big enough
  160. ** to prevent wrapping before dirty meta blocks get to disk.
  161. **
  162. ** If the batch max is smaller than the transaction max, you'll waste space at the end of the journal
  163. ** because journal_end sets the next transaction to start at 0 if the next transaction has any chance of wrapping.
  164. **
  165. ** The large the batch max age, the better the speed, and the more meta data changes you'll lose after a crash.
  166. **
  167. */
  169. /* don't mess with these for a while */
  170. /* we have a node size define somewhere in reiserfs_fs.h. -Hans */
  171. #define JOURNAL_BLOCK_SIZE  4096 /* BUG gotta get rid of this */
  172. #define JOURNAL_MAX_CNODE   1500 /* max cnodes to allocate. */
  173. #define JOURNAL_TRANS_MAX 1024   /* biggest possible single transaction, don't change for now (8/3/99) */
  174. #define JOURNAL_HASH_SIZE 8192   
  175. #define JOURNAL_NUM_BITMAPS 5 /* number of copies of the bitmaps to have floating.  Must be >= 2 */
  176. #define JOURNAL_LIST_COUNT 64
  178. /* these are bh_state bit flag offset numbers, for use in the buffer head */
  180. #define BH_JDirty       16      /* journal data needs to be written before buffer can be marked dirty */
  181. #define BH_JDirty_wait 18 /* commit is done, buffer marked dirty */
  182. #define BH_JNew 19 /* buffer allocated during this transaction, no need to write if freed during this trans too */
  184. /* ugly.  metadata blocks must be prepared before they can be logged.  
  185. ** prepared means unlocked and cleaned.  If the block is prepared, but not
  186. ** logged for some reason, any bits cleared while preparing it must be 
  187. ** set again.
  188. */
  189. #define BH_JPrepared 20 /* block has been prepared for the log */
  190. #define BH_JRestore_dirty 22    /* restore the dirty bit later */
  192. /* One of these for every block in every transaction
  193. ** Each one is in two hash tables.  First, a hash of the current transaction, and after journal_end, a
  194. ** hash of all the in memory transactions.
  195. ** next and prev are used by the current transaction (journal_hash).
  196. ** hnext and hprev are used by journal_list_hash.  If a block is in more than one transaction, the journal_list_hash
  197. ** links it in multiple times.  This allows flush_journal_list to remove just the cnode belonging
  198. ** to a given transaction.
  199. */
  200. struct reiserfs_journal_cnode {
  201.   struct buffer_head *bh ;  /* real buffer head */
  202.   kdev_t dev ;  /* dev of real buffer head */
  203.   unsigned long blocknr ;  /* block number of real buffer head, == 0 when buffer on disk */  
  204.   long state ;
  205.   struct reiserfs_journal_list *jlist ;  /* journal list this cnode lives in */
  206.   struct reiserfs_journal_cnode *next ;  /* next in transaction list */
  207.   struct reiserfs_journal_cnode *prev ;  /* prev in transaction list */
  208.   struct reiserfs_journal_cnode *hprev ; /* prev in hash list */
  209.   struct reiserfs_journal_cnode *hnext ; /* next in hash list */
  210. };
  212. struct reiserfs_bitmap_node {
  213.   int id ;
  214.   char *data ;
  215.   struct list_head list ;
  216. } ;
  218. struct reiserfs_list_bitmap {
  219.   struct reiserfs_journal_list *journal_list ;
  220.   struct reiserfs_bitmap_node **bitmaps ;
  221. } ;
  223. /*
  224. ** transaction handle which is passed around for all journal calls
  225. */
  226. struct reiserfs_transaction_handle {
  227. /* ifdef it. -Hans */
  228.   char *t_caller ;              /* debugging use */
  229.   int t_blocks_logged ;         /* number of blocks this writer has logged */
  230.   int t_blocks_allocated ;      /* number of blocks this writer allocated */
  231.   unsigned long t_trans_id ;    /* sanity check, equals the current trans id */
  232.   struct super_block *t_super ; /* super for this FS when journal_begin was 
  233.                                    called. saves calls to reiserfs_get_super */
  234. } ;
  236. /*
  237. ** one of these for each transaction.  The most important part here is the j_realblock.
  238. ** this list of cnodes is used to hash all the blocks in all the commits, to mark all the
  239. ** real buffer heads dirty once all the commits hit the disk,
  240. ** and to make sure every real block in a transaction is on disk before allowing the log area
  241. ** to be overwritten */
  242. struct reiserfs_journal_list {
  243.   unsigned long j_start ;
  244.   unsigned long j_len ;
  245.   atomic_t j_nonzerolen ;
  246.   atomic_t j_commit_left ;
  247.   atomic_t j_flushing ;
  248.   atomic_t j_commit_flushing ;
  249.   atomic_t j_older_commits_done ;      /* all commits older than this on disk*/
  250.   unsigned long j_trans_id ;
  251.   time_t j_timestamp ;
  252.   struct reiserfs_list_bitmap *j_list_bitmap ;
  253.   struct buffer_head *j_commit_bh ; /* commit buffer head */
  254.   struct reiserfs_journal_cnode *j_realblock  ;
  255.   struct reiserfs_journal_cnode *j_freedlist ; /* list of buffers that were freed during this trans.  free each of these on flush */
  256.   wait_queue_head_t j_commit_wait ; /* wait for all the commit blocks to be flushed */
  257.   wait_queue_head_t j_flush_wait ; /* wait for all the real blocks to be flushed */
  258. } ;
  260. struct reiserfs_page_list  ; /* defined in reiserfs_fs.h */
  262. struct reiserfs_journal {
  263.   struct buffer_head ** j_ap_blocks ; /* journal blocks on disk */
  264.   struct reiserfs_journal_cnode *j_last ; /* newest journal block */
  265.   struct reiserfs_journal_cnode *j_first ; /*  oldest journal block.  start here for traverse */
  267.   long j_state ;
  268.   unsigned long j_trans_id ;
  269.   unsigned long j_mount_id ;
  270.   unsigned long j_start ;             /* start of current waiting commit (index into j_ap_blocks) */
  271.   unsigned long j_len ;               /* lenght of current waiting commit */
  272.   unsigned long j_len_alloc ;         /* number of buffers requested by journal_begin() */
  273.   atomic_t j_wcount ;            /* count of writers for current commit */
  274.   unsigned long j_bcount ;            /* batch count. allows turning X transactions into 1 */
  275.   unsigned long j_first_unflushed_offset ;  /* first unflushed transactions offset */
  276.   unsigned long j_last_flush_trans_id ;    /* last fully flushed journal timestamp */
  277.   struct buffer_head *j_header_bh ;   
  279.   /* j_flush_pages must be flushed before the current transaction can
  280.   ** commit
  281.   */
  282.   struct reiserfs_page_list *j_flush_pages ;
  283.   time_t j_trans_start_time ;         /* time this transaction started */
  284.   wait_queue_head_t j_wait ;         /* wait  journal_end to finish I/O */
  285.   atomic_t j_wlock ;                       /* lock for j_wait */
  286.   wait_queue_head_t j_join_wait ;    /* wait for current transaction to finish before starting new one */
  287.   atomic_t j_jlock ;                       /* lock for j_join_wait */
  288.   int j_journal_list_index ;       /* journal list number of the current trans */
  289.   int j_list_bitmap_index ;       /* number of next list bitmap to use */
  290.   int j_must_wait ;        /* no more journal begins allowed. MUST sleep on j_join_wait */
  291.   int j_next_full_flush ;             /* next journal_end will flush all journal list */
  292.   int j_next_async_flush ;             /* next journal_end will flush all async commits */
  294.   int j_cnode_used ;       /* number of cnodes on the used list */
  295.   int j_cnode_free ;          /* number of cnodes on the free list */
  297.   struct reiserfs_journal_cnode *j_cnode_free_list ;
  298.   struct reiserfs_journal_cnode *j_cnode_free_orig ; /* orig pointer returned from vmalloc */
  300.   int j_free_bitmap_nodes ;
  301.   int j_used_bitmap_nodes ;
  302.   struct list_head j_bitmap_nodes ;
  303.   struct inode j_dummy_inode ;
  304.   struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS] ; /* array of bitmaps to record the deleted blocks */
  305.   struct reiserfs_journal_list j_journal_list[JOURNAL_LIST_COUNT] ;     /* array of all the journal lists */
  306.   struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE] ;      /* hash table for real buffer heads in current trans */ 
  307.   struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE] ; /* hash table for all the real buffer heads in all 
  308.    the transactions */
  309.   struct list_head j_prealloc_list;     /* list of inodes which have preallocated blocks */
  310. };
  312. #define JOURNAL_DESC_MAGIC "ReIsErLB" /* ick.  magic string to find desc blocks in the journal */
  315. typedef __u32 (*hashf_t) (const signed char *, int);
  317. struct proc_dir_entry;
  319. #if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
  320. typedef unsigned long int stat_cnt_t;
  321. typedef struct reiserfs_proc_info_data
  322. {
  323.   spinlock_t lock;
  324.   int exiting;
  325.   int max_hash_collisions;
  327.   stat_cnt_t breads;
  328.   stat_cnt_t bread_miss;
  329.   stat_cnt_t search_by_key;
  330.   stat_cnt_t search_by_key_fs_changed;
  331.   stat_cnt_t search_by_key_restarted;
  333.   stat_cnt_t leaked_oid;
  334.   stat_cnt_t leaves_removable;
  336.   /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */
  337.   stat_cnt_t balance_at[ 5 ]; /* XXX */
  338.   /* sbk == search_by_key */
  339.   stat_cnt_t sbk_read_at[ 5 ]; /* XXX */
  340.   stat_cnt_t sbk_fs_changed[ 5 ];
  341.   stat_cnt_t sbk_restarted[ 5 ];
  342.   stat_cnt_t items_at[ 5 ]; /* XXX */
  343.   stat_cnt_t free_at[ 5 ]; /* XXX */
  344.   stat_cnt_t can_node_be_removed[ 5 ]; /* XXX */
  345.   long int lnum[ 5 ]; /* XXX */
  346.   long int rnum[ 5 ]; /* XXX */
  347.   long int lbytes[ 5 ]; /* XXX */
  348.   long int rbytes[ 5 ]; /* XXX */
  349.   stat_cnt_t get_neighbors[ 5 ];
  350.   stat_cnt_t get_neighbors_restart[ 5 ];
  351.   stat_cnt_t need_l_neighbor[ 5 ];
  352.   stat_cnt_t need_r_neighbor[ 5 ];
  354.   stat_cnt_t free_block;
  355.   struct __find_forward_stats {
  356. stat_cnt_t call;
  357. stat_cnt_t wait;
  358. stat_cnt_t bmap;
  359. stat_cnt_t retry;
  360. stat_cnt_t in_journal_hint;
  361. stat_cnt_t in_journal_out;
  362.   } find_forward;
  363.   struct __journal_stats {
  364. stat_cnt_t in_journal;
  365. stat_cnt_t in_journal_bitmap;
  366. stat_cnt_t in_journal_reusable;
  367. stat_cnt_t lock_journal;
  368. stat_cnt_t lock_journal_wait;
  369. stat_cnt_t journal_being;
  370. stat_cnt_t journal_relock_writers;
  371. stat_cnt_t journal_relock_wcount;
  372. stat_cnt_t mark_dirty;
  373. stat_cnt_t mark_dirty_already;
  374. stat_cnt_t mark_dirty_notjournal;
  375. stat_cnt_t restore_prepared;
  376. stat_cnt_t prepare;
  377. stat_cnt_t prepare_retry;
  378.   } journal;
  379. } reiserfs_proc_info_data_t;
  380. #else
  381. typedef struct reiserfs_proc_info_data
  382. {} reiserfs_proc_info_data_t;
  383. #endif
  385. /* reiserfs union of in-core super block data */
  386. struct reiserfs_sb_info
  387. {
  388.     struct buffer_head * s_sbh;                   /* Buffer containing the super block */
  389. /* both the comment and the choice of
  390.                                    name are unclear for s_rs -Hans */
  391.     struct reiserfs_super_block * s_rs;           /* Pointer to the super block in the buffer */
  392.     struct buffer_head ** s_ap_bitmap;       /* array of buffers, holding block bitmap */
  393.     struct reiserfs_journal *s_journal ; /* pointer to journal information */
  394.     unsigned short s_mount_state;                 /* reiserfs state (valid, invalid) */
  395.   
  396. /* Comment? -Hans */
  397.     void (*end_io_handler)(struct buffer_head *, int);
  398.     hashf_t s_hash_function; /* pointer to function which is used
  399.                                    to sort names in directory. Set on
  400.                                    mount */
  401.     unsigned long s_mount_opt; /* reiserfs's mount options are set
  402.                                    here (currently - NOTAIL, NOLOG,
  403.                                    REPLAYONLY) */
  405. /* Comment? -Hans */
  406.     wait_queue_head_t s_wait;
  407. /* To be obsoleted soon by per buffer seals.. -Hans */
  408.     atomic_t s_generation_counter; // increased by one every time the
  409.     // tree gets re-balanced
  410.     unsigned long s_properties;    /* File system properties. Currently holds
  411.      on-disk FS format */
  412.     
  413.     /* session statistics */
  414.     int s_kmallocs;
  415.     int s_disk_reads;
  416.     int s_disk_writes;
  417.     int s_fix_nodes;
  418.     int s_do_balance;
  419.     int s_unneeded_left_neighbor;
  420.     int s_good_search_by_key_reada;
  421.     int s_bmaps;
  422.     int s_bmaps_without_search;
  423.     int s_direct2indirect;
  424.     int s_indirect2direct;
  425. /* set up when it's ok for reiserfs_read_inode2() to read from
  426.    disk inode with nlink==0. Currently this is only used during
  427.    finish_unfinished() processing at mount time */
  428.     int s_is_unlinked_ok;
  429.     reiserfs_proc_info_data_t s_proc_info_data;
  430.     struct proc_dir_entry *procdir;
  431. };
  433. /* Definitions of reiserfs on-disk properties: */
  434. #define REISERFS_3_5 0
  435. #define REISERFS_3_6 1
  437. /* Mount options */
  438. #define NOTAIL 0  /* -o notail: no tails will be created in a session */
  439. #define REPLAYONLY 3 /* replay journal and return 0. Use by fsck */
  440. #define REISERFS_NOLOG 4      /* -o nolog: turn journalling off */
  441. #define REISERFS_CONVERT 5    /* -o conv: causes conversion of old
  442.                                  format super block to the new
  443.                                  format. If not specified - old
  444.                                  partition will be dealt with in a
  445.                                  manner of 3.5.x */
  447. /* -o hash={tea, rupasov, r5, detect} is meant for properly mounting 
  448. ** reiserfs disks from 3.5.19 or earlier.  99% of the time, this option
  449. ** is not required.  If the normal autodection code can't determine which
  450. ** hash to use (because both hases had the same value for a file)
  451. ** use this option to force a specific hash.  It won't allow you to override
  452. ** the existing hash on the FS, so if you have a tea hash disk, and mount
  453. ** with -o hash=rupasov, the mount will fail.
  454. */
  455. #define FORCE_TEA_HASH 6      /* try to force tea hash on mount */
  456. #define FORCE_RUPASOV_HASH 7  /* try to force rupasov hash on mount */
  457. #define FORCE_R5_HASH 8       /* try to force rupasov hash on mount */
  458. #define FORCE_HASH_DETECT 9   /* try to detect hash function on mount */
  461. /* used for testing experimental features, makes benchmarking new
  462.    features with and without more convenient, should never be used by
  463.    users in any code shipped to users (ideally) */
  465. #define REISERFS_NO_BORDER 11
  466. #define REISERFS_NO_UNHASHED_RELOCATION 12
  467. #define REISERFS_HASHED_RELOCATION 13
  468. #define REISERFS_TEST4 14 
  470. #define REISERFS_TEST1 11
  471. #define REISERFS_TEST2 12
  472. #define REISERFS_TEST3 13
  473. #define REISERFS_TEST4 14 
  475. #define reiserfs_r5_hash(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << FORCE_R5_HASH))
  476. #define reiserfs_rupasov_hash(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << FORCE_RUPASOV_HASH))
  477. #define reiserfs_tea_hash(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << FORCE_TEA_HASH))
  478. #define reiserfs_hash_detect(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << FORCE_HASH_DETECT))
  479. #define reiserfs_no_border(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << REISERFS_NO_BORDER))
  480. #define reiserfs_no_unhashed_relocation(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << REISERFS_NO_UNHASHED_RELOCATION))
  481. #define reiserfs_hashed_relocation(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << REISERFS_HASHED_RELOCATION))
  482. #define reiserfs_test4(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << REISERFS_TEST4))
  484. #define dont_have_tails(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << NOTAIL))
  485. #define replay_only(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << REPLAYONLY))
  486. #define reiserfs_dont_log(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << REISERFS_NOLOG))
  487. #define old_format_only(s) ((s)->u.reiserfs_sb.s_properties & (1 << REISERFS_3_5))
  488. #define convert_reiserfs(s) ((s)->u.reiserfs_sb.s_mount_opt & (1 << REISERFS_CONVERT))
  491. void reiserfs_file_buffer (struct buffer_head * bh, int list);
  492. int reiserfs_is_super(struct super_block *s)  ;
  493. int journal_mark_dirty(struct reiserfs_transaction_handle *, struct super_block *, struct buffer_head *bh) ;
  494. int flush_old_commits(struct super_block *s, int) ;
  495. int show_reiserfs_locks(void) ;
  496. int reiserfs_resize(struct super_block *, unsigned long) ;
  498. #define CARRY_ON                0
  499. #define SCHEDULE_OCCURRED       1
  502. #define SB_BUFFER_WITH_SB(s) ((s)->u.reiserfs_sb.s_sbh)
  503. #define SB_JOURNAL(s) ((s)->u.reiserfs_sb.s_journal)
  504. #define SB_JOURNAL_LIST(s) (SB_JOURNAL(s)->j_journal_list)
  505. #define SB_JOURNAL_LIST_INDEX(s) (SB_JOURNAL(s)->j_journal_list_index) 
  506. #define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free) 
  507. #define SB_AP_BITMAP(s) ((s)->u.reiserfs_sb.s_ap_bitmap)
  510. // on-disk super block fields converted to cpu form
  511. #define SB_DISK_SUPER_BLOCK(s)        ((s)->u.reiserfs_sb.s_rs)
  512. #define SB_BLOCK_COUNT(s)             sb_block_count (SB_DISK_SUPER_BLOCK(s))
  513. #define SB_FREE_BLOCKS(s)             sb_free_blocks (SB_DISK_SUPER_BLOCK(s))
  514. #define SB_REISERFS_MAGIC(s)          (SB_DISK_SUPER_BLOCK(s)->s_magic)
  515. #define SB_ROOT_BLOCK(s)              sb_root_block (SB_DISK_SUPER_BLOCK(s))
  516. #define SB_TREE_HEIGHT(s)             sb_tree_height (SB_DISK_SUPER_BLOCK(s))
  517. #define SB_REISERFS_STATE(s)          sb_state (SB_DISK_SUPER_BLOCK(s))
  518. #define SB_VERSION(s)                 sb_version (SB_DISK_SUPER_BLOCK(s))
  519. #define SB_BMAP_NR(s)                 sb_bmap_nr(SB_DISK_SUPER_BLOCK(s))
  521. #define PUT_SB_BLOCK_COUNT(s, val)    do { set_sb_block_count( SB_DISK_SUPER_BLOCK(s), val); } while (0)
  522. #define PUT_SB_FREE_BLOCKS(s, val)    do { set_sb_free_blocks( SB_DISK_SUPER_BLOCK(s), val); } while (0)
  523. #define PUT_SB_ROOT_BLOCK(s, val)     do { set_sb_root_block( SB_DISK_SUPER_BLOCK(s), val); } while (0)
  524. #define PUT_SB_TREE_HEIGHT(s, val)    do { set_sb_tree_height( SB_DISK_SUPER_BLOCK(s), val); } while (0)
  525. #define PUT_SB_REISERFS_STATE(s, val) do { set_sb_state( SB_DISK_SUPER_BLOCK(s), val); } while (0) 
  526. #define PUT_SB_VERSION(s, val)        do { set_sb_version( SB_DISK_SUPER_BLOCK(s), val); } while (0)
  527. #define PUT_SB_BMAP_NR(s, val)        do { set_sb_bmap_nr( SB_DISK_SUPER_BLOCK(s), val); } while (0)
  529. #endif /* _LINUX_REISER_FS_SB */