1 files changed, 68 insertions, 427 deletions

diff --git a/lib/fuse.c b/lib/fuse.c
index cfac238..7508c54 100644
--- a/lib/fuse.c
+++ b/lib/fuse.c
@@ -15,8 +15,6 @@
 #include "fuse_lowlevel.h"
 #include "fuse_opt.h"
 #include "fuse_misc.h"
-#include "fuse_common_compat.h"
-#include "fuse_compat.h"
 #include "fuse_kernel.h"
 
 #include <stdio.h>
@@ -83,7 +81,6 @@ struct fuse_fs {
 	struct fuse_operations op;
 	struct fuse_module *m;
 	void *user_data;
-	int compat;
 	int debug;
 };
 
@@ -146,8 +143,6 @@ struct fuse {
 	struct fuse_config conf;
 	int intr_installed;
 	struct fuse_fs *fs;
-	int nullpath_ok;
-	int utime_omit_ok;
 	struct lock_queue_element *lockq;
 	int pagesize;
 	struct list_head partial_slabs;
@@ -208,12 +203,6 @@ struct fuse_dh {
 	fuse_ino_t nodeid;
 };
 
-/* old dir handle */
-struct fuse_dirhandle {
-	fuse_fill_dir_t filler;
-	void *buf;
-};
-
 struct fuse_context_i {
 	struct fuse_context ctx;
 	fuse_req_t req;
@@ -1104,10 +1093,13 @@ static void debug_path(struct fuse *f, const char *msg, fuse_ino_t nodeid,
 		if (wr)
 			wnode = lookup_node(f, nodeid, name);
 
-		if (wnode)
-			fprintf(stderr, "%s %li (w)\n",	msg, wnode->nodeid);
-		else
-			fprintf(stderr, "%s %li\n", msg, nodeid);
+		if (wnode) {
+			fprintf(stderr, "%s %llu (w)\n",
+				msg, (unsigned long long) wnode->nodeid);
+		} else {
+			fprintf(stderr, "%s %llu\n",
+				msg, (unsigned long long) nodeid);
+		}
 	}
 }
 
@@ -1182,7 +1174,7 @@ static int get_path_nullok(struct fuse *f, fuse_ino_t nodeid, char **path)
 		*path = NULL;
 	} else {
 		err = get_path_common(f, nodeid, NULL, path, NULL);
-		if (err == -ENOENT && f->nullpath_ok)
+		if (err == -ENOENT)
 			err = 0;
 	}
 
@@ -1464,129 +1456,6 @@ static inline void fuse_prepare_interrupt(struct fuse *f, fuse_req_t req,
 		fuse_do_prepare_interrupt(req, d);
 }
 
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
-
-static int fuse_compat_open(struct fuse_fs *fs, const char *path,
-			    struct fuse_file_info *fi)
-{
-	int err;
-	if (!fs->compat || fs->compat >= 25)
-		err = fs->op.open(path, fi);
-	else if (fs->compat == 22) {
-		struct fuse_file_info_compat tmp;
-		memcpy(&tmp, fi, sizeof(tmp));
-		err = ((struct fuse_operations_compat22 *) &fs->op)->open(path,
-									  &tmp);
-		memcpy(fi, &tmp, sizeof(tmp));
-		fi->fh = tmp.fh;
-	} else
-		err = ((struct fuse_operations_compat2 *) &fs->op)
-			->open(path, fi->flags);
-	return err;
-}
-
-static int fuse_compat_release(struct fuse_fs *fs, const char *path,
-			       struct fuse_file_info *fi)
-{
-	if (!fs->compat || fs->compat >= 22)
-		return fs->op.release(path, fi);
-	else
-		return ((struct fuse_operations_compat2 *) &fs->op)
-			->release(path, fi->flags);
-}
-
-static int fuse_compat_opendir(struct fuse_fs *fs, const char *path,
-			       struct fuse_file_info *fi)
-{
-	if (!fs->compat || fs->compat >= 25)
-		return fs->op.opendir(path, fi);
-	else {
-		int err;
-		struct fuse_file_info_compat tmp;
-		memcpy(&tmp, fi, sizeof(tmp));
-		err = ((struct fuse_operations_compat22 *) &fs->op)
-			->opendir(path, &tmp);
-		memcpy(fi, &tmp, sizeof(tmp));
-		fi->fh = tmp.fh;
-		return err;
-	}
-}
-
-static void convert_statfs_compat(struct fuse_statfs_compat1 *compatbuf,
-				  struct statvfs *stbuf)
-{
-	stbuf->f_bsize	 = compatbuf->block_size;
-	stbuf->f_blocks	 = compatbuf->blocks;
-	stbuf->f_bfree	 = compatbuf->blocks_free;
-	stbuf->f_bavail	 = compatbuf->blocks_free;
-	stbuf->f_files	 = compatbuf->files;
-	stbuf->f_ffree	 = compatbuf->files_free;
-	stbuf->f_namemax = compatbuf->namelen;
-}
-
-static void convert_statfs_old(struct statfs *oldbuf, struct statvfs *stbuf)
-{
-	stbuf->f_bsize	 = oldbuf->f_bsize;
-	stbuf->f_blocks	 = oldbuf->f_blocks;
-	stbuf->f_bfree	 = oldbuf->f_bfree;
-	stbuf->f_bavail	 = oldbuf->f_bavail;
-	stbuf->f_files	 = oldbuf->f_files;
-	stbuf->f_ffree	 = oldbuf->f_ffree;
-	stbuf->f_namemax = oldbuf->f_namelen;
-}
-
-static int fuse_compat_statfs(struct fuse_fs *fs, const char *path,
-			      struct statvfs *buf)
-{
-	int err;
-
-	if (!fs->compat || fs->compat >= 25) {
-		err = fs->op.statfs(fs->compat == 25 ? "/" : path, buf);
-	} else if (fs->compat > 11) {
-		struct statfs oldbuf;
-		err = ((struct fuse_operations_compat22 *) &fs->op)
-			->statfs("/", &oldbuf);
-		if (!err)
-			convert_statfs_old(&oldbuf, buf);
-	} else {
-		struct fuse_statfs_compat1 compatbuf;
-		memset(&compatbuf, 0, sizeof(struct fuse_statfs_compat1));
-		err = ((struct fuse_operations_compat1 *) &fs->op)
-			->statfs(&compatbuf);
-		if (!err)
-			convert_statfs_compat(&compatbuf, buf);
-	}
-	return err;
-}
-
-#else /* __FreeBSD__ || __NetBSD__ */
-
-static inline int fuse_compat_open(struct fuse_fs *fs, char *path,
-				   struct fuse_file_info *fi)
-{
-	return fs->op.open(path, fi);
-}
-
-static inline int fuse_compat_release(struct fuse_fs *fs, const char *path,
-				      struct fuse_file_info *fi)
-{
-	return fs->op.release(path, fi);
-}
-
-static inline int fuse_compat_opendir(struct fuse_fs *fs, const char *path,
-				      struct fuse_file_info *fi)
-{
-	return fs->op.opendir(path, fi);
-}
-
-static inline int fuse_compat_statfs(struct fuse_fs *fs, const char *path,
-				     struct statvfs *buf)
-{
-	return fs->op.statfs(fs->compat == 25 ? "/" : path, buf);
-}
-
-#endif /* __FreeBSD__ || __NetBSD__ */
-
 int fuse_fs_getattr(struct fuse_fs *fs, const char *path, struct stat *buf)
 {
 	fuse_get_context()->private_data = fs->user_data;
@@ -1696,7 +1565,7 @@ int fuse_fs_release(struct fuse_fs *fs,	 const char *path,
 				fi->flush ? "+flush" : "",
 				(unsigned long long) fi->fh, fi->flags);
 
-		return fuse_compat_release(fs, path, fi);
+		return fs->op.release(path, fi);
 	} else {
 		return 0;
 	}
@@ -1713,10 +1582,10 @@ int fuse_fs_opendir(struct fuse_fs *fs, const char *path,
 			fprintf(stderr, "opendir flags: 0x%x %s\n", fi->flags,
 				path);
 
-		err = fuse_compat_opendir(fs, path, fi);
+		err = fs->op.opendir(path, fi);
 
 		if (fs->debug && !err)
-			fprintf(stderr, "   opendir[%lli] flags: 0x%x %s\n",
+			fprintf(stderr, "   opendir[%llu] flags: 0x%x %s\n",
 				(unsigned long long) fi->fh, fi->flags, path);
 
 		return err;
@@ -1736,10 +1605,10 @@ int fuse_fs_open(struct fuse_fs *fs, const char *path,
 			fprintf(stderr, "open flags: 0x%x %s\n", fi->flags,
 				path);
 
-		err = fuse_compat_open(fs, path, fi);
+		err = fs->op.open(path, fi);
 
 		if (fs->debug && !err)
-			fprintf(stderr, "   open[%lli] flags: 0x%x %s\n",
+			fprintf(stderr, "   open[%llu] flags: 0x%x %s\n",
 				(unsigned long long) fi->fh, fi->flags, path);
 
 		return err;
@@ -1958,7 +1827,7 @@ int fuse_fs_statfs(struct fuse_fs *fs, const char *path, struct statvfs *buf)
 		if (fs->debug)
 			fprintf(stderr, "statfs %s\n", path);
 
-		return fuse_compat_statfs(fs, path, buf);
+		return fs->op.statfs(path, buf);
 	} else {
 		buf->f_namemax = 255;
 		buf->f_bsize = 512;
@@ -1981,20 +1850,6 @@ int fuse_fs_releasedir(struct fuse_fs *fs, const char *path,
 	}
 }
 
-static int fill_dir_old(struct fuse_dirhandle *dh, const char *name, int type,
-			ino_t ino)
-{
-	int res;
-	struct stat stbuf;
-
-	memset(&stbuf, 0, sizeof(stbuf));
-	stbuf.st_mode = type << 12;
-	stbuf.st_ino = ino;
-
-	res = dh->filler(dh->buf, name, &stbuf, 0);
-	return res ? -ENOMEM : 0;
-}
-
 int fuse_fs_readdir(struct fuse_fs *fs, const char *path, void *buf,
 		    fuse_fill_dir_t filler, off_t off,
 		    struct fuse_file_info *fi)
@@ -2007,16 +1862,6 @@ int fuse_fs_readdir(struct fuse_fs *fs, const char *path, void *buf,
 				(unsigned long long) off);
 
 		return fs->op.readdir(path, buf, filler, off, fi);
-	} else if (fs->op.getdir) {
-		struct fuse_dirhandle dh;
-
-		if (fs->debug)
-			fprintf(stderr, "getdir[%llu]\n",
-				(unsigned long long) fi->fh);
-
-		dh.filler = filler;
-		dh.buf = buf;
-		return fs->op.getdir(path, &dh, fill_dir_old);
 	} else {
 		return -ENOSYS;
 	}
@@ -2154,16 +1999,6 @@ int fuse_fs_utimens(struct fuse_fs *fs, const char *path,
 				tv[1].tv_sec, tv[1].tv_nsec);
 
 		return fs->op.utimens(path, tv);
-	} else if(fs->op.utime) {
-		struct utimbuf buf;
-
-		if (fs->debug)
-			fprintf(stderr, "utime %s %li %li\n", path,
-				tv[0].tv_sec, tv[1].tv_sec);
-
-		buf.actime = tv[0].tv_sec;
-		buf.modtime = tv[1].tv_sec;
-		return fs->op.utime(path, &buf);
 	} else {
 		return -ENOSYS;
 	}
@@ -2324,8 +2159,9 @@ int fuse_fs_poll(struct fuse_fs *fs, const char *path,
 		int res;
 
 		if (fs->debug)
-			fprintf(stderr, "poll[%llu] ph: %p\n",
-				(unsigned long long) fi->fh, ph);
+			fprintf(stderr, "poll[%llu] ph: %p, events 0x%x\n",
+				(unsigned long long) fi->fh, ph,
+				fi->poll_events);
 
 		res = fs->op.poll(path, fi, ph, reventsp);
 
@@ -2487,8 +2323,8 @@ static int lookup_path(struct fuse *f, fuse_ino_t nodeid,
 			}
 			set_stat(f, e->ino, &e->attr);
 			if (f->conf.debug)
-				fprintf(stderr, "   NODEID: %lu\n",
-					(unsigned long) e->ino);
+				fprintf(stderr, "   NODEID: %llu\n",
+					(unsigned long long) e->ino);
 		}
 	}
 	return res;
@@ -2496,9 +2332,12 @@ static int lookup_path(struct fuse *f, fuse_ino_t nodeid,
 
 static struct fuse_context_i *fuse_get_context_internal(void)
 {
-	struct fuse_context_i *c;
+	return (struct fuse_context_i *) pthread_getspecific(fuse_context_key);
+}
 
-	c = (struct fuse_context_i *) pthread_getspecific(fuse_context_key);
+static struct fuse_context_i *fuse_create_context(struct fuse *f)
+{
+	struct fuse_context_i *c = fuse_get_context_internal();
 	if (c == NULL) {
 		c = (struct fuse_context_i *)
 			calloc(1, sizeof(struct fuse_context_i));
@@ -2511,7 +2350,11 @@ static struct fuse_context_i *fuse_get_context_internal(void)
 			abort();
 		}
 		pthread_setspecific(fuse_context_key, c);
+	} else {
+		memset(c, 0, sizeof(*c));
 	}
+	c->ctx.fuse = f;
+
 	return c;
 }
 
@@ -2551,10 +2394,9 @@ static void fuse_delete_context_key(void)
 
 static struct fuse *req_fuse_prepare(fuse_req_t req)
 {
-	struct fuse_context_i *c = fuse_get_context_internal();
+	struct fuse_context_i *c = fuse_create_context(req_fuse(req));
 	const struct fuse_ctx *ctx = fuse_req_ctx(req);
 	c->req = req;
-	c->ctx.fuse = req_fuse(req);
 	c->ctx.uid = ctx->uid;
 	c->ctx.gid = ctx->gid;
 	c->ctx.pid = ctx->pid;
@@ -2598,10 +2440,8 @@ void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn)
 static void fuse_lib_init(void *data, struct fuse_conn_info *conn)
 {
 	struct fuse *f = (struct fuse *) data;
-	struct fuse_context_i *c = fuse_get_context_internal();
 
-	memset(c, 0, sizeof(*c));
-	c->ctx.fuse = f;
+	fuse_create_context(f);
 	conn->want |= FUSE_CAP_EXPORT_SUPPORT;
 	fuse_fs_init(f->fs, conn);
 }
@@ -2619,10 +2459,8 @@ void fuse_fs_destroy(struct fuse_fs *fs)
 static void fuse_lib_destroy(void *data)
 {
 	struct fuse *f = (struct fuse *) data;
-	struct fuse_context_i *c = fuse_get_context_internal();
 
-	memset(c, 0, sizeof(*c));
-	c->ctx.fuse = f;
+	fuse_create_context(f);
 	fuse_fs_destroy(f->fs);
 	f->fs = NULL;
 }
@@ -2692,8 +2530,7 @@ static void do_forget(struct fuse *f, fuse_ino_t ino, uint64_t nlookup)
 	forget_node(f, ino, nlookup);
 }
 
-static void fuse_lib_forget(fuse_req_t req, fuse_ino_t ino,
-			    unsigned long nlookup)
+static void fuse_lib_forget(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
 {
 	do_forget(req_fuse(req), ino, nlookup);
 	fuse_reply_none(req);
@@ -2796,7 +2633,7 @@ static void fuse_lib_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
 						       attr->st_size);
 		}
 #ifdef HAVE_UTIMENSAT
-		if (!err && f->utime_omit_ok &&
+		if (!err &&
 		    (valid & (FUSE_SET_ATTR_ATIME | FUSE_SET_ATTR_MTIME))) {
 			struct timespec tv[2];
 
@@ -3079,14 +2916,8 @@ static void fuse_do_release(struct fuse *f, fuse_ino_t ino, const char *path,
 {
 	struct node *node;
 	int unlink_hidden = 0;
-	const char *compatpath;
 
-	if (path != NULL || f->nullpath_ok || f->conf.nopath)
-		compatpath = path;
-	else
-		compatpath = "-";
-
-	fuse_fs_release(f->fs, compatpath, fi);
+	fuse_fs_release(f->fs, path, fi);
 
 	pthread_mutex_lock(&f->lock);
 	node = get_node(f, ino);
@@ -3312,7 +3143,6 @@ static struct fuse_dh *get_dirhandle(const struct fuse_file_info *llfi,
 	struct fuse_dh *dh = (struct fuse_dh *) (uintptr_t) llfi->fh;
 	memset(fi, 0, sizeof(struct fuse_file_info));
 	fi->fh = dh->fh;
-	fi->fh_old = dh->fh;
 	return dh;
 }
 
@@ -3517,16 +3347,11 @@ static void fuse_lib_releasedir(fuse_req_t req, fuse_ino_t ino,
 	struct fuse_file_info fi;
 	struct fuse_dh *dh = get_dirhandle(llfi, &fi);
 	char *path;
-	const char *compatpath;
 
 	get_path_nullok(f, ino, &path);
-	if (path != NULL || f->nullpath_ok || f->conf.nopath)
-		compatpath = path;
-	else
-		compatpath = "-";
 
 	fuse_prepare_interrupt(f, req, &d);
-	fuse_fs_releasedir(f->fs, compatpath, &fi);
+	fuse_fs_releasedir(f->fs, path, &fi);
 	fuse_finish_interrupt(f, req, &d);
 	free_path(f, ino, path);
 
@@ -4184,90 +4009,29 @@ int fuse_notify_poll(struct fuse_pollhandle *ph)
 	return fuse_lowlevel_notify_poll(ph);
 }
 
-static void free_cmd(struct fuse_cmd *cmd)
-{
-	free(cmd->buf);
-	free(cmd);
-}
-
-void fuse_process_cmd(struct fuse *f, struct fuse_cmd *cmd)
-{
-	fuse_session_process(f->se, cmd->buf, cmd->buflen, cmd->ch);
-	free_cmd(cmd);
-}
-
-int fuse_exited(struct fuse *f)
-{
-	return fuse_session_exited(f->se);
-}
-
 struct fuse_session *fuse_get_session(struct fuse *f)
 {
 	return f->se;
 }
 
-static struct fuse_cmd *fuse_alloc_cmd(size_t bufsize)
-{
-	struct fuse_cmd *cmd = (struct fuse_cmd *) malloc(sizeof(*cmd));
-	if (cmd == NULL) {
-		fprintf(stderr, "fuse: failed to allocate cmd\n");
-		return NULL;
-	}
-	cmd->buf = (char *) malloc(bufsize);
-	if (cmd->buf == NULL) {
-		fprintf(stderr, "fuse: failed to allocate read buffer\n");
-		free(cmd);
-		return NULL;
-	}
-	return cmd;
-}
-
-struct fuse_cmd *fuse_read_cmd(struct fuse *f)
-{
-	struct fuse_chan *ch = fuse_session_next_chan(f->se, NULL);
-	size_t bufsize = fuse_chan_bufsize(ch);
-	struct fuse_cmd *cmd = fuse_alloc_cmd(bufsize);
-	if (cmd != NULL) {
-		int res = fuse_chan_recv(&ch, cmd->buf, bufsize);
-		if (res <= 0) {
-			free_cmd(cmd);
-			if (res < 0 && res != -EINTR && res != -EAGAIN)
-				fuse_exit(f);
-			return NULL;
-		}
-		cmd->buflen = res;
-		cmd->ch = ch;
-	}
-	return cmd;
-}
-
 static int fuse_session_loop_remember(struct fuse *f)
 {
 	struct fuse_session *se = f->se;
 	int res = 0;
 	struct timespec now;
 	time_t next_clean;
-	struct fuse_chan *ch = fuse_session_next_chan(se, NULL);
-	size_t bufsize = fuse_chan_bufsize(ch);
-	char *buf = (char *) malloc(bufsize);
+	struct fuse_chan *ch = fuse_session_chan(se);
 	struct pollfd fds = {
 		.fd = fuse_chan_fd(ch),
 		.events = POLLIN
 	};
-
-	if (!buf) {
-		fprintf(stderr, "fuse: failed to allocate read buffer\n");
-		return -1;
-	}
+	struct fuse_buf fbuf = {
+		.mem = NULL,
+	};
 
 	curr_time(&now);
 	next_clean = now.tv_sec;
 	while (!fuse_session_exited(se)) {
-		struct fuse_chan *tmpch = ch;
-		struct fuse_buf fbuf = {
-			.mem = buf,
-			.size = bufsize,
-		};
 		unsigned timeout;
 
 		curr_time(&now);
@@ -4283,14 +4047,14 @@ static int fuse_session_loop_remember(struct fuse *f)
 			else
 				break;
 		} else if (res > 0) {
-			res = fuse_session_receive_buf(se, &fbuf, &tmpch);
+			res = fuse_session_receive_buf(se, &fbuf, ch);
 
 			if (res == -EINTR)
 				continue;
 			if (res <= 0)
 				break;
 
-			fuse_session_process_buf(se, &fbuf, tmpch);
+			fuse_session_process_buf(se, &fbuf, ch);
 		} else {
 			timeout = fuse_clean_cache(f);
 			curr_time(&now);
@@ -4298,7 +4062,7 @@ static int fuse_session_loop_remember(struct fuse *f)
 		}
 	}
 
-	free(buf);
+	free(fbuf.mem);
 	fuse_session_reset(se);
 	return res < 0 ? -1 : 0;
 }
@@ -4314,13 +4078,6 @@ int fuse_loop(struct fuse *f)
 	return fuse_session_loop(f->se);
 }
 
-int fuse_invalidate(struct fuse *f, const char *path)
-{
-	(void) f;
-	(void) path;
-	return -EINVAL;
-}
-
 void fuse_exit(struct fuse *f)
 {
 	fuse_session_exit(f->se);
@@ -4328,36 +4085,31 @@ void fuse_exit(struct fuse *f)
 
 struct fuse_context *fuse_get_context(void)
 {
-	return &fuse_get_context_internal()->ctx;
-}
+	struct fuse_context_i *c = fuse_get_context_internal();
 
-/*
- * The size of fuse_context got extended, so need to be careful about
- * incompatibility (i.e. a new binary cannot work with an old
- * library).
- */
-struct fuse_context *fuse_get_context_compat22(void);
-struct fuse_context *fuse_get_context_compat22(void)
-{
-	return &fuse_get_context_internal()->ctx;
+	if (c)
+		return &c->ctx;
+	else
+		return NULL;
 }
-FUSE_SYMVER(".symver fuse_get_context_compat22,fuse_get_context@FUSE_2.2");
 
 int fuse_getgroups(int size, gid_t list[])
 {
-	fuse_req_t req = fuse_get_context_internal()->req;
-	return fuse_req_getgroups(req, size, list);
+	struct fuse_context_i *c = fuse_get_context_internal();
+	if (!c)
+		return -EINVAL;
+
+	return fuse_req_getgroups(c->req, size, list);
 }
 
 int fuse_interrupted(void)
 {
-	return fuse_req_interrupted(fuse_get_context_internal()->req);
-}
+	struct fuse_context_i *c = fuse_get_context_internal();
 
-void fuse_set_getcontext_func(struct fuse_context *(*func)(void))
-{
-	(void) func;
-	/* no-op */
+	if (c)
+		return fuse_req_interrupted(c->req);
+	else
+		return 0;
 }
 
 enum {
@@ -4402,7 +4154,7 @@ static const struct fuse_opt fuse_lib_opts[] = {
 
 static void fuse_lib_help(void)
 {
-	fprintf(stderr,
+	printf(
 "    -o hard_remove         immediate removal (don't hide files)\n"
 "    -o use_ino             let filesystem set inode numbers\n"
 "    -o readdir_ino         try to fill in d_ino in readdir\n"
@@ -4428,7 +4180,7 @@ static void fuse_lib_help(void)
 static void fuse_lib_help_modules(void)
 {
 	struct fuse_module *m;
-	fprintf(stderr, "\nModule options:\n");
+	printf("\nModule options:\n");
 	pthread_mutex_lock(&fuse_context_lock);
 	for (m = fuse_modules; m; m = m->next) {
 		struct fuse_fs *fs = NULL;
@@ -4436,7 +4188,7 @@ static void fuse_lib_help_modules(void)
 		struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
 		if (fuse_opt_add_arg(&args, "") != -1 &&
 		    fuse_opt_add_arg(&args, "-h") != -1) {
-			fprintf(stderr, "\n[%s]\n", m->name);
+			printf("\n[%s]\n", m->name);
 			newfs = m->factory(&args, &fs);
 			assert(newfs == NULL);
 		}
@@ -4459,12 +4211,6 @@ static int fuse_lib_opt_proc(void *data, const char *arg, int key,
 	return 1;
 }
 
-int fuse_is_lib_option(const char *opt)
-{
-	return fuse_lowlevel_is_lib_option(opt) ||
-		fuse_opt_match(fuse_lib_opts, opt);
-}
-
 static int fuse_init_intr_signal(int signum, int *installed)
 {
 	struct sigaction old_sa;
@@ -4517,9 +4263,7 @@ static int fuse_push_module(struct fuse *f, const char *module,
 	}
 	newfs->m = m;
 	f->fs = newfs;
-	f->nullpath_ok = newfs->op.flag_nullpath_ok && f->nullpath_ok;
 	f->conf.nopath = newfs->op.flag_nopath && f->conf.nopath;
-	f->utime_omit_ok = newfs->op.flag_utime_omit_ok && f->utime_omit_ok;
 	return 0;
 }
 
@@ -4589,9 +4333,9 @@ void fuse_stop_cleanup_thread(struct fuse *f)
 	}
 }
 
-struct fuse *fuse_new_common(struct fuse_chan *ch, struct fuse_args *args,
-			     const struct fuse_operations *op,
-			     size_t op_size, void *user_data, int compat)
+struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args,
+		      const struct fuse_operations *op,
+		      size_t op_size, void *user_data)
 {
 	struct fuse *f;
 	struct node *root;
@@ -4611,11 +4355,8 @@ struct fuse *fuse_new_common(struct fuse_chan *ch, struct fuse_args *args,
 	if (!fs)
 		goto out_free;
 
-	fs->compat = compat;
 	f->fs = fs;
-	f->nullpath_ok = fs->op.flag_nullpath_ok;
 	f->conf.nopath = fs->op.flag_nopath;
-	f->utime_omit_ok = fs->op.flag_utime_omit_ok;
 
 	/* Oh f**k, this is ugly! */
 	if (!fs->op.lock) {
@@ -4663,12 +4404,7 @@ struct fuse *fuse_new_common(struct fuse_chan *ch, struct fuse_args *args,
 	f->conf.readdir_ino = 1;
 #endif
 
-	if (compat && compat <= 25) {
-		if (fuse_sync_compat_args(args) == -1)
-			goto out_free_fs;
-	}
-
-	f->se = fuse_lowlevel_new_common(args, &llop, sizeof(llop), f);
+	f->se = fuse_lowlevel_new(args, &llop, sizeof(llop), f);
 	if (f->se == NULL) {
 		if (f->conf.help)
 			fuse_lib_help_modules();
@@ -4678,9 +4414,7 @@ struct fuse *fuse_new_common(struct fuse_chan *ch, struct fuse_args *args,
 	fuse_session_add_chan(f->se, ch);
 
 	if (f->conf.debug) {
-		fprintf(stderr, "nullpath_ok: %i\n", f->nullpath_ok);
 		fprintf(stderr, "nopath: %i\n", f->conf.nopath);
-		fprintf(stderr, "utime_omit_ok: %i\n", f->utime_omit_ok);
 	}
 
 	/* Trace topmost layer by default */
@@ -4729,10 +4463,9 @@ out_free_name_table:
 out_free_session:
 	fuse_session_destroy(f->se);
 out_free_fs:
-	/* Horrible compatibility hack to stop the destructor from being
-	   called on the filesystem without init being called first */
-	fs->op.destroy = NULL;
-	fuse_fs_destroy(f->fs);
+	if (f->fs->m)
+		fuse_put_module(f->fs->m);
+	free(f->fs);
 	free(f->conf.modules);
 out_free:
 	free(f);
@@ -4742,13 +4475,6 @@ out:
 	return NULL;
 }
 
-struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args,
-		      const struct fuse_operations *op, size_t op_size,
-		      void *user_data)
-{
-	return fuse_new_common(ch, args, op, op_size, user_data, 0);
-}
-
 void fuse_destroy(struct fuse *f)
 {
 	size_t i;
@@ -4757,10 +4483,7 @@ void fuse_destroy(struct fuse *f)
 		fuse_restore_intr_signal(f->conf.intr_signal);
 
 	if (f->fs) {
-		struct fuse_context_i *c = fuse_get_context_internal();
-
-		memset(c, 0, sizeof(*c));
-		c->ctx.fuse = f;
+		fuse_create_context(f);
 
 		for (i = 0; i < f->id_table.size; i++) {
 			struct node *node;
@@ -4799,19 +4522,6 @@ void fuse_destroy(struct fuse *f)
 	fuse_delete_context_key();
 }
 
-static struct fuse *fuse_new_common_compat25(int fd, struct fuse_args *args,
-					     const struct fuse_operations *op,
-					     size_t op_size, int compat)
-{
-	struct fuse *f = NULL;
-	struct fuse_chan *ch = fuse_kern_chan_new(fd);
-
-	if (ch)
-		f = fuse_new_common(ch, args, op, op_size, NULL, compat);
-
-	return f;
-}
-
 /* called with fuse_context_lock held or during initialization (before
    main() has been called) */
 void fuse_register_module(struct fuse_module *mod)
@@ -4823,72 +4533,3 @@ void fuse_register_module(struct fuse_module *mod)
 	mod->next = fuse_modules;
 	fuse_modules = mod;
 }
-
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
-
-static struct fuse *fuse_new_common_compat(int fd, const char *opts,
-					   const struct fuse_operations *op,
-					   size_t op_size, int compat)
-{
-	struct fuse *f;
-	struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
-
-	if (fuse_opt_add_arg(&args, "") == -1)
-		return NULL;
-	if (opts &&
-	    (fuse_opt_add_arg(&args, "-o") == -1 ||
-	     fuse_opt_add_arg(&args, opts) == -1)) {
-		fuse_opt_free_args(&args);
-		return NULL;
-	}
-	f = fuse_new_common_compat25(fd, &args, op, op_size, compat);
-	fuse_opt_free_args(&args);
-
-	return f;
-}
-
-struct fuse *fuse_new_compat22(int fd, const char *opts,
-			       const struct fuse_operations_compat22 *op,
-			       size_t op_size)
-{
-	return fuse_new_common_compat(fd, opts, (struct fuse_operations *) op,
-				      op_size, 22);
-}
-
-struct fuse *fuse_new_compat2(int fd, const char *opts,
-			      const struct fuse_operations_compat2 *op)
-{
-	return fuse_new_common_compat(fd, opts, (struct fuse_operations *) op,
-				      sizeof(struct fuse_operations_compat2),
-				      21);
-}
-
-struct fuse *fuse_new_compat1(int fd, int flags,
-			      const struct fuse_operations_compat1 *op)
-{
-	const char *opts = NULL;
-	if (flags & FUSE_DEBUG_COMPAT1)
-		opts = "debug";
-	return fuse_new_common_compat(fd, opts, (struct fuse_operations *) op,
-				      sizeof(struct fuse_operations_compat1),
-				      11);
-}
-
-FUSE_SYMVER(".symver fuse_exited,__fuse_exited@");
-FUSE_SYMVER(".symver fuse_process_cmd,__fuse_process_cmd@");
-FUSE_SYMVER(".symver fuse_read_cmd,__fuse_read_cmd@");
-FUSE_SYMVER(".symver fuse_set_getcontext_func,__fuse_set_getcontext_func@");
-FUSE_SYMVER(".symver fuse_new_compat2,fuse_new@");
-FUSE_SYMVER(".symver fuse_new_compat22,fuse_new@FUSE_2.2");
-
-#endif /* __FreeBSD__ || __NetBSD__  */
-
-struct fuse *fuse_new_compat25(int fd, struct fuse_args *args,
-			       const struct fuse_operations_compat25 *op,
-			       size_t op_size)
-{
-	return fuse_new_common_compat25(fd, args, (struct fuse_operations *) op,
-					op_size, 25);
-}
-
-FUSE_SYMVER(".symver fuse_new_compat25,fuse_new@FUSE_2.5");