15 files changed, 1599 insertions, 0 deletions

diff --git a/qemu/roms/openbios/fs/ext2/build.xml b/qemu/roms/openbios/fs/ext2/build.xml
new file mode 100644
index 000000000..98e9e0569
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/build.xml
@@ -0,0 +1,14 @@
+<build>
+ <library name="fs" type="static" target="target">
+  <object source="ext2_close.c" condition="EXT2"/>
+  <object source="ext2_closedir.c" condition="EXT2"/>
+  <object source="ext2_fs.c" condition="EXT2"/>
+  <object source="ext2_lseek.c" condition="EXT2"/>
+  <object source="ext2_mount.c" condition="EXT2"/>
+  <object source="ext2_open.c" condition="EXT2"/>
+  <object source="ext2_opendir.c" condition="EXT2"/>
+  <object source="ext2_read.c" condition="EXT2"/>
+  <object source="ext2_readdir.c" condition="EXT2"/>
+  <object source="ext2_utils.c" condition="EXT2"/>
+ </library>
+</build>
diff --git a/qemu/roms/openbios/fs/ext2/ext2.h b/qemu/roms/openbios/fs/ext2/ext2.h
new file mode 100644
index 000000000..ad8589284
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2.h
@@ -0,0 +1,33 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#ifndef __EXT2_H__
+#define __EXT2_H__
+
+#include "ext2_fs.h"
+
+typedef struct ext2_VOLUME {
+        int fd;
+	struct ext2_super_block *super;
+	unsigned int current;
+	char *buffer;
+} ext2_VOLUME;
+
+typedef struct ext2_DIR {
+        ext2_VOLUME *volume;
+	struct ext2_inode *inode;
+	off_t index;
+} ext2_DIR;
+
+typedef struct ext2_FILE {
+        ext2_VOLUME *volume;
+	struct ext2_inode *inode;
+	off_t offset;
+	char *path;
+} ext2_FILE;
+#endif /* __LIBEXT2_H__ */
diff --git a/qemu/roms/openbios/fs/ext2/ext2_close.c b/qemu/roms/openbios/fs/ext2/ext2_close.c
new file mode 100644
index 000000000..f370e181e
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_close.c
@@ -0,0 +1,18 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#include "libext2.h"
+
+void ext2_close(ext2_FILE *file)
+{
+	if (file == NULL)
+		return;
+	free(file->inode);
+	free(file->path);
+	free(file);
+}
diff --git a/qemu/roms/openbios/fs/ext2/ext2_closedir.c b/qemu/roms/openbios/fs/ext2/ext2_closedir.c
new file mode 100644
index 000000000..e9f06319c
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_closedir.c
@@ -0,0 +1,18 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#include "libext2.h"
+#include "ext2.h"
+
+void ext2_closedir(ext2_DIR *dir)
+{
+	if (dir == NULL)
+		return;
+	free(dir->inode);
+	free(dir);
+}
diff --git a/qemu/roms/openbios/fs/ext2/ext2_fs.c b/qemu/roms/openbios/fs/ext2/ext2_fs.c
new file mode 100644
index 000000000..66eb0b438
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_fs.c
@@ -0,0 +1,309 @@
+/*
+ *	/packages/ext2-files 
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ * (c) 2010 Mark Cave-Ayland <mark.cave-ayland@siriusit.co.uk>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#include "config.h"
+#include "libopenbios/bindings.h"
+#include "libext2.h"
+#include "ext2_utils.h"
+#include "fs/fs.h"
+#include "libc/vsprintf.h"
+#include "libc/diskio.h"
+
+extern void     ext2_init( void );
+
+typedef struct {
+	enum { FILE, DIR } type;
+	union {
+		ext2_FILE *file;
+		ext2_DIR *dir;
+	};
+} ext2_COMMON;
+
+typedef struct {
+	ext2_VOLUME *volume;
+	ext2_COMMON *common;
+} ext2_info_t;
+
+DECLARE_NODE( ext2, 0, sizeof(ext2_info_t), "+/packages/ext2-files" );
+
+
+static const int days_month[12] =
+	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+static const int days_month_leap[12] =
+	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+
+static inline int is_leap(int year)
+{
+	return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
+}
+
+static void
+print_date(time_t sec)
+{
+	unsigned int second, minute, hour, month, day, year;
+	int current;
+	const int *days;
+
+	second = sec % 60;
+	sec /= 60;
+
+	minute = sec % 60;
+	sec /= 60;
+
+	hour = sec % 24;
+	sec /= 24;
+
+	year = sec * 100 / 36525;
+	sec -= year * 36525 / 100;
+	year += 1970;
+
+	days = is_leap(year) ?  days_month_leap : days_month;
+
+	current = 0;
+	month = 0;
+	while (month < 12) {
+		if (sec <= current + days[month]) {
+			break;
+		}
+		current += days[month];
+		month++;
+	}
+	month++;
+
+	day = sec - current + 1;
+
+	forth_printf("%d-%02d-%02d %02d:%02d:%02d ",
+		     year, month, day, hour, minute, second);
+}
+
+
+/************************************************************************/
+/*	Standard package methods					*/
+/************************************************************************/
+
+/* ( -- success? ) */
+static void
+ext2_files_open( ext2_info_t *mi )
+{
+	int fd;
+	char *path = my_args_copy();
+
+	fd = open_ih( my_parent() );
+	if ( fd == -1 ) {
+		free( path );
+		RET( 0 );
+	}
+
+	mi->volume = ext2_mount(fd);
+	if (!mi->volume) {
+		RET( 0 );
+	}
+
+	mi->common = (ext2_COMMON*)malloc(sizeof(ext2_COMMON));
+	if (mi->common == NULL)
+		RET( 0 );
+
+	mi->common->dir = ext2_opendir(mi->volume, path);
+	if (mi->common->dir == NULL) {
+		mi->common->file = ext2_open(mi->volume, path);
+		if (mi->common->file == NULL) {
+			free(mi->common);
+			RET( 0 );
+		}
+		mi->common->type = FILE;
+		RET( -1 );
+	}
+	mi->common->type = DIR;
+	RET( -1 );
+}
+
+/* ( -- ) */
+static void
+ext2_files_close( ext2_info_t *mi )
+{
+	ext2_COMMON *common = mi->common;
+
+	if (common->type == FILE)
+		ext2_close(common->file);
+	else if (common->type == DIR)
+		ext2_closedir(common->dir);
+	free(common);
+
+	ext2_umount(mi->volume);
+}
+
+/* ( buf len -- actlen ) */
+static void
+ext2_files_read( ext2_info_t *mi )
+{
+	int count = POP();
+	char *buf = (char *)cell2pointer(POP());
+
+	ext2_COMMON *common = mi->common;
+	if (common->type != FILE)
+		RET( -1 );
+
+	RET ( ext2_read( common->file, buf, count ) );
+}
+
+/* ( pos.d -- status ) */
+static void
+ext2_files_seek( ext2_info_t *mi )
+{
+	long long pos = DPOP();
+	int offs = (int)pos;
+	int whence = SEEK_SET;
+	int ret;
+	ext2_COMMON *common = mi->common;
+
+	if (common->type != FILE)
+		RET( -1 );
+
+	ret = ext2_lseek(common->file, offs, whence);
+	if (ret)
+		RET( -1 );
+	else
+		RET( 0 );
+}
+
+/* ( addr -- size ) */
+static void
+ext2_files_load( ext2_info_t *mi )
+{
+	char *buf = (char *)cell2pointer(POP());
+	int count;
+
+	ext2_COMMON *common = mi->common;
+	if (common->type != FILE)
+		RET( -1 );
+
+	/* Seek to the end in order to get the file size */
+	ext2_lseek(common->file, 0, SEEK_END);
+	count = common->file->offset;
+	ext2_lseek(common->file, 0, SEEK_SET);
+
+	RET ( ext2_read( common->file, buf, count ) );
+}
+
+/* ( -- cstr ) */
+static void
+ext2_files_get_path( ext2_info_t *mi )
+{
+	ext2_COMMON *common = mi->common;
+
+	if (common->type != FILE)
+		RET( 0 );
+
+	RET( pointer2cell(strdup(common->file->path)) );
+}
+
+/* ( -- cstr ) */
+static void
+ext2_files_get_fstype( ext2_info_t *mi )
+{
+	PUSH( pointer2cell(strdup("ext2")) );
+}
+
+/* static method, ( pathstr len ihandle -- ) */
+static void
+ext2_files_dir( ext2_info_t *dummy )
+{
+	ext2_COMMON *common;
+	ext2_VOLUME *volume;
+	struct ext2_dir_entry_2 *entry;
+	struct ext2_inode inode;
+	int fd;
+
+	ihandle_t ih = POP();
+	char *path = pop_fstr_copy();
+
+	fd = open_ih( ih );
+	if ( fd == -1 ) {
+		free( path );
+		return;
+	}
+
+	volume = ext2_mount(fd);
+	if (!volume) {
+		return;
+	}
+
+	common = (ext2_COMMON*)malloc(sizeof(ext2_COMMON));
+	common->dir = ext2_opendir(volume, path);
+
+	forth_printf("\n");
+	while ( (entry = ext2_readdir(common->dir)) ) {
+		ext2_get_inode(common->dir->volume, entry->inode, &inode);
+		forth_printf("% 10d ", inode.i_size);
+		print_date(inode.i_mtime);
+		if (S_ISDIR(inode.i_mode))
+			forth_printf("%s\\\n", entry->name);
+		else
+			forth_printf("%s\n", entry->name);
+	}
+
+	ext2_closedir( common->dir );
+	ext2_umount( volume );
+
+	close_io( fd );
+
+	free( common );
+	free( path );
+}
+
+/* static method, ( pos.d ih -- flag? ) */
+static void
+ext2_files_probe( ext2_info_t *dummy )
+{
+	ihandle_t ih = POP_ih();
+	long long offs = DPOP();
+	int fd, ret = 0;
+
+	fd = open_ih(ih);
+        if (fd >= 0) {
+                if (ext2_probe(fd, offs)) {
+                        ret = -1;
+                }
+                close_io(fd);
+        } else {
+                ret = -1;
+        }
+
+	RET (ret);
+}
+
+
+static void
+ext2_initializer( ext2_info_t *dummy )
+{
+	fword("register-fs-package");
+}
+
+NODE_METHODS( ext2 ) = {
+	{ "probe",	ext2_files_probe	},
+	{ "open",	ext2_files_open		},
+	{ "close",	ext2_files_close 	},
+	{ "read",	ext2_files_read		},
+	{ "seek",	ext2_files_seek		},
+	{ "load",	ext2_files_load		},
+	{ "dir",	ext2_files_dir		},
+
+	/* special */
+	{ "get-path",	ext2_files_get_path	},
+	{ "get-fstype",	ext2_files_get_fstype	},
+
+	{ NULL,		ext2_initializer	},
+};
+
+void
+ext2_init( void )
+{
+	REGISTER_NODE( ext2 );
+}
diff --git a/qemu/roms/openbios/fs/ext2/ext2_fs.h b/qemu/roms/openbios/fs/ext2/ext2_fs.h
new file mode 100644
index 000000000..4a7adff7d
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_fs.h
@@ -0,0 +1,534 @@
+/*
+ *  This file has been copied from
+ *  linux/include/linux/ext2_fs.h
+ *
+ * Copyright (C) 1992, 1993, 1994, 1995
+ * Remy Card (card@masi.ibp.fr)
+ * Laboratoire MASI - Institut Blaise Pascal
+ * Universite Pierre et Marie Curie (Paris VI)
+ *
+ *  from
+ *
+ *  linux/include/linux/minix_fs.h
+ *
+ *  Copyright (C) 1991, 1992  Linus Torvalds
+ */
+
+#ifndef _EXT2_FS_H
+#define _EXT2_FS_H
+
+/* from /usr/include/linux/magic.h */
+
+#define EXT2_SUPER_MAGIC	0xEF53
+
+/*
+ * The second extended filesystem constants/structures
+ */
+
+/*
+ * Define EXT2FS_DEBUG to produce debug messages
+ */
+#undef EXT2FS_DEBUG
+
+/*
+ * Define EXT2_RESERVATION to reserve data blocks for expanding files
+ */
+#define EXT2_DEFAULT_RESERVE_BLOCKS     8
+/*max window size: 1024(direct blocks) + 3([t,d]indirect blocks) */
+#define EXT2_MAX_RESERVE_BLOCKS         1027
+#define EXT2_RESERVE_WINDOW_NOT_ALLOCATED 0
+/*
+ * The second extended file system version
+ */
+#define EXT2FS_DATE		"95/08/09"
+#define EXT2FS_VERSION		"0.5b"
+
+/*
+ * Debug code
+ */
+#ifdef EXT2FS_DEBUG
+#	define ext2_debug(f, a...)	{ \
+					printk ("EXT2-fs DEBUG (%s, %d): %s:", \
+						__FILE__, __LINE__, __FUNCTION__); \
+				  	printk (f, ## a); \
+					}
+#else
+#	define ext2_debug(f, a...)	/**/
+#endif
+
+/*
+ * Special inode numbers
+ */
+#define	EXT2_BAD_INO		 1	/* Bad blocks inode */
+#define EXT2_ROOT_INO		 2	/* Root inode */
+#define EXT2_BOOT_LOADER_INO	 5	/* Boot loader inode */
+#define EXT2_UNDEL_DIR_INO	 6	/* Undelete directory inode */
+
+/* First non-reserved inode for old ext2 filesystems */
+#define EXT2_GOOD_OLD_FIRST_INO	11
+
+/* Assume that user mode programs are passing in an ext2fs superblock, not
+ * a kernel struct super_block.  This will allow us to call the feature-test
+ * macros from user land. */
+#define EXT2_SB(sb)	(sb)
+
+/*
+ * Maximal count of links to a file
+ */
+#define EXT2_LINK_MAX		32000
+
+/*
+ * Macro-instructions used to manage several block sizes
+ */
+#define EXT2_MIN_BLOCK_SIZE		1024
+#define	EXT2_MAX_BLOCK_SIZE		4096
+#define EXT2_MIN_BLOCK_LOG_SIZE		  10
+# define EXT2_BLOCK_SIZE(s)		(EXT2_MIN_BLOCK_SIZE << (s)->s_log_block_size)
+#define	EXT2_ADDR_PER_BLOCK(s)		(EXT2_BLOCK_SIZE(s) / sizeof (uint32_t))
+# define EXT2_BLOCK_SIZE_BITS(s)	((s)->s_log_block_size + 10)
+#define EXT2_INODE_SIZE(s)	(((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
+				 EXT2_GOOD_OLD_INODE_SIZE : \
+				 (s)->s_inode_size)
+#define EXT2_FIRST_INO(s)	(((s)->s_rev_level == EXT2_GOOD_OLD_REV) ? \
+				 EXT2_GOOD_OLD_FIRST_INO : \
+				 (s)->s_first_ino)
+
+/*
+ * Macro-instructions used to manage fragments
+ */
+#define EXT2_MIN_FRAG_SIZE		1024
+#define	EXT2_MAX_FRAG_SIZE		4096
+#define EXT2_MIN_FRAG_LOG_SIZE		  10
+# define EXT2_FRAG_SIZE(s)		(EXT2_MIN_FRAG_SIZE << (s)->s_log_frag_size)
+# define EXT2_FRAGS_PER_BLOCK(s)	(EXT2_BLOCK_SIZE(s) / EXT2_FRAG_SIZE(s))
+
+/*
+ * Structure of a blocks group descriptor
+ */
+struct ext2_group_desc
+{
+	uint32_t	bg_block_bitmap;		/* Blocks bitmap block */
+	uint32_t	bg_inode_bitmap;		/* Inodes bitmap block */
+	uint32_t	bg_inode_table;		/* Inodes table block */
+	uint16_t	bg_free_blocks_count;	/* Free blocks count */
+	uint16_t	bg_free_inodes_count;	/* Free inodes count */
+	uint16_t	bg_used_dirs_count;	/* Directories count */
+	uint16_t	bg_pad;
+	uint32_t	bg_reserved[3];
+};
+
+/*
+ * Macro-instructions used to manage group descriptors
+ */
+# define EXT2_BLOCKS_PER_GROUP(s)	((s)->s_blocks_per_group)
+# define EXT2_DESC_PER_BLOCK(s)		(EXT2_BLOCK_SIZE(s) / sizeof (struct ext2_group_desc))
+# define EXT2_INODES_PER_GROUP(s)	((s)->s_inodes_per_group)
+
+/*
+ * Constants relative to the data blocks
+ */
+#define	EXT2_NDIR_BLOCKS		12
+#define	EXT2_IND_BLOCK			EXT2_NDIR_BLOCKS
+#define	EXT2_DIND_BLOCK			(EXT2_IND_BLOCK + 1)
+#define	EXT2_TIND_BLOCK			(EXT2_DIND_BLOCK + 1)
+#define	EXT2_N_BLOCKS			(EXT2_TIND_BLOCK + 1)
+
+/*
+ * Inode flags (GETFLAGS/SETFLAGS)
+ */
+#define	EXT2_SECRM_FL			FS_SECRM_FL	/* Secure deletion */
+#define	EXT2_UNRM_FL			FS_UNRM_FL	/* Undelete */
+#define	EXT2_COMPR_FL			FS_COMPR_FL	/* Compress file */
+#define EXT2_SYNC_FL			FS_SYNC_FL	/* Synchronous updates */
+#define EXT2_IMMUTABLE_FL		FS_IMMUTABLE_FL	/* Immutable file */
+#define EXT2_APPEND_FL			FS_APPEND_FL	/* writes to file may only append */
+#define EXT2_NODUMP_FL			FS_NODUMP_FL	/* do not dump file */
+#define EXT2_NOATIME_FL			FS_NOATIME_FL	/* do not update atime */
+/* Reserved for compression usage... */
+#define EXT2_DIRTY_FL			FS_DIRTY_FL
+#define EXT2_COMPRBLK_FL		FS_COMPRBLK_FL	/* One or more compressed clusters */
+#define EXT2_NOCOMP_FL			FS_NOCOMP_FL	/* Don't compress */
+#define EXT2_ECOMPR_FL			FS_ECOMPR_FL	/* Compression error */
+/* End compression flags --- maybe not all used */
+#define EXT2_BTREE_FL			FS_BTREE_FL	/* btree format dir */
+#define EXT2_INDEX_FL			FS_INDEX_FL	/* hash-indexed directory */
+#define EXT2_IMAGIC_FL			FS_IMAGIC_FL	/* AFS directory */
+#define EXT2_JOURNAL_DATA_FL		FS_JOURNAL_DATA_FL /* Reserved for ext3 */
+#define EXT2_NOTAIL_FL			FS_NOTAIL_FL	/* file tail should not be merged */
+#define EXT2_DIRSYNC_FL			FS_DIRSYNC_FL	/* dirsync behaviour (directories only) */
+#define EXT2_TOPDIR_FL			FS_TOPDIR_FL	/* Top of directory hierarchies*/
+#define EXT2_RESERVED_FL		FS_RESERVED_FL	/* reserved for ext2 lib */
+
+#define EXT2_FL_USER_VISIBLE		FS_FL_USER_VISIBLE	/* User visible flags */
+#define EXT2_FL_USER_MODIFIABLE		FS_FL_USER_MODIFIABLE	/* User modifiable flags */
+
+/*
+ * ioctl commands
+ */
+#define	EXT2_IOC_GETFLAGS		FS_IOC_GETFLAGS
+#define	EXT2_IOC_SETFLAGS		FS_IOC_SETFLAGS
+#define	EXT2_IOC_GETVERSION		FS_IOC_GETVERSION
+#define	EXT2_IOC_SETVERSION		FS_IOC_SETVERSION
+#define	EXT2_IOC_GETRSVSZ		_IOR('f', 5, long)
+#define	EXT2_IOC_SETRSVSZ		_IOW('f', 6, long)
+
+/*
+ * ioctl commands in 32 bit emulation
+ */
+#define EXT2_IOC32_GETFLAGS		FS_IOC32_GETFLAGS
+#define EXT2_IOC32_SETFLAGS		FS_IOC32_SETFLAGS
+#define EXT2_IOC32_GETVERSION		FS_IOC32_GETVERSION
+#define EXT2_IOC32_SETVERSION		FS_IOC32_SETVERSION
+
+/*
+ * Structure of an inode on the disk
+ */
+struct ext2_inode {
+	uint16_t	i_mode;		/* File mode */
+	uint16_t	i_uid;		/* Low 16 bits of Owner Uid */
+	uint32_t	i_size;		/* Size in bytes */
+	uint32_t	i_atime;	/* Access time */
+	uint32_t	i_ctime;	/* Creation time */
+	uint32_t	i_mtime;	/* Modification time */
+	uint32_t	i_dtime;	/* Deletion Time */
+	uint16_t	i_gid;		/* Low 16 bits of Group Id */
+	uint16_t	i_links_count;	/* Links count */
+	uint32_t	i_blocks;	/* Blocks count */
+	uint32_t	i_flags;	/* File flags */
+	union {
+		struct {
+			uint32_t  l_i_reserved1;
+		} linux1;
+		struct {
+			uint32_t  h_i_translator;
+		} hurd1;
+		struct {
+			uint32_t  m_i_reserved1;
+		} masix1;
+	} osd1;				/* OS dependent 1 */
+	uint32_t	i_block[EXT2_N_BLOCKS];/* Pointers to blocks */
+	uint32_t	i_generation;	/* File version (for NFS) */
+	uint32_t	i_file_acl;	/* File ACL */
+	uint32_t	i_dir_acl;	/* Directory ACL */
+	uint32_t	i_faddr;	/* Fragment address */
+	union {
+		struct {
+			uint8_t	l_i_frag;	/* Fragment number */
+			uint8_t	l_i_fsize;	/* Fragment size */
+			uint16_t	i_pad1;
+			uint16_t	l_i_uid_high;	/* these 2 fields    */
+			uint16_t	l_i_gid_high;	/* were reserved2[0] */
+			uint32_t	l_i_reserved2;
+		} linux2;
+		struct {
+			uint8_t	h_i_frag;	/* Fragment number */
+			uint8_t	h_i_fsize;	/* Fragment size */
+			uint16_t	h_i_mode_high;
+			uint16_t	h_i_uid_high;
+			uint16_t	h_i_gid_high;
+			uint32_t	h_i_author;
+		} hurd2;
+		struct {
+			uint8_t	m_i_frag;	/* Fragment number */
+			uint8_t	m_i_fsize;	/* Fragment size */
+			uint16_t	m_pad1;
+			uint32_t	m_i_reserved2[2];
+		} masix2;
+	} osd2;				/* OS dependent 2 */
+};
+
+#define i_size_high	i_dir_acl
+
+#if defined(__KERNEL__) || defined(__linux__)
+#define i_reserved1	osd1.linux1.l_i_reserved1
+#define i_frag		osd2.linux2.l_i_frag
+#define i_fsize		osd2.linux2.l_i_fsize
+#define i_uid_low	i_uid
+#define i_gid_low	i_gid
+#define i_uid_high	osd2.linux2.l_i_uid_high
+#define i_gid_high	osd2.linux2.l_i_gid_high
+#define i_reserved2	osd2.linux2.l_i_reserved2
+#endif
+
+#ifdef	__hurd__
+#define i_translator	osd1.hurd1.h_i_translator
+#define i_frag		osd2.hurd2.h_i_frag;
+#define i_fsize		osd2.hurd2.h_i_fsize;
+#define i_uid_high	osd2.hurd2.h_i_uid_high
+#define i_gid_high	osd2.hurd2.h_i_gid_high
+#define i_author	osd2.hurd2.h_i_author
+#endif
+
+#ifdef	__masix__
+#define i_reserved1	osd1.masix1.m_i_reserved1
+#define i_frag		osd2.masix2.m_i_frag
+#define i_fsize		osd2.masix2.m_i_fsize
+#define i_reserved2	osd2.masix2.m_i_reserved2
+#endif
+
+/*
+ * File system states
+ */
+#define	EXT2_VALID_FS			0x0001	/* Unmounted cleanly */
+#define	EXT2_ERROR_FS			0x0002	/* Errors detected */
+
+/*
+ * Mount flags
+ */
+#define EXT2_MOUNT_CHECK		0x000001  /* Do mount-time checks */
+#define EXT2_MOUNT_OLDALLOC		0x000002  /* Don't use the new Orlov allocator */
+#define EXT2_MOUNT_GRPID		0x000004  /* Create files with directory's group */
+#define EXT2_MOUNT_DEBUG		0x000008  /* Some debugging messages */
+#define EXT2_MOUNT_ERRORS_CONT		0x000010  /* Continue on errors */
+#define EXT2_MOUNT_ERRORS_RO		0x000020  /* Remount fs ro on errors */
+#define EXT2_MOUNT_ERRORS_PANIC		0x000040  /* Panic on errors */
+#define EXT2_MOUNT_MINIX_DF		0x000080  /* Mimics the Minix statfs */
+#define EXT2_MOUNT_NOBH			0x000100  /* No buffer_heads */
+#define EXT2_MOUNT_NO_UID32		0x000200  /* Disable 32-bit UIDs */
+#define EXT2_MOUNT_XATTR_USER		0x004000  /* Extended user attributes */
+#define EXT2_MOUNT_POSIX_ACL		0x008000  /* POSIX Access Control Lists */
+#define EXT2_MOUNT_XIP			0x010000  /* Execute in place */
+#define EXT2_MOUNT_USRQUOTA		0x020000  /* user quota */
+#define EXT2_MOUNT_GRPQUOTA		0x040000  /* group quota */
+#define EXT2_MOUNT_RESERVATION		0x080000  /* Preallocation */
+
+
+#define clear_opt(o, opt)		o &= ~EXT2_MOUNT_##opt
+#define set_opt(o, opt)			o |= EXT2_MOUNT_##opt
+#define test_opt(sb, opt)		(EXT2_SB(sb)->s_mount_opt & \
+					 EXT2_MOUNT_##opt)
+/*
+ * Maximal mount counts between two filesystem checks
+ */
+#define EXT2_DFL_MAX_MNT_COUNT		20	/* Allow 20 mounts */
+#define EXT2_DFL_CHECKINTERVAL		0	/* Don't use interval check */
+
+/*
+ * Behaviour when detecting errors
+ */
+#define EXT2_ERRORS_CONTINUE		1	/* Continue execution */
+#define EXT2_ERRORS_RO			2	/* Remount fs read-only */
+#define EXT2_ERRORS_PANIC		3	/* Panic */
+#define EXT2_ERRORS_DEFAULT		EXT2_ERRORS_CONTINUE
+
+/*
+ * Structure of the super block
+ */
+struct ext2_super_block {
+	uint32_t	s_inodes_count;		/* Inodes count */
+	uint32_t	s_blocks_count;		/* Blocks count */
+	uint32_t	s_r_blocks_count;	/* Reserved blocks count */
+	uint32_t	s_free_blocks_count;	/* Free blocks count */
+	uint32_t	s_free_inodes_count;	/* Free inodes count */
+	uint32_t	s_first_data_block;	/* First Data Block */
+	uint32_t	s_log_block_size;	/* Block size */
+	uint32_t	s_log_frag_size;	/* Fragment size */
+	uint32_t	s_blocks_per_group;	/* # Blocks per group */
+	uint32_t	s_frags_per_group;	/* # Fragments per group */
+	uint32_t	s_inodes_per_group;	/* # Inodes per group */
+	uint32_t	s_mtime;		/* Mount time */
+	uint32_t	s_wtime;		/* Write time */
+	uint16_t	s_mnt_count;		/* Mount count */
+	uint16_t	s_max_mnt_count;	/* Maximal mount count */
+	uint16_t	s_magic;		/* Magic signature */
+	uint16_t	s_state;		/* File system state */
+	uint16_t	s_errors;		/* Behaviour when detecting errors */
+	uint16_t	s_minor_rev_level; 	/* minor revision level */
+	uint32_t	s_lastcheck;		/* time of last check */
+	uint32_t	s_checkinterval;	/* max. time between checks */
+	uint32_t	s_creator_os;		/* OS */
+	uint32_t	s_rev_level;		/* Revision level */
+	uint16_t	s_def_resuid;		/* Default uid for reserved blocks */
+	uint16_t	s_def_resgid;		/* Default gid for reserved blocks */
+	/*
+	 * These fields are for EXT2_DYNAMIC_REV superblocks only.
+	 *
+	 * Note: the difference between the compatible feature set and
+	 * the incompatible feature set is that if there is a bit set
+	 * in the incompatible feature set that the kernel doesn't
+	 * know about, it should refuse to mount the filesystem.
+	 *
+	 * e2fsck's requirements are more strict; if it doesn't know
+	 * about a feature in either the compatible or incompatible
+	 * feature set, it must abort and not try to meddle with
+	 * things it doesn't understand...
+	 */
+	uint32_t	s_first_ino; 		/* First non-reserved inode */
+	uint16_t   s_inode_size; 		/* size of inode structure */
+	uint16_t	s_block_group_nr; 	/* block group # of this superblock */
+	uint32_t	s_feature_compat; 	/* compatible feature set */
+	uint32_t	s_feature_incompat; 	/* incompatible feature set */
+	uint32_t	s_feature_ro_compat; 	/* readonly-compatible feature set */
+	uint8_t	s_uuid[16];		/* 128-bit uuid for volume */
+	char	s_volume_name[16]; 	/* volume name */
+	char	s_last_mounted[64]; 	/* directory where last mounted */
+	uint32_t	s_algorithm_usage_bitmap; /* For compression */
+	/*
+	 * Performance hints.  Directory preallocation should only
+	 * happen if the EXT2_COMPAT_PREALLOC flag is on.
+	 */
+	uint8_t	s_prealloc_blocks;	/* Nr of blocks to try to preallocate*/
+	uint8_t	s_prealloc_dir_blocks;	/* Nr to preallocate for dirs */
+	uint16_t	s_padding1;
+	/*
+	 * Journaling support valid if EXT3_FEATURE_COMPAT_HAS_JOURNAL set.
+	 */
+	uint8_t	s_journal_uuid[16];	/* uuid of journal superblock */
+	uint32_t	s_journal_inum;		/* inode number of journal file */
+	uint32_t	s_journal_dev;		/* device number of journal file */
+	uint32_t	s_last_orphan;		/* start of list of inodes to delete */
+	uint32_t	s_hash_seed[4];		/* HTREE hash seed */
+	uint8_t	s_def_hash_version;	/* Default hash version to use */
+	uint8_t	s_reserved_char_pad;
+	uint16_t	s_reserved_word_pad;
+	uint32_t	s_default_mount_opts;
+ 	uint32_t	s_first_meta_bg; 	/* First metablock block group */
+	uint32_t	s_reserved[190];	/* Padding to the end of the block */
+};
+
+/*
+ * Codes for operating systems
+ */
+#define EXT2_OS_LINUX		0
+#define EXT2_OS_HURD		1
+#define EXT2_OS_MASIX		2
+#define EXT2_OS_FREEBSD		3
+#define EXT2_OS_LITES		4
+
+/*
+ * Revision levels
+ */
+#define EXT2_GOOD_OLD_REV	0	/* The good old (original) format */
+#define EXT2_DYNAMIC_REV	1 	/* V2 format w/ dynamic inode sizes */
+
+#define EXT2_CURRENT_REV	EXT2_GOOD_OLD_REV
+#define EXT2_MAX_SUPP_REV	EXT2_DYNAMIC_REV
+
+#define EXT2_GOOD_OLD_INODE_SIZE 128
+
+/*
+ * Feature set definitions
+ */
+
+#define EXT2_HAS_COMPAT_FEATURE(sb,mask)			\
+	( EXT2_SB(sb)->s_es->s_feature_compat & cpu_to_le32(mask) )
+#define EXT2_HAS_RO_COMPAT_FEATURE(sb,mask)			\
+	( EXT2_SB(sb)->s_es->s_feature_ro_compat & cpu_to_le32(mask) )
+#define EXT2_HAS_INCOMPAT_FEATURE(sb,mask)			\
+	( EXT2_SB(sb)->s_es->s_feature_incompat & cpu_to_le32(mask) )
+#define EXT2_SET_COMPAT_FEATURE(sb,mask)			\
+	EXT2_SB(sb)->s_es->s_feature_compat |= cpu_to_le32(mask)
+#define EXT2_SET_RO_COMPAT_FEATURE(sb,mask)			\
+	EXT2_SB(sb)->s_es->s_feature_ro_compat |= cpu_to_le32(mask)
+#define EXT2_SET_INCOMPAT_FEATURE(sb,mask)			\
+	EXT2_SB(sb)->s_es->s_feature_incompat |= cpu_to_le32(mask)
+#define EXT2_CLEAR_COMPAT_FEATURE(sb,mask)			\
+	EXT2_SB(sb)->s_es->s_feature_compat &= ~cpu_to_le32(mask)
+#define EXT2_CLEAR_RO_COMPAT_FEATURE(sb,mask)			\
+	EXT2_SB(sb)->s_es->s_feature_ro_compat &= ~cpu_to_le32(mask)
+#define EXT2_CLEAR_INCOMPAT_FEATURE(sb,mask)			\
+	EXT2_SB(sb)->s_es->s_feature_incompat &= ~cpu_to_le32(mask)
+
+#define EXT2_FEATURE_COMPAT_DIR_PREALLOC	0x0001
+#define EXT2_FEATURE_COMPAT_IMAGIC_INODES	0x0002
+#define EXT3_FEATURE_COMPAT_HAS_JOURNAL		0x0004
+#define EXT2_FEATURE_COMPAT_EXT_ATTR		0x0008
+#define EXT2_FEATURE_COMPAT_RESIZE_INO		0x0010
+#define EXT2_FEATURE_COMPAT_DIR_INDEX		0x0020
+#define EXT2_FEATURE_COMPAT_ANY			0xffffffff
+
+#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER	0x0001
+#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE	0x0002
+#define EXT2_FEATURE_RO_COMPAT_BTREE_DIR	0x0004
+#define EXT2_FEATURE_RO_COMPAT_ANY		0xffffffff
+
+#define EXT2_FEATURE_INCOMPAT_COMPRESSION	0x0001
+#define EXT2_FEATURE_INCOMPAT_FILETYPE		0x0002
+#define EXT3_FEATURE_INCOMPAT_RECOVER		0x0004
+#define EXT3_FEATURE_INCOMPAT_JOURNAL_DEV	0x0008
+#define EXT2_FEATURE_INCOMPAT_META_BG		0x0010
+#define EXT2_FEATURE_INCOMPAT_ANY		0xffffffff
+
+#define EXT2_FEATURE_COMPAT_SUPP	EXT2_FEATURE_COMPAT_EXT_ATTR
+#define EXT2_FEATURE_INCOMPAT_SUPP	(EXT2_FEATURE_INCOMPAT_FILETYPE| \
+					 EXT2_FEATURE_INCOMPAT_META_BG)
+#define EXT2_FEATURE_RO_COMPAT_SUPP	(EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER| \
+					 EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \
+					 EXT2_FEATURE_RO_COMPAT_BTREE_DIR)
+#define EXT2_FEATURE_RO_COMPAT_UNSUPPORTED	~EXT2_FEATURE_RO_COMPAT_SUPP
+#define EXT2_FEATURE_INCOMPAT_UNSUPPORTED	~EXT2_FEATURE_INCOMPAT_SUPP
+
+/*
+ * Default values for user and/or group using reserved blocks
+ */
+#define	EXT2_DEF_RESUID		0
+#define	EXT2_DEF_RESGID		0
+
+/*
+ * Default mount options
+ */
+#define EXT2_DEFM_DEBUG		0x0001
+#define EXT2_DEFM_BSDGROUPS	0x0002
+#define EXT2_DEFM_XATTR_USER	0x0004
+#define EXT2_DEFM_ACL		0x0008
+#define EXT2_DEFM_UID16		0x0010
+    /* Not used by ext2, but reserved for use by ext3 */
+#define EXT3_DEFM_JMODE		0x0060
+#define EXT3_DEFM_JMODE_DATA	0x0020
+#define EXT3_DEFM_JMODE_ORDERED	0x0040
+#define EXT3_DEFM_JMODE_WBACK	0x0060
+
+/*
+ * Structure of a directory entry
+ */
+#define EXT2_NAME_LEN 255
+
+struct ext2_dir_entry {
+	uint32_t	inode;			/* Inode number */
+	uint16_t	rec_len;		/* Directory entry length */
+	uint16_t	name_len;		/* Name length */
+	char	name[EXT2_NAME_LEN];	/* File name */
+};
+
+/*
+ * The new version of the directory entry.  Since EXT2 structures are
+ * stored in intel byte order, and the name_len field could never be
+ * bigger than 255 chars, it's safe to reclaim the extra byte for the
+ * file_type field.
+ */
+struct ext2_dir_entry_2 {
+	uint32_t	inode;			/* Inode number */
+	uint16_t	rec_len;		/* Directory entry length */
+	uint8_t	name_len;		/* Name length */
+	uint8_t	file_type;
+	char	name[EXT2_NAME_LEN];	/* File name */
+};
+
+/*
+ * Ext2 directory file types.  Only the low 3 bits are used.  The
+ * other bits are reserved for now.
+ */
+enum {
+	EXT2_FT_UNKNOWN,
+	EXT2_FT_REG_FILE,
+	EXT2_FT_DIR,
+	EXT2_FT_CHRDEV,
+	EXT2_FT_BLKDEV,
+	EXT2_FT_FIFO,
+	EXT2_FT_SOCK,
+	EXT2_FT_SYMLINK,
+	EXT2_FT_MAX
+};
+
+/*
+ * EXT2_DIR_PAD defines the directory entries boundaries
+ *
+ * NOTE: It must be a multiple of 4
+ */
+#define EXT2_DIR_PAD		 	4
+#define EXT2_DIR_ROUND 			(EXT2_DIR_PAD - 1)
+#define EXT2_DIR_REC_LEN(name_len)	(((name_len) + 8 + EXT2_DIR_ROUND) & \
+					 ~EXT2_DIR_ROUND)
+#define EXT2_MAX_REC_LEN		((1<<16)-1)
+
+#endif	/* _EXT2_FS_H */
diff --git a/qemu/roms/openbios/fs/ext2/ext2_lseek.c b/qemu/roms/openbios/fs/ext2/ext2_lseek.c
new file mode 100644
index 000000000..e837d89b4
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_lseek.c
@@ -0,0 +1,38 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#include "libext2.h"
+#include "ext2.h"
+
+int ext2_lseek(ext2_FILE *file, long offset, int whence)
+{
+	long new_offset;
+
+	switch(whence)
+	{
+	case SEEK_SET:
+		new_offset = offset;
+		break;
+	case SEEK_CUR:
+		new_offset = file->offset + offset;
+		break;
+	case SEEK_END:
+		new_offset = file->inode->i_size + offset;
+		break;
+	default:
+		return -1;
+	}
+
+	if ( (new_offset < 0) ||
+	     (new_offset > file->inode->i_size) )
+		return -1;
+
+	file->offset = new_offset;
+
+	return new_offset;
+}
diff --git a/qemu/roms/openbios/fs/ext2/ext2_mount.c b/qemu/roms/openbios/fs/ext2/ext2_mount.c
new file mode 100644
index 000000000..06b63deca
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_mount.c
@@ -0,0 +1,62 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#include "libext2.h"
+#include "ext2.h"
+#include "ext2_utils.h"
+
+#define SB_OFFSET (2)
+
+ext2_VOLUME* ext2_mount(int fd)
+{
+	ext2_VOLUME *volume;
+	struct ext2_super_block *super;
+	char *buffer;
+
+	super = (struct ext2_super_block*)malloc(sizeof(struct ext2_super_block));
+	if (super == NULL)
+		return NULL;
+
+	ext2_get_super(fd, super);
+	if (super->s_magic != EXT2_SUPER_MAGIC) {
+		free(super);
+		return NULL;
+	}
+
+	buffer = (char*)malloc(EXT2_BLOCK_SIZE(super));
+	if (buffer == NULL) {
+		free(super);
+		return NULL;
+	}
+
+	volume = (ext2_VOLUME*)malloc(sizeof(ext2_VOLUME));
+	if (volume == NULL) {
+		free(super);
+		free(buffer);
+		return NULL;
+	}
+
+	volume->buffer = buffer;
+	volume->fd = fd;
+	volume->super = super;
+
+	volume->current = -1;
+	ext2_read_block(volume, 0);
+
+	return volume;
+}
+
+int ext2_umount(ext2_VOLUME* volume)
+{
+	if (volume == NULL)
+		return -1;
+	free(volume->super);
+	free(volume->buffer);
+	free(volume);
+	return 0;
+}
diff --git a/qemu/roms/openbios/fs/ext2/ext2_open.c b/qemu/roms/openbios/fs/ext2/ext2_open.c
new file mode 100644
index 000000000..03a89bbd0
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_open.c
@@ -0,0 +1,65 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#include "libext2.h"
+#include "ext2.h"
+#include "ext2_utils.h"
+
+ext2_FILE* ext2_open(ext2_VOLUME *volume, const char* pathname)
+{
+	ext2_FILE *file;
+	struct ext2_inode *inode;
+	int ino;
+	int ret;
+
+	ino = ext2_seek_name(volume, pathname);
+	if (ino == 0)
+		return NULL;
+
+	inode = (struct ext2_inode*)malloc(sizeof(struct ext2_inode));
+	if (inode == NULL)
+		return NULL;
+
+	ret = ext2_get_inode(volume, ino, inode);
+	if (ret == -1) {
+		free(inode);
+		return NULL;
+	}
+	if (S_ISLNK(inode->i_mode)) {
+		static char buffer[1024];
+		int i, last = 0;
+		strcpy(buffer, pathname);
+		for (i = 0; buffer[i]; i++)
+			if (buffer[i] == '\\')
+				last = i;
+		buffer[last] = '\\';
+		strcpy(buffer + last + 1, (char*)inode->i_block);
+		ino = ext2_seek_name((ext2_VOLUME*)volume, buffer);
+		if (ino == 0) {
+			free(inode);
+			return NULL;
+		}
+		ret = ext2_get_inode((ext2_VOLUME*)volume, ino, inode);
+		if (ret == -1) {
+			free(inode);
+			return NULL;
+		}
+	}
+
+	file = (ext2_FILE*)malloc(sizeof(ext2_FILE));
+	if (file == NULL) {
+		free(inode);
+		return NULL;
+	}
+	file->volume = volume;
+	file->inode = inode;
+	file->offset = 0;
+	file->path = strdup(pathname);
+
+	return file;
+}
diff --git a/qemu/roms/openbios/fs/ext2/ext2_opendir.c b/qemu/roms/openbios/fs/ext2/ext2_opendir.c
new file mode 100644
index 000000000..3363e0b3a
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_opendir.c
@@ -0,0 +1,49 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#include "libext2.h"
+#include "ext2.h"
+#include "ext2_utils.h"
+
+ext2_DIR* ext2_opendir(ext2_VOLUME *volume, const char *name)
+{
+	ext2_DIR* dir;
+	int ino;
+	struct ext2_inode *inode;
+	int ret;
+
+	ino = ext2_seek_name(volume, name);
+	if (ino == 0)
+		return NULL;
+
+	inode = (struct ext2_inode*)malloc(sizeof(struct ext2_inode));
+	if (inode == NULL)
+		return NULL;
+
+	ret = ext2_get_inode(volume, ino, inode);
+	if (ret == -1) {
+		free(inode);
+		return NULL;
+	}
+
+	if (!S_ISDIR(inode->i_mode)) {
+		free(inode);
+		return NULL;
+	}
+
+	dir = (ext2_DIR*)malloc(sizeof(ext2_DIR));
+	if (dir == NULL) {
+		free(inode);
+		return NULL;
+	}
+	dir->volume = (ext2_VOLUME*)volume;
+	dir->inode = inode;
+	dir->index = 0;
+
+	return dir;
+}
diff --git a/qemu/roms/openbios/fs/ext2/ext2_read.c b/qemu/roms/openbios/fs/ext2/ext2_read.c
new file mode 100644
index 000000000..975b3675b
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_read.c
@@ -0,0 +1,23 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#include "libext2.h"
+#include "ext2.h"
+#include "ext2_utils.h"
+
+size_t ext2_read(ext2_FILE *file, void *buf, size_t count)
+{
+	int ret;
+
+	ret = ext2_read_data(file->volume, file->inode, file->offset,
+			     buf, count);
+	if (ret == -1)
+		return -1;
+	file->offset += ret;
+	return ret;
+}
diff --git a/qemu/roms/openbios/fs/ext2/ext2_readdir.c b/qemu/roms/openbios/fs/ext2/ext2_readdir.c
new file mode 100644
index 000000000..09ba95c9d
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_readdir.c
@@ -0,0 +1,25 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#include "libext2.h"
+#include "ext2_utils.h"
+
+static struct ext2_dir_entry_2 entry;
+
+struct ext2_dir_entry_2 *ext2_readdir(ext2_DIR *dir)
+{
+	int ret;
+
+	ret = ext2_dir_entry(dir->volume, dir->inode, dir->index, &entry);
+	if (ret == -1)
+		return NULL;
+	dir->index = ret;
+
+	entry.name[entry.name_len] = 0;
+	return &entry;
+}
diff --git a/qemu/roms/openbios/fs/ext2/ext2_utils.c b/qemu/roms/openbios/fs/ext2/ext2_utils.c
new file mode 100644
index 000000000..64563c826
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_utils.c
@@ -0,0 +1,332 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#include "libext2.h"
+#include "ext2_utils.h"
+#include "libopenbios/bindings.h"
+#include "libc/diskio.h"
+#include "libc/byteorder.h"
+
+int ext2_probe(int fd, long long offset)
+{
+	struct ext2_super_block *super;
+
+	super = (struct ext2_super_block*)malloc(sizeof(struct ext2_super_block));
+	seek_io(fd, 2 * 512 + offset);
+	read_io(fd, super, sizeof (*super));
+
+	if (__le16_to_cpu(super->s_magic) != EXT2_SUPER_MAGIC) {
+		free(super);
+		return 0;
+	}
+
+	free(super);
+	return -1;
+}
+
+void ext2_get_super(int fd, struct ext2_super_block *super)
+{
+	seek_io(fd, 2 * 512);
+	read_io(fd, super, sizeof (*super));
+
+	super->s_inodes_count = __le32_to_cpu(super->s_inodes_count);
+	super->s_blocks_count = __le32_to_cpu(super->s_blocks_count);
+	super->s_r_blocks_count = __le32_to_cpu(super->s_r_blocks_count);
+	super->s_free_blocks_count = __le32_to_cpu(super->s_free_blocks_count);
+	super->s_free_inodes_count = __le32_to_cpu(super->s_free_inodes_count);
+	super->s_first_data_block = __le32_to_cpu(super->s_first_data_block);
+	super->s_log_block_size = __le32_to_cpu(super->s_log_block_size);
+	super->s_log_frag_size = __le32_to_cpu(super->s_log_frag_size);
+	super->s_blocks_per_group = __le32_to_cpu(super->s_blocks_per_group);
+	super->s_frags_per_group = __le32_to_cpu(super->s_frags_per_group);
+	super->s_inodes_per_group = __le32_to_cpu(super->s_inodes_per_group);
+	super->s_mtime = __le32_to_cpu(super->s_mtime);
+	super->s_wtime = __le32_to_cpu(super->s_wtime);
+	super->s_mnt_count = __le16_to_cpu(super->s_mnt_count);
+	super->s_max_mnt_count = __le16_to_cpu(super->s_max_mnt_count);
+	super->s_magic = __le16_to_cpu(super->s_magic);
+	super->s_state = __le16_to_cpu(super->s_state);
+	super->s_errors = __le16_to_cpu(super->s_errors);
+	super->s_minor_rev_level = __le16_to_cpu(super->s_minor_rev_level);
+	super->s_lastcheck = __le32_to_cpu(super->s_lastcheck);
+	super->s_checkinterval = __le32_to_cpu(super->s_checkinterval);
+	super->s_creator_os = __le32_to_cpu(super->s_creator_os);
+	super->s_rev_level = __le32_to_cpu(super->s_rev_level);
+	super->s_def_resuid = __le16_to_cpu(super->s_def_resuid);
+	super->s_def_resgid = __le16_to_cpu(super->s_def_resgid);
+	super->s_first_ino = __le32_to_cpu(super->s_first_ino);
+	super->s_inode_size = __le16_to_cpu(super->s_inode_size);
+	super->s_block_group_nr = __le16_to_cpu(super->s_block_group_nr);
+	super->s_feature_compat = __le32_to_cpu(super->s_feature_compat);
+	super->s_feature_incompat = __le32_to_cpu(super->s_feature_incompat);
+	super->s_feature_ro_compat = __le32_to_cpu(super->s_feature_ro_compat);
+	super->s_algorithm_usage_bitmap =
+				__le32_to_cpu(super->s_algorithm_usage_bitmap);
+	super->s_journal_inum = __le32_to_cpu(super->s_journal_inum);
+	super->s_journal_dev = __le32_to_cpu(super->s_journal_dev);
+	super->s_last_orphan = __le32_to_cpu(super->s_last_orphan);
+	super->s_hash_seed[0] = __le32_to_cpu(super->s_hash_seed[0]);
+	super->s_hash_seed[1] = __le32_to_cpu(super->s_hash_seed[1]);
+	super->s_hash_seed[2] = __le32_to_cpu(super->s_hash_seed[2]);
+	super->s_hash_seed[3] = __le32_to_cpu(super->s_hash_seed[3]);
+	super->s_default_mount_opts =
+				__le32_to_cpu(super->s_default_mount_opts);
+	super->s_first_meta_bg = __le32_to_cpu(super->s_first_meta_bg);
+}
+
+void ext2_read_block(ext2_VOLUME* volume, unsigned int fsblock)
+{
+	long long offset;
+
+	if (fsblock == volume->current)
+		return;
+
+	volume->current = fsblock;
+	offset = fsblock * EXT2_BLOCK_SIZE(volume->super);
+
+	seek_io(volume->fd, offset);
+	read_io(volume->fd, volume->buffer, EXT2_BLOCK_SIZE(volume->super));
+}
+
+void ext2_get_group_desc(ext2_VOLUME* volume,
+		   int group_id, struct ext2_group_desc *gdp)
+{
+	unsigned int block, offset;
+	struct ext2_group_desc *le_gdp;
+
+	block = 1 + volume->super->s_first_data_block;
+	block += group_id / EXT2_DESC_PER_BLOCK(volume->super);
+	ext2_read_block(volume,  block);
+
+	offset = group_id % EXT2_DESC_PER_BLOCK(volume->super);
+	offset *= sizeof(*gdp);
+
+	le_gdp = (struct ext2_group_desc *)(volume->buffer + offset);
+
+	gdp->bg_block_bitmap = __le32_to_cpu(le_gdp->bg_block_bitmap);
+	gdp->bg_inode_bitmap = __le32_to_cpu(le_gdp->bg_inode_bitmap);
+	gdp->bg_inode_table = __le32_to_cpu(le_gdp->bg_inode_table);
+	gdp->bg_free_blocks_count = __le16_to_cpu(le_gdp->bg_free_blocks_count);
+	gdp->bg_free_inodes_count = __le16_to_cpu(le_gdp->bg_free_inodes_count);
+	gdp->bg_used_dirs_count = __le16_to_cpu(le_gdp->bg_used_dirs_count);
+}
+
+int ext2_get_inode(ext2_VOLUME* volume,
+		    unsigned int ino, struct ext2_inode *inode)
+{
+	struct ext2_group_desc desc;
+	unsigned int block;
+	unsigned int group_id;
+	unsigned int offset;
+	struct ext2_inode *le_inode;
+	int i;
+
+	ino--;
+
+	group_id = ino / EXT2_INODES_PER_GROUP(volume->super);
+	ext2_get_group_desc(volume, group_id, &desc);
+
+	ino %= EXT2_INODES_PER_GROUP(volume->super);
+
+	block = desc.bg_inode_table;
+	block += ino / (EXT2_BLOCK_SIZE(volume->super) /
+			EXT2_INODE_SIZE(volume->super));
+	ext2_read_block(volume, block);
+
+	offset = ino % (EXT2_BLOCK_SIZE(volume->super) /
+			EXT2_INODE_SIZE(volume->super));
+	offset *= EXT2_INODE_SIZE(volume->super);
+
+	le_inode = (struct ext2_inode *)(volume->buffer + offset);
+
+	inode->i_mode = __le16_to_cpu(le_inode->i_mode);
+	inode->i_uid = __le16_to_cpu(le_inode->i_uid);
+	inode->i_size = __le32_to_cpu(le_inode->i_size);
+	inode->i_atime = __le32_to_cpu(le_inode->i_atime);
+	inode->i_ctime = __le32_to_cpu(le_inode->i_ctime);
+	inode->i_mtime = __le32_to_cpu(le_inode->i_mtime);
+	inode->i_dtime = __le32_to_cpu(le_inode->i_dtime);
+	inode->i_gid = __le16_to_cpu(le_inode->i_gid);
+	inode->i_links_count = __le16_to_cpu(le_inode->i_links_count);
+	inode->i_blocks = __le32_to_cpu(le_inode->i_blocks);
+	inode->i_flags = __le32_to_cpu(le_inode->i_flags);
+	if (S_ISLNK(inode->i_mode)) {
+		memcpy(inode->i_block, le_inode->i_block, EXT2_N_BLOCKS * 4);
+	} else {
+		for (i = 0; i < EXT2_N_BLOCKS; i++)
+			inode->i_block[i] = __le32_to_cpu(le_inode->i_block[i]);
+        }
+	inode->i_generation = __le32_to_cpu(le_inode->i_generation);
+	inode->i_file_acl = __le32_to_cpu(le_inode->i_file_acl);
+	inode->i_dir_acl = __le32_to_cpu(le_inode->i_dir_acl);
+	inode->i_faddr = __le32_to_cpu(le_inode->i_faddr);
+	inode->osd2.linux2.l_i_frag = le_inode->osd2.linux2.l_i_frag;
+	inode->osd2.linux2.l_i_fsize = le_inode->osd2.linux2.l_i_fsize;
+	inode->osd2.linux2.l_i_uid_high =
+			__le16_to_cpu(le_inode->osd2.linux2.l_i_uid_high);
+	inode->osd2.linux2.l_i_gid_high =
+			__le16_to_cpu(le_inode->osd2.linux2.l_i_gid_high);
+	return 0;
+}
+
+unsigned int ext2_get_block_addr(ext2_VOLUME* volume, struct ext2_inode *inode,
+				 unsigned int logical)
+{
+	unsigned int physical;
+	unsigned int addr_per_block;
+
+	/* direct */
+
+	if (logical < EXT2_NDIR_BLOCKS) {
+		physical = inode->i_block[logical];
+		return physical;
+	}
+
+	/* indirect */
+
+	logical -= EXT2_NDIR_BLOCKS;
+
+	addr_per_block = EXT2_ADDR_PER_BLOCK (volume->super);
+	if (logical < addr_per_block) {
+		ext2_read_block(volume, inode->i_block[EXT2_IND_BLOCK]);
+		physical = __le32_to_cpu(((unsigned int *)volume->buffer)[logical]);
+		return physical;
+	}
+
+	/* double indirect */
+
+	logical -=  addr_per_block;
+
+	if (logical < addr_per_block * addr_per_block) {
+		ext2_read_block(volume, inode->i_block[EXT2_DIND_BLOCK]);
+		physical = __le32_to_cpu(((unsigned int *)volume->buffer)
+						[logical / addr_per_block]);
+		ext2_read_block(volume, physical);
+		physical = __le32_to_cpu(((unsigned int *)volume->buffer)
+						[logical % addr_per_block]);
+		return physical;
+	}
+
+	/* triple indirect */
+
+	logical -= addr_per_block * addr_per_block;
+	ext2_read_block(volume, inode->i_block[EXT2_DIND_BLOCK]);
+	physical = __le32_to_cpu(((unsigned int *)volume->buffer)
+				[logical / (addr_per_block * addr_per_block)]);
+	ext2_read_block(volume, physical);
+	logical = logical % (addr_per_block * addr_per_block);
+	physical = __le32_to_cpu(((unsigned int *)volume->buffer)[logical / addr_per_block]);
+	ext2_read_block(volume, physical);
+	physical = __le32_to_cpu(((unsigned int *)volume->buffer)[logical % addr_per_block]);
+	return physical;
+}
+
+int ext2_read_data(ext2_VOLUME* volume, struct ext2_inode *inode,
+		   off_t offset, char *buffer, size_t length)
+{
+	unsigned int logical, physical;
+	int blocksize = EXT2_BLOCK_SIZE(volume->super);
+	int shift;
+	size_t read;
+
+	if (offset >= inode->i_size)
+		return -1;
+
+	if (offset + length >= inode->i_size)
+		length = inode->i_size - offset;
+
+	read = 0;
+	logical = offset / blocksize;
+	shift = offset % blocksize;
+
+	if (shift) {
+		physical = ext2_get_block_addr(volume, inode, logical);
+		ext2_read_block(volume, physical);
+
+		if (length < blocksize - shift) {
+			memcpy(buffer, volume->buffer + shift, length);
+			return length;
+		}
+		read += blocksize - shift;
+		memcpy(buffer, volume->buffer + shift, read);
+
+		buffer += read;
+		length -= read;
+		logical++;
+	}
+
+	while (length) {
+		physical = ext2_get_block_addr(volume, inode, logical);
+		ext2_read_block(volume, physical);
+
+		if (length < blocksize) {
+			memcpy(buffer, volume->buffer, length);
+			read += length;
+			return read;
+		}
+		memcpy(buffer, volume->buffer, blocksize);
+
+		buffer += blocksize;
+		length -= blocksize;
+		read += blocksize;
+		logical++;
+	}
+
+	return read;
+}
+
+off_t ext2_dir_entry(ext2_VOLUME *volume, struct ext2_inode *inode,
+		     off_t index, struct ext2_dir_entry_2 *entry)
+{
+	int ret;
+
+	ret = ext2_read_data(volume, inode, index,
+			     (char*)entry, sizeof(*entry));
+	if (ret == -1)
+		return -1;
+
+        entry->inode = __le32_to_cpu(entry->inode);
+        entry->rec_len = __le16_to_cpu(entry->rec_len);
+	return index + entry->rec_len;
+}
+
+unsigned int ext2_seek_name(ext2_VOLUME *volume, const char *name)
+{
+	struct ext2_inode inode;
+	int ret;
+	unsigned int ino;
+	off_t index;
+	struct ext2_dir_entry_2 entry;
+
+	ino = EXT2_ROOT_INO;
+	while(1) {
+		while (*name == '\\')
+			name++;
+		if (!*name)
+		    break;
+		ret = ext2_get_inode(volume, ino, &inode);
+		if (ret == -1)
+			return 0;
+		index = 0;
+		while (1) {
+			index = ext2_dir_entry(volume, &inode, index, &entry);
+			if (index == -1)
+				return 0;
+			ret = strncmp(name, entry.name, entry.name_len);
+			if (ret == 0  &&
+			    (name[entry.name_len] == 0 ||
+			     name[entry.name_len] == '\\')) {
+			     	ino = entry.inode;
+				break;
+			}
+		}
+		name += entry.name_len;
+	}
+
+	return ino;
+}
diff --git a/qemu/roms/openbios/fs/ext2/ext2_utils.h b/qemu/roms/openbios/fs/ext2/ext2_utils.h
new file mode 100644
index 000000000..43544d870
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/ext2_utils.h
@@ -0,0 +1,54 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#ifndef __EXT2_UTILS_H__
+#define __EXT2_UTILS_H__
+
+#include "ext2_fs.h"
+#include "ext2.h"
+
+/* from linux/stat.h */
+
+#define S_IFMT  00170000
+#define S_IFSOCK 0140000
+#define S_IFLNK	 0120000
+#define S_IFREG  0100000
+#define S_IFBLK  0060000
+#define S_IFDIR  0040000
+#define S_IFCHR  0020000
+#define S_IFIFO  0010000
+#define S_ISUID  0004000
+#define S_ISGID  0002000
+#define S_ISVTX  0001000
+
+#define S_ISLNK(m)	(((m) & S_IFMT) == S_IFLNK)
+#define S_ISREG(m)	(((m) & S_IFMT) == S_IFREG)
+#define S_ISDIR(m)	(((m) & S_IFMT) == S_IFDIR)
+#define S_ISCHR(m)	(((m) & S_IFMT) == S_IFCHR)
+#define S_ISBLK(m)	(((m) & S_IFMT) == S_IFBLK)
+#define S_ISFIFO(m)	(((m) & S_IFMT) == S_IFIFO)
+#define S_ISSOCK(m)	(((m) & S_IFMT) == S_IFSOCK)
+
+/* utilities */
+
+extern int ext2_probe(int fd, long long offset);
+extern void ext2_get_super(int fd, struct ext2_super_block *super);
+extern void ext2_read_block(ext2_VOLUME* volume, unsigned int fsblock);
+extern void ext2_get_group_desc(ext2_VOLUME* volume,
+				int group_id, struct ext2_group_desc *gdp);
+extern int ext2_get_inode(ext2_VOLUME* volume,
+			  unsigned int ino, struct ext2_inode *inode);
+extern unsigned int ext2_get_block_addr(ext2_VOLUME* volume,
+					struct ext2_inode *inode,
+					unsigned int logical);
+extern int ext2_read_data(ext2_VOLUME* volume, struct ext2_inode *inode,
+			  off_t offset, char *buffer, size_t length);
+extern off_t ext2_dir_entry(ext2_VOLUME *volume, struct ext2_inode *inode,
+			    off_t offset, struct ext2_dir_entry_2 *entry);
+extern unsigned int ext2_seek_name(ext2_VOLUME *volume, const char *name);
+#endif /* __EXT2_UTILS_H__ */
diff --git a/qemu/roms/openbios/fs/ext2/libext2.h b/qemu/roms/openbios/fs/ext2/libext2.h
new file mode 100644
index 000000000..12d22a44b
--- /dev/null
+++ b/qemu/roms/openbios/fs/ext2/libext2.h
@@ -0,0 +1,25 @@
+/*
+ *
+ * (c) 2008-2009 Laurent Vivier <Laurent@lvivier.info>
+ *
+ * This file has been copied from EMILE, http://emile.sf.net
+ *
+ */
+
+#ifndef __LIBEXT2_H__
+#define __LIBEXT2_H__
+
+#include "config.h"
+#include "ext2.h"
+
+extern ext2_VOLUME* ext2_mount(int fd);
+extern int ext2_umount(ext2_VOLUME *volume);
+extern ext2_DIR* ext2_opendir(ext2_VOLUME *, const char *name);
+extern struct ext2_dir_entry_2* ext2_readdir(ext2_DIR* dir);
+extern void ext2_closedir(ext2_DIR *dir);
+extern ext2_FILE* ext2_open(ext2_VOLUME *, const char* pathname);
+extern size_t ext2_read(ext2_FILE *file, void *buf, size_t count);
+extern void ext2_close(ext2_FILE *file);
+extern int ext2_lseek(ext2_FILE *file, long offset, int whence);
+
+#endif /* __LIBEXT2_H__ */