DISTFILES=	${DISTNAME}${EXTRACT_SUFX}:ntfs

BUILD_DEPENDS=	fusefs-libs>=2.6.0:${PORTSDIR}/sysutils/fusefs-libs

USE_AUTOTOOLS=	libtool:15

CONFIGURE_TARGET=	--build=${ARCH}-portbld-freebsd${OSREL}

OPTIONS=	LOCK "Lock the device when mounting (avoids access)" off \

		UBLIO "Enable user space cache for improved speed" on

post-patch:

	@${REINPLACE_CMD} -e 's|,nonempty||' ${WRKSRC}/src/ntfs-3g.c

MD5 (libublio-20070103.tar.gz) = ec8b05fe4d831111f29485b0ab8a0161

SHA256 (libublio-20070103.tar.gz) = 7c87d1cd7a65ab5ab61f9d7b5279bab6c8169d33d552148d396995c767be919f

SIZE (libublio-20070103.tar.gz) = 17238

--- ./libntfs-3g/Makefile.am.orig	Fri Apr  6 17:22:09 2007

+++ ./libntfs-3g/Makefile.am	Mon Apr 30 13:34:44 2007

@@ -54,7 +54,8 @@

 	security.c	\

 	unistr.c	\

 	version.c	\

-	volume.c

+	volume.c \

+	ublio.c

 AM_CPPFLAGS = $(linux_ntfsincludedir) $(all_includes)

--- ./src/ntfs-3g.c.orig	Sun Apr 15 20:52:01 2007

+++ ./src/ntfs-3g.c	Mon Apr 30 14:12:57 2007

@@ -1603,7 +1603,11 @@

 	.mkdir		= ntfs_fuse_mkdir,

 	.rmdir		= ntfs_fuse_rmdir,

 	.utime		= ntfs_fuse_utime,

+#ifdef __linux__

 	.bmap		= ntfs_fuse_bmap,

+#else

+	.bmap		= NULL,

+#endif

 	.destroy        = ntfs_fuse_destroy2,

 #ifdef HAVE_SETXATTR

 	.getxattr	= ntfs_fuse_getxattr,

--- libntfs-3g/Makefile.in.orig	Sun Apr 15 20:50:19 2007

+++ libntfs-3g/Makefile.in	Mon Apr 30 14:49:21 2007

@@ -97,7 +97,7 @@

 	libntfs_3g_la-misc.lo libntfs_3g_la-mst.lo \

 	libntfs_3g_la-runlist.lo libntfs_3g_la-security.lo \

 	libntfs_3g_la-unistr.lo libntfs_3g_la-version.lo \

-	libntfs_3g_la-volume.lo

+	libntfs_3g_la-volume.lo libntfs_3g_la-ublio.lo

 libntfs_3g_la_OBJECTS = $(am_libntfs_3g_la_OBJECTS)

 DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir)

 depcomp = $(SHELL) $(top_srcdir)/depcomp

@@ -261,7 +261,8 @@

 	security.c	\

 	unistr.c	\

 	version.c	\

-	volume.c

+	volume.c	\

+	ublio.c

 AM_CPPFLAGS = $(linux_ntfsincludedir) $(all_includes)

 EXTRA_DIST = unix_io.c

@@ -359,6 +360,7 @@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libntfs_3g_la-unistr.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libntfs_3g_la-version.Plo@am__quote@

 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libntfs_3g_la-volume.Plo@am__quote@

+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libntfs_3g_la-ublio.Plo@am__quote@

 .c.o:

 @am__fastdepCC_TRUE@	if $(COMPILE) -MT $@ -MD -MP -MF "$(DEPDIR)/$*.Tpo" -c -o $@ $<; \

@@ -546,8 +548,13 @@

 @am__fastdepCC_TRUE@	if $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libntfs_3g_la_CFLAGS) $(CFLAGS) -MT libntfs_3g_la-volume.lo -MD -MP -MF "$(DEPDIR)/libntfs_3g_la-volume.Tpo" -c -o libntfs_3g_la-volume.lo `test -f 'volume.c' || echo '$(srcdir)/'`volume.c; \

 @am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/libntfs_3g_la-volume.Tpo" "$(DEPDIR)/libntfs_3g_la-volume.Plo"; else rm -f "$(DEPDIR)/libntfs_3g_la-volume.Tpo"; exit 1; fi

 @AMDEP_TRUE@@am__fastdepCC_FALSE@	source='volume.c' object='libntfs_3g_la-volume.lo' libtool=yes @AMDEPBACKSLASH@

+libntfs_3g_la-ublio.lo: ublio.c

+@am__fastdepCC_TRUE@	if $(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libntfs_3g_la_CFLAGS) $(CFLAGS) -MT libntfs_3g_la-ublio.lo -MD -MP -MF "$(DEPDIR)/libntfs_3g_la-ublio.Tpo" -c -o libntfs_3g_la-ublio.lo `test -f 'ublio.c' || echo '$(srcdir)/'`ublio.c; \

+@am__fastdepCC_TRUE@	then mv -f "$(DEPDIR)/libntfs_3g_la-ublio.Tpo" "$(DEPDIR)/libntfs_3g_la-ublio.Plo"; else rm -f "$(DEPDIR)/libntfs_3g_la-ublio.Tpo"; exit 1; fi

+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='ublio.c' object='libntfs_3g_la-ublio.lo' libtool=yes @AMDEPBACKSLASH@

 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@

 @am__fastdepCC_FALSE@	$(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libntfs_3g_la_CFLAGS) $(CFLAGS) -c -o libntfs_3g_la-volume.lo `test -f 'volume.c' || echo '$(srcdir)/'`volume.c

+@am__fastdepCC_FALSE@	$(LIBTOOL) --tag=CC --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(libntfs_3g_la_CFLAGS) $(CFLAGS) -c -o libntfs_3g_la-ublio.lo `test -f 'ublio.c' || echo '$(srcdir)/'`ublio.c

 mostlyclean-libtool:

 	-rm -f *.lo

--- ./libntfs-3g/device.c.orig	Tue Jan  9 18:22:57 2007

+++ ./libntfs-3g/device.c	Mon Apr 30 13:40:54 2007

@@ -63,6 +63,9 @@

 #ifdef HAVE_LINUX_HDREG_H

 #include <linux/hdreg.h>

 #endif

+#ifdef __FreeBSD__

+#include <sys/disk.h>

+#endif

 #include "types.h"

 #include "mst.h"

@@ -533,6 +536,17 @@

 		}

 	}

 #endif

+#ifdef DIOCGMEDIASIZE 

+	{       off_t size;

+

+		if (dev->d_ops->ioctl(dev, DIOCGMEDIASIZE, &size) >= 0) {

+			ntfs_log_debug("DIOCGMEDIASIZE nr bytes = %llu (0x%llx)\n",

+					(unsigned long long)size,

+					(unsigned long long)size);

+			return (s64)size / block_size;

+		}

+	}

+#endif

 	/*

 	 * We couldn't figure it out by using a specialized ioctl,

 	 * so do binary search to find the size of the device.

@@ -681,7 +695,24 @@

 			return sect_size;

 		}

 	}

-#else

+#elif defined(DIOCGSECTORSIZE)

+	/*

+	 * XXX On FreeBSD (where we have DIOCGSECTORSIZE) the low-level I/O

+	 * system already knows the sector size, and doing an ioctl is needless.

+	 * However, I don't know how to extract that information cleanly,

+	 * without letting a bunch of platform specific #ifdef-s to sneak in.

+	 * So now I rather just re-do the ioctl...

+	 */

+	{

+		size_t sect_size = 0;

+

+		if (!dev->d_ops->ioctl(dev, DIOCGSECTORSIZE, &sect_size)) {

+			ntfs_log_debug("DIOCGSECTORSIZE sector size = %d bytes\n",

+				(int)sect_size);

+			return sect_size;

+		}

+	}

+#else

 	errno = EOPNOTSUPP;

 #endif

 	return -1;

--- libntfs-3g/unix_io.c.orig	Tue Dec 12 20:16:43 2006

+++ libntfs-3g/unix_io.c	Thu May  3 22:27:13 2007

@@ -54,6 +54,22 @@

 #include <linux/fd.h>

 #endif

+/*

+ * The following build definitions are available:

+ * USE_ALIGNED_IO	- All I/O is done by blocks.

+ * USE_UBLIO		- Use the ublio user space cache library.

+ * USE_LOCK		- Lock the device/file when mounted.

+ */

+

+#ifdef __FreeBSD__

+#include <sys/disk.h>

+#define USE_ALIGNED_IO	1

+#endif

+

+#if USE_UBLIO

+#include <sys/uio.h>

+#endif

+

 #include "types.h"

 #include "mst.h"

 #include "debug.h"

@@ -61,13 +77,90 @@

 #include "logging.h"

 #include "misc.h"

-#define DEV_FD(dev)	(*(int *)dev->d_private)

+#if USE_UBLIO

+#define UBLIO_USE_API		1

+#include "ublio.h"

+#define UBLIO_DEFAULT_ENABLE	1

+#define UBLIO_DEFAULT_BLOCKSIZE	1048576

+#define UBLIO_DEFAULT_ITEMS	64

+#define UBLIO_DEFAULT_GRACE	32

+#define UBLIO_DEFAULT_SYNC_IO	0

+#endif

+

+#if USE_ALIGNED_IO

+#define RAW_IO_ALIGNED(dev, offset, count)			\

+	(DEV_HANDLE(dev)->block_size == 0 ||			\

+	 ((offset) % DEV_HANDLE(dev)->block_size == 0 &&	\

+	  (count) % DEV_HANDLE(dev)->block_size == 0))

+#define RAW_IO_ALIGN(dev, offset)				\

+	((offset) / DEV_HANDLE(dev)->block_size * DEV_HANDLE(dev)->block_size)

+#define RAW_IO_MAX_SIZE (128 * 1024 * 1024)

+#endif

+

+struct unix_filehandle {

+	int fd;

+#if USE_ALIGNED_IO

+	s64 pos;

+	s32 block_size;

+	s64 media_size;

+#endif

+#if USE_UBLIO

+	ublio_filehandle_t ublio_fh;

+#endif

+};

+

+#define DEV_HANDLE(dev)	((struct unix_filehandle *)dev->d_private)

+#define DEV_FD(dev)	(DEV_HANDLE(dev)->fd)

 /* Define to nothing if not present on this system. */

 #ifndef O_EXCL

 #	define O_EXCL 0

 #endif

+#if USE_ALIGNED_IO

+/**

+ * Get block_size and media_size

+ */

+static int

+raw_io_get_size(struct ntfs_device *dev)

+{

+	int bs;

+	off_t ms;

+	struct stat sb;

+

+	if (fstat(DEV_FD(dev), &sb) < 0) {

+		ntfs_log_perror("Failed to stat '%s'", dev->d_name);

+		return -1;

+	}

+

+	if (S_ISREG(sb.st_mode)) {

+		DEV_HANDLE(dev)->media_size = sb.st_size;

+		ntfs_log_trace("%s: regular file (media_size %lld)\n",

+		    dev->d_name, DEV_HANDLE(dev)->media_size);

+		if (getenv("FORCE_ALIGNED_IO"))

+			DEV_HANDLE(dev)->block_size = 512;

+		return 0;

+	}

+

+	if (ioctl(DEV_FD(dev), DIOCGSECTORSIZE, &bs) < 0) {

+		ntfs_log_perror("Failed to ioctl(DIOCGSECTORSIZE) '%s'",

+		    dev->d_name);

+		return -1;

+	}

+	DEV_HANDLE(dev)->block_size = bs;

+	ntfs_log_trace("%s: block size %d\n", dev->d_name, bs);

+

+	if (ioctl(DEV_FD(dev), DIOCGMEDIASIZE, &ms) < 0) {

+		ntfs_log_perror("Failed to ioctl(DIOCGMEDIASIZE) '%s'",

+		    dev->d_name);

+		return -1;

+	}

+	DEV_HANDLE(dev)->media_size = ms;

+	ntfs_log_trace("%s: media size %lld\n", dev->d_name, ms);

+	return 0;

+}

+#endif

+

 /**

  * ntfs_device_unix_io_open - Open a device and lock it exclusively

  * @dev:

@@ -79,9 +172,21 @@

  */

 static int ntfs_device_unix_io_open(struct ntfs_device *dev, int flags)

 {

+#if USE_ALIGNED_IO

+	size_t sectsize;

+#endif

+#if USE_LOCK

 	struct flock flk;

+#endif

 	struct stat sbuf;

-	int err;

+	struct unix_filehandle *ufh;

+	int err = 0;

+	int is_special = 0;

+#if USE_UBLIO

+	struct ublio_param up;

+	int use_ublio = 0;

+	char *xenv, *xgarbage;

+#endif

 	if (NDevOpen(dev)) {

 		errno = EBUSY;

@@ -91,20 +196,28 @@

 		ntfs_log_perror("Failed to access '%s'", dev->d_name);

 		return -1;

 	}

-	if (S_ISBLK(sbuf.st_mode))

-		NDevSetBlock(dev);

+	if (S_ISBLK(sbuf.st_mode) || S_ISCHR(sbuf.st_mode))

+		is_special = 1;

-	dev->d_private = ntfs_malloc(sizeof(int));

-	if (!dev->d_private)

+	ufh = ntfs_malloc(sizeof(*ufh));

+	if (!ufh)

 		return -1;

+	dev->d_private = ufh;

+#if USE_ALIGNED_IO

+	ufh->fd = -1;

+	ufh->pos = 0;

+	ufh->block_size = 0;

+	ufh->media_size = 0;

+#endif

+

 	/*

 	 * Open file for exclusive access if mounting r/w.

 	 * Fuseblk takes care about block devices.

 	 */ 

-	if (!NDevBlock(dev) && (flags & O_RDWR) == O_RDWR)

+	if (!is_special && (flags & O_RDWR) == O_RDWR)

 		flags |= O_EXCL;

-	*(int*)dev->d_private = open(dev->d_name, flags);

-	if (*(int*)dev->d_private == -1) {

+	ufh->fd = open(dev->d_name, flags);

+	if (ufh->fd == -1) {

 		err = errno;

 		goto err_out;

 	}

@@ -112,6 +225,37 @@

 	if ((flags & O_RDWR) != O_RDWR)

 		NDevSetReadOnly(dev);

+#if USE_UBLIO

+	ufh->ublio_fh = NULL;

+	if ((xenv = getenv("NTFS_USE_UBLIO")) &&

+	    (xenv[0] == '0' || xenv[0] == '1') && xenv[1] == '\0')

+		use_ublio = (xenv[0] == '1');

+	else

+		use_ublio = UBLIO_DEFAULT_ENABLE;

+	if ((xenv = getenv("UBLIO_BLOCKSIZE")))

+		up.up_blocksize = strtoul(xenv, &xgarbage, 10);

+	if (!xenv || *xgarbage != '\0')

+		up.up_blocksize = UBLIO_DEFAULT_BLOCKSIZE;

+	if ((xenv = getenv("UBLIO_ITEMS")))

+		up.up_items = strtoul(xenv, &xgarbage, 10);

+	if (!xenv || *xgarbage != '\0')

+		up.up_items = UBLIO_DEFAULT_ITEMS;

+	if ((xenv = getenv("UBLIO_GRACE")))

+		up.up_grace = strtoul(xenv, &xgarbage, 10);

+	if (!xenv || *xgarbage != '\0')

+		up.up_grace = UBLIO_DEFAULT_GRACE;

+	if ((xenv = getenv("UBLIO_SYNC_IO")) &&

+	    (xenv[0] == '0' || xenv[0] == '1') && xenv[1] == '\0')

+		up.up_sync_io = (xenv[0] == '1');

+	else

+		up.up_sync_io = UBLIO_DEFAULT_SYNC_IO;

+	up.up_priv	= &ufh->fd;

+	up.up_pread	= NULL;

+	up.up_preadv	= NULL;

+	up.up_pwrite	= NULL;

+	up.up_pwritev	= NULL;

+#endif

+#if USE_LOCK

 	memset(&flk, 0, sizeof(flk));

 	if (NDevReadOnly(dev))

 		flk.l_type = F_RDLCK;

@@ -119,7 +263,21 @@

 		flk.l_type = F_WRLCK;

 	flk.l_whence = SEEK_SET;

 	flk.l_start = flk.l_len = 0LL;

-	if (fcntl(DEV_FD(dev), F_SETLK, &flk)) {

+#endif

+#if USE_ALIGNED_IO

+	if (raw_io_get_size(dev) < 0) {

+		err = errno;

+		close(DEV_FD(dev));

+		goto err_out;

+	}

+	if (S_ISBLK(sbuf.st_mode) || S_ISCHR(sbuf.st_mode))

+		NDevSetBlock(dev);

+#else

+	if (S_ISBLK(sbuf.st_mode))

+		NDevSetBlock(dev);

+#endif /* USE_ALIGNED_IO */

+#if USE_LOCK

+	if (!NDevBlock(dev) && fcntl(DEV_FD(dev), F_SETLK, &flk)) {

 		err = errno;

 		ntfs_log_perror("Failed to %s lock '%s'", NDevReadOnly(dev) ? 

 				"read" : "write", dev->d_name);

@@ -127,7 +285,16 @@

 			ntfs_log_perror("Failed to close '%s'", dev->d_name);

 		goto err_out;

 	}

-	

+#endif

+#if USE_UBLIO

+	if (use_ublio) {

+		ufh->ublio_fh = ublio_open(&up);

+		if (!ufh->ublio_fh) {

+			close(DEV_FD(dev));

+			goto err_out;

+		}

+	}

+#endif

 	NDevSetOpen(dev);

 	return 0;

 err_out:

@@ -147,7 +314,10 @@

  */

 static int ntfs_device_unix_io_close(struct ntfs_device *dev)

 {

+	/* XXX no error if fysnc, fcntl (ublio_close) fails? */

+#if USE_LOCK

 	struct flock flk;

+#endif

 	if (!NDevOpen(dev)) {

 		errno = EBADF;

@@ -155,14 +325,21 @@

 	}

 	if (NDevDirty(dev))

 		fsync(DEV_FD(dev));

+#if USE_LOCK

 	/* Release exclusive (mandatory) lock on the whole device. */

 	memset(&flk, 0, sizeof(flk));

 	flk.l_type = F_UNLCK;

 	flk.l_whence = SEEK_SET;

 	flk.l_start = flk.l_len = 0LL;

-	if (fcntl(DEV_FD(dev), F_SETLK, &flk))

+

+	if (!NDevBlock(dev) && fcntl(DEV_FD(dev), F_SETLK, &flk))

 		ntfs_log_perror("ntfs_device_unix_io_close: Warning: Could not "

-				"unlock %s", dev->d_name);

+			"unlock %s", dev->d_name);

+#endif

+#if USE_UBLIO

+	if (DEV_HANDLE(dev)->ublio_fh)

+		ublio_close(DEV_HANDLE(dev)->ublio_fh);

+#endif

 	/* Close the file descriptor and clear our open flag. */

 	if (close(DEV_FD(dev)))

 		return -1;

@@ -185,10 +362,235 @@

 static s64 ntfs_device_unix_io_seek(struct ntfs_device *dev, s64 offset,

 		int whence)

 {

+#if USE_ALIGNED_IO

+	s64 abs_pos;

+

+	ntfs_log_trace("seek offset = 0x%llx, whence = %d.\n", offset, whence);

+	switch (whence) {

+	case SEEK_SET:

+		abs_pos = offset;

+		break;

+

+	case SEEK_CUR:

+		abs_pos = DEV_HANDLE(dev)->pos + offset;

+		break;

+

+	case SEEK_END:

+		abs_pos = DEV_HANDLE(dev)->media_size + offset;

+		break;

+

+	default:

+		ntfs_log_trace("Wrong mode %d.\n", whence);

+		errno = EINVAL;

+		return -1;

+	}

+

+	if (abs_pos < 0 || abs_pos > DEV_HANDLE(dev)->media_size) {

+		ntfs_log_trace("Seeking outsize seekable area.\n");

+		errno = EINVAL;

+		return -1;

+	}

+	DEV_HANDLE(dev)->pos = abs_pos;

+	return abs_pos;

+#else

 	return lseek(DEV_FD(dev), offset, whence);

+#endif

+}

+

+#if USE_ALIGNED_IO

+

+#if USE_UBLIO

+#define pread_wrap(fd, buf, count, off)					\

+	(DEV_HANDLE(fd)->ublio_fh ?					\

+	ublio_pread(DEV_HANDLE(fd)->ublio_fh, buf, count, off) :	\

+	pread(DEV_FD(fd), buf, count, off))

+#define pwrite_wrap(fd, buf, count, off)				\

+	(DEV_HANDLE(fd)->ublio_fh ?					\

+	ublio_pwrite(DEV_HANDLE(fd)->ublio_fh, buf, count, off) :	\

+	pwrite(DEV_FD(fd), buf, count, off))

+#else

+#define pread_wrap(fd, buf, count, off)		\

+	pread(DEV_FD(fd), buf, count, off)

+#define pwrite_wrap(fd, buf, count, off)	\

+	pwrite(DEV_FD(fd), buf, count, off)

+#endif

+

+/**

+ * aligned_pread - Perform an aligned positioned read from the device

+ */

+static s64 aligned_pread(struct ntfs_device *dev, void *buf, s64 count, s64 offset)

+{

+	s64 start, start_aligned;

+	s64 end, end_aligned;

+	size_t count_aligned;

+	char *buf_aligned;

+	ssize_t nr;

+

+	/* short-circuit for regular files */

+	start = offset;

+	if (count > RAW_IO_MAX_SIZE)

+		count = RAW_IO_MAX_SIZE;

+	if (RAW_IO_ALIGNED(dev, start, count))

+		return pread_wrap(dev, buf, count, start);

+

+	/*

+	 * +- start_aligned                 +- end_aligned

+	 * |                                |

+	 * |     +- start           +- end  |

+	 * v     v                  v       v

+	 * |----------|----------|----------|

+	 *       ^                  ^

+	 *       +----- count ------+

+	 * ^                                ^

+	 * +-------- count_aligned ---------+

+	 */

+	start_aligned = RAW_IO_ALIGN(dev, start);

+	end = start + count;

+	end_aligned = RAW_IO_ALIGN(dev, end) +

+	    (RAW_IO_ALIGNED(dev, end, 0) ? 0 : DEV_HANDLE(dev)->block_size);

+	count_aligned = end_aligned - start_aligned;

+	ntfs_log_trace(

+	    "%s: count = 0x%llx/0x%x, start = 0x%llx/0x%llx, end = 0x%llx/0x%llx\n",

+	    dev->d_name, count, count_aligned,

+	    start, start_aligned, end, end_aligned);

+

+	/* allocate buffer */

+	buf_aligned = ntfs_malloc(count_aligned);

+	if (buf_aligned == NULL) {

+		ntfs_log_trace("ntfs_malloc(%d) failed\n", count_aligned);

+		return -1;

+	}

+

+	/* read aligned data */

+	nr = pread_wrap(dev, buf_aligned, count_aligned, start_aligned);

+	if (nr == 0)

+		return 0;

+	if (nr < 0 || nr < start - start_aligned) {

+		free(buf_aligned);

+		return -1;

+	}

+

+	/* copy out */

+	memcpy(buf, buf_aligned + (start - start_aligned), count);

+	free(buf_aligned);

+

+	nr -= start - start_aligned;

+	if (nr > count)

+		nr = count;

+	return nr;

 }

 /**

+ * aligned_pwrite - Perform an aligned positioned write from the device

+ */

+static s64 aligned_pwrite(struct ntfs_device *dev, void *buf, s64 count, s64 offset)

+{

+	s64 start, start_aligned;

+	s64 end, end_aligned;

+	size_t count_aligned;

+	char *buf_aligned;

+	ssize_t nw;

+

+	if (NDevReadOnly(dev)) {

+		errno = EROFS;

+		return -1;

+	}

+	NDevSetDirty(dev);

+

+	/* short-circuit for regular files */

+	start = offset;

+	if (count > RAW_IO_MAX_SIZE)

+		count = RAW_IO_MAX_SIZE;

+	if (RAW_IO_ALIGNED(dev, start, count))

+		return pwrite_wrap(dev, buf, count, start);

+

+	/*

+	 * +- start_aligned                 +- end_aligned

+	 * |                                |

+	 * |     +- start           +- end  |

+	 * v     v                  v       v

+	 * |----------|----------|----------|

+	 *       ^                  ^

+	 *       +----- count ------+

+	 * ^                                ^

+	 * +-------- count_aligned ---------+

+	 */

+	start_aligned = RAW_IO_ALIGN(dev, start);

+	end = start + count;

+	end_aligned = RAW_IO_ALIGN(dev, end) +

+	    (RAW_IO_ALIGNED(dev, end, 0) ? 0 : DEV_HANDLE(dev)->block_size);

+	count_aligned = end_aligned - start_aligned;

+	ntfs_log_trace(

+	    "%s: count = 0x%llx/0x%x, start = 0x%llx/0x%llx, end = 0x%llx/0x%llx\n",

+	    dev->d_name, count, count_aligned,

+	    start, start_aligned, end, end_aligned);

+

+	/* allocate buffer */

+	buf_aligned = ntfs_malloc(count_aligned);

+	if (buf_aligned == NULL) {

+		ntfs_log_trace("ntfs_malloc(%d) failed\n", count_aligned);

+		return -1;

+	}

+

+	/* read aligned lead-in */

+	if (pread_wrap(dev, buf_aligned, DEV_HANDLE(dev)->block_size, start_aligned) != DEV_HANDLE(dev)->block_size) {

+		ntfs_log_trace("read lead-in failed\n");

+		free(buf_aligned);

+		return -1;

+	}

+

+	/* read aligned lead-out */

+	if (end != end_aligned && count_aligned > DEV_HANDLE(dev)->block_size) {

+		if (pread_wrap(dev, buf_aligned + count_aligned - DEV_HANDLE(dev)->block_size, DEV_HANDLE(dev)->block_size, end_aligned - DEV_HANDLE(dev)->block_size) != DEV_HANDLE(dev)->block_size) {

+			ntfs_log_trace("read lead-out failed\n");

+			free(buf_aligned);

+			return -1;

+		}

+	}

+

+	/* copy data to write */

+	memcpy(buf_aligned + (start - start_aligned), buf, count);

+

+	/* write aligned data */

+	nw = pwrite_wrap(dev, buf_aligned, count_aligned, start_aligned);

+	free(buf_aligned);

+	if (nw < 0 || nw < start - start_aligned)

+		return -1;

+

+	nw -= start - start_aligned;

+	if (nw > count)

+		nw = count;

+	return nw;

+}

+

+/**

+ * aligned_read - Perform an aligned read from the device

+ */

+static s64 aligned_read(struct ntfs_device *dev, void *buf, s64 count)

+{

+	s64 nr = aligned_pread(dev, buf, count, DEV_HANDLE(dev)->pos);

+	if (nr > 0)

+		DEV_HANDLE(dev)->pos += nr;

+	return nr;

+}

+

+/**

+ * aligned_write - Perform an aligned read from the device

+ */

+static s64 aligned_write(struct ntfs_device *dev, void *buf, s64 count)

+{

+	s64 nw = aligned_pwrite(dev, buf, count, DEV_HANDLE(dev)->pos);

+	if (nw > 0)

+		DEV_HANDLE(dev)->pos += nw;

+	return nw;

+}

+

+#undef ublio_pwrite

+#undef ublio_pread

+

+#endif

+

+/**

  * ntfs_device_unix_io_read - Read from the device, from the current location

  * @dev:

  * @buf:

@@ -201,6 +603,29 @@

 static s64 ntfs_device_unix_io_read(struct ntfs_device *dev, void *buf,

 		s64 count)

 {

+#if USE_ALIGNED_IO

+	return aligned_read(dev, buf, count);

+#elif USE_UBLIO

+	if (DEV_HANDLE(dev)->ublio_fh) {

+		off_t offset;

+		ssize_t res;

+

+		offset = lseek(DEV_FD(dev), 0, SEEK_CUR);

+		if (offset == -1)

+			return -1;

+

+		res = ublio_pread(DEV_HANDLE(dev)->ublio_fh, buf, count,

+		    offset);

+		if (res == -1)

+			return -1;

+

+		if (lseek(DEV_FD(dev), res, SEEK_CUR) == -1)

+			return -1;

+

+		return res;

+	}

+#endif

+

 	return read(DEV_FD(dev), buf, count);

 }

@@ -222,6 +647,28 @@

 		return -1;

 	}

 	NDevSetDirty(dev);

+#if USE_ALIGNED_IO

+	return aligned_write(dev, buf, count);

+#elif USE_UBLIO

+	if (DEV_HANDLE(dev)->ublio_fh)

+		off_t offset;

+		ssize_t res;

+

+		offset = lseek(DEV_FD(dev), 0, SEEK_CUR);

+		if (offset == -1)

+			return -1;

+

+		res = ublio_pwrite(DEV_HANDLE(dev)->ublio_fh, (void *)buf,

+		    count, offset);

+		if (res == -1)

+			return -1;

+

+		if (lseek(DEV_FD(dev), res, SEEK_CUR) == -1)

+			return -1;

+

+		return res;

+	}

+#endif

 	return write(DEV_FD(dev), buf, count);

 }

@@ -239,6 +686,13 @@

 static s64 ntfs_device_unix_io_pread(struct ntfs_device *dev, void *buf,

 		s64 count, s64 offset)

 {

+#if USE_ALIGNED_IO

+	return aligned_pread(dev, buf, count, offset);

+#elif USE_UBLIO

+	if (DEV_HANDLE(dev)->ublio_fh)

+		return ublio_pread(DEV_HANDLE(dev)->ublio_fh, buf, count,

+		    offset);

+#endif

 	return pread(DEV_FD(dev), buf, count, offset);

 }

@@ -261,6 +715,13 @@

 		return -1;

 	}

 	NDevSetDirty(dev);

+#if USE_ALIGNED_IO

+	return aligned_pwrite(dev, buf, count, offset);

+#elif USE_UBLIO

+	if (DEV_HANDLE(dev)->ublio_fh)

+		return ublio_pwrite(DEV_HANDLE(dev)->ublio_fh, (void *)buf,

+		    count, offset);

+#endif

 	return pwrite(DEV_FD(dev), buf, count, offset);

 }

@@ -275,7 +736,16 @@

 static int ntfs_device_unix_io_sync(struct ntfs_device *dev)

 {

 	if (!NDevReadOnly(dev)) {

-		int res = fsync(DEV_FD(dev));

+		int res;

+

+#if USE_UBLIO

+		if (DEV_HANDLE(dev)->ublio_fh) {

+			res = ublio_fsync(DEV_HANDLE(dev)->ublio_fh);

+			if (res)

+				return res;

+		}

+#endif

+		res = fsync(DEV_FD(dev));

 		if (!res)

 			NDevClearDirty(dev);

 		return res;

==============================================================================

NTFS-3G has been installed, and was built with UBLIO support.

The UBLIO layer is configured through environment variables, which are read

when mounting the filesystem. The following are available:

NTFS_USE_UBLIO	- Enable the UBLIO cache.

UBLIO_BLOCKSIZE	- Actual reads/writes will be multiples of this quantity.

UBLIO_ITEMS	- Number of cache entries, each of UBLIO_BLOCKSIZE length.

UBLIO_GRACE	- Number of times a cache entry will refuse being recycled.

UBLIO_SYNC_IO	- If enabled, all writes will be immediatly executed.

To give an idea about tuning, here are the default values with some notes

(they are only based on some simple benchmarks, and may be wrong):

NTFS_USE_UBLIO	- 1. Disabling it drastically decreases performance.

UBLIO_BLOCKSIZE	- 1048576 (1MB). Larger improves reading/writing speed of

		  large files, and smaller makes filesystem operations

		  (creation, deletion, moving, find(1)) perform faster.

		  Try 2/4MB and 512/256KB for the different approaches. Note

		  that after that points performance descreases again.

UBLIO_ITEMS	- 64. When greater, increases speed of filesystem operations,

		  but consumes more memory. Try 128.

UBLIO_GRACE	- 32. Makes the cache items have more chances to be reused.

UBLIO_SYNC_IO	- 0. If enabled, highly decreases writing speed, but the data

		  is written immediatly to the disk.

For example (improves performance over large files):

# env UBLIO_BLOCKSIZE=2097152 ntfs-3g /dev/ad0s1 /mnt

It is also possible to enforce block aligned I/O on regular files by setting

the FORCE_ALIGNED_IO variable (it will be set to 512 bytes), but this is only

useful for testing purposes and in practice has no use.

==============================================================================