Attachment 179583 Details for Bug 256234 – sys-fs/e2fsprogs-1.41.3-r1 files patch

[patch] sys-fs/e2fsprogs-1.41.3-r1 files patch

e2fsprogs-1.41-mint.patch (text/plain), 38.30 KB, created by Alan Hourihane on 2009-01-24 20:57:40 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Alan Hourihane

Created: 2009-01-24 20:57:40 UTC

Size: 38.30 KB

patch

obsolete

>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: mint_io.c,v 1.4 2003/11/18 21:05:42 standa 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;

Actions: View | Diff

Attachments on bug 256234: 179579 | 179580 | 179582 | 179583