path: root/sys-fs/e2fsprogs/files/e2fsprogs-1.41-mint.patch

http://bugs.gentoo.org/show_bug.cgi?id=256234
http://sourceforge.net/tracker/?func=detail&aid=2550325&group_id=2406&atid=302406

diff -ur --new-file e2fsprogs-1.41.3/lib/ext2fs/Makefile.in e2fsprogs-1.41.3-mint/lib/ext2fs/Makefile.in
--- e2fsprogs-1.41.3/lib/ext2fs/Makefile.in	2008-10-07 14:22:39.000000000 +0000
+++ e2fsprogs-1.41.3-mint/lib/ext2fs/Makefile.in	2009-01-23 10:48:50.000000000 +0000
@@ -74,7 +74,9 @@
 	unix_io.o \
 	unlink.o \
 	valid_blk.o \
-	version.o
+	version.o \
+	mint_io.o \
+	xhdi.o
 
 SRCS= ext2_err.c \
 	$(srcdir)/alloc.c \
@@ -146,6 +148,8 @@
 	$(srcdir)/unlink.c \
 	$(srcdir)/valid_blk.c \
 	$(srcdir)/version.c \
+ 	$(srcdir)/mint_io.c \
+ 	$(srcdir)/xhdi.c \
 	$(srcdir)/write_bb_file.c
 
 HFILES= bitops.h ext2fs.h ext2_io.h ext2_fs.h ext2_ext_attr.h ext3_extents.h \
diff -ur --new-file e2fsprogs-1.41.3/lib/ext2fs/bitops.h e2fsprogs-1.41.3-mint/lib/ext2fs/bitops.h
--- e2fsprogs-1.41.3/lib/ext2fs/bitops.h	2008-10-07 14:22:39.000000000 +0000
+++ e2fsprogs-1.41.3-mint/lib/ext2fs/bitops.h	2009-01-23 10:47:35.000000000 +0000
@@ -125,7 +125,7 @@
  */
 #ifdef NO_INLINE_FUNCS
 #if (defined(__GNUC__) && (defined(__i386__) || defined(__i486__) || \
-			   defined(__i586__) || defined(__mc68000__)))
+			   defined(__i586__) || defined(__mc68020__)))
 	/* This prevents bitops.c from trying to include the C */
 	/* function version of these functions */
 #define _EXT2_HAVE_ASM_BITOPS_
@@ -246,7 +246,7 @@
 #endif	/* i386 */
 
 #if ((defined __GNUC__) && !defined(_EXT2_USE_C_VERSIONS_) && \
-     (defined(__mc68000__)))
+     (defined(__mc68020__)))
 
 #define _EXT2_HAVE_ASM_BITOPS_
 
@@ -280,6 +280,50 @@
 	return retval;
 }
 
+#elif  defined(__mc68000__)
+
+#define _EXT2_HAVE_ASM_BITOPS_
+
+_INLINE_ int
+ext2fs_set_bit (unsigned int nr, void *addr)
+{
+	int mask, retval;
+	unsigned char *ADDR = (unsigned char *) addr;
+	
+	ADDR += nr >> 3;
+	mask = 1UL << (nr & 0x07);
+	retval = (mask & *ADDR) != 0;
+	*ADDR |= mask;
+	
+	return retval;
+}
+
+_INLINE_ int
+ext2fs_clear_bit (unsigned int nr, void *addr)
+{
+	int mask, retval;
+	unsigned char *ADDR = (unsigned char *) addr;
+	
+	ADDR += nr >> 3;
+	mask = 1UL << (nr & 0x07);
+	retval = (mask & *ADDR) != 0;
+	*ADDR &= ~mask;
+	
+	return retval;
+}
+
+_INLINE_ int
+ext2fs_test_bit (unsigned int nr, const void *addr)
+{
+	int mask;
+	const unsigned char *ADDR = (const unsigned char *) addr;
+	
+	ADDR += nr >> 3;
+	mask = 1UL << (nr & 0x07);
+	
+	return ((mask & *ADDR) != 0);
+}
+
 #endif /* __mc68000__ */
 
 
diff -ur --new-file e2fsprogs-1.41.3/lib/ext2fs/ext2_fs.h e2fsprogs-1.41.3-mint/lib/ext2fs/ext2_fs.h
--- e2fsprogs-1.41.3/lib/ext2fs/ext2_fs.h	2009-01-23 10:01:34.000000000 +0000
+++ e2fsprogs-1.41.3-mint/lib/ext2fs/ext2_fs.h	2009-01-23 10:49:44.000000000 +0000
@@ -307,6 +307,7 @@
 #define _IOT_ext2_new_group_input _IOT (_IOTS(__u32), 5, _IOTS(__u16), 2, 0, 0)
 #endif
 
+#ifndef __MINT__
 #define EXT2_IOC_GETFLAGS		_IOR('f', 1, long)
 #define EXT2_IOC_SETFLAGS		_IOW('f', 2, long)
 #define EXT2_IOC_GETVERSION		_IOR('v', 1, long)
@@ -316,6 +317,9 @@
 #define EXT2_IOC_GROUP_EXTEND		_IOW('f', 7, unsigned long)
 #define EXT2_IOC_GROUP_ADD		_IOW('f', 8,struct ext2_new_group_input)
 #define EXT4_IOC_GROUP_ADD		_IOW('f', 8,struct ext4_new_group_input)
+#else
+#include <mint/dcntl.h>
+#endif
 
 /*
  * Structure of an inode on the disk
diff -ur --new-file e2fsprogs-1.41.3/lib/ext2fs/getsize.c e2fsprogs-1.41.3-mint/lib/ext2fs/getsize.c
--- e2fsprogs-1.41.3/lib/ext2fs/getsize.c	2008-10-07 14:22:39.000000000 +0000
+++ e2fsprogs-1.41.3-mint/lib/ext2fs/getsize.c	2009-01-23 10:47:35.000000000 +0000
@@ -58,6 +58,11 @@
 #define BLKGETSIZE DKIOCGETBLOCKCOUNT32
 #endif /* APPLE_DARWIN */
 
+#ifdef __MINT__
+#include <sys/ioctl.h>
+#include "mint_io.h"
+#endif
+
 #include "ext2_fs.h"
 #include "ext2fs.h"
 
diff -ur --new-file e2fsprogs-1.41.3/lib/ext2fs/llseek.c e2fsprogs-1.41.3-mint/lib/ext2fs/llseek.c
--- e2fsprogs-1.41.3/lib/ext2fs/llseek.c	2008-10-07 14:22:39.000000000 +0000
+++ e2fsprogs-1.41.3-mint/lib/ext2fs/llseek.c	2009-01-23 10:47:35.000000000 +0000
@@ -115,6 +115,8 @@
 
 #else /* !linux */
 
+#ifndef __MINT__
+
 #ifndef EINVAL
 #define EINVAL EXT2_ET_INVALID_ARGUMENT
 #endif
@@ -133,6 +135,8 @@
 #endif
 }
 
+#endif /* __MINT__ */
+
 #endif 	/* linux */
 
 
diff -ur --new-file e2fsprogs-1.41.3/lib/ext2fs/mint_io.c e2fsprogs-1.41.3-mint/lib/ext2fs/mint_io.c
--- e2fsprogs-1.41.3/lib/ext2fs/mint_io.c	1970-01-01 00:00:00.000000000 +0000
+++ e2fsprogs-1.41.3-mint/lib/ext2fs/mint_io.c	2009-01-23 10:49:51.000000000 +0000
@@ -0,0 +1,858 @@
+/*
+ * $Id: e2fsprogs-1.41-mint.patch,v 1.1 2010/11/19 18:49:02 jlec Exp $
+ * 
+ * This file belongs to FreeMiNT. It's not in the original MiNT 1.12
+ * distribution. See the file CHANGES for a detailed log of changes.
+ * 
+ * 
+ * Copyright 2000 Frank Naumann <fnaumann@freemint.de>
+ * All rights reserved.
+ * 
+ * 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, or (at your option)
+ * any later version.
+ * 
+ * This file 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.
+ * 
+ * 
+ * Author: Frank Naumann <fnaumann@freemint.de>
+ * Started: 200-06-14
+ * 
+ * Please send suggestions, patches or bug reports to me or
+ * the MiNT mailing list.
+ * 
+ */
+
+# ifdef __MINT__
+
+# include <assert.h>
+# include <ctype.h>
+# include <errno.h>
+# include <fcntl.h>
+# include <limits.h>
+# include <stdarg.h>
+# include <stdlib.h>
+# include <stdio.h>
+# include <string.h>
+# include <time.h>
+# include <unistd.h>
+
+# include "et/com_err.h"
+# include "ext2fs/ext2_io.h"
+# include <sys/ioctl.h>
+# include <sys/stat.h>
+# define loff_t ext2_loff_t
+# define llseek ext2fs_llseek
+
+# include <mintbind.h>
+# include "mint_io.h"
+# include "xhdi.h"
+
+
+# if 0
+# define DEBUG(x)	printf x
+# else
+# define DEBUG(x)
+# endif
+
+
+/* prototypes */
+
+int __open_v(const char *_filename, int iomode, va_list argp);
+
+int open(__const char *__file, int __oflag, ...) __THROW;
+int __open(__const char *__file, int __oflag, ...) __THROW;
+
+int ioctl(int fd, int cmd, void *arg);
+int __ioctl(int fd, int cmd, void *arg);
+
+int fsync(int __fd) __THROW;
+int __fsync(int __fd) __THROW;
+
+__off_t lseek(int __fd, __off_t __offset, int __whence) __THROW;
+__off_t __lseek(int __fd, __off_t __offset, int __whence) __THROW;
+
+int close(int __fd) __THROW;
+int __close(int __fd) __THROW;
+
+ssize_t read(int __fd, void *__buf, size_t __nbytes) __THROW;
+ssize_t __read(int __fd, void *__buf, size_t __nbytes) __THROW;
+
+ssize_t write(int __fd, __const void *__buf, size_t __n) __THROW;
+ssize_t __write(int __fd, __const void *__buf, size_t __n) __THROW;
+
+int fstat(int __fd, struct stat *__buf) __THROW;
+int __fstat(int __fd, struct stat *__buf) __THROW;
+
+int stat(const char *filename, struct stat *st) __THROW;
+
+
+struct device
+{
+	int used;
+	
+	int drv;
+	int open_flags;
+	
+	ushort xhdi_maj;
+	ushort xhdi_min;
+	ulong xhdi_start;
+	ulong xhdi_blocks;
+	ulong xhdi_blocksize;
+	char xhdi_id[4];
+	
+	loff_t pos;
+};
+
+# define DEVS 16
+static struct device devs[DEVS];
+
+static void
+init_device(struct device *dev)
+{
+	dev->used = 0;
+	
+	dev->drv = -1;
+	dev->open_flags = 0;
+	dev->xhdi_maj = 0;
+	dev->xhdi_min = 0;
+	dev->xhdi_start = 0;
+	dev->xhdi_blocks = 0;
+	dev->xhdi_blocksize = 0;
+	
+	dev->pos = 0;
+}
+
+static inline void
+init(void)
+{
+	static int done = 0;
+	int i;
+	
+	if (done)
+		return;
+	
+	assert(sizeof(loff_t) == sizeof(long long));
+	
+	for (i = 0; i < DEVS; i++)
+		init_device (&devs[i]);
+	
+	init_XHDI();
+	
+	/* we are now initialized */
+	done = 1;
+}
+
+static struct device *
+get_device(int fd)
+{
+	struct device *dev;
+	
+	if ((fd < 1024) || (fd >= (1024 + DEVS)))
+		return NULL;
+	
+	fd -= 1024;
+	dev = &devs[fd];
+	
+	assert(dev->used);
+	
+	return dev;
+}
+
+static int
+alloc_device(void)
+{
+	int i;
+	
+	for (i = 0; i < DEVS; i++)
+	{
+		struct device *dev = &devs[i];
+		
+		if (!dev->used)
+		{
+			dev->used = 1;
+			return (i + 1024);
+		}
+	}
+	
+	__set_errno(ENOMEM);
+	return -1;
+}
+
+static void
+free_device(struct device *dev)
+{
+	assert(dev->used);
+	
+	init_device (dev);
+}
+
+
+int
+open(const char *filename, int iomode, ...)
+{
+	const char *f = filename;
+	struct device *mydev = NULL;
+	int dev = -1;
+	long ret;
+	
+	init();
+	
+	if (!filename)
+	{
+		__set_errno(EINVAL);
+		return -1;
+	}
+	
+	if ((f[1] == ':') && (f[2] == '\0'))
+	{
+		int c = tolower(f[0]);
+		
+		if (c >= 'a' && c <= 'z')
+			c = c - 'a';
+		else if (c >= '1' && c <= '6')
+			c = 26 + (c - '1');
+		
+		if ((c >= 0) && (c < 32))
+		{
+			dev = alloc_device();
+			if (dev != -1)
+			{
+				mydev = get_device(dev);
+				assert(mydev);
+				
+				mydev->drv = c;
+				mydev->open_flags = iomode;
+			}
+		}
+	}
+	
+	if (dev == -1)
+	{
+		/* fall through */
+		
+		va_list args;
+		int retval;
+		
+		va_start(args, iomode);
+		retval = __open_v(filename, iomode, args);
+		va_end(args);
+		
+		return retval;
+	}
+	
+	if (mydev->open_flags == O_RDONLY)
+	{
+		DEBUG(("readonly mode!\n"));
+		sync();
+	}
+	else if (Dlock(1, mydev->drv))
+	{
+		printf("Can't lock partition %c:!\n", mydev->drv+'A');
+		
+		if (mydev)
+			free_device(mydev);
+		
+		__set_errno(EACCES);
+		return -1;
+	}
+	
+	__set_errno(EERROR);
+	
+	ret = XHGetVersion ();
+	DEBUG(("XHDI version: %lx\n", ret));
+	
+	ret = XHInqDev2(mydev->drv,
+			&mydev->xhdi_maj, &mydev->xhdi_min,
+			&mydev->xhdi_start, NULL,
+			&mydev->xhdi_blocks, mydev->xhdi_id);
+	if (ret)
+	{
+		printf("XHInqDev2 [%c] fail (ret = %li, errno = %i)\n",
+			mydev->drv+'A', ret, errno);
+		ret = -1;
+	}
+	else
+	{
+		ret = XHInqTarget(mydev->xhdi_maj, mydev->xhdi_min,
+				  &mydev->xhdi_blocksize, NULL, NULL);
+		if (ret)
+		{
+			printf("XHInqTarget [%i:%i] fail (ret = %li, errno = %i)\n",
+				mydev->xhdi_maj, mydev->xhdi_min, ret, errno);
+			ret = -1;
+		}
+		else
+		{
+			char *xhdi_id = mydev->xhdi_id;
+			
+			if (       0
+			        || ((xhdi_id[0] == 'G') && (xhdi_id[1] == 'E') && (xhdi_id[2] == 'M')) /* GEM */
+				|| ((xhdi_id[0] == 'B') && (xhdi_id[1] == 'G') && (xhdi_id[2] == 'M')) /* BGM */
+				|| ((xhdi_id[0] == 'F') && (xhdi_id[1] == '3') && (xhdi_id[2] == '2')) /* F32 */
+				|| ((xhdi_id[0] == 'M') && (xhdi_id[1] == 'I') && (xhdi_id[2] == 'X')) /* MIX */
+				|| ((xhdi_id[0] == 'R') && (xhdi_id[1] == 'A') && (xhdi_id[2] == 'W')) /* RAW */
+				|| ((xhdi_id[0] == 'L') && (xhdi_id[1] == 'N') && (xhdi_id[2] == 'X')) /* LNX */
+				|| ((xhdi_id[0] == '\0') && (xhdi_id[1] == 'D')))                  /* any DOS */
+			{
+				DEBUG(("Partition ok and accepted!\n"));
+				DEBUG(("start = %lu, blocks = %lu, blocksize = %lu\n",
+					mydev->xhdi_start, mydev->xhdi_blocks,
+					mydev->xhdi_blocksize));
+			}
+			else
+			{
+				xhdi_id [3] = '\0';
+				printf("Wrong partition ID [%s]!\n", xhdi_id);
+				printf("Only 'RAW', 'LNX' and DOS partitions are supported.\n");
+				
+				__set_errno(EPERM);
+				ret = -1;
+			}
+		}
+	}
+	
+	if (ret)
+	{
+		if (mydev)
+			free_device(mydev);
+		
+		dev = -1;
+	}
+	
+	return dev;
+}
+
+int
+close(int fd)
+{
+	struct device *mydev = get_device(fd);
+	int ret = 0;
+	
+	if (!mydev)
+		/* fall through */
+		return __close(fd);
+	
+	if (mydev->open_flags == O_RDONLY)
+	{
+		;
+	}
+	else if (Dlock(0, mydev->drv))
+	{
+		printf("Can't unlock partition %c:!\n", 'A'+mydev->drv);
+		
+		__set_errno(EACCES);
+		ret = -1;
+	}
+	
+	free_device(mydev);
+	return ret;
+}
+
+/* simple buffer */
+static char buffer[1024L * 128];
+static ulong buf_recno = 0;
+static long buf_n = 0;
+
+static long
+rwabs_xhdi(struct device *mydev, ushort rw, void *buf, ulong size, ulong recno)
+{
+	ulong n = size / mydev->xhdi_blocksize;
+	long r;
+	
+	assert((size % mydev->xhdi_blocksize) == 0);
+	
+	if (!n || (recno + n) > mydev->xhdi_blocks)
+	{
+		printf("rwabs_xhdi: access outside partition (drv = %c:)\n", 'A'+mydev->drv);
+		exit(2);
+	}
+	
+	if (n > 65535UL)
+	{
+		printf("rwabs_xhdi: n to large (drv = %c)\n", 'A'+mydev->drv);
+		exit(2);
+	}
+	
+	if (!rw && (buf_recno == recno) && (buf_n == n))
+	{
+		bcopy(buffer, buf, buf_n * mydev->xhdi_blocksize);
+		return 0;
+	}
+	
+	r = XHReadWrite (mydev->xhdi_maj, mydev->xhdi_min, rw, mydev->xhdi_start + recno, n, buf);
+	
+	if (!r && (n * mydev->xhdi_blocksize) <= sizeof(buffer))
+	{
+		bcopy(buf, buffer, n * mydev->xhdi_blocksize);
+		
+		buf_recno = recno;
+		buf_n = n;
+	}
+	else
+		buf_n = 0;
+	
+	return r;
+}
+
+# define max(a,b)	(a > b ? a : b)
+# define min(a,b)	(a > b ? b : a)
+
+int
+read(int fd, void *_buf, size_t size)
+{
+	struct device *mydev = get_device(fd);
+	
+	if (!mydev)
+		/* fall through */
+		return __read(fd, _buf, size);
+		
+{
+	char *buf = _buf;
+	long todo;		/* characters remaining */
+	long done;		/* characters processed */
+	
+	todo = size;
+	done = 0;
+	
+	if (todo == 0)
+		return 0;
+	
+	/* partial block copy
+	 */
+	if (mydev->pos % mydev->xhdi_blocksize)
+	{
+		char tmp[mydev->xhdi_blocksize];
+		
+		ulong recno = mydev->pos / mydev->xhdi_blocksize;
+		ulong offset = mydev->pos % mydev->xhdi_blocksize;
+		ulong data;
+		long ret;
+		
+		ret = rwabs_xhdi(mydev, 0, tmp, mydev->xhdi_blocksize, recno);
+		if (ret)
+		{
+			DEBUG(("read: partial part: read failure (r = %li, errno = %i)\n", ret, errno));
+			goto out;
+		}
+		
+		data = mydev->xhdi_blocksize - offset;
+		data = min (todo, data);
+		
+		memcpy(buf, tmp + offset, data);
+		
+		buf += data;
+		todo -= data;
+		done += data;
+		mydev->pos += data;
+	}
+	
+	if (todo)
+	{
+		assert((todo > 0));
+		assert((mydev->pos % mydev->xhdi_blocksize) == 0);
+	}
+	
+	
+	/* full blocks
+	 */
+	if (todo / mydev->xhdi_blocksize)
+	{
+		ulong recno = mydev->pos / mydev->xhdi_blocksize;
+		ulong data = (todo / mydev->xhdi_blocksize) * mydev->xhdi_blocksize;
+		long ret;
+		
+		ret = rwabs_xhdi (mydev, 0, buf, data, recno);
+		if (ret)
+		{
+			DEBUG(("read: full blocks: read failure (r = %li, errno = %i)\n", ret, errno));
+			goto out;
+		}
+		
+		buf += data;
+		todo -= data;
+		done += data;
+		mydev->pos += data;
+	}
+	
+	if (todo)
+	{
+		assert((todo > 0) && (todo < mydev->xhdi_blocksize));
+		assert((mydev->pos % mydev->xhdi_blocksize) == 0);
+	}
+	
+	/* anything left?
+	 */
+	if (todo)
+	{
+		char tmp[mydev->xhdi_blocksize];
+		
+		ulong recno = mydev->pos / mydev->xhdi_blocksize;
+		long ret;
+		
+		ret = rwabs_xhdi (mydev, 0, tmp, mydev->xhdi_blocksize, recno);
+		if (ret)
+		{
+			DEBUG(("read: left part: read failure (r = %li, errno = %i)]\n", ret, errno));
+			goto out;
+		}
+		
+		memcpy(buf, tmp, todo);
+		
+		done += todo;
+		mydev->pos += todo;
+	}
+	
+	assert(done == size);
+	
+out:
+	return done;
+}
+}
+
+int
+write(int fd, const void *_buf, size_t size)
+{
+	struct device *mydev = get_device(fd);
+	
+	if (!mydev)
+		/* fall through */
+		return __write(fd, _buf, size);
+	
+	if (mydev->open_flags == O_RDONLY)
+	{
+		__set_errno(EPERM);
+		return -1;
+	}
+{
+	const char *buf = _buf;
+	long todo;		/* characters remaining */
+	long done;		/* characters processed */
+	
+	todo = size;
+	done = 0;
+	
+	if (todo == 0)
+		return 0;
+	
+	/* partial block copy
+	 */
+	if (mydev->pos % mydev->xhdi_blocksize)
+	{
+		char tmp[mydev->xhdi_blocksize];
+		
+		ulong recno = mydev->pos / mydev->xhdi_blocksize;
+		ulong offset = mydev->pos % mydev->xhdi_blocksize;
+		ulong data;
+		long ret;
+		
+		ret = rwabs_xhdi(mydev, 0, tmp, mydev->xhdi_blocksize, recno);
+		if (ret)
+		{
+			DEBUG(("write: partial part: read failure (r = %li, errno = %i)\n", ret, errno));
+			goto out;
+		}
+		
+		data = mydev->xhdi_blocksize - offset;
+		data = min (todo, data);
+		
+		memcpy(tmp + offset, buf, data);
+		
+		ret = rwabs_xhdi(mydev, 1, tmp, mydev->xhdi_blocksize, recno);
+		if (ret)
+		{
+			DEBUG(("write: partial part: write failure (r = %li, errno = %i)\n", ret, errno));
+			goto out;
+		}
+		
+		buf += data;
+		todo -= data;
+		done += data;
+		mydev->pos += data;
+	}
+	
+	if (todo)
+	{
+		assert((todo > 0));
+		assert((mydev->pos % mydev->xhdi_blocksize) == 0);
+	}
+	
+	/* full blocks
+	 */
+	if (todo / mydev->xhdi_blocksize)
+	{
+		ulong recno = mydev->pos / mydev->xhdi_blocksize;
+		ulong data = (todo / mydev->xhdi_blocksize) * mydev->xhdi_blocksize;
+		long ret;
+		
+		ret = rwabs_xhdi(mydev, 1, (void *)buf, data, recno);
+		if (ret)
+		{
+			DEBUG(("write: full blocks: write failure (r = %li, errno = %i)\n", ret, errno));
+			goto out;
+		}
+		
+		buf += data;
+		todo -= data;
+		done += data;
+		mydev->pos += data;
+	}
+	
+	if (todo)
+	{
+		assert((todo > 0) && (todo < mydev->xhdi_blocksize));
+		assert((mydev->pos % mydev->xhdi_blocksize) == 0);
+	}
+	
+	/* anything left?
+	 */
+	if (todo)
+	{
+		char tmp[mydev->xhdi_blocksize];
+		
+		ulong recno = mydev->pos / mydev->xhdi_blocksize;
+		long ret;
+		
+		ret = rwabs_xhdi(mydev, 0, tmp, mydev->xhdi_blocksize, recno);
+		if (ret)
+		{
+			DEBUG(("write: left part: read failure (r = %li, errno = %i)]\n", ret, errno));
+			goto out;
+		}
+		
+		memcpy(tmp, buf, todo);
+		
+		ret = rwabs_xhdi(mydev, 1, tmp, mydev->xhdi_blocksize, recno);
+		if (ret)
+		{
+			DEBUG(("write: partial part: write failure (r = %li, errno = %i)\n", ret, errno));
+			goto out;
+		}
+		
+		done += todo;
+		mydev->pos += todo;
+	}
+	
+	assert(done == size);
+	
+out:
+	return done;
+}
+}
+
+int
+ioctl(int fd, int cmd, void *arg)
+{
+	struct device *mydev = get_device(fd);
+	
+	if (!mydev)
+		/* fall through */
+		return __ioctl(fd, cmd, arg);
+	
+	DEBUG(("ioctl: cmd = %i\n", cmd));
+	
+	switch (cmd)
+	{
+		case BLKGETSIZE:
+		{
+			ulong *size = arg;
+			*size = mydev->xhdi_blocks * (mydev->xhdi_blocksize / 512);
+			break;
+		}
+		case BLOCKSIZE:
+		{
+			ulong *block_size = arg;
+			*block_size = mydev->xhdi_blocksize;
+			break;
+		}
+		default:
+			__set_errno(EINVAL);
+			return -1;
+	}
+	
+	return 0;
+}
+
+int
+fstat(int fd, struct stat *st)
+{
+	struct device *mydev = get_device(fd);
+	
+	if (!mydev)
+		/* fall through */
+		return __fstat(fd, st);
+	
+	bzero(st, sizeof(*st));
+	
+	st->st_dev	= mydev->xhdi_maj;
+	st->st_ino	= mydev->drv;
+	st->st_mode	= S_IFBLK | S_IRUSR | S_IWUSR;
+	st->st_nlink	= 1;
+	st->st_uid	= 0;
+	st->st_gid	= 0;
+	st->st_rdev	= mydev->xhdi_min;
+	st->st_atime	= time (NULL);
+	st->st_mtime	= time (NULL);
+	st->st_ctime	= time (NULL);
+	st->st_size	= (int64_t) mydev->xhdi_blocks * mydev->xhdi_blocksize;
+	st->st_blocks	= (int64_t) mydev->xhdi_blocks * mydev->xhdi_blocksize / 512;
+	st->st_blksize	= mydev->xhdi_blocksize;
+	st->st_flags	= 0;
+	st->st_gen	= 0;
+	
+	return 0;
+}
+
+int
+stat(const char *filename, struct stat *st)
+{
+	struct device *mydev;
+	int fd, res;
+	
+	fd = open(filename, O_RDONLY);
+	if (fd == -1)
+		return -1;
+
+	mydev = get_device(fd);
+	if (!mydev)
+	{
+		close(fd);
+		
+		/* fall through */
+		return __stat(filename, st);
+	}
+	
+	res = fstat(fd, st); 
+	close(fd);
+	
+	return res;
+}
+
+int
+fsync(int fd)
+{
+	struct device *mydev = get_device(fd);
+	
+	if (!mydev)
+		/* fall through */
+		return __fsync(fd);
+	
+	/* nothing todo */
+	return 0;
+}
+
+loff_t llseek(int fd, loff_t offset, int origin);
+
+loff_t
+llseek(int fd, loff_t offset, int origin)
+{
+	struct device *mydev = get_device(fd);
+	
+	if (!mydev)
+		/* fall through */
+		return __lseek(fd, (off_t) offset, origin);
+	
+	
+	switch (origin)
+	{
+		case SEEK_SET:
+			break;
+		case SEEK_CUR:
+			offset += mydev->pos;
+			break;
+		case SEEK_END:
+			offset += (int64_t) mydev->xhdi_blocks * mydev->xhdi_blocksize;
+			break;
+		default:
+			return -1;
+	}
+	
+	if (offset > (loff_t) mydev->xhdi_blocks * mydev->xhdi_blocksize)
+	{
+		__set_errno(EINVAL);
+		return -1;
+	}
+	
+	mydev->pos = offset;
+	return mydev->pos;
+}
+
+loff_t lseek64(int fd, loff_t offset, int origin);
+
+loff_t
+lseek64(int fd, loff_t offset, int origin)
+{
+	return llseek(fd, offset, origin);
+}
+
+__off_t
+lseek(int fd, __off_t offset, int mode)
+{
+	struct device *mydev = get_device(fd);
+	
+	if (!mydev)
+		/* fall through */
+		return __lseek(fd, offset, mode);
+	
+{
+	loff_t _offset = offset;
+	
+	switch (mode)
+	{
+		case SEEK_SET:
+			break;
+		case SEEK_CUR:
+			_offset += mydev->pos;
+			break;
+		case SEEK_END:
+			_offset += (loff_t) mydev->xhdi_blocks * mydev->xhdi_blocksize;
+			break;
+		default:
+			return -1;
+	}
+	
+	if (_offset > LONG_MAX)
+	{
+		__set_errno(EINVAL);
+		return -1;
+	}
+	
+	if (_offset > (loff_t) mydev->xhdi_blocks * mydev->xhdi_blocksize)
+	{
+		__set_errno(EINVAL);
+		return -1;
+	}
+	
+	mydev->pos = _offset;
+	return (off_t) mydev->pos;
+}
+}
+
+int gettype(int fd);
+
+int
+gettype(int fd)
+{
+	struct device *mydev = get_device(fd);
+	char *xhdi_id;
+	
+	if (!mydev)
+		return -1;
+
+	/* Get filesystem type by XHDI ID */
+	xhdi_id = mydev->xhdi_id;
+	if ((xhdi_id[0] == '\0') && (xhdi_id[1] == 'D'))
+		return 0;   /* DOS (\0D*) */
+	else
+		return 1;   /* Atari (GEM/GBM) */
+}
+
+# endif /* __MINT__ */
diff -ur --new-file e2fsprogs-1.41.3/lib/ext2fs/mint_io.h e2fsprogs-1.41.3-mint/lib/ext2fs/mint_io.h
--- e2fsprogs-1.41.3/lib/ext2fs/mint_io.h	1970-01-01 00:00:00.000000000 +0000
+++ e2fsprogs-1.41.3-mint/lib/ext2fs/mint_io.h	2009-01-23 10:49:53.000000000 +0000
@@ -0,0 +1,22 @@
+/*
+ * mint_io.h
+ *
+ * Copyright (C) 2000 Frank Naumann <fnaumann@freemint.de>.
+ *
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ */
+
+# ifdef __MINT__
+
+# ifndef _mint_io_h
+# define _mint_io_h
+
+# define BLKGETSIZE		(('b'<< 8) | 1)
+# define BLOCKSIZE		(('b'<< 8) | 2)
+
+# endif /* _mint_io_h */
+
+# endif /* __MINT__ */
diff -ur --new-file e2fsprogs-1.41.3/lib/ext2fs/unix_io.c e2fsprogs-1.41.3-mint/lib/ext2fs/unix_io.c
--- e2fsprogs-1.41.3/lib/ext2fs/unix_io.c	2008-10-13 03:12:22.000000000 +0000
+++ e2fsprogs-1.41.3-mint/lib/ext2fs/unix_io.c	2009-01-23 10:47:35.000000000 +0000
@@ -51,9 +51,15 @@
 #define BLKROGET   _IO(0x12, 94) /* Get read-only status (0 = read_write).  */
 #endif
 
+#ifdef __MINT__
+#include <sys/ioctl.h>
+#include "mint_io.h"
+#endif
+
 #include "ext2_fs.h"
 #include "ext2fs.h"
 
+
 /*
  * For checking structure magic numbers...
  */
@@ -512,6 +518,16 @@
 		}
 	}
 #endif
+	
+#ifdef __MINT__
+	{
+		unsigned long block_size;
+		retval = ioctl(data->dev, BLOCKSIZE, &block_size);
+		if (retval == 0)
+			io->block_size = block_size;
+	}
+#endif
+	
 	*channel = io;
 	return 0;
 
diff -ur --new-file e2fsprogs-1.41.3/lib/ext2fs/xhdi.c e2fsprogs-1.41.3-mint/lib/ext2fs/xhdi.c
--- e2fsprogs-1.41.3/lib/ext2fs/xhdi.c	1970-01-01 00:00:00.000000000 +0000
+++ e2fsprogs-1.41.3-mint/lib/ext2fs/xhdi.c	2009-01-23 10:49:55.000000000 +0000
@@ -0,0 +1,577 @@
+/*
+ * Copyright 2000 Frank Naumann <fnaumann@freemint.de>
+ * All rights reserved.
+ * 
+ * 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, or (at your option)
+ * any later version.
+ * 
+ * This file 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.
+ * 
+ * 
+ * Started:      2000-05-02
+ * 
+ * Changes:
+ * 
+ * 0.1:
+ * 
+ * fix: Cookie handling stuff; use Getcookie from MiNT-Lib now
+ *      requires an actual MiNT-Lib (>= PL49)
+ * 
+ * 0.0:
+ * 
+ * - inital version
+ * 
+ */
+
+# include "xhdi.h"
+
+# include <stdio.h>
+# include <stdlib.h>
+# include <errno.h>
+# include <mintbind.h>
+# include <mint/cookie.h>
+
+
+/*
+ * internal usage
+ */
+
+/* dummy routine */
+static long
+XHDIfail (void)
+{
+	return -ENOSYS;
+}
+
+/* XHDI handler function */
+static long (*XHDI)() = XHDIfail;
+
+ushort XHDI_installed = 0;
+
+
+# define C_XHDI		0x58484449L
+# define XHDIMAGIC	0x27011992L
+
+/* initalize flag */
+static ushort init = 1;
+
+long
+init_XHDI (void)
+{
+	long *val;
+	long r;
+	
+	init = 0;
+	
+	r = Getcookie (C_XHDI, (long *) &val);
+	if (r == C_FOUND)
+	{
+		long *magic_test = val;
+		
+		/* check magic */
+		if (magic_test)
+		{
+			magic_test--;
+			if (*magic_test == XHDIMAGIC)
+			{
+				XHDI = val;
+			}
+		}
+	}
+	
+	r = XHGetVersion ();
+	if (r < 0)
+	{
+		perror ("XHGetVersion");
+		
+		XHDI = XHDIfail;
+		return r;
+	}
+	
+	/* we need at least XHDI 1.10 */
+	if (r >= 0x110)
+	{
+		XHDI_installed = r;
+		return 0;
+	}
+	
+	XHDI = XHDIfail;
+	return -1;
+}
+
+
+/*
+ * XHDI wrapper routines
+ */
+
+# define CALL \
+	long oldstack = 0;		\
+	long r;				\
+					\
+	if (init) init_XHDI ();		\
+					\
+	if (!Super (1L))		\
+		oldstack = Super (0L);	\
+					\
+	r = XHDI (args);		\
+	if (r < 0)			\
+	{				\
+		__set_errno (-r);	\
+		r = -1;			\
+	}				\
+					\
+	if (oldstack)			\
+		Super (oldstack);	\
+					\
+	return r
+
+long
+XHGetVersion (void)
+{
+	struct args_XHGetVersion
+	{
+		ushort	opcode;
+	}
+	args = 
+	{
+		0
+	};
+	
+	CALL;
+}
+
+long
+XHInqTarget (ushort major, ushort minor, ulong *block_size, ulong *device_flags, char *product_name)
+{
+	struct args_XHInqTarget
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+		ulong	*block_size;
+		ulong	*device_flags;
+		char	*product_name;
+	}
+	args =
+	{
+		1,
+		major,
+		minor,
+		block_size,
+		device_flags,
+		product_name
+	};
+	
+	CALL;
+}
+
+long
+XHReserve (ushort major, ushort minor, ushort do_reserve, ushort key)
+{
+	struct args_XHReserve
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+		ushort	do_reserve;
+		ushort	key;
+	}
+	args =
+	{
+		2,
+		major,
+		minor,
+		do_reserve,
+		key
+	};
+	
+	CALL;
+}
+
+long
+XHLock (ushort major, ushort minor, ushort do_lock, ushort key)
+{
+	struct args_XHLock
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+		ushort	do_lock;
+		ushort	key;
+	}
+	args =
+	{
+		3,
+		major,
+		minor,
+		do_lock,
+		key
+	};
+	
+	CALL;
+}
+
+long
+XHStop (ushort major, ushort minor, ushort do_stop, ushort key)
+{
+	struct args_XHStop
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+		ushort	do_stop;
+		ushort	key;
+	}
+	args =
+	{
+		4,
+		major,
+		minor,
+		do_stop,
+		key
+	};
+	
+	CALL;
+}
+
+long
+XHEject (ushort major, ushort minor, ushort do_eject, ushort key)
+{
+	struct args_XHEject
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+		ushort	do_eject;
+		ushort	key;
+	}
+	args =
+	{
+		5,
+		major,
+		minor,
+		do_eject,
+		key
+	};
+	
+	CALL;
+}
+
+long
+XHDrvMap (void)
+{
+	struct args_XHDrvMap
+	{
+		ushort	opcode;
+	}
+	args =
+	{
+		6
+	};
+	
+	CALL;
+}
+
+long
+XHInqDev (ushort bios, ushort *major, ushort *minor, ulong *start, __BPB *bpb)
+{
+	struct args_XHInqDev
+	{
+		ushort	opcode;
+		ushort	bios;
+		ushort	*major;
+		ushort	*minor;
+		ulong	*start;
+		__BPB	*bpb;
+	}
+	args =
+	{
+		7,
+		bios,
+		major,
+		minor,
+		start,
+		bpb
+	};
+	
+	CALL;
+}
+
+long
+XHInqDriver (ushort bios, char *name, char *version, char *company, ushort *ahdi_version, ushort *maxIPL)
+{
+	struct args_XHInqDriver
+	{
+		ushort	opcode;
+		ushort	bios;
+		char	*name;
+		char	*version;
+		char	*company;
+		ushort	*ahdi_version;
+		ushort	*maxIPL;
+	}
+	args =
+	{
+		8,
+		bios,
+		name,
+		version,
+		company,
+		ahdi_version,
+		maxIPL
+	};
+	
+	CALL;
+}
+
+long
+XHNewCookie (void *newcookie)
+{
+	struct args_XHNewCookie
+	{
+		ushort	opcode;
+		void	*newcookie;
+	}
+	args =
+	{
+		9,
+		newcookie
+	};
+	
+	CALL;
+}
+
+long
+XHReadWrite (ushort major, ushort minor, ushort rwflag, ulong recno, ushort count, void *buf)
+{
+	struct args_XHReadWrite
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+		ushort	rwflag;
+		ulong	recno;
+		ushort	count;
+		void	*buf;
+	}
+	args =
+	{
+		10,
+		major,
+		minor,
+		rwflag,
+		recno,
+		count,
+		buf
+	};
+	
+	CALL;
+}
+
+long
+XHInqTarget2 (ushort major, ushort minor, ulong *block_size, ulong *device_flags, char *product_name, ushort stringlen)
+{
+	struct args_XHInqTarget2
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+		ulong	*block_size;
+		ulong	*device_flags;
+		char	*product_name;
+		ushort	stringlen;
+	}
+	args =
+	{
+		11,
+		major,
+		minor,
+		block_size,
+		device_flags,
+		product_name,
+		stringlen
+	};
+	
+	CALL;
+}
+
+long
+XHInqDev2 (ushort bios, ushort *major, ushort *minor, ulong *start, __BPB *bpb, ulong *blocks, char *partid)
+{
+	struct args_XHInqDev2
+	{
+		ushort	opcode;
+		ushort	bios;
+		ushort	*major;
+		ushort	*minor;
+		ulong	*start;
+		__BPB	*bpb;
+		ulong	*blocks;
+		char	*partid;
+	}
+	args =
+	{
+		12,
+		bios,
+		major,
+		minor,
+		start,
+		bpb,
+		blocks,
+		partid
+	};
+	
+	CALL;
+}
+
+long
+XHDriverSpecial (ulong key1, ulong key2, ushort subopcode, void *data)
+{
+	struct args_XHDriverSpecial
+	{
+		ushort	opcode;
+		ulong	key1;
+		ulong	key2;
+		ushort	subopcode;
+		void 	*data;
+	}
+	args =
+	{
+		13,
+		key1,
+		key2,
+		subopcode,
+		data
+	};
+	
+	CALL;
+}
+
+long
+XHGetCapacity (ushort major, ushort minor, ulong *blocks, ulong *bs)
+{
+	struct args_XHGetCapacity
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+		ulong	*blocks;
+		ulong	*bs;
+	}
+	args =
+	{
+		14,
+		major,
+		minor,
+		blocks,
+		bs
+	};
+	
+	CALL;
+}
+
+long
+XHMediumChanged (ushort major, ushort minor)
+{
+	struct args_XHMediumChanged
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+	}
+	args =
+	{
+		15,
+		major,
+		minor
+	};
+	
+	CALL;
+}
+
+long
+XHMiNTInfo (ushort op, void *data)
+{
+	struct args_XHMiNTInfo
+	{
+		ushort	opcode;
+		ushort	op;
+		void	*data;
+	}
+	args =
+	{
+		16,
+		op,
+		data
+	};
+	
+	CALL;
+}
+
+long
+XHDOSLimits (ushort which, ulong limit)
+{
+	struct args_XHDOSLimits
+	{
+		ushort	opcode;
+		ushort	which;
+		ulong	limit;
+	}
+	args =
+	{
+		17,
+		which,
+		limit
+	};
+	
+	CALL;
+}
+
+long
+XHLastAccess (ushort major, ushort minor, ulong *ms)
+{
+	struct args_XHLastAccess
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+		ulong	*ms;
+	}
+	args =
+	{
+		18,
+		major,
+		minor,
+		ms
+	};
+	
+	CALL;
+}
+
+long
+XHReaccess (ushort major, ushort minor)
+{
+	struct args_XHReaccess
+	{
+		ushort	opcode;
+		ushort	major;
+		ushort	minor;
+	}
+	args =
+	{
+		19,
+		major,
+		minor
+	};
+	
+	CALL;
+}
diff -ur --new-file e2fsprogs-1.41.3/lib/ext2fs/xhdi.h e2fsprogs-1.41.3-mint/lib/ext2fs/xhdi.h
--- e2fsprogs-1.41.3/lib/ext2fs/xhdi.h	1970-01-01 00:00:00.000000000 +0000
+++ e2fsprogs-1.41.3-mint/lib/ext2fs/xhdi.h	2009-01-23 10:49:56.000000000 +0000
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2000 Frank Naumann <fnaumann@freemint.de>
+ * All rights reserved.
+ * 
+ * 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, or (at your option)
+ * any later version.
+ * 
+ * This file 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.
+ * 
+ */
+
+# ifndef _xhdi_h
+# define _xhdi_h
+
+# include <sys/types.h>
+
+typedef unsigned char uchar;
+
+
+/*
+ * BIOS parameter block (osbind.h is buggy)
+ */
+
+typedef struct
+{
+	ushort	recsiz;		/* bytes per sector */
+	short	clsiz;		/* sectors per cluster */
+	ushort	clsizb;		/* bytes per cluster */
+	short	rdlen;		/* root directory size */
+	short	fsiz;		/* size of FAT */
+	short	fatrec;		/* startsector of second FAT */
+	short	datrec;		/* first data sector */
+	ushort	numcl;		/* total number of clusters */
+	short	bflags;		/* some flags */
+	
+} __BPB;
+
+
+/*
+ * Extended BIOS Parameter Block (XHDI)
+ */
+
+typedef struct
+{
+	ushort	recsiz;		/* bytes per sector */
+	short	clsiz;		/* sectors per cluster */
+	ushort	clsizb;		/* bytes per cluster */
+	short	rdlen;		/* root directory size or 0 if FAT32 */
+	short	fsiz;		/* size of FAT or 0 if FAT32 */
+	short	fatrec;		/* startsector of second FAT or 0 if FAT32 */
+	short	datrec;		/* first data sector or 0 if FAT32 */
+	ushort	numcl;		/* total number of clusters or 0 if FAT32 */
+	short	bflags;		/* bit 0: 0 = FAT12, 1 = FAT16
+				 * bit 1: 0 = 2 FATs, 1 = 1 FAT
+				 * bit 2: 0 = BPB, 1 = EXTENDED_BPB
+				 */
+	
+	/* Ab hier undokumentiert, nur A: und B:! */
+	short	ntracks;	/* Anzahl Spuren */
+	short	nsides;		/* Anzahl Seiten */
+	short	spc;		/* Sektoren pro Zylinder */
+	short	spt;		/* Sektoren pro Spur */
+	ushort	nhid;		/* Anzahl versteckte Sektoren */
+	uchar	ser[3];		/* Seriennummer */
+	uchar	serms[4];	/* ab TOS 2.06: MS-DOS-4.0-Seriennummer */
+	char	unused;
+	
+	/* if bit 2 of bflags are set */
+	long	l_recsiz;	/* bytes per sector */
+	long	l_clsiz;	/* sectors per cluster */
+	long	l_clsizb;	/* bytes per cluster */
+	long	l_rdlen;	/* root directory size */
+	long	l_fsiz;		/* size of FAT */
+	long	l_fatrec;	/* startsector of second FAT */
+	long	l_datrec;	/* first data sector */
+	long	l_numcl;	/* total number of clusters */
+	long	l_rdstcl;	/* if FAT32: startcluster of root directory
+				 * otherwise 0
+				 */
+} __xhdi_BPB;
+
+
+# define XH_TARGET_STOPPABLE	0x00000001L
+# define XH_TARGET_REMOVABLE	0x00000002L
+# define XH_TARGET_LOCKABLE	0x00000004L
+# define XH_TARGET_EJECTABLE	0x00000008L
+# define XH_TARGET_LOCKED	0x20000000L
+# define XH_TARGET_STOPPED	0x40000000L
+# define XH_TARGET_RESERVED	0x80000000L
+
+# define XH_MI_SETKERINFO	0
+# define XH_MI_GETKERINFO	1
+
+# define XH_DL_SECSIZ		0
+# define XH_DL_MINFAT		1
+# define XH_DL_MAXFAT		2
+# define XH_DL_MINSPC		3
+# define XH_DL_MAXSPC		4
+# define XH_DL_CLUSTS		5
+# define XH_DL_MAXSEC		6
+# define XH_DL_DRIVES		7
+# define XH_DL_CLSIZB		8
+# define XH_DL_RDLEN		9
+# define XH_DL_CLUSTS12		12
+# define XH_DL_CLUSTS32		13
+# define XH_DL_BFLAGS		14
+
+
+extern ushort XHDI_installed;
+
+long	init_XHDI	(void);
+
+long	XHGetVersion	(void);
+long	XHInqTarget	(ushort major, ushort minor, ulong *block_size, ulong *device_flags, char *product_name);
+long	XHReserve	(ushort major, ushort minor, ushort do_reserve, ushort key);
+long	XHLock		(ushort major, ushort minor, ushort do_lock, ushort key);
+long	XHStop		(ushort major, ushort minor, ushort do_stop, ushort key);
+long	XHEject		(ushort major, ushort minor, ushort do_eject, ushort key);
+long	XHDrvMap	(void);
+long	XHInqDev	(ushort bios, ushort *major, ushort *minor, ulong *start, __BPB *bpb);
+long	XHInqDriver	(ushort bios, char *name, char *version, char *company, ushort *ahdi_version, ushort *maxIPL);
+long	XHNewCookie	(void *newcookie);
+long	XHReadWrite	(ushort major, ushort minor, ushort rwflag, ulong recno, ushort count, void *buf);
+long	XHInqTarget2	(ushort major, ushort minor, ulong *block_size, ulong *device_flags, char *product_name, ushort stringlen);
+long	XHInqDev2	(ushort bios, ushort *major, ushort *minor, ulong *start, __BPB *bpb, ulong *blocks, char *partid);
+long	XHDriverSpecial	(ulong key1, ulong key2, ushort subopcode, void *data);
+long	XHGetCapacity	(ushort major, ushort minor, ulong *blocks, ulong *bs);
+long	XHMediumChanged	(ushort major, ushort minor);
+long	XHMiNTInfo	(ushort op, void *data);
+long	XHDOSLimits	(ushort which, ulong limit);
+long	XHLastAccess	(ushort major, ushort minor, ulong *ms);
+long	XHReaccess	(ushort major, ushort minor);
+
+
+# endif /* _xhdi_h */
diff -ur --new-file e2fsprogs-1.41.3/misc/e2undo.c e2fsprogs-1.41.3-mint/misc/e2undo.c
--- e2fsprogs-1.41.3/misc/e2undo.c	2009-01-23 12:59:44.000000000 +0000
+++ e2fsprogs-1.41.3-mint/misc/e2undo.c	2009-01-23 12:56:40.000000000 +0000
@@ -19,6 +19,7 @@
 #if HAVE_ERRNO_H
 #include <errno.h>
 #endif
+#include <sys/types.h>
 #include "ext2fs/tdb.h"
 #include "ext2fs/ext2fs.h"
 #include "nls-enable.h"
diff -ur --new-file e2fsprogs-1.41.3/misc/e2initrd_helper.c e2fsprogs-1.41.3-mint/misc/e2initrd_helper.c
--- e2fsprogs-1.41.3/misc/e2initrd_helper.c	2009-01-23 12:58:29.000000000 +0000
+++ e2fsprogs-1.41.3-mint/misc/e2initrd_helper.c	2009-01-23 12:59:11.000000000 +0000
@@ -50,7 +50,7 @@
 	int	ptr;
 };
 
-struct fs_info {
+struct _fs_info {
 	char  *device;
 	char  *mountpt;
 	char  *type;
@@ -58,7 +58,7 @@
 	int   freq;
 	int   passno;
 	int   flags;
-	struct fs_info *next;
+	struct _fs_info *next;
 };
 
 static void usage(void)
@@ -230,7 +230,7 @@
 	*q = 0;
 }
 
-static int parse_fstab_line(char *line, struct fs_info *fs)
+static int parse_fstab_line(char *line, struct _fs_info *fs)
 {
 	char	*dev, *device, *mntpnt, *type, *opts, *freq, *passno, *cp;
 
@@ -280,7 +280,7 @@
 	return 0;
 }
 
-static void free_fstab_line(struct fs_info *fs)
+static void free_fstab_line(struct _fs_info *fs)
 {
 	if (fs->device)
 		fs->device = 0;
@@ -290,7 +290,7 @@
 		fs->type = 0;
 	if (fs->opts)
 		fs->opts = 0;
-	memset(fs, 0, sizeof(struct fs_info));
+	memset(fs, 0, sizeof(struct _fs_info));
 }
 
 
@@ -334,7 +334,7 @@
 	errcode_t retval;
 	struct mem_file file;
 	char 		*buf;
-	struct fs_info fs_info;
+	struct _fs_info _fs_info;
 	int		ret;
 
 	retval = get_file(fs, "/etc/fstab", &file);
@@ -344,14 +344,14 @@
 		if (!buf)
 			continue;
 
-		ret = parse_fstab_line(buf, &fs_info);
+		ret = parse_fstab_line(buf, &_fs_info);
 		if (ret < 0)
 			goto next_line;
 
-		if (!strcmp(fs_info.mountpt, "/"))
-			printf("%s\n", fs_info.type);
+		if (!strcmp(_fs_info.mountpt, "/"))
+			printf("%s\n", _fs_info.type);
 
-		free_fstab_line(&fs_info);
+		free_fstab_line(&_fs_info);
 
 	next_line:
 		free(buf);
diff -ur --new-file e2fsprogs-1.41.3/misc/mke2fs.c e2fsprogs-1.41.3-mint/misc/mke2fs.c
--- e2fsprogs-1.41.3/misc/mke2fs.c	2008-10-07 14:22:39.000000000 +0000
+++ e2fsprogs-1.41.3-mint/misc/mke2fs.c	2009-01-23 10:47:35.000000000 +0000
@@ -1819,6 +1819,36 @@
 	return retval;
 }
 
+#ifdef __MINT__
+void
+warn (const char *drv)
+{
+	char c;
+	int check;
+	
+	check = open (drv, O_RDONLY);
+	if (check == -1)
+		return;
+	
+	close (check);
+	
+	if (check < 1024)
+		return;
+	
+	fprintf (stderr, "\n");
+	fprintf (stderr, "WARNING: THIS WILL TOTALLY DESTROY ANY DATA ON %s:\n", drv);
+	fprintf (stderr, "Are you ABSOLUTELY SURE you want to do this? (y/n) ");
+	scanf ("%c", &c);
+	fprintf (stderr, "\n");
+	
+	if (c == 'y' || c == 'Y')
+		return;
+	
+	fprintf (stderr, "Aborted\n");
+	exit (1);
+}
+#endif
+
 int main (int argc, char *argv[])
 {
 	errcode_t	retval = 0;
@@ -1839,6 +1869,11 @@
 #endif
 	PRS(argc, argv);
 
+#ifdef __MINT__
+	if (!quiet)
+		warn (device_name);
+#endif
+
 #ifdef CONFIG_TESTIO_DEBUG
 	if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
 		io_ptr = test_io_manager;