E-procinfo.patch
Add configuration option to create under /proc/fs/reiserfs
hierarchy of files, displaying various ReiserFS statistics and
internal data on the expense of making your kernel or module
slightly larger (+8K). This also increases amount of kernel memory
required for each mount. Only ReiserFS developers and people
fine-tuning reiserfs or tracing problems should be interested in this.
diff -rup linux-2.4.6/Documentation/Configure.help linux-2.4.6.cleanup/Documentation/Configure.help
--- linux-2.4.6/Documentation/Configure.help Wed Jul 4 13:45:40 2001
+++ linux-2.4.6.cleanup/Documentation/Configure.help Wed Jul 11 19:58:09 2001
@@ -11669,6 +11669,15 @@ CONFIG_REISERFS_CHECK
report, say yes and you might get a useful error message. Almost
everyone should say no.
+Publish some reiserfs-specific info under /proc/fs/reiserfs
+CONFIG_REISERFS_PROC_INFO
+ Create under /proc/fs/reiserfs hierarchy of files, displaying
+ various ReiserFS statistics and internal data on the expense of
+ making your kernel or module slightly larger (+8K). This also increases
+ amount of kernel memory required for each mount. Almost everyone
+ but ReiserFS developers and people fine-tuning reiserfs or tracing
+ problems should say NO.
+
Second extended fs support
CONFIG_EXT2_FS
This is the de facto standard Linux file system (method to organize
diff -rup linux-2.4.6/fs/Config.in linux-2.4.6.cleanup/fs/Config.in
--- linux-2.4.6/fs/Config.in Wed Jul 4 13:45:54 2001
+++ linux-2.4.6.cleanup/fs/Config.in Wed Jul 11 19:58:09 2001
@@ -10,6 +10,7 @@ tristate 'Kernel automounter version 4 s
dep_tristate 'Reiserfs support' CONFIG_REISERFS_FS $CONFIG_EXPERIMENTAL
dep_mbool ' Have reiserfs do extra internal checking' CONFIG_REISERFS_CHECK $CONFIG_REISERFS_FS $CONFIG_EXPERIMENTAL
+dep_mbool ' Stats in /proc/fs/reiserfs' CONFIG_REISERFS_PROC_INFO $CONFIG_REISERFS_FS $CONFIG_EXPERIMENTAL
dep_tristate 'ADFS file system support' CONFIG_ADFS_FS $CONFIG_EXPERIMENTAL
dep_mbool ' ADFS write support (DANGEROUS)' CONFIG_ADFS_FS_RW $CONFIG_ADFS_FS $CONFIG_EXPERIMENTAL
diff -rup linux-2.4.6/fs/reiserfs/Makefile linux-2.4.6.cleanup/fs/reiserfs/Makefile
--- linux-2.4.6/fs/reiserfs/Makefile Mon Jan 15 23:42:32 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/Makefile Wed Jul 11 19:58:09 2001
@@ -9,7 +9,7 @@
O_TARGET := reiserfs.o
obj-y := bitmap.o do_balan.o namei.o inode.o file.o dir.o fix_node.o super.o prints.o objectid.o \
-lbalance.o ibalance.o stree.o hashes.o buffer2.o tail_conversion.o journal.o resize.o tail_conversion.o version.o item_ops.o ioctl.o
+lbalance.o ibalance.o stree.o hashes.o buffer2.o tail_conversion.o journal.o resize.o tail_conversion.o version.o item_ops.o ioctl.o procfs.o
obj-m := $(O_TARGET)
diff -rup linux-2.4.6/fs/reiserfs/bitmap.c linux-2.4.6.cleanup/fs/reiserfs/bitmap.c
--- linux-2.4.6/fs/reiserfs/bitmap.c Wed Jul 11 17:47:37 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/bitmap.c Wed Jul 11 19:58:09 2001
@@ -95,6 +95,8 @@ void reiserfs_free_block (struct reiserf
RFALSE(!s, "vs-4060: trying to free block on nonexistent device");
RFALSE(is_reusable (s, block, 1) == 0, "vs-4070: can not free such block");
+ PROC_INFO_INC( s, free_block );
+
rs = SB_DISK_SUPER_BLOCK (s);
sbh = SB_BUFFER_WITH_SB (s);
apbh = SB_AP_BITMAP (s);
@@ -136,10 +138,14 @@ static int find_forward (struct super_bl
unsigned long block_to_try = 0;
unsigned long next_block_to_try = 0 ;
- for (i = *bmap_nr; i < SB_BMAP_NR (s); i ++, *offset = 0) {
+ PROC_INFO_INC( s, find_forward.call );
+
+ for (i = *bmap_nr; i < SB_BMAP_NR (s); i ++, *offset = 0,
+ PROC_INFO_INC( s, find_forward.bmap )) {
/* get corresponding bitmap block */
bh = SB_AP_BITMAP (s)[i];
if (buffer_locked (bh)) {
+ PROC_INFO_INC( s, find_forward.wait );
__wait_on_buffer (bh);
}
retry:
@@ -174,17 +180,21 @@ retry:
int new_i ;
get_bit_address (s, next_block_to_try, &new_i, offset);
+ PROC_INFO_INC( s, find_forward.in_journal_hint );
+
/* block is not in this bitmap. reset i and continue
** we only reset i if new_i is in a later bitmap.
*/
if (new_i > i) {
i = (new_i - 1 ); /* i gets incremented by the for loop */
+ PROC_INFO_INC( s, find_forward.in_journal_out );
continue ;
}
} else {
/* no suggestion was made, just try the next block */
*offset = j+1 ;
}
+ PROC_INFO_INC( s, find_forward.retry );
goto retry ;
}
}
diff -rup linux-2.4.6/fs/reiserfs/buffer2.c linux-2.4.6.cleanup/fs/reiserfs/buffer2.c
--- linux-2.4.6/fs/reiserfs/buffer2.c Wed Jul 11 19:43:00 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/buffer2.c Wed Jul 11 19:58:09 2001
@@ -16,6 +16,7 @@
#include <linux/locks.h>
#include <linux/reiserfs_fs.h>
#include <linux/smp_lock.h>
+#include <linux/kernel_stat.h>
/*
* wait_buffer_until_released
@@ -63,9 +64,16 @@ void wait_buffer_until_released (const s
block. */
/* The function is NOT SCHEDULE-SAFE! */
-struct buffer_head * reiserfs_bread (kdev_t n_dev, int n_block, int n_size)
+struct buffer_head * reiserfs_bread (struct super_block *super, int n_block, int n_size)
{
- return bread (n_dev, n_block, n_size);
+ struct buffer_head *result;
+ PROC_EXP( unsigned int ctx_switches = kstat.context_swtch );
+
+ result = bread (super -> s_dev, n_block, n_size);
+ PROC_INFO_INC( super, breads );
+ PROC_EXP( if( kstat.context_swtch != ctx_switches )
+ PROC_INFO_INC( super, bread_miss ) );
+ return result;
}
/* This function looks for a buffer which contains a given block. If
diff -rup linux-2.4.6/fs/reiserfs/do_balan.c linux-2.4.6.cleanup/fs/reiserfs/do_balan.c
--- linux-2.4.6/fs/reiserfs/do_balan.c Wed Jul 11 19:43:00 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/do_balan.c Wed Jul 11 19:58:09 2001
@@ -338,6 +338,9 @@ static int balance_leaf (struct tree_bal
tb->insert_size [0]);
}
#endif
+
+ PROC_INFO_INC( tb -> tb_sb, balance_at[ 0 ] );
+
/* Make balance in case insert_size[0] < 0 */
if ( tb->insert_size[0] < 0 )
return balance_leaf_when_delete (tb, flag);
diff -rup linux-2.4.6/fs/reiserfs/fix_node.c linux-2.4.6.cleanup/fs/reiserfs/fix_node.c
--- linux-2.4.6/fs/reiserfs/fix_node.c Wed Jul 11 17:47:37 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/fix_node.c Wed Jul 11 19:58:09 2001
@@ -575,6 +575,11 @@ static void set_parameters (struct tree_
tb->lbytes = lb;
tb->rbytes = rb;
}
+ PROC_INFO_ADD( tb -> tb_sb, lnum[ h ], lnum );
+ PROC_INFO_ADD( tb -> tb_sb, rnum[ h ], rnum );
+
+ PROC_INFO_ADD( tb -> tb_sb, lbytes[ h ], lb );
+ PROC_INFO_ADD( tb -> tb_sb, rbytes[ h ], rb );
}
@@ -667,6 +672,7 @@ static int are_leaves_removable (struct
if (MAX_CHILD_SIZE (S0) + vn->vn_size <= rfree + lfree + ih_size) {
set_parameters (tb, 0, -1, -1, -1, NULL, -1, -1);
+ PROC_INFO_INC( tb -> tb_sb, leaves_removable );
return 1;
}
return 0;
@@ -1179,6 +1185,7 @@ static inline int can_node_be_removed (i
return NO_BALANCING_NEEDED;
}
}
+ PROC_INFO_INC( tb -> tb_sb, can_node_be_removed[ h ] );
return !NO_BALANCING_NEEDED;
}
@@ -1916,8 +1923,11 @@ static int get_neighbors(
struct buffer_head * p_s_bh;
+ PROC_INFO_INC( p_s_sb, get_neighbors[ n_h ] );
+
if ( p_s_tb->lnum[n_h] ) {
/* We need left neighbor to balance S[n_h]. */
+ PROC_INFO_INC( p_s_sb, need_l_neighbor[ n_h ] );
p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
RFALSE( p_s_bh == p_s_tb->FL[n_h] &&
@@ -1926,11 +1936,12 @@ static int get_neighbors(
n_child_position = ( p_s_bh == p_s_tb->FL[n_h] ) ? p_s_tb->lkey[n_h] : B_NR_ITEMS (p_s_tb->FL[n_h]);
n_son_number = B_N_CHILD_NUM(p_s_tb->FL[n_h], n_child_position);
- p_s_bh = reiserfs_bread(p_s_sb->s_dev, n_son_number, p_s_sb->s_blocksize);
+ p_s_bh = reiserfs_bread(p_s_sb, n_son_number, p_s_sb->s_blocksize);
if (!p_s_bh)
return IO_ERROR;
if ( FILESYSTEM_CHANGED_TB (p_s_tb) ) {
decrement_bcount(p_s_bh);
+ PROC_INFO_INC( p_s_sb, get_neighbors_restart[ n_h ] );
return REPEAT_SEARCH;
}
@@ -1949,6 +1960,7 @@ static int get_neighbors(
if ( p_s_tb->rnum[n_h] ) { /* We need right neighbor to balance S[n_path_offset]. */
+ PROC_INFO_INC( p_s_sb, need_r_neighbor[ n_h ] );
p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
RFALSE( p_s_bh == p_s_tb->FR[n_h] &&
@@ -1957,11 +1969,12 @@ static int get_neighbors(
n_child_position = ( p_s_bh == p_s_tb->FR[n_h] ) ? p_s_tb->rkey[n_h] + 1 : 0;
n_son_number = B_N_CHILD_NUM(p_s_tb->FR[n_h], n_child_position);
- p_s_bh = reiserfs_bread(p_s_sb->s_dev, n_son_number, p_s_sb->s_blocksize);
+ p_s_bh = reiserfs_bread(p_s_sb, n_son_number, p_s_sb->s_blocksize);
if (!p_s_bh)
return IO_ERROR;
if ( FILESYSTEM_CHANGED_TB (p_s_tb) ) {
decrement_bcount(p_s_bh);
+ PROC_INFO_INC( p_s_sb, get_neighbors_restart[ n_h ] );
return REPEAT_SEARCH;
}
decrement_bcount(p_s_tb->R[n_h]);
@@ -2302,6 +2315,8 @@ int fix_nodes (int n_op_mode,
int wait_tb_buffers_run = 0 ;
int windex ;
struct buffer_head * p_s_tbS0 = PATH_PLAST_BUFFER(p_s_tb->tb_path);
+
+ ++ p_s_tb -> tb_sb -> u.reiserfs_sb.s_fix_nodes;
n_pos_in_item = p_s_tb->tb_path->pos_in_item;
diff -rup linux-2.4.6/fs/reiserfs/ibalance.c linux-2.4.6.cleanup/fs/reiserfs/ibalance.c
--- linux-2.4.6/fs/reiserfs/ibalance.c Wed Jul 11 19:43:00 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/ibalance.c Wed Jul 11 19:58:09 2001
@@ -754,6 +754,8 @@ int balance_internal (struct tree_balanc
RFALSE( h < 1, "h (%d) can not be < 1 on internal level", h);
+ PROC_INFO_INC( tb -> tb_sb, balance_at[ h ] );
+
order = ( tbSh ) ? PATH_H_POSITION (tb->tb_path, h + 1)/*tb->S[h]->b_item_order*/ : 0;
/* Using insert_size[h] calculate the number insert_num of items
diff -rup linux-2.4.6/fs/reiserfs/journal.c linux-2.4.6.cleanup/fs/reiserfs/journal.c
--- linux-2.4.6/fs/reiserfs/journal.c Wed Jul 11 19:43:00 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/journal.c Wed Jul 11 19:59:18 2001
@@ -524,12 +524,14 @@ int reiserfs_in_journal(struct super_blo
return 0 ;
}
+ PROC_INFO_INC( p_s_sb, journal.in_journal );
/* If we aren't doing a search_all, this is a metablock, and it will be logged before use.
** if we crash before the transaction that freed it commits, this transaction won't
** have committed either, and the block will never be written
*/
if (search_all) {
for (i = 0 ; i < JOURNAL_NUM_BITMAPS ; i++) {
+ PROC_INFO_INC( p_s_sb, journal.in_journal_bitmap );
jb = SB_JOURNAL(p_s_sb)->j_list_bitmap + i ;
if (jb->journal_list && jb->bitmaps[bmap_nr] &&
test_bit(bit_nr, jb->bitmaps[bmap_nr]->data)) {
@@ -552,6 +554,7 @@ int reiserfs_in_journal(struct super_blo
return 1;
}
+ PROC_INFO_INC( p_s_sb, journal.in_journal_reusable );
/* safe for reuse */
return 0 ;
}
@@ -572,7 +575,9 @@ inline void insert_journal_hash(struct r
/* lock the current transaction */
inline static void lock_journal(struct super_block *p_s_sb) {
+ PROC_INFO_INC( p_s_sb, journal.lock_journal );
while(atomic_read(&(SB_JOURNAL(p_s_sb)->j_wlock)) > 0) {
+ PROC_INFO_INC( p_s_sb, journal.lock_journal_wait );
sleep_on(&(SB_JOURNAL(p_s_sb)->j_wait)) ;
}
atomic_set(&(SB_JOURNAL(p_s_sb)->j_wlock), 1) ;
@@ -1995,6 +2000,7 @@ static int do_journal_begin_r(struct rei
th->t_super = p_s_sb ; /* others will check this for the don't log flag */
return 0 ;
}
+ PROC_INFO_INC( p_s_sb, journal.journal_being );
relock:
lock_journal(p_s_sb) ;
@@ -2002,6 +2008,7 @@ relock:
if (test_bit(WRITERS_BLOCKED, &SB_JOURNAL(p_s_sb)->j_state)) {
unlock_journal(p_s_sb) ;
reiserfs_wait_on_write_block(p_s_sb) ;
+ PROC_INFO_INC( p_s_sb, journal.journal_relock_writers );
goto relock ;
}
@@ -2040,6 +2047,7 @@ relock:
sleep_on(&(SB_JOURNAL(p_s_sb)->j_join_wait)) ;
}
}
+ PROC_INFO_INC( p_s_sb, journal.journal_relock_wcount );
goto relock ;
}
@@ -2086,6 +2094,7 @@ int journal_mark_dirty(struct reiserfs_t
int count_already_incd = 0 ;
int prepared = 0 ;
+ PROC_INFO_INC( p_s_sb, journal.mark_dirty );
if (reiserfs_dont_log(th->t_super)) {
mark_buffer_dirty(bh) ;
return 0 ;
@@ -2100,6 +2109,7 @@ int journal_mark_dirty(struct reiserfs_t
prepared = test_and_clear_bit(BH_JPrepared, &bh->b_state) ;
/* already in this transaction, we are done */
if (buffer_journaled(bh)) {
+ PROC_INFO_INC( p_s_sb, journal.mark_dirty_already );
return 0 ;
}
@@ -2129,6 +2139,7 @@ int journal_mark_dirty(struct reiserfs_t
if (buffer_journal_dirty(bh)) {
count_already_incd = 1 ;
+ PROC_INFO_INC( p_s_sb, journal.mark_dirty_notjournal );
mark_buffer_notjournal_dirty(bh) ;
}
@@ -2597,6 +2608,7 @@ int journal_mark_freed(struct reiserfs_t
void reiserfs_restore_prepared_buffer(struct super_block *p_s_sb,
struct buffer_head *bh) {
+ PROC_INFO_INC( p_s_sb, journal.restore_prepared );
if (reiserfs_dont_log (p_s_sb))
return;
@@ -2618,6 +2630,7 @@ void reiserfs_prepare_for_journal(struct
struct buffer_head *bh, int wait) {
int retry_count = 0 ;
+ PROC_INFO_INC( p_s_sb, journal.prepare );
if (reiserfs_dont_log (p_s_sb))
return;
@@ -2633,6 +2646,7 @@ void reiserfs_prepare_for_journal(struct
"waiting while do_balance was running\n") ;
wait_on_buffer(bh) ;
}
+ PROC_INFO_INC( p_s_sb, journal.prepare_retry );
retry_count++ ;
}
}
diff -rup linux-2.4.6/fs/reiserfs/namei.c linux-2.4.6.cleanup/fs/reiserfs/namei.c
--- linux-2.4.6/fs/reiserfs/namei.c Wed Jul 11 19:43:00 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/namei.c Wed Jul 11 20:00:59 2001
@@ -480,6 +480,9 @@ static int reiserfs_add_entry (struct re
deh->deh_offset = cpu_to_le32 (SET_GENERATION_NUMBER (deh_offset (deh), gen_number));
set_cpu_key_k_offset (&entry_key, le32_to_cpu (deh->deh_offset));
+ /* update max-hash-collisions counter in reiserfs_sb_info */
+ PROC_INFO_MAX( th -> t_super, max_hash_collisions, gen_number );
+
if (gen_number != 0) { /* we need to re-search for the insertion point */
if (search_by_entry_key (dir->i_sb, &entry_key, &path, &de) != NAME_NOT_FOUND) {
reiserfs_warning ("vs-7032: reiserfs_add_entry: "
diff -rup linux-2.4.6/fs/reiserfs/objectid.c linux-2.4.6.cleanup/fs/reiserfs/objectid.c
--- linux-2.4.6/fs/reiserfs/objectid.c Wed Jul 11 19:43:00 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/objectid.c Wed Jul 11 19:58:09 2001
@@ -145,9 +145,11 @@ void reiserfs_release_objectid (struct r
return;
}
- if (rs->s_oid_cursize == rs->s_oid_maxsize)
+ if (rs->s_oid_cursize == rs->s_oid_maxsize) {
/* objectid map must be expanded, but there is no space */
+ PROC_INFO_INC( s, leaked_oid );
return;
+ }
/* expand the objectid map*/
memmove (map + i + 3, map + i + 1,
diff -rup linux-2.4.6/fs/reiserfs/prints.c linux-2.4.6.cleanup/fs/reiserfs/prints.c
--- linux-2.4.6/fs/reiserfs/prints.c Tue Jul 10 20:26:53 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/prints.c Wed Jul 11 19:58:09 2001
@@ -527,7 +527,7 @@ static int print_super_block (struct buf
printk ("Filesystem state %s\n",
(le16_to_cpu (rs->s_state) == REISERFS_VALID_FS) ? "VALID" : "ERROR");
printk ("Hash function \"%s\"\n", le16_to_cpu (rs->s_hash_function_code) == TEA_HASH ? "tea" :
- ((le16_to_cpu (rs->s_hash_function_code) == YURA_HASH) ? "rupasov" : "unknown"));
+ ( le16_to_cpu (rs->s_hash_function_code) == YURA_HASH ? "rupasov" : (le16_to_cpu (rs->s_hash_function_code) == R5_HASH ? "r5" : "unknown")));
#if 0
__u32 s_journal_trans_max ; /* max number of blocks in a transaction. */
diff -rup linux-2.4.6/fs/reiserfs/procfs.c linux-2.4.6.cleanup/fs/reiserfs/procfs.c
--- linux-2.4.6/fs/reiserfs/procfs.c Wed Jul 11 19:43:00 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/procfs.c Wed Jul 11 20:02:53 2001
@@ -0,0 +1,727 @@
+/* -*- linux-c -*- */
+
+/* fs/reiserfs/procfs.c */
+
+/*
+ * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README
+ */
+
+/* proc info support a la one created by
[email protected] for PGC */
+
+/* $Id: procfs.c,v 1.1.8.2 2001/07/15 17:08:42 god Exp $ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/sched.h>
+#include <asm/uaccess.h>
+#include <linux/reiserfs_fs.h>
+#include <linux/smp_lock.h>
+#include <linux/locks.h>
+#include <linux/init.h>
+#include <linux/proc_fs.h>
+
+#if defined( REISERFS_PROC_INFO )
+
+/*
+ * LOCKING:
+ *
+ * reiserfs_proc_info_data_t part of reiserfs super-block is protected
+ * by spinlock_t field .lock. Each procinfo display function acting on
+ * super-block, first takes this lock, then searches though list of all
+ * super-blocks (super_blocks), until current super-block is found. If
+ * it is not, or current super-block .exiting field is set, spinlock is
+ * released and operation aborted. Otherwise, data are stuffed into page
+ * and spinlock released. .exiting field is set up in
+ * reiserfs_proc_info_done() called from reiserfs_put_super() under
+ * spinlock.
+ *
+ * This all is against proc vs. umount races pointed out by Al Viro
+ * at fsdevel.
+ *
+ */
+
+/** implements locking logic described above. */
+static struct super_block *procinfo_prologue( kdev_t dev )
+{
+ struct super_block *result;
+
+ result = NULL;
+ result = get_super( dev );
+ if( result != NULL ) {
+ if( !reiserfs_is_super( result ) )
+ result = NULL;
+ else {
+ spin_lock( & __PINFO( result ).lock );
+ if( __PINFO( result ).exiting ) {
+ result = NULL;
+ spin_unlock( & __PINFO( result ).lock );
+ }
+ }
+ }
+ if( result == NULL )
+ printk( KERN_DEBUG "reiserfs: procfs-74: "
+ "race between procinfo and umount\n" );
+ return result;
+}
+
+int procinfo_epilogue( struct super_block *super )
+{
+ spin_unlock( & __PINFO( super ).lock );
+ return 0;
+}
+
+int reiserfs_proc_tail( int len, char *buffer, char **start,
+ off_t offset, int count, int *eof )
+{
+ /* this is black procfs magic */
+ if( offset >= len ) {
+ *start = buffer;
+ *eof = 1;
+ return 0;
+ }
+ *start = buffer + offset;
+ if( ( len -= offset ) > count ) {
+ return count;
+ }
+ *eof = 1;
+ return len;
+}
+
+int reiserfs_version_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{
+ int len = 0;
+ struct super_block *sb;
+
+ sb = procinfo_prologue( ( kdev_t ) ( int ) data );
+ if( sb == NULL )
+ return -ENOENT;
+ len += sprintf( &buffer[ len ], "%s format\twith checks %s\n",
+ old_format_only( sb ) ? "old" : "new",
+#if defined( CONFIG_REISERFS_CHECK )
+ "on"
+#else
+ "off"
+#endif
+ );
+ procinfo_epilogue( sb );
+ return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
+}
+
+int reiserfs_global_version_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{
+ int len = 0;
+
+ len += sprintf( &buffer[ len ], "%s [%s]\n",
+ reiserfs_get_version_string(),
+#if defined( CONFIG_REISERFS_FS_MODULE )
+ "as module"
+#else
+ "built into kernel"
+#endif
+ );
+ return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
+}
+
+#define SF( x ) ( r -> x )
+#define SFP( x ) SF( s_proc_info_data.x )
+#define SFPL( x ) SFP( x[ level ] )
+#define SFPF( x ) SFP( find_forward.x )
+#define SFPJ( x ) SFP( journal.x )
+
+#define D2C( x ) le16_to_cpu( x )
+#define D4C( x ) le32_to_cpu( x )
+#define DF( x ) D2C( rs -> x )
+#define DFL( x ) D4C( rs -> x )
+
+#define objectid_map( s, rs ) (old_format_only (s) ? \
+ (__u32 *)((struct reiserfs_super_block_v1 *)rs + 1) : \
+ (__u32 *)(rs + 1))
+#define MAP( i ) D4C( objectid_map( sb, rs )[ i ] )
+
+#define DJF( x ) le32_to_cpu( rs -> x )
+#define JF( x ) ( r -> s_journal -> x )
+
+int reiserfs_super_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{
+ struct super_block *sb;
+ struct reiserfs_sb_info *r;
+ int len = 0;
+
+ sb = procinfo_prologue( ( kdev_t ) ( int ) data );
+ if( sb == NULL )
+ return -ENOENT;
+ r = &sb->u.reiserfs_sb;
+ len += sprintf( &buffer[ len ],
+ "state: \t%s\n"
+ "mount options: \t%s%s%s%s%s%s%s%s%s%s%s%s\n"
+ "gen. counter: \t%i\n"
+ "s_kmallocs: \t%i\n"
+ "s_disk_reads: \t%i\n"
+ "s_disk_writes: \t%i\n"
+ "s_fix_nodes: \t%i\n"
+ "s_do_balance: \t%i\n"
+ "s_unneeded_left_neighbor: \t%i\n"
+ "s_good_search_by_key_reada: \t%i\n"
+ "s_bmaps: \t%i\n"
+ "s_bmaps_without_search: \t%i\n"
+ "s_direct2indirect: \t%i\n"
+ "s_indirect2direct: \t%i\n"
+ "\n"
+ "max_hash_collisions: \t%i\n"
+
+ "breads: \t%lu\n"
+ "bread_misses: \t%lu\n"
+
+ "search_by_key: \t%lu\n"
+ "search_by_key_fs_changed: \t%lu\n"
+ "search_by_key_restarted: \t%lu\n"
+
+ "leaked_oid: \t%lu\n"
+ "leaves_removable: \t%lu\n",
+
+ SF( s_mount_state ) == REISERFS_VALID_FS ?
+ "REISERFS_VALID_FS" : "REISERFS_ERROR_FS",
+ reiserfs_r5_hash( sb ) ? "FORCE_R5 " : "",
+ reiserfs_rupasov_hash( sb ) ? "FORCE_RUPASOV " : "",
+ reiserfs_tea_hash( sb ) ? "FORCE_TEA " : "",
+ reiserfs_hash_detect( sb ) ? "DETECT_HASH " : "",
+ reiserfs_no_border( sb ) ? "NO_BORDER " : "BORDER ",
+ reiserfs_no_unhashed_relocation( sb ) ? "NO_UNHASHED_RELOCATION " : "",
+ reiserfs_hashed_relocation( sb ) ? "UNHASHED_RELOCATION " : "",
+ reiserfs_test4( sb ) ? "TEST4 " : "",
+ dont_have_tails( sb ) ? "NO_TAILS " : "TAILS ",
+ replay_only( sb ) ? "REPLAY_ONLY " : "",
+ reiserfs_dont_log( sb ) ? "DONT_LOG " : "LOG ",
+ old_format_only( sb ) ? "CONV " : "",
+
+ atomic_read( &r -> s_generation_counter ),
+ SF( s_kmallocs ),
+ SF( s_disk_reads ),
+ SF( s_disk_writes ),
+ SF( s_fix_nodes ),
+ SF( s_do_balance ),
+ SF( s_unneeded_left_neighbor ),
+ SF( s_good_search_by_key_reada ),
+ SF( s_bmaps ),
+ SF( s_bmaps_without_search ),
+ SF( s_direct2indirect ),
+ SF( s_indirect2direct ),
+ SFP( max_hash_collisions ),
+ SFP( breads ),
+ SFP( bread_miss ),
+ SFP( search_by_key ),
+ SFP( search_by_key_fs_changed ),
+ SFP( search_by_key_restarted ),
+ SFP( leaked_oid ),
+ SFP( leaves_removable ) );
+
+ procinfo_epilogue( sb );
+ return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
+}
+
+int reiserfs_per_level_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{
+ struct super_block *sb;
+ struct reiserfs_sb_info *r;
+ int len = 0;
+ int level;
+
+ sb = procinfo_prologue( ( kdev_t ) ( int ) data );
+ if( sb == NULL )
+ return -ENOENT;
+ r = &sb->u.reiserfs_sb;
+
+ len += sprintf( &buffer[ len ],
+ "level\t"
+ " balances"
+ " [sbk: reads"
+ " fs_changed"
+ " restarted]"
+ " free space"
+ " items"
+ " can_remove"
+ " lnum"
+ " rnum"
+ " lbytes"
+ " rbytes"
+ " get_neig"
+ " get_neig_res"
+ " need_l_neig"
+ " need_r_neig"
+ "\n"
+
+ );
+
+ for( level = 0 ; level < MAX_HEIGHT ; ++ level ) {
+ if( len > PAGE_SIZE - 240 ) {
+ len += sprintf( &buffer[ len ], "... and more\n" );
+ break;
+ }
+ len += sprintf( &buffer[ len ],
+ "%i\t"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ " %12li"
+ " %12li"
+ " %12li"
+ " %12li"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ "\n",
+ level,
+ SFPL( balance_at ),
+ SFPL( sbk_read_at ),
+ SFPL( sbk_fs_changed ),
+ SFPL( sbk_restarted ),
+ SFPL( free_at ),
+ SFPL( items_at ),
+ SFPL( can_node_be_removed ),
+ SFPL( lnum ),
+ SFPL( rnum ),
+ SFPL( lbytes ),
+ SFPL( rbytes ),
+ SFPL( get_neighbors ),
+ SFPL( get_neighbors_restart ),
+ SFPL( need_l_neighbor ),
+ SFPL( need_r_neighbor )
+ );
+ }
+
+ procinfo_epilogue( sb );
+ return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
+}
+
+int reiserfs_bitmap_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{
+ struct super_block *sb;
+ struct reiserfs_sb_info *r = &sb->u.reiserfs_sb;
+ int len = 0;
+
+ sb = procinfo_prologue( ( kdev_t ) ( int ) data );
+ if( sb == NULL )
+ return -ENOENT;
+ r = &sb->u.reiserfs_sb;
+
+ len += sprintf( &buffer[ len ], "free_block: %lu\n"
+ "find_forward:"
+ " wait"
+ " bmap"
+ " retry"
+ " journal_hint"
+ " journal_out"
+ "\n"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ " %12lu"
+ "\n",
+ SFP( free_block ),
+ SFPF( call ),
+ SFPF( wait ),
+ SFPF( bmap ),
+ SFPF( retry ),
+ SFPF( in_journal_hint ),
+ SFPF( in_journal_out ) );
+
+ procinfo_epilogue( sb );
+ return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
+}
+
+int reiserfs_on_disk_super_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{
+ struct super_block *sb;
+ struct reiserfs_sb_info *sb_info;
+ struct reiserfs_super_block *rs;
+ int hash_code;
+ int len = 0;
+
+ sb = procinfo_prologue( ( kdev_t ) ( int ) data );
+ if( sb == NULL )
+ return -ENOENT;
+ sb_info = &sb->u.reiserfs_sb;
+ rs = sb_info -> s_rs;
+ hash_code = DFL( s_hash_function_code );
+
+ len += sprintf( &buffer[ len ],
+ "block_count: \t%i\n"
+ "free_blocks: \t%i\n"
+ "root_block: \t%i\n"
+ "blocksize: \t%i\n"
+ "oid_maxsize: \t%i\n"
+ "oid_cursize: \t%i\n"
+ "state: \t%i\n"
+ "magic: \t%12.12s\n"
+ "hash: \t%s\n"
+ "tree_height: \t%i\n"
+ "bmap_nr: \t%i\n"
+ "version: \t%i\n",
+
+ DFL( s_block_count ),
+ DFL( s_free_blocks ),
+ DFL( s_root_block ),
+ DF( s_blocksize ),
+ DF( s_oid_maxsize ),
+ DF( s_oid_cursize ),
+ DF( s_state ),
+ rs -> s_magic,
+ hash_code == TEA_HASH ? "tea" :
+ ( hash_code == YURA_HASH ) ? "rupasov" :
+ ( hash_code == R5_HASH ) ? "r5" :
+ ( hash_code == UNSET_HASH ) ? "unset" : "unknown",
+ DF( s_tree_height ),
+ DF( s_bmap_nr ),
+ DF( s_version ) );
+
+ procinfo_epilogue( sb );
+ return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
+}
+
+int reiserfs_oidmap_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{
+ struct super_block *sb;
+ struct reiserfs_sb_info *sb_info;
+ struct reiserfs_super_block *rs;
+ int i;
+ unsigned int mapsize;
+ unsigned long total_used;
+ int len = 0;
+ int exact;
+
+ sb = procinfo_prologue( ( kdev_t ) ( int ) data );
+ if( sb == NULL )
+ return -ENOENT;
+ sb_info = &sb->u.reiserfs_sb;
+ rs = sb_info -> s_rs;
+ mapsize = le16_to_cpu( rs -> s_oid_cursize );
+ total_used = 0;
+
+ for( i = 0 ; i < mapsize ; ++i ) {
+ __u32 right;
+
+ right = ( i == mapsize - 1 ) ? MAX_KEY_OBJECTID : MAP( i + 1 );
+ len += sprintf( &buffer[ len ], "%s: [ %x .. %x )\n",
+ ( i & 1 ) ? "free" : "used", MAP( i ), right );
+ if( ! ( i & 1 ) ) {
+ total_used += right - MAP( i );
+ }
+ if( len > PAGE_SIZE - 100 ) {
+ len += sprintf( &buffer[ len ], "... and more\n" );
+ break;
+ }
+ }
+#if defined( REISERFS_USE_OIDMAPF )
+ if( sb_info -> oidmap.use_file && ( sb_info -> oidmap.mapf != NULL ) ) {
+ loff_t size;
+
+ size = sb_info -> oidmap.mapf -> f_dentry -> d_inode -> i_size;
+ total_used += size / sizeof( reiserfs_oidinterval_d_t );
+ exact = 1;
+ } else
+#endif
+ {
+ exact = ( i == mapsize );
+ }
+ len += sprintf( &buffer[ len ], "total: \t%i [%i/%i] used: %lu [%s]\n",
+ i,
+ mapsize, le16_to_cpu( rs -> s_oid_maxsize ),
+ total_used, exact ? "exact" : "estimation" );
+
+ procinfo_epilogue( sb );
+ return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
+}
+
+int reiserfs_journal_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{
+ struct super_block *sb;
+ struct reiserfs_sb_info *r;
+ struct reiserfs_super_block *rs;
+ int len = 0;
+
+ sb = procinfo_prologue( ( kdev_t ) ( int ) data );
+ if( sb == NULL )
+ return -ENOENT;
+ r = &sb->u.reiserfs_sb;
+ rs = r -> s_rs;
+
+ len += sprintf( &buffer[ len ],
+ /* on-disk fields */
+ "s_journal_block: \t%i\n"
+ "s_journal_dev: \t%s[%x]\n"
+ "s_orig_journal_size: \t%i\n"
+ "s_journal_trans_max: \t%i\n"
+ "s_journal_block_count: \t%i\n"
+ "s_journal_max_batch: \t%i\n"
+ "s_journal_max_commit_age: \t%i\n"
+ "s_journal_max_trans_age: \t%i\n"
+ /* incore fields */
+ "j_state: \t%i\n"
+ "j_trans_id: \t%lu\n"
+ "j_mount_id: \t%lu\n"
+ "j_start: \t%lu\n"
+ "j_len: \t%lu\n"
+ "j_len_alloc: \t%lu\n"
+ "j_wcount: \t%i\n"
+ "j_bcount: \t%lu\n"
+ "j_first_unflushed_offset: \t%lu\n"
+ "j_last_flush_trans_id: \t%lu\n"
+ "j_trans_start_time: \t%li\n"
+ "j_journal_list_index: \t%i\n"
+ "j_list_bitmap_index: \t%i\n"
+ "j_must_wait: \t%i\n"
+ "j_next_full_flush: \t%i\n"
+ "j_next_async_flush: \t%i\n"
+ "j_cnode_used: \t%i\n"
+ "j_cnode_free: \t%i\n"
+ "\n"
+ /* reiserfs_proc_info_data_t.journal fields */
+ "in_journal: \t%12lu\n"
+ "in_journal_bitmap: \t%12lu\n"
+ "in_journal_reusable: \t%12lu\n"
+ "lock_journal: \t%12lu\n"
+ "lock_journal_wait: \t%12lu\n"
+ "journal_begin: \t%12lu\n"
+ "journal_relock_writers: \t%12lu\n"
+ "journal_relock_wcount: \t%12lu\n"
+ "mark_dirty: \t%12lu\n"
+ "mark_dirty_already: \t%12lu\n"
+ "mark_dirty_notjournal: \t%12lu\n"
+ "restore_prepared: \t%12lu\n"
+ "prepare: \t%12lu\n"
+ "prepare_retry: \t%12lu\n",
+
+ DJF( s_journal_block ),
+ DJF( s_journal_dev ) == 0 ? "none" : bdevname( DJF( s_journal_dev ) ),
+ DJF( s_journal_dev ),
+ DJF( s_orig_journal_size ),
+ DJF( s_journal_trans_max ),
+ DJF( s_journal_block_count ),
+ DJF( s_journal_max_batch ),
+ DJF( s_journal_max_commit_age ),
+ DJF( s_journal_max_trans_age ),
+
+ JF( j_state ),
+ JF( j_trans_id ),
+ JF( j_mount_id ),
+ JF( j_start ),
+ JF( j_len ),
+ JF( j_len_alloc ),
+ atomic_read( & r -> s_journal -> j_wcount ),
+ JF( j_bcount ),
+ JF( j_first_unflushed_offset ),
+ JF( j_last_flush_trans_id ),
+ JF( j_trans_start_time ),
+ JF( j_journal_list_index ),
+ JF( j_list_bitmap_index ),
+ JF( j_must_wait ),
+ JF( j_next_full_flush ),
+ JF( j_next_async_flush ),
+ JF( j_cnode_used ),
+ JF( j_cnode_free ),
+
+ SFPJ( in_journal ),
+ SFPJ( in_journal_bitmap ),
+ SFPJ( in_journal_reusable ),
+ SFPJ( lock_journal ),
+ SFPJ( lock_journal_wait ),
+ SFPJ( journal_being ),
+ SFPJ( journal_relock_writers ),
+ SFPJ( journal_relock_wcount ),
+ SFPJ( mark_dirty ),
+ SFPJ( mark_dirty_already ),
+ SFPJ( mark_dirty_notjournal ),
+ SFPJ( restore_prepared ),
+ SFPJ( prepare ),
+ SFPJ( prepare_retry )
+ );
+
+ procinfo_epilogue( sb );
+ return reiserfs_proc_tail( len, buffer, start, offset, count, eof );
+}
+
+
+static struct proc_dir_entry *proc_info_root = NULL;
+static const char *proc_info_root_name = "fs/reiserfs";
+
+int reiserfs_proc_info_init( struct super_block *sb )
+{
+ spin_lock_init( & __PINFO( sb ).lock );
+ sb->u.reiserfs_sb.procdir = proc_mkdir( bdevname( sb -> s_dev ),
+ proc_info_root );
+ if( sb->u.reiserfs_sb.procdir ) {
+ sb->u.reiserfs_sb.procdir -> owner = THIS_MODULE;
+ return 0;
+ }
+ reiserfs_warning( "reiserfs: cannot create /proc/%s/%s\n",
+ proc_info_root_name, bdevname( sb -> s_dev ) );
+ return 1;
+}
+
+
+int reiserfs_proc_info_done( struct super_block *sb )
+{
+ spin_lock( & __PINFO( sb ).lock );
+ __PINFO( sb ).exiting = 1;
+ spin_unlock( & __PINFO( sb ).lock );
+ if ( proc_info_root ) {
+ remove_proc_entry( bdevname( sb -> s_dev ), proc_info_root );
+ sb->u.reiserfs_sb.procdir = NULL;
+ }
+ return 0;
+}
+
+/* Create /proc/fs/reiserfs/DEV/name and attach read procedure @func
+ to it. Other parts of reiserfs use this function to make their
+ per-device statistics available via /proc */
+
+struct proc_dir_entry *reiserfs_proc_register( struct super_block *sb,
+ char *name, read_proc_t *func )
+{
+ return ( sb->u.reiserfs_sb.procdir ) ? create_proc_read_entry
+ ( name, 0, sb->u.reiserfs_sb.procdir, func,
+ ( void * ) ( int ) sb -> s_dev ) : NULL;
+}
+
+void reiserfs_proc_unregister( struct super_block *sb, const char *name )
+{
+ remove_proc_entry( name, sb->u.reiserfs_sb.procdir );
+}
+
+struct proc_dir_entry *reiserfs_proc_register_global( char *name,
+ read_proc_t *func )
+{
+ return ( proc_info_root ) ? create_proc_read_entry( name, 0,
+ proc_info_root,
+ func, NULL ) : NULL;
+}
+
+void reiserfs_proc_unregister_global( const char *name )
+{
+ remove_proc_entry( name, proc_info_root );
+}
+
+int reiserfs_proc_info_global_init( void )
+{
+ if( proc_info_root == NULL ) {
+ proc_info_root = proc_mkdir( proc_info_root_name, 0 );
+ if( proc_info_root ) {
+ proc_info_root -> owner = THIS_MODULE;
+ } else {
+ reiserfs_warning( "reiserfs: cannot create /proc/%s\n",
+ proc_info_root_name );
+ return 1;
+ }
+ }
+ return 0;
+}
+
+int reiserfs_proc_info_global_done( void )
+{
+ if ( proc_info_root != NULL ) {
+ proc_info_root = NULL;
+ remove_proc_entry( proc_info_root_name, 0 );
+ }
+ return 0;
+}
+
+/* REISERFS_PROC_INFO */
+#else
+
+int reiserfs_proc_info_init( struct super_block *sb ) { return 0; }
+int reiserfs_proc_info_done( struct super_block *sb ) { return 0; }
+
+struct proc_dir_entry *reiserfs_proc_register( struct super_block *sb,
+ char *name,
+ read_proc_t *func )
+{ return NULL; }
+
+void reiserfs_proc_unregister( struct super_block *sb, const char *name )
+{;}
+
+struct proc_dir_entry *reiserfs_proc_register_global( char *name,
+ read_proc_t *func )
+{ return NULL; }
+
+void reiserfs_proc_unregister_global( const char *name ) {;}
+
+int reiserfs_proc_info_global_init( void ) { return 0; }
+int reiserfs_proc_info_global_done( void ) { return 0; }
+
+int reiserfs_global_version_in_proc( char *buffer, char **start,
+ off_t offset,
+ int count, int *eof, void *data )
+{ return 0; }
+
+int reiserfs_version_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{ return 0; }
+
+int reiserfs_super_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{ return 0; }
+
+int reiserfs_per_level_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{ return 0; }
+
+int reiserfs_bitmap_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{ return 0; }
+
+int reiserfs_on_disk_super_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{ return 0; }
+
+int reiserfs_oidmap_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{ return 0; }
+
+int reiserfs_journal_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data )
+{ return 0; }
+
+/* REISERFS_PROC_INFO */
+#endif
+
+/*
+ * $Log: procfs.c,v $
+ * Revision 1.1.8.2 2001/07/15 17:08:42 god
+ * . use get_super() in procfs.c
+ * . remove remove_save_link() from reiserfs_do_truncate()
+ *
+ * I accept terms and conditions stated in the Legal Agreement
+ * (available at
http://www.namesys.com/legalese.html)
+ *
+ * Revision 1.1.8.1 2001/07/11 16:48:50 god
+ * proc info support
+ *
+ * I accept terms and conditions stated in the Legal Agreement
+ * (available at
http://www.namesys.com/legalese.html)
+ *
+ */
+
+/*
+ * Make Linus happy.
+ * Local variables:
+ * c-indentation-style: "K&R"
+ * mode-name: "LC"
+ * c-basic-offset: 8
+ * tab-width: 8
+ * End:
+ */
diff -rup linux-2.4.6/fs/reiserfs/stree.c linux-2.4.6.cleanup/fs/reiserfs/stree.c
--- linux-2.4.6/fs/reiserfs/stree.c Wed Jul 11 19:43:00 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/stree.c Wed Jul 11 20:02:53 2001
@@ -648,7 +648,6 @@ int search_by_key (struct super_block *
stop at leaf level - set to
DISK_LEAF_NODE_LEVEL */
) {
- kdev_t n_dev = p_s_sb->s_dev;
int n_block_number = SB_ROOT_BLOCK (p_s_sb),
expected_level = SB_TREE_HEIGHT (p_s_sb),
n_block_size = p_s_sb->s_blocksize;
@@ -661,7 +660,9 @@ int search_by_key (struct super_block *
#ifdef CONFIG_REISERFS_CHECK
int n_repeat_counter = 0;
#endif
-
+
+ PROC_INFO_INC( p_s_sb, search_by_key );
+
/* As we add each node to a path we increase its count. This means that
we must be careful to release all nodes in a path before we either
discard the path struct or re-use the path struct, as we do here. */
@@ -696,17 +697,24 @@ int search_by_key (struct super_block *
/* Read the next tree node, and set the last element in the path to
have a pointer to it. */
if ( ! (p_s_bh = p_s_last_element->pe_buffer =
- reiserfs_bread(n_dev, n_block_number, n_block_size)) ) {
+ reiserfs_bread(p_s_sb, n_block_number, n_block_size)) ) {
p_s_search_path->path_length --;
pathrelse(p_s_search_path);
return IO_ERROR;
}
+ if( fs_changed (fs_gen, p_s_sb) ) {
+ PROC_INFO_INC( p_s_sb, search_by_key_fs_changed );
+ PROC_INFO_INC( p_s_sb, sbk_fs_changed[ expected_level - 1 ] );
+ }
+
/* It is possible that schedule occurred. We must check whether the key
to search is still in the tree rooted from the current buffer. If
not then repeat search from the root. */
if ( fs_changed (fs_gen, p_s_sb) &&
(!B_IS_IN_TREE (p_s_bh) || !key_in_buffer(p_s_search_path, p_s_key, p_s_sb)) ) {
+ PROC_INFO_INC( p_s_sb, search_by_key_restarted );
+ PROC_INFO_INC( p_s_sb, sbk_restarted[ expected_level - 1 ] );
decrement_counters_in_path(p_s_search_path);
/* Get the root block number so that we can repeat the search
@@ -740,6 +748,8 @@ int search_by_key (struct super_block *
/* ok, we have acquired next formatted node in the tree */
n_node_level = B_LEVEL (p_s_bh);
+
+ PROC_INFO_BH_STAT( p_s_sb, p_s_bh, n_node_level - 1 );
RFALSE( n_node_level < n_stop_level,
"vs-5152: tree level (%d) is less than stop level (%d)",
diff -rup linux-2.4.6/fs/reiserfs/super.c linux-2.4.6.cleanup/fs/reiserfs/super.c
--- linux-2.4.6/fs/reiserfs/super.c Wed Jul 11 19:43:00 2001
+++ linux-2.4.6.cleanup/fs/reiserfs/super.c Wed Jul 11 19:58:09 2001
@@ -114,10 +114,18 @@ void reiserfs_put_super (struct super_bl
print_statistics (s);
if (s->u.reiserfs_sb.s_kmallocs != 0) {
- reiserfs_warning ("vs-2004: reiserfs_put_super: aloocated memory left %d\n",
+ reiserfs_warning ("vs-2004: reiserfs_put_super: allocated memory left %d\n",
s->u.reiserfs_sb.s_kmallocs);
}
+ reiserfs_proc_unregister( s, "journal" );
+ reiserfs_proc_unregister( s, "oidmap" );
+ reiserfs_proc_unregister( s, "on-disk-super" );
+ reiserfs_proc_unregister( s, "bitmap" );
+ reiserfs_proc_unregister( s, "per-level" );
+ reiserfs_proc_unregister( s, "super" );
+ reiserfs_proc_unregister( s, "version" );
+ reiserfs_proc_info_done( s );
return;
}
@@ -300,11 +308,11 @@ static int read_bitmaps (struct super_bl
labeling scheme currently used will have enough space. Then we
need one block for the super. -Hans */
bmp = (REISERFS_DISK_OFFSET_IN_BYTES / s->s_blocksize) + 1; /* first of bitmap blocks */
- SB_AP_BITMAP (s)[0] = reiserfs_bread (s->s_dev, bmp, s->s_blocksize);
+ SB_AP_BITMAP (s)[0] = reiserfs_bread (s, bmp, s->s_blocksize);
if(!SB_AP_BITMAP(s)[0])
return 1;
for (i = 1, bmp = dl = rs->s_blocksize * 8; i < le16_to_cpu (rs->s_bmap_nr); i ++) {
- SB_AP_BITMAP (s)[i] = reiserfs_bread (s->s_dev, bmp, s->s_blocksize);
+ SB_AP_BITMAP (s)[i] = reiserfs_bread (s, bmp, s->s_blocksize);
if (!SB_AP_BITMAP (s)[i])
return 1;
bmp += dl;
@@ -327,7 +335,7 @@ static int read_old_bitmaps (struct supe
memset (SB_AP_BITMAP (s), 0, sizeof (struct buffer_head *) * le16_to_cpu (rs->s_bmap_nr));
for (i = 0; i < le16_to_cpu (rs->s_bmap_nr); i ++) {
- SB_AP_BITMAP (s)[i] = reiserfs_bread (s->s_dev, bmp1 + i, s->s_blocksize);
+ SB_AP_BITMAP (s)[i] = reiserfs_bread (s, bmp1 + i, s->s_blocksize);
if (!SB_AP_BITMAP (s)[i])
return 1;
}
@@ -454,7 +462,7 @@ static int read_super_block (struct supe
if (s->s_blocksize != size)
set_blocksize (s->s_dev, s->s_blocksize);
- bh = reiserfs_bread (s->s_dev, REISERFS_DISK_OFFSET_IN_BYTES / s->s_blocksize, s->s_blocksize);
+ bh = reiserfs_bread (s, REISERFS_DISK_OFFSET_IN_BYTES / s->s_blocksize, s->s_blocksize);
if (!bh) {
printk("read_super_block: unable to read superblock on dev %s\n", kdevname(s->s_dev));
return 1;
@@ -656,7 +664,6 @@ int function2code (hashf_t func)
return 0;
}
-
//
// a portion of this function, particularly the VFS interface portion,
// was derived from minix or ext2's analog and evolved as the
@@ -805,6 +812,14 @@ struct super_block * reiserfs_read_super
}
}
+ reiserfs_proc_info_init( s );
+ reiserfs_proc_register( s, "version", reiserfs_version_in_proc );
+ reiserfs_proc_register( s, "super", reiserfs_super_in_proc );
+ reiserfs_proc_register( s, "per-level", reiserfs_per_level_in_proc );
+ reiserfs_proc_register( s, "bitmap", reiserfs_bitmap_in_proc );
+ reiserfs_proc_register( s, "on-disk-super", reiserfs_on_disk_super_in_proc );
+ reiserfs_proc_register( s, "oidmap", reiserfs_oidmap_in_proc );
+ reiserfs_proc_register( s, "journal", reiserfs_journal_in_proc );
init_waitqueue_head (&(s->u.reiserfs_sb.s_wait));
printk("%s\n", reiserfs_get_version_string()) ;
@@ -854,21 +869,20 @@ int reiserfs_statfs (struct super_block
static DECLARE_FSTYPE_DEV(reiserfs_fs_type,"reiserfs",reiserfs_read_super);
-//
-// this is exactly what 2.3.99-pre9's init_ext2_fs is
-//
static int __init init_reiserfs_fs (void)
{
+ reiserfs_proc_info_global_init();
+ reiserfs_proc_register_global( "version",
+ reiserfs_global_version_in_proc );
return register_filesystem(&reiserfs_fs_type);
}
EXPORT_NO_SYMBOLS;
-//
-// this is exactly what 2.3.99-pre9's init_ext2_fs is
-//
static void __exit exit_reiserfs_fs(void)
{
+ reiserfs_proc_unregister_global( "version" );
+ reiserfs_proc_info_global_done();
unregister_filesystem(&reiserfs_fs_type);
}
diff -rup linux-2.4.6/include/linux/reiserfs_fs.h linux-2.4.6.cleanup/include/linux/reiserfs_fs.h
--- linux-2.4.6/include/linux/reiserfs_fs.h Wed Jul 11 19:43:01 2001
+++ linux-2.4.6.cleanup/include/linux/reiserfs_fs.h Wed Jul 11 20:27:28 2001
@@ -18,6 +18,7 @@
#include <linux/slab.h>
#include <linux/tqueue.h>
#include <asm/hardirq.h>
+#include <linux/proc_fs.h>
#endif
/*
@@ -1783,6 +1784,67 @@ int read_old_super_block (struct super_b
struct super_block * reiserfs_read_super (struct super_block * s, void * data, int silent);
int reiserfs_statfs (struct super_block * s, struct statfs * buf);
+/* procfs.c */
+
+#if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
+#define REISERFS_PROC_INFO
+#else
+#undef REISERFS_PROC_INFO
+#endif
+
+int reiserfs_proc_info_init( struct super_block *sb );
+int reiserfs_proc_info_done( struct super_block *sb );
+struct proc_dir_entry *reiserfs_proc_register( struct super_block *sb,
+ char *name, read_proc_t *func );
+void reiserfs_proc_unregister( struct super_block *sb, const char *name );
+struct proc_dir_entry *reiserfs_proc_register_global( char *name,
+ read_proc_t *func );
+void reiserfs_proc_unregister_global( const char *name );
+int reiserfs_proc_info_global_init( void );
+int reiserfs_proc_info_global_done( void );
+int reiserfs_proc_tail( int len, char *buffer, char **start,
+ off_t offset, int count, int *eof );
+int reiserfs_global_version_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data );
+int reiserfs_version_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data );
+int reiserfs_super_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data );
+int reiserfs_per_level_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data );
+int reiserfs_bitmap_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data );
+int reiserfs_on_disk_super_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data );
+int reiserfs_oidmap_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data );
+int reiserfs_journal_in_proc( char *buffer, char **start, off_t offset,
+ int count, int *eof, void *data );
+
+#if defined( REISERFS_PROC_INFO )
+
+#define PROC_EXP( e ) e
+
+#define MAX( a, b ) ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) )
+#define __PINFO( sb ) ( sb ) -> u.reiserfs_sb.s_proc_info_data
+#define PROC_INFO_MAX( sb, field, value ) \
+ __PINFO( sb ).field = \
+ MAX( ( sb ) -> u.reiserfs_sb.s_proc_info_data.field, value )
+#define PROC_INFO_INC( sb, field ) ( ++ ( __PINFO( sb ).field ) )
+#define PROC_INFO_ADD( sb, field, val ) ( __PINFO( sb ).field += ( val ) )
+#define PROC_INFO_BH_STAT( sb, bh, level ) \
+ PROC_INFO_INC( sb, sbk_read_at[ ( level ) ] ); \
+ PROC_INFO_ADD( sb, free_at[ ( level ) ], B_FREE_SPACE( bh ) ); \
+ PROC_INFO_ADD( sb, items_at[ ( level ) ], B_NR_ITEMS( bh ) )
+#else
+#define PROC_EXP( e )
+#define VOID_V ( ( void ) 0 )
+#define PROC_INFO_MAX( sb, field, value ) VOID_V
+#define PROC_INFO_INC( sb, field ) VOID_V
+#define PROC_INFO_ADD( sb, field, val ) VOID_V
+#define PROC_INFO_BH_STAT( p_s_sb, p_s_bh, n_node_level ) VOID_V
+#endif
+
/* dir.c */
extern struct inode_operations reiserfs_dir_inode_operations;
extern struct file_operations reiserfs_dir_operations;
@@ -1804,8 +1866,8 @@ int get_new_buffer (struct reiserfs_tran
/* buffer2.c */
struct buffer_head * reiserfs_getblk (kdev_t n_dev, int n_block, int n_size);
void wait_buffer_until_released (const struct buffer_head * bh);
-struct buffer_head * reiserfs_bread (kdev_t n_dev, int n_block, int n_size);
-
+struct buffer_head * reiserfs_bread (struct super_block *super, int n_block,
+ int n_size);
/* fix_nodes.c */
void * reiserfs_kmalloc (size_t size, int flags, struct super_block * s);
diff -rup linux-2.4.6/include/linux/reiserfs_fs_sb.h linux-2.4.6.cleanup/include/linux/reiserfs_fs_sb.h
--- linux-2.4.6/include/linux/reiserfs_fs_sb.h Wed May 2 14:04:19 2001
+++ linux-2.4.6.cleanup/include/linux/reiserfs_fs_sb.h Wed Jul 11 20:20:49 2001
@@ -262,6 +262,74 @@ struct reiserfs_journal {
typedef __u32 (*hashf_t) (const char *, int);
+struct proc_dir_entry;
+
+#if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )
+typedef unsigned long int stat_cnt_t;
+typedef struct reiserfs_proc_info_data
+{
+ spinlock_t lock;
+ int exiting;
+ int max_hash_collisions;
+
+ stat_cnt_t breads;
+ stat_cnt_t bread_miss;
+ stat_cnt_t search_by_key;
+ stat_cnt_t search_by_key_fs_changed;
+ stat_cnt_t search_by_key_restarted;
+
+ stat_cnt_t leaked_oid;
+ stat_cnt_t leaves_removable;
+
+ /* balances per level. Use explicit 5 as MAX_HEIGHT is not visible yet. */
+ stat_cnt_t balance_at[ 5 ]; /* XXX */
+ /* sbk == search_by_key */
+ stat_cnt_t sbk_read_at[ 5 ]; /* XXX */
+ stat_cnt_t sbk_fs_changed[ 5 ];
+ stat_cnt_t sbk_restarted[ 5 ];
+ stat_cnt_t items_at[ 5 ]; /* XXX */
+ stat_cnt_t free_at[ 5 ]; /* XXX */
+ stat_cnt_t can_node_be_removed[ 5 ]; /* XXX */
+ long int lnum[ 5 ]; /* XXX */
+ long int rnum[ 5 ]; /* XXX */
+ long int lbytes[ 5 ]; /* XXX */
+ long int rbytes[ 5 ]; /* XXX */
+ stat_cnt_t get_neighbors[ 5 ];
+ stat_cnt_t get_neighbors_restart[ 5 ];
+ stat_cnt_t need_l_neighbor[ 5 ];
+ stat_cnt_t need_r_neighbor[ 5 ];
+
+ stat_cnt_t free_block;
+ struct __find_forward_stats {
+ stat_cnt_t call;
+ stat_cnt_t wait;
+ stat_cnt_t bmap;
+ stat_cnt_t retry;
+ stat_cnt_t in_journal_hint;
+ stat_cnt_t in_journal_out;
+ } find_forward;
+ struct __journal_stats {
+ stat_cnt_t in_journal;
+ stat_cnt_t in_journal_bitmap;
+ stat_cnt_t in_journal_reusable;
+ stat_cnt_t lock_journal;
+ stat_cnt_t lock_journal_wait;
+ stat_cnt_t journal_being;
+ stat_cnt_t journal_relock_writers;
+ stat_cnt_t journal_relock_wcount;
+ stat_cnt_t mark_dirty;
+ stat_cnt_t mark_dirty_already;
+ stat_cnt_t mark_dirty_notjournal;
+ stat_cnt_t restore_prepared;
+ stat_cnt_t prepare;
+ stat_cnt_t prepare_retry;
+ } journal;
+} reiserfs_proc_info_data_t;
+#else
+typedef struct reiserfs_proc_info_data
+{} reiserfs_proc_info_data_t;
+#endif
+
/* reiserfs union of in-core super block data */
struct reiserfs_sb_info
{
@@ -300,6 +368,8 @@ struct reiserfs_sb_info
int s_bmaps_without_search;
int s_direct2indirect;
int s_indirect2direct;
+ reiserfs_proc_info_data_t s_proc_info_data;
+ struct proc_dir_entry *procdir;
};
