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