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