2006-11-30  Miklos Szeredi <miklos@szeredi.hu>

	* Fix API version 21 and 22 compatibility for fuse_teardown.
	Reported by Bgs

2006-11-29  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: Print a more helpful message in case the kernel
	doesn't support the 'fuseblk' filesystem type.  This has been
	biting ntfs-3g users.  Reported by Yura Pakhuchiy

	* kernel: fix build problem for "make -C ...".  Reported by
	Stephen Bryant

2006-11-19  Miklos Szeredi <miklos@szeredi.hu>

	* Fix bug in certain error paths of lookup routines.  The request
	object was reused for sending FORGET, which is illegal.  This bug
	could cause an Oops in linux-2.6.18 or in fuse-2.6.0, and might
	silently corrupt memory in earlier versions.  Report and test
	program by Russ Cox

2006-11-11  Miklos Szeredi <miklos@szeredi.hu>

	* Print an error if an incompatible kernel interface version is
	detected in INIT.  This will only show if filesystem is started
	with -d or -f

	* Fix order of fuse_destroy()/fuse_unmount() in error cleanup of
	fuse_setup_common().  Reported by Szakacsits Szabolcs

2006-11-06  Miklos Szeredi <miklos@szeredi.hu>

	* Fix recursive locking in fuse_create().  Thanks to Takuya
	Ishibashi for the bug report

2006-10-28  Miklos Szeredi <miklos@szeredi.hu>

	* Fix automake problem.  Patch from Nix

2006-10-26  Miklos Szeredi <miklos@szeredi.hu>

	* Fix mount.fuse to use /bin/sh instead of /bin/bash, which is not
	always available on embedded systems.  Patch from Paul Smith

	* Fix util/Makefile.am, so that failure to run update-rc.d or
	device creation doesn't cause make to fail.  Reported by Paul
	Smith

2006-10-21  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.6.0

2006-10-18  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: don't try to create a lock file if /etc/mtab is a
	symlink.  Report and patch from Alexei Sheplyakov (debian bug
	#393693)

2006-10-17  Miklos Szeredi <miklos@szeredi.hu>

	* Minor changes, sync with mainline tree

2006-10-16  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.6.0-rc3

2006-10-15  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: cleanups

2006-10-13  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: Fix compilation on patched 2.6.18 (fc6) and 2.6.19.
	Report from David Shaw

	* lib: Fix lost error on renaming a file. Report from David Shaw

	* lib: Fix lost error on hiding open files (renaming to
	.fuse_hiddenXXXX)

	* kernel: Fix a rare hang on SMP/32bit on heavy filesystem
	activity.  The cause of the bug was that some calls to
	i_size_write() were not protected by a lock, and hence
	i_size_seqcount could become corrupted.  This caused subsequent
	calls to i_size_read() to spin forever.  This is a long standing
	bug was probably introduced in version 2.2, and thought to be
	related to NFS exporting (it's not).  It was reported by various
	people, but Dana Henriksen has finally helped me to track it down,
	so big thanks to him

	* kernel: Protect against truncation of a swapfile

2006-10-10  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: Check for signature of super_operations->umount_begin().
	Ubuntu kernel 2.6.17 seems to use the new signature found in
	2.6.18.  Thanks to Florent Mertens for the report

2006-10-08  Miklos Szeredi <miklos@szeredi.hu>

	* Make sure inode numers wrap around at 2^32.  This is needed on
	dual 64bit/32bit architectures, because 32bit applications using
	the non-largefile interface would otherwise break (EOVERFLOW error
	would be returned by the stat() system call family)

	* ulockmgr: handle the case, when a locking operation fails
	because no more file desctriptors are available in
	ulockmgr_server.  Also work around a Linux kernel bug (known to
	exist for all Linux kernel versions <= 2.6.18) which may cause
	sent file descriptors to be lost in the above case

	* ulockmgr: optimize file descriptor use

	* restore needed cpp flags to util/Makefile.am

	* Install udev rules as 99-fuse.rules instead of 60-fuse.rules

	* Minor clean up of udev rules

	* Add a synchronous DESTROY message to kernel interface.  This is
	invoked from umount, when the final instance of the filesystem is
	released.  It is only sent for filesystems mounted with the
	'blkdev' option for security reasons.

	* If the DESTROY message is received, call the filesystem's
	->destroy() method.  In this case it's not called from session
	destruction as it would be otherwise.

2006-10-01  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.6.0-rc2

2006-10-01  Miklos Szeredi <miklos@szeredi.hu>

	* Add support for FLUSH+RELEASE operation for FreeBSD.  Original
	patch by Csaba Henk

	* Add init script to insert fuse module and mount the control
	filesystem.  The script is installed as /etc/init.d/fuse and on
	debian based systems (where update-rc.d is available) symlinks
	from /etc/rc*.d/ are also installed.

	* Include '#define FUSE_USE_VERSION=XX' into examples so they
	become more self contained.

2006-09-30  Miklos Szeredi <miklos@szeredi.hu>

	* API changes:

	* Move lock_owner from a separate argument into fuse_file_info

	* Add a flag to fuse_file_info indicating (1) a highlevel lock
	operation (unlock all) was initiated by a flush, (2) a lowlevel
	release operation should perform a flush as well.

	* fusermount: revert modprobe change (2006-08-18) since it
	doesn't work reliably with udev

	* Add support for block device backed filesystems.  This mode is
	selected with the 'blkdev' option, which is privileged.

	* Add support for the bmap (FIBMAP ioctl) operation on block
	device backed filesystems.  This allows swapon and lilo to work on
	such filesystems.

	* kernel changes:

	* Drop support for kernels earlier than 2.6.9.  Kernel module from
	previous (2.5.x) release can be used with library from this
	release

	* In fuse_dentry_revalidate() use dget_parent() instead of
	dereferencing d_parent, since there's no protection against parent
	changing and going away

	* Protect nlookup from concurrent updates

	* In lookup if a directory alias exists but is unused,
	then get rid of it, otherwise return -EBUSY.

	* In mkdir if a directory alias exists, return success, but leave
	dentry negative.  In reality this could happen if a remote rename
	immediately followed the mkdir.

	* Don't BUG in fuse_iget() if multiple retries are needed to get a
	good inode.  This could happen if several lookups are racing for
	the same inode.

2006-09-29  Miklos Szeredi <miklos@szeredi.hu>

	* Fix compilation on 2.6.9.  Report from Troy Ayers

2006-09-27  Miklos Szeredi <miklos@szeredi.hu>

	* Fix Oops in fuse_readpages().  Reported by David Shaw

2006-09-24  Csaba Henk <csaba.henk@creo.hu>

	* Add support for nanosec times on FreeBSD

	* Fix FreeBSD compatibility issues

2006-09-23  Miklos Szeredi <miklos@szeredi.hu>

	* Fix one more compatibility bug.  Thanks to Ricardo Correia

	* Fix utimens compilation with uClibc.  Patch from Jamie Guinan

2006-09-22  Miklos Szeredi <miklos@szeredi.hu>

	* Fixed several compatibility bugs in low level interface.
	Reported by Ricardo Correia

	* Add workaround for ARM caching bug

2006-09-16  Miklos Szeredi <miklos@szeredi.hu>

	* Rename new utimes() method to more logical utimens()

2006-09-14  Miklos Szeredi <miklos@szeredi.hu>

	* Fuse tried to unlink already unlinked hidden files.  Bug
	reported by Milan Svoboda

2006-09-10  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.6.0-rc1

2006-09-10  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: Fix unlock on close for kernels < 2.6.18

	* Add ulockmgr library & server.  This can be used for handling
	file locking requests either directly from libfuse or over a
	network, etc.  This first version is not optimized and the number
	of file descriptors it uses may get out of hand

2006-09-07  Miklos Szeredi <miklos@szeredi.hu>

	* lib: Add interrupt support to high level library, which may be
	enabled with the 'intr' mount option.

	* When an operation is interrupted the thread handling that
	operation will receive SIGUSR1 (or other signal specified with the
	'intr_signal=N' option).  The library installs a no-op signal
	handler for this signal, unless there's already a handler
	installed.

	* The filesystem may query interrupt status (regardless of 'intr')
	with the fuse_interrupted() function.

	* mount.fuse: initialize $HOME if not set.  Report from Sven Goldt

2006-09-03  Miklos Szeredi <miklos@szeredi.hu>

	* lib: Multithreaded loop now allows unlimited number of threads.
	This is needed for locking operations which may block
	indefinitely.  Also the kernel now doesn't limit the number of
	outstanding requests so the library shouldn't do so either.

2006-09-01  Miklos Szeredi <miklos@szeredi.hu>

	* Fix recursive lock bug in interrupt handling

	* Add utimes() method to highlevel interface, which supports
	setting times with nanosecond resolution

2006-08-18  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: fix page leak if fuse_readpages() failed in it's
	initialization.  Bug found and original patch from Alexander
	Zarochentsev

	* For linux kernels >=2.6.18 (2.6.19 if using the fuse module from
	the kernel tree) the statfs method will receive the path within
	the filesystem on which the stat(v)fs syscall was called

	* fusermount: try to modprobe fuse module if invoked by root and
	unable to open device.  This is needed with udev, since the device
	node will be created only when the module is inserted, hence
	module autoloading won't work.  Reported by Szakacsits Szabolcs

2006-07-30  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: if selinux is active, restore the original file's
	security context in unmount_rename().  Redhat bugzilla id 188561.
	Patch from Yves Perrenoud

	* Add POSIX file locking operation to high level library

	* Initialize context for unlink of hidden files on umount.  Bug
	reported by Tim Stoakes

2006-07-14  Miklos Szeredi <miklos@szeredi.hu>

	* Multiple release() calls can race with each other, resulting in
	the hidden file being deleted before the last release finishes.
	Bug found and patch tested by Mark Huijgen

2006-07-05  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: if /dev/fuse doesn't exist, suggest modprobing fuse;
	this makes sense on systems using udev.  Reported by Szakacsits
	Szabolcs

2006-06-29  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.6.0-pre3

2006-06-29  Miklos Szeredi <miklos@szeredi.hu>

	* Support in kernel module for file locking and interruption.  The
	same functionality is available in official kernels >= 2.6.18

2006-06-28  Miklos Szeredi <miklos@szeredi.hu>

	* Add POSIX file locking support

	* Add request interruption

2006-06-06  Miklos Szeredi <miklos@szeredi.hu>

	* Add missing pthread_rwlock_destroy().  Patch from Remy Blank

2006-06-05  Remy Blank <remy.blank@pobox.com>

	* lib: canonicalize mount point in fuse_helper_opt_proc() so that
	unmounting succeeds even if mount point was relative.

2006-06-04  Csaba Henk <csaba.henk@creo.hu>

	* lib: fix emergency umount in helper.c when malloc fails.
	(The way it was done would end up in a segfault.)

2006-06-01  Csaba Henk <csaba.henk@creo.hu>

	* lib: adjust threading related compiler flags.
	Switch to "-pthread" from "-lpthread" as that's the preferred
	one on several platforms. Consulted with Terrence Cole and
	Miklos Szeredi

2006-05-08  Miklos Szeredi <miklos@szeredi.hu>

	* lib: search fusermount in installation directory (bindir) as
	well as in PATH.

2006-05-03  Miklos Szeredi <miklos@szeredi.hu>

	* lib: fix compilation if CLOCK_MONOTONIC is not defined.
	Reported by Christian Magnusson

2006-04-23  Csaba Henk <csaba.henk@creo.hu>

	* lib: make FreeBSD mount routine recognize if kernel features
        backgrounded init and if it does, run the mount util in foreground
        (similarly to Linux)

2006-04-21  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: fix fput deadlock fix, the lockless solution could lead
	to "VFS: busy inodes after umount..."

	* kernel: fix race between checking and setting file->private_data
	for the device.  Found by Al Viro

2006-04-11  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: remove request pool, instead allocate requests on
	demand.  Account the number of background requests, and if they go
	over a limit, block the allocation of new requests.

	* kernel: fix deadlock if backgrounded request holds the last
	reference to the super block

	* kernel: don't use fuse_reset_request() during direct I/O

2006-04-06  Csaba Henk <csaba.henk@creo.hu>

	* lib: Let FreeBSD mount option parsing routine recognize "no"
	prefixes for FUSE specific options as well

2006-04-01  Miklos Szeredi <miklos@szeredi.hu>

	* lib: Add missing rwlock initialization.  Patch by Ryan Bradetich

2006-03-17  Miklos Szeredi <miklos@szeredi.hu>

	* API changes:

	* fuse_main(), fuse_setup() and fuse_new() have an additionl
	user_data parameter

	* fuse_mount() returns a 'struct fuse_chan' pointer instead of a
	file descriptor

	* fuse_unmount() receives a 'struct fuse_chan' pointer.  It
	destroys the given channel

	* fuse_teardown() no longer has a file descriptor parameter

	* new exported functions: fuse_session_remove_chan(),
	fuse_get_session(), fuse_daemonize()

	* fuse_chan_recv() may now return a new channel which will be used
	to send the reply

2006-03-16  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.6.0-pre2

2006-03-16  Miklos Szeredi <miklos@szeredi.hu>

	* Don't unmount if already unmounted.  This fixes a problem seen
	in the following situation: Lazy unmount a busy filesystem; Mount
	a new one in top; When the first finally unmounts, the second also
	unmounts.  Reported by Franco Broi

2006-03-15  Miklos Szeredi <miklos@szeredi.hu>

	* lowlevel lib: use indirect function calls instead of a
	switch/case construct.  Besides increased efficiency it helps
	maintainability & readability too.  Patch from Florin Malita

2006-03-13  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: replace global spinlock with a per-connection spinlock

2006-03-10  Miklos Szeredi <miklos@szeredi.hu>

	* Fix source compatibility breakage for fuse_unmount().  Report
	from Yura Pakhuchiy

2006-03-02  Miklos Szeredi <miklos@szeredi.hu>

	* Fix O_ASYNC handling in fuse_dev_release().  From Jeff Dike

2006-03-01  Miklos Szeredi <miklos@szeredi.hu>

	* Add O_ASYNC and O_NONBLOCK support to FUSE device.  Patch by
	Jeff Dike

	* Renamed fuse_chan_receive() to fuse_chan_recv() and changed
	interface to return -errno in case of error.

2006-03-01  Csaba Henk <csaba.henk@creo.hu>

	* libfuse: pass device file descriptor to fuse_unmount(), rewrite
	FreeBSD implementation so that it uses libc (sysctl backed) instead
	of an embdedded script (kmem backed). Adjust the control flow of
	hello_ll so that device doesn't get closed before unmount attempt.

2006-02-25  Miklos Szeredi <miklos@szeredi.hu>

	* Lowlevel lib: return all-zero statvfs data if filesystem doesn't
	implement method.  This is needed on FreeBSD, and nicer on Linux
	too.  Highlevel lib already did this.  Reported by Csaba Henk

	* Fix negative entry handling.  There was a bug, that negative
	lookups with timeouts (nodeid == 0) returned -EIO.

2006-02-23  Miklos Szeredi <miklos@szeredi.hu>

	* Fix race between RELEASE and UNLINK, which might leave
	.fuse_hidden* files around

2006-02-21  Miklos Szeredi <miklos@szeredi.hu>

	* fusexmp_fh: implement flush() method and call close() on the
	open file descriptor.  This is needed if used on an NFS
	filesystem, which buffers data until file is closed.  Franco Broi
	spotted the situation when 'cp -p' failed to set the modification
	time because of this.

2006-02-20  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.6.0-pre1

2006-02-19  Miklos Szeredi <miklos@szeredi.hu>

	* libfuse: fix use-after-free bug in interruptred reply_entry().
	Patch from John Muir

	* libfuse: fix wrong symbol versioning for fuse_mount.  Debian bug
	ID: 352631.  Found by Stéphane Rosi

2006-02-17  Miklos Szeredi <miklos@szeredi.hu>

	* Lowlevel lib: Unify fuse_dirent_size() and fuse_add_dirent()
	into a single function fuse_add_direntry().  This cleans up the
	interface and makes it possible to do stacking.

2006-02-16  Miklos Szeredi <miklos@szeredi.hu>

	* Fix rare race betweeen abort and release caused by failed iget()
	in fuse_create_open().

	* Add 'ac_attr_timeout' option e.g. for filesystems which do their
	own attribute caching.

2006-02-15  Miklos Szeredi <miklos@szeredi.hu>

	* Work around FreeBSD runtime linker "feature" which binds an old
	version of a symbol to internal references if the symbol has more
	than one version.  This resulted in infinite recursion in
	fuse_lowlevel_new_compat25().

2006-02-10  Csaba Henk <csaba.henk@creo.hu>

	* Refine clock_gettime() querying so that linker options
	shall be set as it's appropriate for the target platform.

2006-02-09  Miklos Szeredi <miklos@szeredi.hu>

	* Fix udev rule syntax.  Reported by Nix

2006-02-08  Miklos Szeredi <miklos@szeredi.hu>

	* In some cases udev rule seems to be ineffective when installed
	as 40-fuse.rules but work as 60-fuse.rules.  Reported by John Hunt

2006-02-03  Miklos Szeredi <miklos@szeredi.hu>

	* Fix compilation when build directory is different from source
	directory.  Reported by Frédéric L. W. Meunier

2006-02-02  Miklos Szeredi <miklos@szeredi.hu>

	* Fix even bigger bug introduced in fix for request_end() on
	2006-01-14.  Reported by Gal Rosen

2006-01-30  Miklos Szeredi <miklos@szeredi.hu>

	* highlevel-lib: add 'auto_cache' option.  This caches file data
	based on modification time and size

2006-01-20  Miklos Szeredi <miklos@szeredi.hu>

	* Sanitize storage type and help message in mount_bsd.c.  Patch
	from Csaba Henk

	* fuse_opt: add new helper constants FUSE_OPT_KEY_KEEP and
	FUSE_OPT_KEY_DISCARD

	* Add options 'max_readahead', 'sync_read' and 'async_read'

	* Kernel ABI version 7.6:

	* Negotiate the 'max_readahead' value and 'async_read' flags with
	userspace in the INIT method

	* Add connection info to ->init() methods to both lowlevel and
	highlevel API

	* Fall back to synchronous read() behavior if either library or
	userspace filesystem is using the old interface version.  This is
	needed so non-updated filesystems won't be confused by the
	different read() behavior

2006-01-19  Miklos Szeredi <miklos@szeredi.hu>

	* lib: if "fsname=" option was given, pass it to fusermount

	* fuse_opt: add new fuse_opt_insert_arg() function, which is
	needed by filesystems to implement some argument manipulations
	correctly

	* fuse_opt: fix memory leak in handling "--" option

2006-01-18  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: fix detection of case when fuse is not configured into
	the kernel either as module or built-in

	* fuse_opt.h: fix incompatibility with C++ compilers by renaming
	'template' structure member to 'templ'.  Reported by Takashi Iwai

	* fuse.h: fix compatibility bugs.  Patch by Yura Pakhuchiy

	* kernel: support version 2.6.16 (i_sem -> i_mutex)

2006-01-16  Miklos Szeredi <miklos@szeredi.hu>

	* Added (again) asynchronous readpages support

	* Each connection now shows up under /sys/fs/fuse/connections

	* Connection attributes exported to sysfs: 'waiting' number of
	waiting requests; 'abort' abort the connection

	* Connection may be aborted through either the sysfs interface or
	with 'umount -f mountpoint'

2006-01-14  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.5.0

2006-01-14  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: fix a couple of bugs

	* Order of request_end() and fuse_copy_finish() was wrong.
	Posthumous note: Franco Broi managed to exploit this, though it
	seemed quite impossible

	* request_end() used request pointer after decrementing refcount

	* Clearing ->connected or ->mounted connection flags could race
	with setting other bitfields not protected with a lock

2006-01-10  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: add necessary compile flags for 2.4.X/x86_64.
	Report from Sean Ziegeler

2006-01-09  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.5.0-pre2

2006-01-09  Miklos Szeredi <miklos@szeredi.hu>

	* Applied patch from Csaba Henk, to update mount_bsd to new
	fuse_mount() semantics

	* Ignore auto,noauto,... options in mount.fuse.  Reported by Frank
	Steiner and Don Taber

	* fusermount: add 'dirsync' mount option

2006-01-07  Miklos Szeredi <miklos@szeredi.hu>

	* Improved help reporting and added version reporting to library

2006-01-06  Miklos Szeredi <miklos@szeredi.hu>

	* Change working directory to "/" even if running in the
	foreground.  Patch from Jonathan Brandmeyer

	* Changed lots of functions to use 'struct fuse_args' instead of
	separate argc and argv

	* Added fuse_parse_cmdline(), fuse_set_signal_handlers() and
	fuse_remove_signal_handlers() functions, so that it's now pretty
	easy to get all the functionality of fuse_main() with a filesystem
	using the lowlevel API.

2006-01-02  Miklos Szeredi <miklos@szeredi.hu>

	* mount.fuse: the 'user' option should be ignored. Report and
	solution from Mattd.

	* mount.fuse: export PATH in the right place. Report and patch
	from Hannes Schweizer

2005-12-16  Miklos Szeredi <miklos@szeredi.hu>

	* Clean up the option parsing interface slightly, by creating an
	"argument list" structure, that contains the argument vector and
	count

2005-12-15  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: check if /mnt/mtab is a symlink and don't modify it
	in that case

	* kernel: simplify request size limiting. INIT only contains
	maximum write size, maximum path component size remains fixed at
	1024 bytes, and maximum xattr size depends on read buffer.

2005-12-14  Miklos Szeredi <miklos@szeredi.hu>

	* Fix readdir() failure on x86_64, of 32bit programs compiled
	without largefile support.  Bug report and help from Anthony
	Kolasny

	* If lookup returns invalid mode, return -EIO instead of creating
	a regular file

	* Add current output argument vector to option processing
	function

2005-12-12  Miklos Szeredi <miklos@szeredi.hu>

	* Fix stale code in ifdef FreeBSD.  Patch from Csaba Henk

2005-12-09  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.5.0-pre1

2005-12-09  Miklos Szeredi <miklos@szeredi.hu>

	* libfuse: added option parsing interface, defined in
	<fuse_opt.h>.

2005-12-07  Miklos Szeredi <miklos@szeredi.hu>

	* Return EIO for file operations (read, write, fsync, flush) on
	open files whose inode has become "bad".  Inodes will be marked
	"bad" if their type changes.  Bug report by Csaba Henk

2005-12-06  Miklos Szeredi <miklos@szeredi.hu>

	* Use bigger request buffer size.  write() did not work on archs
	with > 4k page size, Bug report by Mark Haney

	* ABI version 7.5:

	* Extend INIT reply with data size limits

2005-12-02  Miklos Szeredi <miklos@szeredi.hu>

	* Fix memory leak in fuse_read_cmd()/fuse_process_cmd().  Bug
	reported by Vincenzo Ciancia

	* Handle exit-by-umount in fuse_read_cmd()

2005-11-29  Miklos Szeredi <miklos@szeredi.hu>

	* Check if '-msoft-float' option is supported by compiler when
	configuring for a 2.4.x kernel.  Bug report by Mark Haney

	* In multithreaded loop send a TERM signal to the main thread if
	one of the other threads exit.  Needed on FreeBSD for a clean exit
	on umount.  Should not cause any harm on Linux either

2005-11-28  Miklos Szeredi <miklos@szeredi.hu>

	* Fix bug in 32-bit file handle compatibility

2005-11-27  Miklos Szeredi <miklos@szeredi.hu>

	* Block TERM, INT, HUP and QUIT signals in all but the main
	thread.  According to POSIX it's not specified which thread will
	receive these signals.

	* Kernel changes:

	* Check for directory aliasing on mkdir, not just on lookup

	* Check for special node ID values in create+open operation

	* Sync with -mm: readv, writev, aio_read and aio_write methods
	added to file operations

	* Cleanups: lookup code, page offset calculation

	* ABI stepped to 7.4, changes:

	* frsize member added to fuse_kstatfs structure

	* added support for negative entry caching: on lowlevel API if
	fuse_entry_param::ino is set to zero in reply to a lookup request,
	the kernel will cache the dentry for the specified amount of time.

	* libfuse: added 'negative_timeout' option: specifies how much
	negative entries should be cached.  Default is zero, to be
	compatible with prior versions

2005-11-22  Miklos Szeredi <miklos@szeredi.hu>

	* Add detection of mainline FUSE code in running kernel

2005-11-21  Miklos Szeredi <miklos@szeredi.hu>

	* Don't use async cancelation in multithreaded loop.  This makes
	it more portable to systems where read() is not async cancel safe.
	Report from Andriy Gapon

2005-11-20  Miklos Szeredi <miklos@szeredi.hu>

	* Warn if API version 11 compatibility is requested

2005-11-17  Miklos Szeredi <miklos@szeredi.hu>

	* More FreeBSD merge

	* fusermount: don't allow mountpoints with '\n', '\t', or '\\' in
	them, because it corrupts /etc/mtab.  Found by Thomas Biege
	CVE-2005-3531

	* libfuse: don't use system() to invoke 'fusermount -u ...'
	because it breaks mountpoints with spaces in them into multiple
	arguments

2005-11-16  Miklos Szeredi <miklos@szeredi.hu>

	* Merge library part of FreeBSD port.  Patch by Csaba Henk

2005-11-11  Miklos Szeredi <miklos@szeredi.hu>

	* Use 64bit type for file handle, so the full range supported by
	the kernel interface is available to applications

2005-11-10  Miklos Szeredi <miklos@szeredi.hu>

	* Moved mountpoint argument checking from fuse_parse_cmdline() to
	fuse_mount() in preparation to FreeBSD merge.

2005-11-08  Miklos Szeredi <miklos@szeredi.hu>

	* Remove unneeded close() from fuse_teardown().  Spotted by Csaba
	Henk.

2005-11-07  Miklos Szeredi <miklos@szeredi.hu>

	* Make the statfs change backwards compatible.

2005-11-06  Miklos Szeredi <miklos@szeredi.hu>

	* Change ->statfs() method to use 'struct statvfs' instead of
	'struct statfs'.  This makes the API more portable since statvfs()
	is defined by POSIX.

2005-10-28  Miklos Szeredi <miklos@szeredi.hu>

	* Add fgetattr() method, which currently will only be called after
	a successful call to a create() method.

2005-10-26  Miklos Szeredi <miklos@szeredi.hu>

	* Change kernel ABI version to 7.3

	* Add ACCESS operation.  This is called from the access() system
	call if 'default_permissions' mount option is not given, and is
	not called on kernels 2.4.*

	* Add atomic CREATE+OPEN operation.  This will only work with
	2.6.15 (presumably) or later Linux kernels.

	* Add ftruncate() method.  This will only work with 2.6.15
	(presumably) or later Linux kernels.

	* Fix kernel module compile if kernel source and build directories
	differ.  Report and initial patch by John Eastman

2005-10-18  Miklos Szeredi <miklos@szeredi.hu>

	* lib: optimize buffer reallocation in fill_dir.

2005-10-17  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.4.1

2005-10-14  Miklos Szeredi <miklos@szeredi.hu>

	* libfuse: add debug for write result (by Shaun Jackman) and
	warnings for too large read/write result

2005-10-11  Miklos Szeredi <miklos@szeredi.hu>

	* Spelling fixes, thanks to Ioannis Barkas

2005-10-10  Miklos Szeredi <miklos@szeredi.hu>

	* fuse_common.h: use extern "C".  Thanks to Valient Gough for the
	patch

2005-10-07  Miklos Szeredi <miklos@szeredi.hu>

	* highlevel-lib: init() and destroy() methods didn't have an
	initialized fuse_context.  Bug reported by Tim Stoakes

2005-10-04  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.4.0

2005-10-03  Miklos Szeredi <miklos@szeredi.hu>

	* Add documentation to fuse_lowlevel.h

	* API cleanups:

	* Remove definitions of unused FATTR_CTIME / FUSE_SET_ATTR_CTIME

	* Move fuse_mount() and fuse_unmount() to fuse_common.h

	* Change the return type of fuse_reply_none() from int to void.

2005-09-30  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: NFS exporting leaked dentries.  Bug found and fixed by
	Akshat Aranya.

2005-09-29  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: fix error message, when unable to open /dev/fuse.
	Report by Balázs Pozsár

2005-09-28  Miklos Szeredi <miklos@szeredi.hu>

	* UClibc fixes from Christian Magnusson

2005-09-27  Miklos Szeredi <miklos@szeredi.hu>

	* Added NAME="%k" to util/udev.rules.  Fix by Mattias Wadman.

2005-09-26  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.4.0-rc1

2005-09-26  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: allow user umount in the case when /etc/mtab is a
	symlink to /proc/mounts.  Reported by Balázs Pozsár.

2005-09-23  Miklos Szeredi <miklos@szeredi.hu>

	* Check for special node ID values in lookup and creation

2005-09-22  Miklos Szeredi <miklos@szeredi.hu>

	* Slight optimization in returning EINVAL error in case of an open
	with O_DIRECT flag.

2005-09-20  Miklos Szeredi <miklos@szeredi.hu>

	* Remove '--enable-auto-modprobe' configure flag.  Module
	auto-loading is now handled by the kernel.

2005-09-15  Miklos Szeredi <miklos@szeredi.hu>

	* Install UDEV rule file, so /dev/fuse is created with mode 0666.
	Help from Jens M. Noedler.

2005-09-14  Miklos Szeredi <miklos@szeredi.hu>

	* Add memory cleanup on thread exit

2005-09-13  Miklos Szeredi <miklos@szeredi.hu>

	* Set umask to zero in fusexmp and fusexmp_fh, so that
	files/directories are created with the requested mode.

2005-09-12  Miklos Szeredi <miklos@szeredi.hu>

	* Don't ignore read error in multithreaded loop

2005-09-08  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.4.0-pre2

2005-09-08  Miklos Szeredi <miklos@szeredi.hu>

	* Revert lock and access operations.  Postpone these until 2.5.

2005-09-02  Miklos Szeredi <miklos@szeredi.hu>

	* Fix compile warning on 2.6.13 and later

	* Fix compilation on old kernels

2005-08-19  Miklos Szeredi <miklos@szeredi.hu>

	* lib: always refresh directory contents after rewinddir() to
	conform to SUS.  Bug found by John Muir.

2005-08-15  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.4.0-pre1

2005-08-14  Miklos Szeredi <miklos@szeredi.hu>

	* lib: cleaned up (or messed up, depending on your POV) the low
	level library API.  Hopefully this is close to the final form.

2005-08-05  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: don't allow empty mountpoint argument, which defeats
	automatic umounting in fuse_main().  Bugreport by Václav Jůza

2005-08-03  Miklos Szeredi <miklos@szeredi.hu>

	* fix warnings in fuse.h and fuse_lowlevel.h if -Wshadow compiler
	option is used (Paul Alfille).

2005-08-02  Miklos Szeredi <miklos@szeredi.hu>

	* highlevel-lib: added mount options "attr_timeout" and
	"entry_timeout".  These options control the length of time file
	attributes and entries (names) are cached.  Both default to 1.0
	second.

	* kernel: correctly handle zero timeout for attributes and entries

2005-08-01  Miklos Szeredi <miklos@szeredi.hu>

	* Added missing symbols to versionscript (Joshua J. Berry)

	* kernel: implement two flags, open can set: 'direct_io' and
	'keep_cache'.  These correspond exactly to mount options
	'direct_io' and 'kernel_cache', but allow a per-open setting.

	* Move 'direct_io' and 'kernel_cache' mount option handling to
	userspace.  For both mount options, if the option is given, then
	the respective open flag is set, otherwise the open flag is left
	unmodified (so the filesystem can set it).

	* lib (highlevel): make open method optional

2005-07-28  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: invalidate attributes for read/readdir/readlink
	operations

	* kernel: detect newer UML kernels

2005-07-26  Miklos Szeredi <miklos@szeredi.hu>

	* Make the installation path of fuse.ko and mount.fuse
	configurable through INSTALL_MOD_PATH and MOUNT_FUSE_PATH
	environment variables.  Requirement and help from Csaba Henk.

2005-07-22  Miklos Szeredi <miklos@szeredi.hu>

	* Fix bug, that causes filesystem requests to hang when unique
	request counter becomes negative.  This happens after
	2,147,483,648 operations, so most people won't care.  Thanks to
	Franco Broi for the report and testing.

2005-07-21  Miklos Szeredi <miklos@szeredi.hu>

	* Don't change mtime/ctime/atime to local time on read/write.
	Bug reported by Ben Grimm

	* Install fuse_common.h and fuse_lowlevel.h.  Report by Christian
	Magnusson

	* fusermount: use getopt_long() for option parsing.  It allows the
	use of '--' to stop argument scanning, so fusermount can now
	operate on directories whose names begin with a '-'.  Patch by
	Adam Connell

2005-07-15  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: add '-v', '--version' and '--help' options

	* add inode based API

2005-07-12  Miklos Szeredi <miklos@szeredi.hu>

	* lib: don't block signals in worker threads.  Problem noticed by
	Usarin Heininga

2005-07-07  Miklos Szeredi <miklos@szeredi.hu>

	* lib: don't allow both 'allow_other' and 'allow_root' options to
	be given

2005-07-06  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: check if mountpoint is empty (only '.' and '..' for
	directories, and size = 0 for regular files).  If "nonempty"
	option is given, omit this check.  This is useful, so users don't
	accidentally hide data (e.g. from backup programs).  Thanks to
	Frank van Maarseveen for pointing this out.

	* kernel: check if mandatory mount options ('fd', 'rootmode',
	'user_id', 'group_id') are all given

	* lib: simplify 'readdir_ino' handling

	* lib: add mount options 'umask=M', 'uid=N', 'gid=N'

2005-07-03  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: clean up 'direct_io' code

2005-06-28  Miklos Szeredi <miklos@szeredi.hu>

	* Add 'mount.fuse' written by Petr Klima

	* '/dev/fuse' is created by 'make install' if does not yet exist

2005-06-20  Miklos Szeredi <miklos@szeredi.hu>

	* Fix UCLIBC compile error.  Patch by Christian Magnusson

2005-06-08  Miklos Szeredi <miklos@szeredi.hu>

	* Enable the auto-loading of the module via access to the
	corresponding device file.  Patch by Takashi Iwai.

	* Allow mounting a regular file (over a regular file) for
	unprivleged users.

	* Do not create temporary device file.  Require "/dev/fuse" to
	exist, and be readable/writable by the mounting user.

2005-06-02  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.3.0

2005-06-02  Miklos Szeredi <miklos@szeredi.hu>

	* Fix serious information leak: if the filesystem returns a short
	byte count to a read request, and there are non-zero number of
	pages which are not filled at all, these pages will not be zeroed.
	Hence the user can read out previous memory contents.  Found by
	Sven Tantau.

2005-05-27  Miklos Szeredi <miklos@szeredi.hu>

	* Add "readdir_ino" mount option, which tries to fill in the d_ino
	field in struct dirent.  This mount option is ignored if "use_ino"
	is used.  It helps some programs (e.g. 'pwd' used over NFS from a
	non-Linux OS).  Patch by David Shaw.

2005-05-12  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.3-rc1

2005-05-12  Miklos Szeredi <miklos@szeredi.hu>

	* File save in krusader and other editors doesn't work with sshfs,
	because open() is interrupted by a periodic signal, and open()
	restarts forever, without any progress.  This could just be fixed
	in open(), but the problem is more generic: if signals are
	received more often than the filesystem can get the request to
	userspace, it will never finish.  This is probably only a
	theoretical problem, nevertheless I'm removing the possibility to
	interrupt requests with anything other than SIGKILL, even before
	being sent to userspace.  Bugreport by Eduard Czimbalmos.

2005-05-09  Miklos Szeredi <miklos@szeredi.hu>

	* libfuse: add "tree_lock" rwlock, that is locked for write in
	rename, unlink and rmdir, and locked for read in all other
	operations.  This should fix the rename/release race reported by
	Valient Gough and others.  The solution is very coarse, a finer
	grained locking scheme could be implemented, but it would be much
	more complex.  Let's see whether this is good enough.

2005-05-09  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.3-pre7

2005-05-08  Miklos Szeredi <miklos@szeredi.hu>

	* Better fix for out of order FORGET messages.  Now the
	LOOKUP/FORGET messages are balanced exactly (one FORGET can
	balance many lookups), so the order no longer matters.  This
	changes the kernel ABI slightly, but the library remains backward
	compatible.

2005-05-06  Miklos Szeredi <miklos@szeredi.hu>

	* Fix abort for out of order FORGET messages.  Again.  Spotted by
	Franco Broi again.  Sorry :)

2005-04-29  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.3-pre6

2005-04-29  Miklos Szeredi <miklos@szeredi.hu>

	* Make fusermount work with fuse kernel modules not yet supporting
	the "group_id" option (added for the purpose of stricter
	permission checking).

2005-04-28  Miklos Szeredi <miklos@szeredi.hu>

	* Check for hard-linked directories in lookup.  This could cause
	problems in the VFS, which assumes that such objects never exist.

	* Make checking of permission for other users more strict.  Now
	the same privilege is required for the mount owner as for ptrace
	on the process performing the filesystem operation.

2005-04-23  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.3-pre5

2005-04-22  Miklos Szeredi <miklos@szeredi.hu>

	* Add -msoft-float to kernel module compile flags for 2.4.X.  This
	is needed on certain architectures.  Report from Chris Kirby

	* Fix buggy behavior of open(..., O_CREAT|O_EXCL) if interrupted.
	Reported by David Shaw

	* Remove "allow_root" option from kernel module, and implement
	it's functionality in the library

	* Fix Oops caused by premature release of fuse_conn.  Clean up
	related code, to be more readable

	* Sendfile should not use page cache if "direct_io" mount option
	is given

2005-04-08  Miklos Szeredi <miklos@szeredi.hu>

	* Fix Oops in case of nfs export.  Spotted by David Shaw

	* Fix another Oops in case of write over nfs with direct_io turned
	on.  Again spotted by David Shaw

2005-04-07  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.3-pre4

2005-04-07  Miklos Szeredi <miklos@szeredi.hu>

	* lib: finalized new readdir() interface, which now supersedes the
	getdir() method.

2005-04-03  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.3-pre3

2005-04-03  Miklos Szeredi <miklos@szeredi.hu>

	* Implement backward compatibility with version 5 kernel ABI

2005-04-01  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.3-pre2

2005-04-01  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: fix dirent offset handling

	* lib: add readdir and releasedir methods

	* lib: use fh field of fuse_file_info in opendir, readdir,
	releasedir and fsyncdir methods

	* lib: check kernel API version and bail out of it's old.  This
	will be properly fixed in the next release

2005-03-31  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.3-pre1

2005-03-31  Miklos Szeredi <miklos@szeredi.hu>

	* kernel API: add padding to structures, so 64bit and 32bit
	compiler will return the same size

	* kernel API: add offset field to fuse_dirent.  This will allow
	more sophisticated readdir interface for userspace

	* kernel API: change major number to 6

	* kernel: fix warnings on 64bit archs

	* kernel: in case of API version mismatch, return ECONNREFUSED

2005-03-24  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: trivial cleanups

2005-03-21  Miklos Szeredi <miklos@szeredi.hu>

	* Add fsyncdir() operation

2005-03-19  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: add locking to background list (fixes previous fix)

2005-03-18  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: fix bug which could cause leave busy inodes after
	unmount, and Oops.

2005-03-08  Miklos Szeredi <miklos@szeredi.hu>

	* examples: add -lpthread to link flags to work around valgrind
	quirk

	* lib: don't exit threads, so cancelation doesn't cause segfault

2005-03-04  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: fix nasty bug which could cause an Oops under certain
	situations.  Found by Magnus Johansson

2005-02-28  Miklos Szeredi <miklos@szeredi.hu>

	* libfuse: added opendir() method.  This can be used in case
	permission checking in getdir() is too late.  Thanks to Usarin
	Heininga for pointing out this deficiency

	* libfuse: added init() and destroy() methods to fuse_operations

	* kernel: llseek() method for files and directories made explicit

	* kernel: fixed inode leak in NFS export in case of nodeid
	wrapping

2005-02-15  Miklos Szeredi <miklos@szeredi.hu>

	* libfuse: clean up some unitialized memory found with valgrind

	* Add -lpthread to Libs in fuse.pc.  Valgrind seems to need an
	explicitly linked libpthread for applications

2005-02-10  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: set umask, otherwise /etc/mtab will have
	unpredictable permission.  Spotted by Jindrich Kolorenc

	* fusermount: set owner and group of /etc/mtab to original values
	on unmount

	* libfuse: add 'use_ino' option to help.  Patch by Valient Gough

2005-02-07  Miklos Szeredi <miklos@szeredi.hu>

	* Cleaned up directory reading (temporary file is not used)

2005-02-02  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.2

2005-02-02  Miklos Szeredi <miklos@szeredi.hu>

	* Fix possible race when operation is interrupted

2005-01-28  Miklos Szeredi <miklos@szeredi.hu>

	* Fix compilation on 2.6.7

2005-01-26  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.2-pre6

2005-01-26  Miklos Szeredi <miklos@szeredi.hu>

	* Fix bug in link() operation which caused the wrong path to be
	passed as the first argument.  Found by Anton Altaparmakov

2005-01-21  Miklos Szeredi <miklos@szeredi.hu>

	* LIB: fix double reply in readdir operation

	* fusermount: fix uid checking bug.  Patch by Adam Connell

	* KERNEL: fix compile on various RedHat patched 2.4 kernels.
	Patch by Keshava Gowda

2005-01-20  Miklos Szeredi <miklos@szeredi.hu>

	* KERNEL: provide correct llseek semantics for fuse device (fixes
	a bug on Progeny 2.4.20 kernel).  Reported by Valient Gough

2005-01-20  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.2-pre5 (matches kernel 2.6.11-rc1-mm2)

2005-01-18  Miklos Szeredi <miklos@szeredi.hu>

	* KERNEL ABI: remove GETDIR operation, and add OPENDIR, READDIR
	and RELEASEDIR.  This ends the ugly hack of passing a file
	descriptor to the kernel, and actually makes the code simpler.

2005-01-17  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.2-pre4

2005-01-17  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: remove capability setting, which was the cause of
	problems for some users.  It seems that FS related capabilities
	are removed by setfsuid(), so this isn't even needed.

2005-01-15  Miklos Szeredi <miklos@szeredi.hu>

	* fix compilation on 2.4 kernels (reported by Valient Gough)

	* fix failure to unmount bug (found by David Shaw)

	* fusermount: improve parsing of /etc/fuse.conf

2005-01-13  Miklos Szeredi <miklos@szeredi.hu>

	* Remove 'mount_max' and 'user_allow_other' module options.  These
	are now checked by fusermount, and can be set in /etc/fuse.conf

	* KERNEL: change check for fsid == 0 to capable(CAP_DAC_OVERRIDE)

2005-01-11  Miklos Szeredi <miklos@szeredi.hu>

	* KERNEL: fix possible inode allocation problem, where
	sizeof(struct inode) is not aligned (found by Mike Waychison)

	* KERNEL: use new follow_link/put_link methods

	* KERNEL: cosmetic fixes

2005-01-10  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.2-pre3

2005-01-10  Miklos Szeredi <miklos@szeredi.hu>

	* Add missing code that was accidently left out

2005-01-09  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.2-pre2

2005-01-09  Miklos Szeredi <miklos@szeredi.hu>

	* Change "uid" mount option to "user_id" to avoid confusion with a
	mount option "uid" commonly used by many filesystems

2005-01-09  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.2-pre1

2005-01-09  Miklos Szeredi <miklos@szeredi.hu>

	* If FUSE is configured in the kernel, don't build it by default

2005-01-07  Miklos Szeredi <miklos@szeredi.hu>

	* Compile fix by Christian Magnusson

2005-01-05  Miklos Szeredi <miklos@szeredi.hu>

	* Fix compilation for 2.6.{0-5} kernels

2005-01-04  Miklos Szeredi <miklos@szeredi.hu>

	* KERNEL: if request is interrupted, still keep reference to used
	inode(s) and file, so that FORGET and RELEASE are not sent until
	userspace finishes the request.

	* remove /{sys,proc}/fs/fuse/version, and instead add an INIT
	request with the same information, which is more flexible,
	simpler, works on embedded systems.

2004-12-16  Miklos Szeredi <miklos@szeredi.hu>

	* KERNEL ABI: update interface to make it independent of type
	sizes.  This will help on 64 bit architectures which can run
	legacy 32 bit applications.

	* KERNEL ABI: add "len" field to request headers.  This will allow
	sending/receiving requests in multiple chunks.

	* KERNEL: handle file type change more intelligently

	* LIB: "-o debug" option should disable backgrounding (fix by
	Fabien Reygrobellet)

2004-12-13  Miklos Szeredi <miklos@szeredi.hu>

	* KERNEL: invalidate dentry/attributes if interrupted request
	could leave filesystem in an unknown state.

2004-12-12  Miklos Szeredi <miklos@szeredi.hu>

	* KERNEL: lots of cleanups related to avoiding possible deadlocks.
	These will cause some regressions, but stability is considered
	more important.  If any of these features turns out to be
	important, it can be readded with the deadlock problems addressed.

	* Make all requests interruptible (only with SIGKILL currently).
	This can be used to break any deadlock produced by the userspace
	filesystem accessing it's own exported files.  The RELEASE request
	is special, because if it's interrupted before sending it to
	userspace it is still sent, but the reply is not awaited.

	* If request is interrupted before being sent to userspace, and if
	it hasn't yet got any side effects, it is always restarted,
	regardless of the SA_RESTART flag.  This makes these interruptions
	transparent to the process.

	* Remove shared-writable mmap support, which was prone to an
	out-of-memory deadlock situation

	* Remove INVALIDATE userspace initiated request

	* Make readpages() synchronous.  Asynchronous requests are
	deadlock prone, since they cannot be interrupted.

	* Add readv/writev support to fuse device operations

	* Remove some printks, which userspace FS can use for a DoS
	against syslog

	* Remove 'large_read' mount option from 2.6 in kernel, check it in
	fusermount instead

	* LIB: improve compatibility with a fuse.h header installed in
	${prefix}/include which in turn includes the real header.

	* LIB: improve compatibility by defining fuse_main() (which is now
	not used), so old configure scripts find it.

2004-12-10  Miklos Szeredi <miklos@szeredi.hu>

	* When mounting on a subdirectory of / don't duplicate slashes at
	the beggining of path (spotted by David Shaw)

2004-12-09  Miklos Szeredi <miklos@szeredi.hu>

	* Fix bug causing garbage in mount options (spotted by David Shaw)

2004-12-07  Miklos Szeredi <miklos@szeredi.hu>

	* Add 'writepage' flag to 'fuse_file_info'.

	* More comments in fuse.h

	* Get rid of double underscores

2004-12-04  Miklos Szeredi <miklos@szeredi.hu>

	* Add -D_FILE_OFFSET_BITS=64 to cflags provided by pkg-config

	* helper.c: add -ho option, which only displays the options not
	the usage header.  This can be used by filesystems which have
	their own options.

2004-12-03  Miklos Szeredi <miklos@szeredi.hu>

	* Add source compatibility to 2.1 and 1.1 APIs.  To select betwen
	versions simply define FUSE_USE_VERSION to 22, 21 or 11 before
	including the fuse header

	* Add binary compatibility to 2.1 version of library with symbol
	versioning

2004-12-03  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.1

2004-12-01  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: clean up writing functions

	* kernel: no allocation on write in direct_io mode

	* move linux/fuse.h to fuse_kernel.h

2004-11-30  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: clean up reading functions

2004-11-29  Miklos Szeredi <miklos@szeredi.hu>

	* kernel: make readpage() uninterruptible

	* kernel: check readonly filesystem flag in fuse_permission

	* lib: don't die if version file not found and new style device
	exists

	* lib: add '-r' option, which is short for '-o ro'

	* fusermount: simplify device opening

	* kernel: when direct_io is turend on, copy data directly to
	destination without itermediate buffer.  More efficient and safer,
	since no allocation is done.

	* fusermount: fix warning if fuse module is not loaded

	* kernel: use /dev/fuse on 2.4 too

2004-11-26  Miklos Szeredi <miklos@szeredi.hu>

	* libfuse API change: open, read, write, flush, fsync and release
	are passed a 'struct fuse_file_info' pointer containing the open
	flags (open and release), and the file handle.  Verion changed to
	3.0.

2004-11-23  Miklos Szeredi <miklos@szeredi.hu>

	* More cleanups in the kernel

	* The 10,229 charater device number has been assigned for FUSE

	* Version file checking fix (reported by Christian Magnusson)

	* fusermount: opening the fuse device now doesn't need /sys.

	* Optimize reading by controlling the maximum readahead based on
	the 'max_read' mount option

	* fixes for UCLIBC (Christian Magnusson)

2004-11-19  Miklos Szeredi <miklos@szeredi.hu>

	* Cleaned up kernel in preparation for merge into mainline:

	* Use /sys/fs/fuse/version instead of /proc/fs/fuse/version

	* Use real device (/dev/fuse) instead of /proc/fs/fuse/dev

	* __user annotations for sparse

	* allocate individual pages instead of kmalloc in fuse_readdir,
	fuse_read and fuse_write.

	* Fix NFS export in case "use_ino" mount option is given

	* Make libfuse and fusermount compatible with future versions

	* fusermount: properly add mount options to /etc/mtab

2004-11-15  Miklos Szeredi <miklos@szeredi.hu>

	* fusermount: do not resolve last component of mountpoint on if it
	is '.' or '..'.  This new path resolvation is now done on mount as
	well as unmount.  This enables relative paths to work on unmount.

	* fusermount: parse common mount options like "ro", "rw", etc...

	* Allow module params to be changed through sysfs

2004-11-14  Miklos Szeredi <miklos@szeredi.hu>

	* Released 2.1-pre1

2004-11-14  Miklos Szeredi <miklos@szeredi.hu>

	* Fix bug in fuse_readpages() causing Oops in certain situations.
	Bug found by Vincenzo Ciancia.

	* Fix compilation with kernels versions > 2.6.9.

2004-11-11  Miklos Szeredi <miklos@szeredi.hu>

	* Check kernel interface version in fusermount to prevent
	strangeness in case of mismatch.

	* No need to allocate fuse_conn until actual mount happens

	* Fix potential race between umount and fuse_invalidate

	* Check superblock of proc file in addition to inode number

	* Fix race between request_send_noreply() and fuse_dev_release()

2004-11-10  Miklos Szeredi <miklos@szeredi.hu>

	* Separate configure for the kernel directory

	* Don't allow write to return more than 'count'

	* Extend kernel interface for future use

2004-11-09  Miklos Szeredi <miklos@szeredi.hu>

	* Fix 'makeconf.sh' to use autoreconf if available

2004-11-08  Miklos Szeredi <miklos@szeredi.hu>

	* Add ino argument to 'fuse_dirfil_t'.  NOTE: This breaks source
	compatibility with earlier versions.  To compile earier versions
	just add '-DFUSE_DIRFIL_COMPAT' compile flag or fix the source.
	Do not use the "use_ino" mount flag with filesystems compiled with
	FUSE_DIRFIL_COMPAT.

	* Add pkg-config support.  To compile a FUSE based filesystem you
	can do  "gcc -Wall `pkg-config --cflags --libs fuse` myfs.c -o myfs"
	or similar.  Note, that the PKG_CONFIG_PATH environment variable
	usually needs to be set to "/usr/local/lib/pkgconfig".

	* fuse.h is now installed in ${prefix}/include/fuse/

2004-11-02  Miklos Szeredi <miklos@szeredi.hu>

	* Added "use_ino" mount option.  This enables the filesystems to
	set the st_ino field on files

2004-11-01  Miklos Szeredi <miklos@szeredi.hu>

	* Fix compile problems with ancient (<=2.4.18) kernels (reported
	by Jeremy Smith)

	* Add "allow_root" mount option.  Patch by Yaroslav Rastrigin

	* Clear the 'exited' flag when mail loop is finished

2004-10-28  Miklos Szeredi <miklos@szeredi.hu>

	* Make xattr functions work under 2.6 (bug found by Vincenzo
	Ciancia)

2004-10-26  Miklos Szeredi <miklos@szeredi.hu>

	* Reset request in fuse_flush() (bugreport by David Shaw)

2004-10-21  Miklos Szeredi <miklos@szeredi.hu>

	* fuse_main() now does not exit on error, rather it returns an
	error code

	* Exported __fuse_setup() and __fuse_teardown() functions, which
	make it easier to implement a custom event loop.

	* Use daemon() call to background the filesystem after mounting.
	This function closes the standard input, output and error and
	changes the current working directory to "/".

2004-10-14  Miklos Szeredi <miklos@szeredi.hu>

	* Released 1.9

2004-10-09  Miklos Szeredi <miklos@szeredi.hu>

	* Don't allow fuse_flush() to be interrupted (bug found by David
	Shaw)

2004-09-27  Miklos Szeredi <miklos@szeredi.hu>

	* Add PID to fuse_context.  Patch by Steven James

	* Change file handle type to 'unsigned long' in kernel interface

2004-09-22  Miklos Szeredi <miklos@szeredi.hu>

	* A slight API change: fuse_get_context() doesn't need the "fuse"
	pointer, but the returned context contains it instead.  The
	fuse_get() function is not needed anymore, so it's removed.

	* Fix mounting and umounting FUSE filesystem under another FUSE
	filesystem by non-root (bug spotted by Valient Gough)

2004-09-21  Miklos Szeredi <miklos@szeredi.hu>

	* Fix deadlock in case of memory allocation failure.  Patch by
	Christian Magnusson

2004-09-16  Miklos Szeredi <miklos@szeredi.hu>

	* Check memory allocation failures in libfuse

2004-09-14  Miklos Szeredi <miklos@szeredi.hu>

	* Check temporary file creation failure in do_getdir().  Bug
	spotted by Terje Oseberg

2004-09-13  Miklos Szeredi <miklos@szeredi.hu>

	* Allow "large_read" option for 2.6 kernels but warn of deprecation

	* Make requests non-interruptible so race with FORGET is avoided.
	This is only a temporary solution

	* Support compiling FUSE kernel module on 2.4.x UML kernels

2004-09-09  Miklos Szeredi <miklos@szeredi.hu>

	* Fix bug in case two FORGETs for the same node are executed in
	the wrong order.  Bug spotted and endured for months by Franco
	Broi, and logfile for solution provided by Terje Oseberg

2004-09-01  Miklos Szeredi <miklos@szeredi.hu>

	* Add -D_REENTRANT to the compile flags

	* Add documentation of fuse internals by Terje Oseberg

2004-08-16  Miklos Szeredi <miklos@szeredi.hu>

	* Change release method to be non-interruptible.  Fixes bug
	causing missing release() call when program which has opened files
	is killed (reported by Franco Broi and David Shaw)

2004-07-29  Miklos Szeredi <miklos@szeredi.hu>

	* Add fuse_invalidate() to library API

2004-07-26  Miklos Szeredi <miklos@szeredi.hu>

	* Check permissions in setattr if 'default_permissions' flag is
	set.  Bug spotted by Damjan Lango

2004-07-24  Miklos Szeredi <miklos@szeredi.hu>

	* 'large_read' mount option removed for 2.6 kernels, since the
	default (dynamic read size) is better

	* Extend kernel API with file handles.  A file handle is returned
	by open, and passed to read, write, flush, fsync and release.
	This is currently only used for debug output in the library.

	* Security changes:

	* Change the current directory to the mountpoint before checking
	the permissions and mount filesystem on "."

	* By default don't modprobe the fuse module for non-root.  The old
	behavior can be restored with the '--enable-auto-modprobe' flag of
	./configure

	* By default don't allow shared writable mappings for non-root.
	The old behavior can be restored with the 'user_mmap=1' module
	parameter

2004-07-23  Miklos Szeredi <miklos@szeredi.hu>

	* Clean up mount option passing to fusermount and to fuse_new()
	BEWARE: this changes the userspace API slightly, and the command
	line usage of programs using fuse_main()

2004-07-20  Miklos Szeredi <miklos@szeredi.hu>

	* Optimize reading under 2.6 kernels by issuing multiple page
	asynchronous read requests

2004-07-18  Miklos Szeredi <miklos@szeredi.hu>

	* Only use redirty_page_for_writepage() for kernels >= 2.6.6

2004-07-16  Miklos Szeredi <miklos@szeredi.hu>

	* Separate directory entry and inode attribute validity timer

	* New write semaphore to stop page writeback during truncate

	* Fsync now waits for all writes to complete before sending the
	request

	* Optimization: if a page is completely written by
	fuse_commit_write(), clear the dirty flag and set the uptodate
	flag for that page

	* Some memory cleanup at exit

2004-07-13  Miklos Szeredi <miklos@szeredi.hu>

	* Add FUSE_HARD_REMOVE flag, and '-i' option to fuse main, which
	disable the "hide if open" behavior of unlink/rename.

	* If temporary buffer allocation fails in raw read, fall back to a
	smaller buffer

2004-07-12  Miklos Szeredi <miklos@szeredi.hu>

	* Fix bug in do_open() in libfuse: open count was incremented
	after the reply is sent so it could race with unlink/forget and
	cause an abort.

2004-07-08  Miklos Szeredi <miklos@szeredi.hu>

	* When performing create or remove operation, refresh the parent's
	attributes on next revalidate, as i_nlink (and maybe size/time)
	could be inacurate.

	* Use redirty_page_for_writepage() in fuse_writepage() for skipped
	pages (2.6 only)

	* Set set_page_dirty address space operation (2.6 only)

2004-07-06  Miklos Szeredi <miklos@szeredi.hu>

	* Minor fix in read:  print debug info even if read size is zero

2004-07-04  Miklos Szeredi <miklos@szeredi.hu>

	* Fix race between truncate and writepage (fsx-linux now runs
	without error)

2004-07-02  Miklos Szeredi <miklos@szeredi.hu>

	* Fix kernel hang on mkfifo under 2.4 kernels (spotted and patch
	by Mattias Wadman)

	* Added option for direct read/write (-r)

	* Fix revalidate time setting for newly created inodes

	* Remove uid==0 check for '-x' option in fusermount (kernel checks
	this)

	* fuse_main() only installs handlers for signals (out of INT, HUP,
	TERM, PIPE), for which no handler has yet been installed

	* Add module option 'user_allow_other' which if set to non-zero
	will allow non root user to specify the 'allow_other' mount option
	('-x' option of fusermount)

	* Fix deadlock between page writeback completion and truncate
	(bug found by Valient Gough with the fsx-linux utility)

2004-07-01  Miklos Szeredi <miklos@szeredi.hu>

	* Change passing fuse include dir to 2.6 kernel make system more
	robust (fixes compile problems seen on SuSE 9.1 with updated 2.6
	kernel)

2004-06-30  Miklos Szeredi <miklos@szeredi.hu>

	* Acquire inode->i_sem before open and release methods to prevent
	concurrent rename or unlink operations.

	* Make __fuse_read_cmd() read only one command.  This allows
	multiplexing the fuse file descriptor with other event sources
	using select() or poll() (patch by Jeff Harris)

	* Export 'exited' flag with __fuse_exited() (patch by Jeff Harris)

2004-06-27  Miklos Szeredi <miklos@szeredi.hu>

	* Fix file offset wrap around at 4G when doing large reads

2004-06-24  Miklos Szeredi <miklos@szeredi.hu>

	* Fix memory leak in open (Valient Gough)

2004-06-24  Miklos Szeredi <miklos@szeredi.hu>

	* Add "close after delete" support to libfuse (patch by Valient
	Gough)

	* Cancel all worker threads before exit in multithreaded mode

2004-06-23  Miklos Szeredi <miklos@szeredi.hu>

	* Fix locking bugs

	* Don't send reply to RELEASE

	* Work with newer libtool (1.5a)

	* Check for st_atim member of struct stat

2004-06-22  Miklos Szeredi <miklos@szeredi.hu>

	* No request allocation needed on inode and file release

2004-06-21  Miklos Szeredi <miklos@szeredi.hu>

	* Fix possible inode leak in userspace in case of unfinished
	lookup/mknod/mkdir/symlink/link operation.

2004-06-20  Miklos Szeredi <miklos@szeredi.hu>

	* Fix some races and cleanups in fuse_read_super()

2004-06-19  Miklos Szeredi <miklos@szeredi.hu>

	* Requests are allocated at open time

2004-06-03  Miklos Szeredi <miklos@szeredi.hu>

	* Build shared library as well as static (using libtool)

	* Change FUSE_MINOR_VERSION from 1 to 0.  I know it's illegal but
	there has not been a release with the previous minor number, and I
	hope nobody is using it for anything.

	* Change fuse_main(), so that default behavior is to go into
	background if mount is successful.  '-f' and '-d' options disable
	backgrounding.  This fixes the "Why does my FUSE daemon hang?"
	newbie complaint.

	* Cache ENOSYS (function not implemented) errors on *xattr, flush
	and fsync

	* Don't call getdir method from open() only from first readdir().
	Open is sometimes just used to store the current directory
	(e.g. find)

2004-05-18  Miklos Szeredi <miklos@szeredi.hu>

	* Added flush() call

2004-05-04  Miklos Szeredi <miklos@szeredi.hu>

	* Extended attributes support for 2.4 (patch by Cody Pisto)

2004-04-20  Miklos Szeredi <miklos@szeredi.hu>

	* Fixed parser with modversions (Mattias Wadman)

2004-04-19  Miklos Szeredi <miklos@szeredi.hu>

	* Added mount option parser to 2.4 build

2004-04-13  Miklos Szeredi <miklos@szeredi.hu>

	* Replaced binary mount data with text options

	* Show FUSE specific mount options in /proc/mounts

	* Check in fuse.h whether _FILE_OFFSET_BITS is set to 64

2004-04-09  Miklos Szeredi <miklos@szeredi.hu>

	* Check some limits so userspace won't get too big requests

2004-04-05  Miklos Szeredi <miklos@szeredi.hu>

	* Kill compile warning

	* Upgraded user-mount patch for 2.6.5

2004-04-02  Miklos Szeredi <miklos@szeredi.hu>

	* Add detection of user-mode-linux to configure

2004-03-31  Miklos Szeredi <miklos@szeredi.hu>

	* fixed zero size case for getxattr and listxattr

2004-03-30  Miklos Szeredi <miklos@szeredi.hu>

	* new fusermount flag '-z': lazy unmount, default is not lazy

	* Extended attributes operations added (getxattr, setxattr,
	listxattr, removexattr)

2004-03-25  Miklos Szeredi <miklos@szeredi.hu>

	* If filesystem doesn't define a statfs operation, then an
	all-zero default statfs is returned instead of ENOSYS

2004-03-24  Miklos Szeredi <miklos@szeredi.hu>

	* Add FS_BINARY_MOUNTDATA filesystem flag for kernels > 2.6.4

2004-03-09  Miklos Szeredi <miklos@szeredi.hu>

	* Fix for uClinux (Christian Magnusson)

2004-03-02  Miklos Szeredi <miklos@szeredi.hu>

	* fuse_main() adds "-n progname" to the fusermount command line

	* More kernel interface changes:

	* Lookup/getattr return cache timeout values

2004-02-25  Miklos Szeredi <miklos@szeredi.hu>

	* Clean up option parsing in fuse_main()

	* Added fuse_get() function which returns the fuse object created
	by fuse_main()

2004-02-20  Miklos Szeredi <miklos@szeredi.hu>

	* removed old way of mounting (fusermount mountpoint program)

	* more kernel interface changes:

	* added nanosecond precision to file times

	* removed interface version from mount data

	* added /proc/fs/fuse/version which contains MAJOR.MINOR

2004-02-19  Miklos Szeredi <miklos@szeredi.hu>

	* statfs library API changed to match other methods.  Since this
	  is not backward compatible FUSE_MAJOR_VERSION is changed to 2

	* kernel interface changes follow:

	* statfs changed to 64 bits, added 'bavail' field

	* add generation number to lookup result

	* optimized mknod/mkdir/symlink/link (no separate lookup is
	needed)

	* rdev size increased to 32 bits for mknod

	* kernel interface version changed to 3.1

2004-02-18  Miklos Szeredi <miklos@szeredi.hu>

	* user-mount upgraded for 2.6.3 kernel

2004-02-17  Miklos Szeredi <miklos@szeredi.hu>

	* Added user-mount.2.6.2-rc3.patch

	* Add FS_SAFE flag to fuse filesystem

	* fusermount should allow (un)mounting for non-root even if not
	suid-root

2004-02-12  Miklos Szeredi <miklos@szeredi.hu>

	* Remove MS_PERMISSION mount flag (that means something else now)

2004-02-10  Miklos Szeredi <miklos@szeredi.hu>

	* Added check for i_size_read/write functions to configure.in
	(patch by Valient Gough)

2004-02-06  Miklos Szeredi <miklos@szeredi.hu>

	* Fixed writing >= 2G files

	* Check file size on open (with generic_file_open())

	* Readpage calls flush_dcache_page() after storing data

	* Use i_size_read/write for accessing inode->i_size

	* Make loopback mount of a fuse file work

2004-02-04  Miklos Szeredi <miklos@szeredi.hu>

	* Released 1.1

2004-01-29  Miklos Szeredi <miklos@szeredi.hu>

	* Properly check if the inode exists in fuse_invalidate

2004-01-27  Miklos Szeredi <miklos@szeredi.hu>

	* Added -q option for fusermount

	* fuse_unmount() now uses -q option of fusermount, so no error is
	printed if the cause of the program exit is that the filesystem
	has already been unmounted

	* Fix i_nlink correctness after rmdir/unlink

2004-01-26  Miklos Szeredi <miklos@szeredi.hu>

	* Released 1.1-pre2

2004-01-26  Miklos Szeredi <miklos@szeredi.hu>

	* Fix typo (thanks Marcos Dione)

	* Compile fixes for 2.4 kernels

2004-01-23  Miklos Szeredi <miklos@szeredi.hu>

	* Fix CONFIG_MODVERSIONS compile on 2.6

2004-01-22  Miklos Szeredi <miklos@szeredi.hu>

	* Write all pending data before a RELEASE operation

	* Suppress 'Bad file descriptor' warning on exit

	* Replaced fusermount option '-d xxx' with '-n xxx' so it doesn't
	get confused with '-d' of fuse_main() (sorry about this change)

	* New fusermount option '-l' which enables big reads.  Big reads
	are now disabled by default.

	* fuse_main() can accept fusermount arguments after a '--'

2004-01-19  Miklos Szeredi <miklos@szeredi.hu>

	* Support for exporting filesystem over NFS (see README.NFS)

2004-01-14  Miklos Szeredi <miklos@szeredi.hu>

	* Support non-blocking writepage on 2.6.  This makes FUSE behave
	much more nicely in low-memory situations

	* Fix 32-bit dev handling in getattr and mknod for 2.6 kernels.
	(Note: the mknod method does not yet use 32bit device number)

2004-01-13  Miklos Szeredi <miklos@szeredi.hu>

	* Code cleanups

2004-01-07  Miklos Szeredi <miklos@szeredi.hu>

	* Released 1.1-pre1

2004-01-06  Miklos Szeredi <miklos@szeredi.hu>

	* Integrated 2.6 kernel support patch by Michael Grigoriev

	* Improvements and cleanups for 2.6 kernels

2004-01-05  Miklos Szeredi <miklos@szeredi.hu>

	* Added -d option to fusermount

2003-12-15  Miklos Szeredi <miklos@szeredi.hu>

	* Added major+minor version to library API, and minor version to
	  kernel API

2003-12-13  David McNab <david@rebirthing.co.nz>

	* Implemented fsync support in examples/example.py

	* Implemented 'fsync' and 'statfs' methods in python
	  interface

2003-12-12  Miklos Szeredi <miklos@szeredi.hu>

	* Make it compile on 2.4.19.

	* Add fsync operation (write file failed on xemacs & vi)

2003-12-12  David McNab <david@rebirthing.co.nz>

	* Added distutils support to the python module, as per standard
	  python development practice

2003-12-11  Miklos Szeredi <miklos@szeredi.hu>

	* Add file locking for mount/unmount (based on patch by Valient
	Gough)

2003-12-11  David McNab <david@rebirthing.co.nz>

	* Python filesystem - was broken with python2.3, now fixed:
	   - changed PyTuple_* calls to PySequence_*, because os.lstat
	     is no longer returning a pure tuple
	   - changed PyInt_Check() calls to also call PyLong_Check,
	     to cover for cases (eg os.lstat) where longs are returned
	   - Added support for file 'release' handling, which IMO is
	     essential since this signals to a FS that writes to a file
	     are complete (and therefore the file can now be disposed of
	     meaningfully at the python filesystem's discretion)
	   - Added '__init__' handler to base Fuse class, which allows
	     your Python class to know the mountpoint and mount args,
	     as attributes myfs.mountpoint, myfs.optlist, myfs.optdict

	* General:
	   - added 'mount.fuse' script (in util/ dir), which is meant to be
	     symlinked from /sbin, and which allows FUSE filesystems to
	     be mounted with the 'mount' command, and listed in fstab;
	     also, mount arguments get passed to your filesystem


2003-11-04  Miklos Szeredi <miklos@szeredi.hu>

	* Fix kernel version detection (again).  Bugreport by Peter Levart

2003-11-03  Miklos Szeredi <miklos@szeredi.hu>

	* Applied read combining patch by Michael Grigoriev (tested by
	Valient Gough and Vincent Wagelaar)

2003-10-22  Miklos Szeredi <miklos@szeredi.hu>

	* Mtab handling fix in fusermount by "Valient Gough" (SF patch
	#766443)

2003-10-13  Miklos Szeredi <miklos@szeredi.hu>

	* Error code fixes in kernel module

2003-10-04  Miklos Szeredi <miklos@szeredi.hu>

	* kernel version detection fix

	* fusermount now uses "lazy" umount option

	* fusermount can use modprobe with module-init-tools

2003-09-08  Miklos Szeredi <miklos@szeredi.hu>

	* Integrated caching patch by Michael Grigoriev

	* Added "Filesystems" file with descriptions of projects using
	FUSE

	* Added patch by Michael Grigoriev to allow compliation of FUSE
	kernel module for 2.6 kernels

2003-06-02  Miklos Szeredi <miklos@szeredi.hu>

	* And another spec-file fix by Achim Settelmeier

2003-05-26  Miklos Szeredi <miklos@szeredi.hu>

	* Spec-file fix by Achim Settelmeier

2003-03-10  Miklos Szeredi <miklos@szeredi.hu>

	* Fix umount oops (found by Samuli Kärkkäinen)

2003-03-05  Miklos Szeredi <miklos@szeredi.hu>

	* Merge of fuse_redhat.spec and fuse.spec by Achim Settelmeier

2003-03-04  Miklos Szeredi <miklos@szeredi.hu>

	* Updated fuse.spec file (Achim Settelmeier)

2003-02-19  Miklos Szeredi <miklos@szeredi.hu>

	* Version 1.0 released

2003-02-12  Miklos Szeredi <miklos@szeredi.hu>

	* SuSE compilation fix by Juan-Mariano de Goyeneche

2002-12-10  Miklos Szeredi <miklos@szeredi.hu>

	* The release() VFS call is now exported to the FUSE interface

2002-12-05  Miklos Szeredi <miklos@szeredi.hu>

	* 64 bit file offset fixes in the fuse kernel module

	* Added function 'fuse_exit()' which can be used to exit the main
	loop

2002-12-03  Miklos Szeredi <miklos@szeredi.hu>

	* Added _FILE_OFFSET_BITS=64 define to fuse.h.  Note, that this is
	an incompatible interface change.

2002-10-28  Miklos Szeredi <miklos@szeredi.hu>

	* Portablility fix (bug reported by C. Chris Erway)

2002-10-25  Miklos Szeredi <miklos@szeredi.hu>

	* Use Mark Glines' fd passing method for default operation instead
	of old reexec

2002-10-22  Miklos Szeredi <miklos@szeredi.hu>

	* fix "Stale NFS file handle" bug caused by changes in 2.4.19

2002-10-22  Miklos Szeredi <miklos@szeredi.hu>

	* fix incompatiblity with Red Hat kernels, with help from Nathan
	Thompson-Amato.

2002-04-18  Mark Glines <mark@glines.org>

	* added an alternative to fuse_mount(), called
      fuse_mount_ioslave(), which does not need to reexec the
      FUSE program.
	* added a small helper util needed by fuse_mount_ioslave().

2002-03-16  Mark Glines <mark@glines.org>

	* use struct fuse_statfs everywhere possible to avoid problems
      with the headerfiles changing struct statfs member sizes

2002-03-01  Miklos Szeredi <miklos@szeredi.hu>

	* Another RPM spec file for RedHat >= 7 by Ian Pilcher

2002-01-14  Miklos Szeredi <miklos@szeredi.hu>

	* RPM support by Achim Settelmeier

2002-01-09  Miklos Szeredi <miklos@szeredi.hu>

	* Version 0.95 released

2002-01-09  Miklos Szeredi <miklos@szeredi.hu>

	* Revaidate all path components not just the last, this means a
	very small performance penalty for being more up-to-date.

2002-01-08  Miklos Szeredi <miklos@szeredi.hu>

	* Update and fix python interface

2002-01-07  Mark Glines <mark@glines.org>

	* Added statfs() support to kernel, lib, examples, and perl!

2001-12-26  Miklos Szeredi <miklos@szeredi.hu>

	* Better cross compilation support

	* Ported to Compaq IPAQ

2001-12-20  Miklos Szeredi <miklos@szeredi.hu>

	* Added function fuse_get_context() to library API (inspired by
	patch from Matt Ryan)

	* Added flags to fusermount and to kernel interface to control
	permission checking

	* Integrated fuse_set_operations() into fuse_new()

2001-12-08  Miklos Szeredi <miklos@szeredi.hu>

	* Applied header protection + extern "C" patch by Roland
	Bauerschmidt

2001-12-02  Miklos Szeredi <miklos@szeredi.hu>

	* Added perl bindings by Mark Glines

2001-11-21  Miklos Szeredi <miklos@szeredi.hu>

	* Cleaned up way of mounting simple filesystems.

	* fuse_main() helper function added

2001-11-18  Miklos Szeredi <miklos@szeredi.hu>

	* Optimized read/write operations, so that minimal copying of data
	is done

2001-11-14  Miklos Szeredi <miklos@szeredi.hu>

	* Python bindings by Jeff Epler added

2001-11-13  Miklos Szeredi <miklos@szeredi.hu>

	* Fixed vfsmount reference leak in fuse_follow_link

	* FS blocksize is set to PAGE_CACHE_SIZE, blksize attribute from
	userspace is ignored

2001-11-09  Miklos Szeredi <miklos@szeredi.hu>

	* Started ChangeLog
