[patch] add reiserfs support to aboot

aboot-reiserfs.diff (text/plain), 41.53 KB, created by ibm on 2005-09-21 19:40:47 UTC

diff -urN aboot-1.0_pre20040408/Makefile aboot-1.0_pre20040408-mine/Makefile
--- aboot-1.0_pre20040408/Makefile	2004-04-08 11:19:01.000000000 -0400
+++ aboot-1.0_pre20040408-mine/Makefile	2005-09-21 21:28:06.000000000 -0400
@@ -58,7 +58,7 @@
 	$(CC) $(ASFLAGS) -D__ASSEMBLY__ -traditional -c -o $*.o $<
 
 NET_OBJS = net.o
-DISK_OBJS = disk.o fs/ext2.o fs/ufs.o fs/dummy.o fs/iso.o
+DISK_OBJS = disk.o fs/ext2.o fs/ufs.o fs/dummy.o fs/iso.o fs/reiserfs.o
 ifeq ($(TESTING),)
 ABOOT_OBJS = \
 	head.o aboot.o cons.o utils.o \
diff -urN aboot-1.0_pre20040408/disk.c aboot-1.0_pre20040408-mine/disk.c
--- aboot-1.0_pre20040408/disk.c	2004-04-08 14:14:06.000000000 -0400
+++ aboot-1.0_pre20040408-mine/disk.c	2005-09-21 21:46:11.000000000 -0400
@@ -42,6 +42,7 @@
 extern struct bootfs iso;
 extern struct bootfs ufs;
 extern struct bootfs dummyfs;
+extern struct bootfs reiserfs;
 
 struct disklabel * label;
 int boot_part = -1;
@@ -49,7 +50,9 @@
 static struct bootfs *bootfs[] = {
 	&ext2fs,
 	&iso,
-	&ufs
+	&ufs,
+	&reiserfs,
+	NULL
 };
 
 /*
@@ -313,7 +316,7 @@
 		}
 	} else if (!label) {
 		/* floppies and such, no disklabel */
-		for (i = 0; i < (int)(sizeof(bootfs)/sizeof(bootfs[0])); ++i) {
+		for (i = 0; bootfs[i] != NULL; ++i) {
 			if ((*bootfs[i]->mount)(dev, 0, 1) >= 0) {
 				fs = bootfs[i];
 				break;
@@ -329,21 +332,19 @@
 			return 0;
 		}
 		part = &label->d_partitions[partition - 1];
-		for (i = 0; bootfs[i]->fs_type != part->p_fstype; ++i) {
-			if (i + 1
-			    >= (int) (sizeof(bootfs)/sizeof(bootfs[0])))
-			{
-				printf("aboot: don't know how to mount "
-				       "partition %d (filesystem type %d)\n",
-				       partition, part->p_fstype);
-				return 0;
-			}
-		}
-		fs = bootfs[i];
-		if ((*fs->mount)(dev, (long)(part->p_offset) * (long)(label->d_secsize), 0)
-		    < 0) {
-			printf("aboot: mount of partition %d failed\n",
-			       partition);
+		for (i = 0; bootfs[i] != NULL; ++i) {
+			if (bootfs[i]->fs_type != part->p_fstype) continue;
+			fs = bootfs[i];
+			if ((*fs->mount)(dev, (long)(part->p_offset) *
+					(long)(label->d_secsize), 0) < 0) {
+				printf("aboot: mount of partition %d failed\n",
+				       partition);
+			} else break;
+		}
+		if (bootfs[i] == NULL) {
+			printf("aboot: don't know how to mount "
+			       "partition %d (filesystem type %d)\n",
+			       partition, part->p_fstype);
 			return 0;
 		}
 	}
diff -urN aboot-1.0_pre20040408/fs/reiserfs.c aboot-1.0_pre20040408-mine/fs/reiserfs.c
--- aboot-1.0_pre20040408/fs/reiserfs.c	1969-12-31 19:00:00.000000000 -0500
+++ aboot-1.0_pre20040408-mine/fs/reiserfs.c	2005-09-21 21:55:29.000000000 -0400
@@ -0,0 +1,1180 @@
+/* reiserfs.c - an implementation for the ReiserFS filesystem */
+/*
+ * This file was taken from GRUB and adapted to the aboot interface by
+ * Ilia Mirkin [[e-mail]] in September 2005. Copyrights from
+ * GRUB follow:
+ *
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2000, 2001  Free Software Foundation, Inc.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#include <asm/system.h>
+
+#include <config.h>
+#include <aboot.h>
+#include <bootfs.h>
+#include <cons.h>
+#include <utils.h>
+#include <disklabel.h>
+#include <string.h>
+
+#define BLOCKSIZE (16*SECT_SIZE)
+
+//#define REISERDEBUG 1
+#undef REISERDEBUG
+
+#define ERR_FSYS_CORRUPT 2
+
+/* Some parts of this code (mainly the structures and defines) are
+ * from the original reiser fs code, as found in the linux kernel.
+ */
+
+/* include/asm-i386/types.h */
+/*typedef __signed__ char __s8;
+typedef unsigned char __u8;
+typedef __signed__ short __s16;
+typedef unsigned short __u16;
+typedef __signed__ int __s32;
+typedef unsigned int __u32;
+typedef unsigned long long __u64;*/
+
+/* linux/posix_type.h */
+typedef long linux_off_t;
+
+/* linux/little_endian.h */
+/*#define __cpu_to_le64(x) ((__u64) (x))
+#define __le64_to_cpu(x) ((__u64) (x))
+#define __cpu_to_le32(x) ((__u32) (x))
+#define __le32_to_cpu(x) ((__u32) (x))
+#define __cpu_to_le16(x) ((__u16) (x))
+#define __le16_to_cpu(x) ((__u16) (x))*/
+
+/* include/linux/reiser_fs.h */
+/* This is the new super block of a journaling reiserfs system */
+struct reiserfs_super_block
+{
+  __u32 s_block_count;			/* blocks count         */
+  __u32 s_free_blocks;                  /* free blocks count    */
+  __u32 s_root_block;           	/* root block number    */
+  __u32 s_journal_block;           	/* journal block number    */
+  __u32 s_journal_dev;           	/* journal device number  */
+  __u32 s_journal_size; 		/* size of the journal on FS creation.  used to make sure they don't overflow it */
+  __u32 s_journal_trans_max;            /* max number of blocks in a transaction.  */
+  __u32 s_journal_magic;                /* random value made on fs creation */
+  __u32 s_journal_max_batch;            /* max number of blocks to batch into a trans */
+  __u32 s_journal_max_commit_age;       /* in seconds, how old can an async commit be */
+  __u32 s_journal_max_trans_age;        /* in seconds, how old can a transaction be */
+  __u16 s_blocksize;                   	/* block size           */
+  __u16 s_oid_maxsize;			/* max size of object id array  */
+  __u16 s_oid_cursize;			/* current size of object id array */
+  __u16 s_state;                       	/* valid or error       */
+  char s_magic[16];                     /* reiserfs magic string indicates that file system is reiserfs */
+  __u16 s_tree_height;                  /* height of disk tree */
+  __u16 s_bmap_nr;                      /* amount of bitmap blocks needed to address each block of file system */
+  __u16 s_version;
+  char s_unused[128];			/* zero filled by mkreiserfs */
+};
+
+#define REISERFS_MAX_SUPPORTED_VERSION 2
+#define REISERFS_SUPER_MAGIC_STRING "ReIsErFs"
+#define REISER2FS_SUPER_MAGIC_STRING "ReIsEr2Fs"
+#define REISER3FS_SUPER_MAGIC_STRING "ReIsEr3Fs"
+
+#define MAX_HEIGHT 7
+
+/* must be correct to keep the desc and commit structs at 4k */
+#define JOURNAL_TRANS_HALF 1018
+
+/* first block written in a commit.  */
+struct reiserfs_journal_desc {
+  __u32 j_trans_id;			/* id of commit */
+  __u32 j_len;				/* length of commit. len +1 is the commit block */
+  __u32 j_mount_id;			/* mount id of this trans*/
+  __u32 j_realblock[JOURNAL_TRANS_HALF]; /* real locations for the first blocks */
+  char j_magic[12];
+};
+
+/* last block written in a commit */
+struct reiserfs_journal_commit {
+  __u32 j_trans_id;			/* must match j_trans_id from the desc block */
+  __u32 j_len;			/* ditto */
+  __u32 j_realblock[JOURNAL_TRANS_HALF]; /* real locations for the last blocks */
+  char j_digest[16];			/* md5 sum of all the blocks involved, including desc and commit. not used, kill it */
+};
+
+/* this header block gets written whenever a transaction is considered
+   fully flushed, and is more recent than the last fully flushed
+   transaction.  
+   fully flushed means all the log blocks and all the real blocks are
+   on disk, and this transaction does not need to be replayed.  
+*/
+struct reiserfs_journal_header {
+  /* id of last fully flushed transaction */
+  __u32 j_last_flush_trans_id;
+  /* offset in the log of where to start replay after a crash */
+  __u32 j_first_unflushed_offset;
+  /* mount id to detect very old transactions */
+  __u32 j_mount_id;
+};
+
+/* magic string to find desc blocks in the journal */
+#define JOURNAL_DESC_MAGIC "ReIsErLB" 
+
+
+/*
+ * directories use this key as well as old files
+ */
+struct offset_v1
+{
+  /*
+   * for regular files this is the offset to the first byte of the
+   * body, contained in the object-item, as measured from the start of
+   * the entire body of the object.
+   *
+   * for directory entries, k_offset consists of hash derived from
+   * hashing the name and using few bits (23 or more) of the resulting
+   * hash, and generation number that allows distinguishing names with
+   * hash collisions. If number of collisions overflows generation
+   * number, we return EEXIST.  High order bit is 0 always 
+   */
+  __u32 k_offset;
+  __u32 k_uniqueness;
+};
+
+struct offset_v2
+{
+  /*
+   * for regular files this is the offset to the first byte of the
+   * body, contained in the object-item, as measured from the start of
+   * the entire body of the object.
+   *
+   * for directory entries, k_offset consists of hash derived from
+   * hashing the name and using few bits (23 or more) of the resulting
+   * hash, and generation number that allows distinguishing names with
+   * hash collisions. If number of collisions overflows generation
+   * number, we return EEXIST.  High order bit is 0 always 
+   */
+  __u64 k_offset:60;
+  __u64 k_type: 4;
+};
+
+
+struct key
+{
+  /* packing locality: by default parent directory object id */
+  __u32 k_dir_id;
+  /* object identifier */
+  __u32 k_objectid;
+  /* the offset and node type (old and new form) */
+  union
+  {
+    struct offset_v1 v1;
+    struct offset_v2 v2;
+  }
+  u;
+};
+
+#define KEY_SIZE (sizeof (struct key))
+
+/* Header of a disk block.  More precisely, header of a formatted leaf
+   or internal node, and not the header of an unformatted node. */
+struct block_head
+{       
+  __u16 blk_level;        /* Level of a block in the tree. */
+  __u16 blk_nr_item;      /* Number of keys/items in a block. */
+  __u16 blk_free_space;   /* Block free space in bytes. */
+  struct key  blk_right_delim_key; /* Right delimiting key for this block (supported for leaf level nodes
+				      only) */
+};
+#define BLKH_SIZE (sizeof (struct block_head))
+#define DISK_LEAF_NODE_LEVEL  1 /* Leaf node level.                       */
+
+struct item_head
+{
+  struct key ih_key; 	/* Everything in the tree is found by searching for it based on its key.*/
+  
+  union
+  {
+    __u16 ih_free_space; /* The free space in the last unformatted node of an indirect item if this
+			    is an indirect item.  This equals 0xFFFF iff this is a direct item or
+			    stat data item. Note that the key, not this field, is used to determine
+			    the item type, and thus which field this union contains. */
+    __u16 ih_entry_count; /* Iff this is a directory item, this field equals the number of directory
+			     entries in the directory item. */
+  }
+  u;
+  __u16 ih_item_len;           /* total size of the item body                  */
+  __u16 ih_item_location;      /* an offset to the item body within the block  */
+  __u16 ih_version;	       /* ITEM_VERSION_1 for all old items, 
+				  ITEM_VERSION_2 for new ones. 
+				  Highest bit is set by fsck
+                                  temporary, cleaned after all done */
+};
+/* size of item header     */
+#define IH_SIZE (sizeof (struct item_head))
+
+#define ITEM_VERSION_1 0
+#define ITEM_VERSION_2 1
+#define IH_KEY_OFFSET(ih) ((ih)->ih_version == ITEM_VERSION_1 \
+			   ? (ih)->ih_key.u.v1.k_offset \
+			   : (ih)->ih_key.u.v2.k_offset)
+
+#define IH_KEY_ISTYPE(ih, type) ((ih)->ih_version == ITEM_VERSION_1 \
+				 ? (ih)->ih_key.u.v1.k_uniqueness == V1_##type \
+				 : (ih)->ih_key.u.v2.k_type == V2_##type)
+
+struct disk_child
+{
+  __u32       dc_block_number;              /* Disk child's block number. */
+  __u16      dc_size;		            /* Disk child's used space.   */
+    __u16      dc_reserved;
+};
+
+#define DC_SIZE (sizeof (struct disk_child))
+
+/* Stat Data on disk.
+ *
+ * Note that reiserfs has two different forms of stat data.  Luckily
+ * the fields needed by grub are at the same position.
+ */
+struct stat_data
+{
+  __u16 sd_mode;	/* file type, permissions */
+  __u16 sd_notused1[3]; /* fields not needed by reiserfs */
+  __u32 sd_size;	/* file size */
+  __u32 sd_size_hi;	/* file size high 32 bits (since version 2) */
+};
+
+struct reiserfs_de_head
+{
+  __u32 deh_offset;  /* third component of the directory entry key */
+  __u32 deh_dir_id;  /* objectid of the parent directory of the
+			object, that is referenced by directory entry */
+  __u32 deh_objectid;/* objectid of the object, that is referenced by
+                        directory entry */
+  __u16 deh_location;/* offset of name in the whole item */
+  __u16 deh_state;   /* whether 1) entry contains stat data (for
+			future), and 2) whether entry is hidden
+			(unlinked) */
+};
+
+#define DEH_SIZE (sizeof (struct reiserfs_de_head))
+
+#define DEH_Statdata (1 << 0)			/* not used now */
+#define DEH_Visible  (1 << 2)
+
+#define SD_OFFSET  0
+#define SD_UNIQUENESS 0
+#define DOT_OFFSET 1
+#define DOT_DOT_OFFSET 2
+#define DIRENTRY_UNIQUENESS 500
+
+#define V1_TYPE_STAT_DATA 0x0
+#define V1_TYPE_DIRECT 0xffffffff
+#define V1_TYPE_INDIRECT 0xfffffffe
+#define V1_TYPE_DIRECTORY_MAX 0xfffffffd
+#define V2_TYPE_STAT_DATA 0
+#define V2_TYPE_INDIRECT 1
+#define V2_TYPE_DIRECT 2
+#define V2_TYPE_DIRENTRY 3 
+
+#define REISERFS_ROOT_OBJECTID 2
+#define REISERFS_ROOT_PARENT_OBJECTID 1
+#define REISERFS_DISK_OFFSET_IN_BYTES (64 * 1024)
+/* the spot for the super in versions 3.5 - 3.5.11 (inclusive) */
+#define REISERFS_OLD_DISK_OFFSET_IN_BYTES (8 * 1024)
+#define REISERFS_OLD_BLOCKSIZE 4096
+
+#define S_ISREG(mode) (((mode) & 0170000) == 0100000)
+#define S_ISDIR(mode) (((mode) & 0170000) == 0040000)
+#define S_ISLNK(mode) (((mode) & 0170000) == 0120000)
+
+#define PATH_MAX       1024	/* include/linux/limits.h */
+#define MAX_LINK_COUNT    5	/* number of symbolic links to follow */
+
+/* The size of the node cache */
+#define FSYSREISER_CACHE_SIZE 24*1024
+#define FSYSREISER_MIN_BLOCKSIZE SECTOR_SIZE
+#define FSYSREISER_MAX_BLOCKSIZE FSYSREISER_CACHE_SIZE / 3
+
+/* Info about currently opened file */
+struct fsys_reiser_fileinfo
+{
+  __u32 k_dir_id;
+  __u32 k_objectid;
+};
+
+/* In memory info about the currently mounted filesystem */
+struct fsys_reiser_info
+{
+  /* The last read item head */
+  struct item_head *current_ih;
+  /* The last read item */
+  char *current_item;
+  /* The information for the currently opened file */
+  struct fsys_reiser_fileinfo fileinfo;
+  /* The start of the journal */
+  __u32 journal_block;
+  /* The size of the journal */
+  __u32 journal_block_count;
+  /* The first valid descriptor block in journal
+     (relative to journal_block) */
+  __u32 journal_first_desc;
+
+  /* The ReiserFS version. */
+  __u16 version;
+  /* The current depth of the reiser tree. */
+  __u16 tree_depth;
+  /* SECTOR_SIZE << blocksize_shift == blocksize. */
+  __u8  blocksize_shift;
+  /* 1 << full_blocksize_shift == blocksize. */
+  __u8  fullblocksize_shift;
+  /* The reiserfs block size  (must be a power of 2) */
+  __u16 blocksize;
+  /* The number of cached tree nodes */
+  __u16 cached_slots;
+  /* The number of valid transactions in journal */
+  __u16 journal_transactions;
+  
+  unsigned int blocks[MAX_HEIGHT];
+  unsigned int next_key_nr[MAX_HEIGHT];
+};
+
+/* The cached s+tree blocks in FSYS_BUF,  see below
+ * for a more detailed description.
+ */
+
+#define FSYS_BUF ((__u64)fsys_buffer)
+#define FSYS_BUFLEN  (0x8000L)
+
+#define ROOT     ((char *) ((__u64) FSYS_BUF))
+#define CACHE(i) (ROOT + (((__u64)i) << INFO->fullblocksize_shift))
+#define LEAF     CACHE (DISK_LEAF_NODE_LEVEL)
+
+#define BLOCKHEAD(cache) ((struct block_head *) cache)
+#define ITEMHEAD         ((struct item_head  *) ((__u64) LEAF + BLKH_SIZE))
+#define KEY(cache)       ((struct key        *) ((__u64) cache + BLKH_SIZE))
+#define DC(cache)        ((struct disk_child *) \
+			  ((__u64) cache + BLKH_SIZE + KEY_SIZE * nr_item))
+/* The fsys_reiser_info block.
+ */
+#define INFO \
+    ((struct fsys_reiser_info *) ((__u64) FSYS_BUF + FSYSREISER_CACHE_SIZE))
+/* 
+ * The journal cache.  For each transaction it contains the number of
+ * blocks followed by the real block numbers of this transaction.  
+ *
+ * If the block numbers of some transaction won't fit in this space,
+ * this list is stopped with a 0xffffffff marker and the remaining
+ * uncommitted transactions aren't cached.  
+ */
+#define JOURNAL_START    ((__u32 *) (INFO + 1))
+#define JOURNAL_END      ((__u32 *) (FSYS_BUF + FSYS_BUFLEN))
+
+#define MAX_OPEN_FILES 5
+
+static struct fd_table_entry {
+    struct item_head *ih;
+    char *current_item;
+    int current_item_pos;
+    int used;
+    char *cur_name;
+    int mode;
+    struct fsys_reiser_fileinfo fileinfo;
+} fd_table[MAX_OPEN_FILES];
+
+static int errnum = 0;
+
+static __inline__ unsigned long
+log2 (unsigned long word)
+{
+  __asm__ ("bsfl %1,%0"
+	   : "=r" (word)
+	   : "r" (word));
+  return word;
+}
+
+static __inline__ int
+is_power_of_two (unsigned long word)
+{
+  return (word & -word) == word;
+}
+
+static int reiserfs_mount(long cons_dev, long p_offset, long quiet);
+static int reiserfs_bread(int fd, long blkno, long nblks, char *buffer);
+static int reiserfs_open(const char *filename);
+static void reiserfs_close(int fd);
+static const char *reiserfs_readdir(int fd, int rewind);
+static int next_key(int);
+static int search_stat(int, __u32, __u32);
+
+struct bootfs reiserfs = {
+	FS_EXT2, 0,
+	reiserfs_mount,
+	reiserfs_open,  reiserfs_bread,  reiserfs_close,
+        reiserfs_readdir
+};
+
+int isspace(char ch) {
+    if (ch == ' ' || ch == '\r' || ch == '\n') return 1;
+    return 0;
+}
+
+static long dev = -1;
+static long partition_offset = 0;
+
+static void *fsys_buffer;
+
+static int devread(int sector, int byte_offset, int byte_len, char *buf) {
+    //printf("devread(sector = %d, offt = %d, len = %d, buf = %p)\n", sector,
+    //       byte_offset, byte_len, buf);
+    if (sector < 0) {
+        return 0;
+    }
+
+    long offset = (((long)sector) << 9) + partition_offset + byte_offset;
+    return cons_read(dev, buf, byte_len, offset);
+}
+
+static int 
+journal_read (int block, int len, char *buffer) 
+{
+    //printf("journal_read(block = %d, len = %d, buffer = %p)\n", block, len, buffer);
+    return devread ((int)((INFO->journal_block + block) << INFO->blocksize_shift),
+                    0, len, buffer);
+}
+
+/* Read a block from ReiserFS file system, taking the journal into
+ * account.  If the block nr is in the journal, the block from the
+ * journal taken.  
+ */
+static int
+block_read (int blockNr, int start, int len, char *buffer)
+{
+
+    //printf("block_read(blockNr = %d, start = %d, len = %d, buffer = %p)\n", blockNr,
+    //       start, len, buffer);
+
+    int transactions = INFO->journal_transactions;
+    int desc_block = INFO->journal_first_desc;
+    int journal_mask = INFO->journal_block_count - 1;
+    int translatedNr = blockNr;
+    __u32 *journal_table = JOURNAL_START;
+    while (transactions-- > 0) {
+        int i = 0;
+        int j_len;
+        if (*journal_table != 0xffffffff) {
+            /* Search for the blockNr in cached journal */
+            j_len = *journal_table++;
+            while (i++ < j_len) {
+                if (*journal_table++ == blockNr) {
+                    journal_table += j_len - i;
+                    goto found;
+                }
+            }
+        } else {
+            /* This is the end of cached journal marker.  The remaining
+             * transactions are still on disk.
+             */
+            struct reiserfs_journal_desc   desc;
+            struct reiserfs_journal_commit commit;
+            
+            if (! journal_read (desc_block, sizeof (desc), (char *) &desc))
+                return 0;
+            
+            j_len = desc.j_len;
+            while (i < j_len && i < JOURNAL_TRANS_HALF)
+                if (desc.j_realblock[i++] == blockNr)
+                    goto found;
+            
+            if (j_len >= JOURNAL_TRANS_HALF) {
+                int commit_block = (desc_block + 1 + j_len) & journal_mask;
+                if (! journal_read (commit_block, 
+                                    sizeof (commit), (char *) &commit))
+                    return 0;
+                while (i < j_len)
+                    if (commit.j_realblock[i++ - JOURNAL_TRANS_HALF] == blockNr)
+                        goto found;
+            }
+        }
+        goto not_found;
+        
+    found:
+        translatedNr = INFO->journal_block + ((desc_block + i) & journal_mask);
+#ifdef REISERDEBUG
+        printf ("block_read: block %d is mapped to journal block %d.\n", 
+                blockNr, translatedNr - INFO->journal_block);
+#endif
+        /* We must continue the search, as this block may be overwritten
+         * in later transactions.
+         */
+    not_found:
+        desc_block = (desc_block + 2 + j_len) & journal_mask;
+    }
+    return devread (translatedNr << INFO->blocksize_shift, start, len, buffer);
+}
+
+/* Init the journal data structure.  We try to cache as much as
+ * possible in the JOURNAL_START-JOURNAL_END space, but if it is full
+ * we can still read the rest from the disk on demand.
+ *
+ * The first number of valid transactions and the descriptor block of the
+ * first valid transaction are held in INFO.  The transactions are all 
+ * adjacent, but we must take care of the journal wrap around. 
+ */
+static int
+journal_init (void)
+{
+    //printf("in journal_init()\n");
+
+    unsigned int block_count = INFO->journal_block_count;
+    unsigned int desc_block;
+    unsigned int commit_block;
+    unsigned int next_trans_id;
+    struct reiserfs_journal_header header;
+    struct reiserfs_journal_desc   desc;
+    struct reiserfs_journal_commit commit;
+    __u32 *journal_table = JOURNAL_START;
+    
+    journal_read (block_count, sizeof (header), (char *) &header);
+    desc_block = header.j_first_unflushed_offset;
+    if (desc_block >= block_count)
+        return 0;
+    
+    INFO->journal_first_desc = desc_block;
+    next_trans_id = header.j_last_flush_trans_id + 1;
+    
+#ifdef REISERDEBUG
+    printf ("journal_init: last flushed %d\n", 
+            header.j_last_flush_trans_id);
+#endif
+
+    while (1) {
+        journal_read (desc_block, sizeof (desc), (char *) &desc);
+        if (strcmp(JOURNAL_DESC_MAGIC, desc.j_magic) ||
+            desc.j_trans_id != next_trans_id ||
+            desc.j_mount_id != header.j_mount_id)
+            /* no more valid transactions */
+            break;
+      
+        commit_block = (desc_block + desc.j_len + 1) & (block_count - 1);
+        journal_read (commit_block, sizeof (commit), (char *) &commit);
+        if (desc.j_trans_id != commit.j_trans_id
+            || desc.j_len != commit.j_len)
+            /* no more valid transactions */
+            break;
+      
+#ifdef REISERDEBUG
+        printf ("Found valid transaction %d/%d at %d.\n", 
+                desc.j_trans_id, desc.j_mount_id, desc_block);
+#endif
+
+        next_trans_id++;
+        if (journal_table < JOURNAL_END) {
+            if ((journal_table + 1 + desc.j_len) >= JOURNAL_END) {
+                /* The table is almost full; mark the end of the cached
+                 * journal.*/
+                *journal_table = 0xffffffff;
+                journal_table = JOURNAL_END;
+	    } else {
+                int i;
+                /* Cache the length and the realblock numbers in the table.
+                 * The block number of descriptor can easily be computed.
+                 * and need not to be stored here.
+                 */
+                *journal_table++ = desc.j_len;
+                for (i = 0; i < desc.j_len && i < JOURNAL_TRANS_HALF; i++) {
+                    *journal_table++ = desc.j_realblock[i];
+#ifdef REISERDEBUG
+                    printf ("block %d is in journal %d.\n", 
+                            desc.j_realblock[i], desc_block);
+#endif
+		}
+                for (     ; i < desc.j_len; i++) {
+                    *journal_table++ = commit.j_realblock[i-JOURNAL_TRANS_HALF];
+#ifdef REISERDEBUG
+                    printf ("block %d is in journal %d.\n", 
+                            commit.j_realblock[i-JOURNAL_TRANS_HALF], 
+                            desc_block);
+#endif
+		}
+	    }
+	}
+        desc_block = (commit_block + 1) & (block_count - 1);
+    }
+#ifdef REISERDEBUG
+    printf ("Transaction %d/%d at %d isn't valid.\n", 
+            desc.j_trans_id, desc.j_mount_id, desc_block);
+#endif
+
+    INFO->journal_transactions
+        = next_trans_id - header.j_last_flush_trans_id - 1;
+    return errnum == 0;
+}
+
+
+/*
+ * Initialize 'filesystem' 
+ * Returns 0 if successful, -1 on failure.
+ */
+static int
+reiserfs_mount(long cons_dev, long p_offset, long quiet)
+{
+    struct reiserfs_super_block super;
+    dev = cons_dev;
+    partition_offset = p_offset;
+    int superblock = REISERFS_DISK_OFFSET_IN_BYTES;
+    
+    memset(fd_table, 0, sizeof(fd_table));
+
+    if (!cons_read(dev, &super, sizeof(super), partition_offset + superblock) ||
+        (strcmp(REISER3FS_SUPER_MAGIC_STRING, super.s_magic) &&
+         strcmp(REISER2FS_SUPER_MAGIC_STRING, super.s_magic) &&
+         strcmp(REISERFS_SUPER_MAGIC_STRING, super.s_magic)) ||
+        (super.s_journal_block * super.s_blocksize <= 
+         REISERFS_DISK_OFFSET_IN_BYTES)) {
+        printf("FIXME: check for old partition type.\n");
+        printf("ReiserFS partition not found\n");
+        return -1;
+    }
+
+    if (super.s_version > REISERFS_MAX_SUPPORTED_VERSION) return -1;
+
+#define SECTOR_BITS                9
+#define SECTOR_SIZE                0x200
+
+    fsys_buffer = malloc(0x8000);
+
+    INFO->version = super.s_version;
+    INFO->blocksize = super.s_blocksize;
+    reiserfs.blocksize = super.s_blocksize;
+    INFO->fullblocksize_shift = 12;//log2 (super.s_blocksize);
+    //printf("expecting s_blocksize to be 4096. it is %d\n", super.s_blocksize);
+    INFO->blocksize_shift = INFO->fullblocksize_shift - SECTOR_BITS;
+    INFO->cached_slots = (FSYSREISER_CACHE_SIZE >> INFO->fullblocksize_shift) - 1;
+    
+    if (!quiet) {
+        printf("reiserfs_mount: version = %d, blocksize = %d, root block = %d\n",
+               super.s_version, super.s_blocksize, super.s_root_block);
+    }
+
+    memset(INFO->blocks, 0, sizeof(INFO->blocks));
+
+    if (super.s_blocksize < FSYSREISER_MIN_BLOCKSIZE || 
+        super.s_blocksize > FSYSREISER_MAX_BLOCKSIZE ||
+        (SECTOR_SIZE << INFO->blocksize_shift) != super.s_blocksize)
+        return -1;
+
+    INFO->journal_transactions = 0;
+
+    if (super.s_journal_block != 0 && super.s_journal_dev == 0) {
+        INFO->journal_block = super.s_journal_block;
+        INFO->journal_block_count = super.s_journal_size;
+        if (is_power_of_two (INFO->journal_block_count))
+            journal_init ();
+
+        /* Read in super block again, maybe it is in the journal */
+        block_read (superblock >> INFO->fullblocksize_shift, 
+                    0, sizeof (struct reiserfs_super_block), (char *) &super);
+    }
+
+    if (! block_read (super.s_root_block, 0, INFO->blocksize, (char*) ROOT))
+        return -1;
+  
+    INFO->tree_depth = BLOCKHEAD (ROOT)->blk_level;
+  
+#ifdef REISERDEBUG
+    printf ("root read_in: block=%d, depth=%d\n", 
+            super.s_root_block, INFO->tree_depth);
+#endif /* REISERDEBUG */
+
+    if (INFO->tree_depth >= MAX_HEIGHT)
+        return -1;
+    if (INFO->tree_depth == DISK_LEAF_NODE_LEVEL) {
+        /* There is only one node in the whole filesystem, 
+         * which is simultanously leaf and root */
+        memcpy (LEAF, ROOT, INFO->blocksize);
+    }
+
+    return 0;
+}
+
+
+/*
+ * Read block number "blkno".
+ */
+static int
+reiserfs_bread(int fd, long blkno, long nblks, char *buffer)
+{
+    //ok. this is going to be highly inefficient. seek to the
+    //beginning of the file, then go to the block and read that data
+    //into the buffer.
+    search_stat(fd, fd_table[fd].fileinfo.k_dir_id, fd_table[fd].fileinfo.k_objectid);
+
+    unsigned int blocksize;
+    unsigned int offset;
+    unsigned int to_read;
+    char *prev_buf = buffer;
+    long len = (blkno + nblks) * INFO->blocksize;
+    long filepos = 0;
+    errnum = 0;
+  
+#ifdef REISERDEBUG
+    printf ("reiserfs_read: filepos=%d len=%d (really %d), offset=%x:%x\n",
+            filepos, len, nblks * INFO->blocksize, (__u64) IH_KEY_OFFSET (fd_table[fd].ih) - 1);
+#endif /* REISERDEBUG */
+  
+    goto get_next_key;
+  
+    while (! errnum) {
+        if (fd_table[fd].ih->ih_key.k_objectid != fd_table[fd].fileinfo.k_objectid)
+            break;
+      
+        offset = filepos - IH_KEY_OFFSET (fd_table[fd].ih) + 1;
+        blocksize = fd_table[fd].ih->ih_item_len;
+      
+#ifdef REISERDEBUG
+        printf ("  loop: filepos=%d len=%d, offset=%d blocksize=%d\n",
+                filepos, len, offset, blocksize);
+#endif /* REISERDEBUG */
+      
+        if (IH_KEY_ISTYPE(fd_table[fd].ih, TYPE_DIRECT) && offset < blocksize) {
+#ifdef REISERDEBUG
+            printf ("direct_read: offset=%d, blocksize=%d\n",
+                    offset, blocksize);
+#endif /* REISERDEBUG */
+            to_read = blocksize - offset;
+            if (to_read > len)
+                to_read = len;
+
+            if (filepos < blkno * INFO->blocksize) {
+                if (filepos + to_read > blkno * INFO->blocksize) {
+                    int change = blkno * INFO->blocksize - filepos;
+                    len -= change;
+                    offset += change;
+                    filepos += change;
+                    to_read -= change;
+                } else {
+                    goto update_buf_len;
+                }
+            }
+	    memcpy (buffer, fd_table[fd].current_item + offset, to_read);
+            buffer += to_read;
+            goto update_buf_len;
+	} else if (IH_KEY_ISTYPE(fd_table[fd].ih, TYPE_INDIRECT)) {
+            blocksize = (blocksize >> 2) << INFO->fullblocksize_shift;
+#ifdef REISERDEBUG
+            printf ("indirect_read: offset=%d, blocksize=%d\n",
+                    offset, blocksize);
+#endif /* REISERDEBUG */
+	  
+            while (offset < blocksize) {
+                __u32 blocknr = ((__u32 *) fd_table[fd].current_item)
+                    [offset >> INFO->fullblocksize_shift];
+                int blk_offset = offset & (INFO->blocksize-1);
+	      
+                to_read = INFO->blocksize - blk_offset;
+                if (to_read > len)
+                    to_read = len;
+	      
+                if (filepos < blkno * INFO->blocksize) {
+                    if (filepos + to_read > blkno * INFO->blocksize) {
+                        int change = blkno * INFO->blocksize - filepos;
+                        len -= change;
+                        offset += change;
+                        blk_offset += change;
+                        filepos += change;
+                        to_read -= change;
+                    } else {
+                        goto update_buf_len;
+                    }
+                }
+
+                /* Journal is only for meta data.  Data blocks can be read
+                 * directly without using block_read
+                 */
+                devread (blocknr << INFO->blocksize_shift,
+                         blk_offset, to_read, buffer);
+	      
+                buffer += to_read;
+	    update_buf_len:
+                len -= to_read;
+                offset += to_read;
+                filepos += to_read;
+                if (len == 0)
+                    goto done;
+	    }
+	}
+    get_next_key:
+        next_key (fd);
+    }
+ done:
+    return errnum ? -errnum : buffer - prev_buf;
+}
+
+
+/*
+ * Unix-like open routine.  Returns a small integer 
+ * (does not care what file, we say it's OK)
+ */
+static int reiserfs_open(const char *filename)
+{
+    struct reiserfs_de_head *de_head;
+    __u32 dir_id, objectid, parent_dir_id = 0, parent_objectid = 0;
+
+    int fd;
+
+    char filname[128];
+    char *fname = filname;
+
+    if (strlen(fname) > 127) return -1;
+    strncpy(fname, filename, 127);
+
+    dir_id = REISERFS_ROOT_PARENT_OBJECTID;
+    objectid = REISERFS_ROOT_OBJECTID;
+
+    for (fd = 0; fd < MAX_OPEN_FILES; fd++) {
+        if (fd_table[fd].used == 0) {
+            break;
+        }
+    }
+
+    if (fd == MAX_OPEN_FILES) {
+        printf("reiserfs: no free fd's\n");
+        return -1;
+    }
+
+    while (1) {
+        //find object id (starts with /, then goes on from there)
+        if (!search_stat(fd, dir_id, objectid))
+            return -1;
+
+        fd_table[fd].mode = ((struct stat_data *)fd_table[fd].current_item)->sd_mode;
+
+        if (S_ISLNK(fd_table[fd].mode)) {
+            printf("symlink detected in path -- currently not supported\n");
+            return -1;
+        }
+
+        //remove prepended /'s
+        while (*fname == '/') fname++;
+
+        if (*fname == 0 || isspace(*fname)) {
+            //we must have found it!
+            fd_table[fd].current_item_pos = 0;
+            fd_table[fd].fileinfo.k_dir_id = dir_id;
+            fd_table[fd].fileinfo.k_objectid = objectid;
+            //printf("calling next_key to init file (fd = %d)\n", fd);
+            next_key(fd);
+            //printf("open: found (fd = %d)!\n", fd);
+            fd_table[fd].used = 1;
+            return fd;
+        }
+
+        char *rest;
+        char ch;
+        //figure out what directory/file we want to find
+        for (rest = fname; (ch = *rest) && !isspace(ch) && ch != '/'; rest++);
+        *rest = 0;
+
+        //find that directory/file
+        while (1) {
+            char *name_end;
+            int num_entries;
+
+            if (!next_key(fd))
+                return -1;
+
+            if (fd_table[fd].ih->ih_key.k_objectid != objectid) {
+                break;
+            }
+
+            name_end = fd_table[fd].current_item + fd_table[fd].ih->ih_item_len;
+            de_head = (struct reiserfs_de_head *) fd_table[fd].current_item;
+            num_entries = fd_table[fd].ih->u.ih_entry_count;
+            while (num_entries > 0) {
+                char *name = fd_table[fd].current_item + de_head->deh_location;
+                if ((de_head->deh_state & DEH_Visible)) {
+                    int cmp;
+                    char tmp = *name_end;
+                    *name_end = 0;
+                    cmp = strcmp(name, fname);
+                    *name_end = tmp;
+                    if (cmp == 0) goto found;
+                }
+                name_end = name;
+                de_head++;
+                num_entries--;
+            }
+        }
+        *rest = ch;
+        return -1;
+    found:
+        *rest = ch;
+        fname = rest;
+
+        parent_dir_id = dir_id;
+        parent_objectid = objectid;
+        dir_id = de_head->deh_dir_id;
+        objectid = de_head->deh_objectid;
+    }
+}
+
+
+static void reiserfs_close(int fd)
+{
+    if (fd_table[fd].cur_name) free(fd_table[fd].cur_name);
+    fd_table[fd].cur_name = NULL;
+    fd_table[fd].used = 0;
+}
+
+static const char *reiserfs_readdir(int fd, int rewind)
+{
+    //printf("readdir(%d)\n", fd);
+    struct reiserfs_de_head *de_head;
+    if (fd_table[fd].ih->u.ih_entry_count <= 
+        fd_table[fd].current_item_pos) return NULL;
+    if (fd_table[fd].cur_name == NULL) {
+        fd_table[fd].cur_name = malloc(128);
+    }
+    de_head = (struct reiserfs_de_head *) fd_table[fd].current_item;
+    de_head += fd_table[fd].current_item_pos;
+
+    /*printf("from %p for %d bytes\n", fd_table[fd].current_item + de_head->deh_location,
+           fd_table[fd].ih->ih_item_len - de_head->deh_location);
+    */
+    if ((de_head->deh_state & DEH_Visible)) {
+        strncpy(fd_table[fd].cur_name,
+                fd_table[fd].current_item + de_head->deh_location, 
+                fd_table[fd].ih->ih_item_len - de_head->deh_location);
+        fd_table[fd].cur_name[127] = 0;
+        fd_table[fd].current_item_pos++;
+        return fd_table[fd].cur_name;
+    } else {
+        fd_table[fd].current_item_pos++;
+        return reiserfs_readdir(fd, rewind);
+    }
+}
+
+/***************** TREE ACCESSING METHODS *****************************/
+
+/* I assume you are familiar with the ReiserFS tree, if not go to
+ * http://www.namesys.com/content_table.html
+ *
+ * My tree node cache is organized as following
+ *   0   ROOT node
+ *   1   LEAF node  (if the ROOT is also a LEAF it is copied here
+ *   2-n other nodes on current path from bottom to top.  
+ *       if there is not enough space in the cache, the top most are
+ *       omitted.
+ *
+ * I have only two methods to find a key in the tree:
+ *   search_stat(dir_id, objectid) searches for the stat entry (always
+ *       the first entry) of an object.
+ *   next_key() gets the next key in tree order.
+ *
+ * This means, that I can only sequential reads of files are
+ * efficient, but this really doesn't hurt for grub.  
+ */
+
+/* Read in the node at the current path and depth into the node cache.
+ * You must set INFO->blocks[depth] before.
+ */
+static char *
+read_tree_node (unsigned int blockNr, int depth)
+{
+  char* cache = CACHE(depth);
+  int num_cached = INFO->cached_slots;
+  if (depth < num_cached)
+    {
+      /* This is the cached part of the path.  Check if same block is
+       * needed.  
+       */
+      if (0 && blockNr == INFO->blocks[depth])
+	return cache;
+    }
+  else
+    cache = CACHE(num_cached);
+
+#ifdef REISERDEBUG
+  //printf ("  next read_in: block=%d (depth=%d)\n",
+  //blockNr, depth);
+#endif /* REISERDEBUG */
+  if (! block_read (blockNr, 0, INFO->blocksize, cache))
+    return 0;
+  /* Make sure it has the right node level */
+  if (BLOCKHEAD (cache)->blk_level != depth)
+    {
+      errnum = ERR_FSYS_CORRUPT;
+      return 0;
+    }
+
+  INFO->blocks[depth] = blockNr;
+  return cache;
+}
+
+/* Get the next key, i.e. the key following the last retrieved key in
+ * tree order.  INFO->current_ih and 
+ * INFO->current_info are adapted accordingly.  */
+static int
+next_key (int fd)
+{
+  int depth;
+  struct item_head *ih = fd_table[fd].ih + 1;
+  char *cache;
+  
+  if (ih == &ITEMHEAD[BLOCKHEAD (LEAF)->blk_nr_item])
+    {
+      depth = DISK_LEAF_NODE_LEVEL;
+      /* The last item, was the last in the leaf node.  
+       * Read in the next block 
+       */
+      do
+	{
+	  if (depth == INFO->tree_depth)
+	    {
+	      /* There are no more keys at all.
+	       * Return a dummy item with MAX_KEY */
+	      ih = (struct item_head *) &BLOCKHEAD (LEAF)->blk_right_delim_key;
+	      goto found;
+	    }
+	  depth++;
+#ifdef REISERDEBUG
+	  printf ("  depth=%d, i=%d\n", depth, INFO->next_key_nr[depth]);
+#endif /* REISERDEBUG */
+	}
+      while (INFO->next_key_nr[depth] == 0);
+      
+      if (depth == INFO->tree_depth)
+	cache = ROOT;
+      else if (depth <= INFO->cached_slots)
+	cache = CACHE (depth);
+      else 
+	{
+	  cache = read_tree_node (INFO->blocks[depth], depth);
+	  if (! cache)
+	    return 0;
+	}
+      
+      do
+	{
+	  int nr_item = BLOCKHEAD (cache)->blk_nr_item;
+	  int key_nr = INFO->next_key_nr[depth]++;
+#ifdef REISERDEBUG
+	  printf ("  depth=%d, i=%d/%d\n", depth, key_nr, nr_item);
+#endif /* REISERDEBUG */
+	  if (key_nr == nr_item)
+	    /* This is the last item in this block, set the next_key_nr to 0 */
+	    INFO->next_key_nr[depth] = 0;
+
+	  cache = read_tree_node (DC (cache)[key_nr].dc_block_number, --depth);
+	  if (! cache)
+	    return 0;
+	}
+      while (depth > DISK_LEAF_NODE_LEVEL);
+      
+      ih = ITEMHEAD;
+    }
+ found:
+  fd_table[fd].ih   = ih;
+  fd_table[fd].current_item = &LEAF[ih->ih_item_location];
+#ifdef REISERDEBUG
+  printf ("  new ih: key %d:%d:%d:%d version:%d\n", 
+	  fd_table[fd].ih->ih_key.k_dir_id, 
+	  fd_table[fd].ih->ih_key.k_objectid, 
+	  fd_table[fd].ih->ih_key.u.v1.k_offset,
+	  fd_table[fd].ih->ih_key.u.v1.k_uniqueness,
+	  fd_table[fd].ih->ih_version);
+#endif /* REISERDEBUG */
+  return 1;
+}
+
+/* preconditions: reiserfs_mount already executed, therefore 
+ *   INFO block is valid
+ * returns: 0 if error (errnum is set), 
+ *   nonzero iff we were able to find the key successfully.
+ * postconditions: on a nonzero return, the current_ih and 
+ *   current_item fields describe the key that equals the
+ *   searched key.  INFO->next_key contains the next key after
+ *   the searched key.
+ * side effects: messes around with the cache.
+ */
+static int
+search_stat (int fd, __u32 dir_id, __u32 objectid) 
+{
+  char *cache;
+  int depth;
+  int nr_item;
+  int i;
+  struct item_head *ih;
+#ifdef REISERDEBUG
+  printf ("search_stat (%d):\n  key %d:%d:0:0\n", fd, dir_id, objectid);
+#endif /* REISERDEBUG */
+  
+  depth = INFO->tree_depth;
+  cache = ROOT;
+  
+  while (depth > DISK_LEAF_NODE_LEVEL)
+    {
+      struct key *key;
+      nr_item = BLOCKHEAD (cache)->blk_nr_item;
+      
+      key = KEY (cache);
+      
+      for (i = 0; i < nr_item; i++) 
+	{
+	  if (key->k_dir_id > dir_id
+	      || (key->k_dir_id == dir_id 
+		  && (key->k_objectid > objectid
+		      || (key->k_objectid == objectid
+			  && ((__u32)(key->u.v1.k_offset
+			      | key->u.v1.k_uniqueness)) > 0))))
+	    break;
+	  key++;
+	}
+      
+#ifdef REISERDEBUG
+      printf ("  depth=%d, i=%d/%d\n", depth, i, nr_item);
+      //printf ("      (%d:%d)\n", key->k_dir_id, key->k_objectid);
+#endif /* REISERDEBUG */
+      INFO->next_key_nr[depth] = (i == nr_item) ? 0 : i+1;
+      cache = read_tree_node (DC (cache)[i].dc_block_number, --depth);
+      if (! cache)
+	return 0;
+    }
+  
+  /* cache == LEAF */
+  nr_item = BLOCKHEAD (LEAF)->blk_nr_item;
+  ih = ITEMHEAD;
+  for (i = 0; i < nr_item; i++) 
+    {
+      if (ih->ih_key.k_dir_id == dir_id 
+	  && ih->ih_key.k_objectid == objectid
+	  && ih->ih_key.u.v1.k_offset == 0
+	  && ih->ih_key.u.v1.k_uniqueness == 0)
+	{
+#ifdef REISERDEBUG
+            printf ("  depth=%d, i=%d/%d\n", depth, i, nr_item);
+#endif /* REISERDEBUG */
+	  fd_table[fd].ih   = ih;
+	  fd_table[fd].current_item = &LEAF[ih->ih_item_location];
+	  return 1;
+        }
+      ih++;
+    }
+  errnum = ERR_FSYS_CORRUPT;
+  return 0;
+}