diff --git a/lib/fuse.c b/lib/fuse.c
index 45ea1b3..b93ded3 100644
--- a/lib/fuse.c
+++ b/lib/fuse.c
@@ -8,8 +8,6 @@
 
 #include "fuse_i.h"
 #include "fuse_compat.h"
-#include "fuse_kernel.h"
-#include "fuse_kernel_compat5.h"
 
 #include <stdio.h>
 #include <string.h>
@@ -34,9 +32,6 @@
 /** Use st_ino field in getattr instead of generating inode numbers  */
 #define FUSE_USE_INO     (1 << 3)
 
-/** Only allow root or the owner to access the filesystem */
-#define FUSE_ALLOW_ROOT  (1 << 4)
-
 /** Make a best effort to fill in inode number in a readdir **/
 #define FUSE_READDIR_INO (1 << 5)
 
@@ -54,30 +49,18 @@
 
 
 #define FUSE_MAX_PATH 4096
-#define PARAM_T(inarg, type) (((char *)(inarg)) + sizeof(type))
-#define PARAM(inarg) PARAM_T(inarg, *(inarg))
-#define PARAM_COMPAT(f, inarg, type) \
-    ((f)->major == 5 ? PARAM_T(inarg, struct type ## _compat5) : PARAM(inarg))
 
-#define MEMBER_COMPAT(f, ptr, memb, type) \
-    ((f)->major == 5 ? &((struct type ## _compat5 *) (ptr))->memb : &ptr->memb)
-
-#define SIZEOF_COMPAT(f, type) \
-    ((f)->major == 5 ? sizeof(struct type ## _compat5) : sizeof(struct type))
-
-#define ENTRY_REVALIDATE_TIME 1 /* sec */
-#define ATTR_REVALIDATE_TIME 1 /* sec */
-
+#define ENTRY_REVALIDATE_TIME 1.0 /* sec */
+#define ATTR_REVALIDATE_TIME 1.0 /* sec */
 
 struct node {
     struct node *name_next;
     struct node *id_next;
-    nodeid_t nodeid;
+    fuse_ino_t nodeid;
     unsigned int generation;
     int refctr;
-    nodeid_t parent;
+    fuse_ino_t parent;
     char *name;
-    uint64_t version;
     uint64_t nlookup;
     int open_count;
     int is_hidden;
@@ -93,15 +76,9 @@
     int filled;
     unsigned long fh;
     int error;
-    nodeid_t nodeid;
+    fuse_ino_t nodeid;
 };
 
-struct fuse_cmd {
-    char *buf;
-    size_t buflen;
-};
-
-
 static struct fuse_context *(*fuse_getcontext)(void) = NULL;
 
 #ifndef USE_UCLIBC
@@ -117,56 +94,7 @@
 }
 #endif
 
-static const char *opname(enum fuse_opcode opcode)
-{
-    switch (opcode) {
-    case FUSE_LOOKUP:		return "LOOKUP";
-    case FUSE_FORGET:		return "FORGET";
-    case FUSE_GETATTR:		return "GETATTR";
-    case FUSE_SETATTR:		return "SETATTR";
-    case FUSE_READLINK:		return "READLINK";
-    case FUSE_SYMLINK:		return "SYMLINK";
-    case FUSE_MKNOD:		return "MKNOD";
-    case FUSE_MKDIR:		return "MKDIR";
-    case FUSE_UNLINK:		return "UNLINK";
-    case FUSE_RMDIR:		return "RMDIR";
-    case FUSE_RENAME:		return "RENAME";
-    case FUSE_LINK:		return "LINK";
-    case FUSE_OPEN:		return "OPEN";
-    case FUSE_READ:		return "READ";
-    case FUSE_WRITE:		return "WRITE";
-    case FUSE_STATFS:		return "STATFS";
-    case FUSE_FLUSH:		return "FLUSH";
-    case FUSE_RELEASE:		return "RELEASE";
-    case FUSE_FSYNC:		return "FSYNC";
-    case FUSE_SETXATTR:		return "SETXATTR";
-    case FUSE_GETXATTR:		return "GETXATTR";
-    case FUSE_LISTXATTR:	return "LISTXATTR";
-    case FUSE_REMOVEXATTR:	return "REMOVEXATTR";
-    case FUSE_INIT:		return "INIT";
-    case FUSE_OPENDIR:		return "OPENDIR";
-    case FUSE_READDIR:		return "READDIR";
-    case FUSE_RELEASEDIR:	return "RELEASEDIR";
-    case FUSE_FSYNCDIR:		return "FSYNCDIR";
-    default: 			return "???";
-    }
-}
-
-static inline void fuse_dec_avail(struct fuse *f)
-{
-    pthread_mutex_lock(&f->worker_lock);
-    f->numavail --;
-    pthread_mutex_unlock(&f->worker_lock);
-}
-
-static inline void fuse_inc_avail(struct fuse *f)
-{
-    pthread_mutex_lock(&f->worker_lock);
-    f->numavail ++;
-    pthread_mutex_unlock(&f->worker_lock);
-}
-
-static struct node *get_node_nocheck(struct fuse *f, nodeid_t nodeid)
+static struct node *get_node_nocheck(struct fuse *f, fuse_ino_t nodeid)
 {
     size_t hash = nodeid % f->id_table_size;
     struct node *node;
@@ -178,7 +106,7 @@
     return NULL;
 }
 
-static struct node *get_node(struct fuse *f, nodeid_t nodeid)
+static struct node *get_node(struct fuse *f, fuse_ino_t nodeid)
 {
     struct node *node = get_node_nocheck(f, nodeid);
     if (!node) {
@@ -214,7 +142,7 @@
     f->id_table[hash] = node;
 }
 
-static unsigned int name_hash(struct fuse *f, nodeid_t parent, const char *name)
+static unsigned int name_hash(struct fuse *f, fuse_ino_t parent, const char *name)
 {
     unsigned int hash = *name;
 
@@ -249,7 +177,7 @@
     }
 }
 
-static int hash_name(struct fuse *f, struct node *node, nodeid_t parent,
+static int hash_name(struct fuse *f, struct node *node, fuse_ino_t parent,
                      const char *name)
 {
     size_t hash = name_hash(f, parent, name);
@@ -283,7 +211,7 @@
         delete_node(f, node);
 }
 
-static nodeid_t next_id(struct fuse *f)
+static fuse_ino_t next_id(struct fuse *f)
 {
     do {
         f->ctr++;
@@ -293,7 +221,7 @@
     return f->ctr;
 }
 
-static struct node *lookup_node(struct fuse *f, nodeid_t parent,
+static struct node *lookup_node(struct fuse *f, fuse_ino_t parent,
                                 const char *name)
 {
     size_t hash = name_hash(f, parent, name);
@@ -306,8 +234,8 @@
     return NULL;
 }
 
-static struct node *find_node(struct fuse *f, nodeid_t parent, char *name,
-                              uint64_t version)
+static struct node *find_node(struct fuse *f, fuse_ino_t parent,
+                              const char *name)
 {
     struct node *node;
 
@@ -330,7 +258,6 @@
         }
         hash_id(f, node);
     }
-    node->version = version;
     node->nlookup ++;
  out_err:
     pthread_mutex_unlock(&f->lock);
@@ -352,7 +279,7 @@
     return s;
 }
 
-static char *get_path_name(struct fuse *f, nodeid_t nodeid, const char *name)
+static char *get_path_name(struct fuse *f, fuse_ino_t nodeid, const char *name)
 {
     char buf[FUSE_MAX_PATH];
     char *s = buf + FUSE_MAX_PATH - 1;
@@ -388,12 +315,12 @@
         return strdup(s);
 }
 
-static char *get_path(struct fuse *f, nodeid_t nodeid)
+static char *get_path(struct fuse *f, fuse_ino_t nodeid)
 {
     return get_path_name(f, nodeid, NULL);
 }
 
-static void forget_node(struct fuse *f, nodeid_t nodeid, uint64_t nlookup)
+static void forget_node(struct fuse *f, fuse_ino_t nodeid, uint64_t nlookup)
 {
     struct node *node;
     if (nodeid == FUSE_ROOT_ID)
@@ -409,29 +336,7 @@
     pthread_mutex_unlock(&f->lock);
 }
 
-static void forget_node_old(struct fuse *f, nodeid_t nodeid, uint64_t version)
-{
-    struct node *node;
-
-    pthread_mutex_lock(&f->lock);
-    node = get_node_nocheck(f, nodeid);
-    if (node && node->version == version && nodeid != FUSE_ROOT_ID) {
-        node->version = 0;
-        unhash_name(f, node);
-        unref_node(f, node);
-    }
-    pthread_mutex_unlock(&f->lock);
-}
-
-static void cancel_lookup(struct fuse *f, nodeid_t nodeid, uint64_t version)
-{
-    if (f->major <= 6)
-        forget_node_old(f, nodeid, version);
-    else
-        forget_node(f, nodeid, 1);
-}
-
-static void remove_node(struct fuse *f, nodeid_t dir, const char *name)
+static void remove_node(struct fuse *f, fuse_ino_t dir, const char *name)
 {
     struct node *node;
 
@@ -442,8 +347,8 @@
     pthread_mutex_unlock(&f->lock);
 }
 
-static int rename_node(struct fuse *f, nodeid_t olddir, const char *oldname,
-                        nodeid_t newdir, const char *newname, int hide)
+static int rename_node(struct fuse *f, fuse_ino_t olddir, const char *oldname,
+                        fuse_ino_t newdir, const char *newname, int hide)
 {
     struct node *node;
     struct node *newnode;
@@ -478,94 +383,19 @@
     return err;
 }
 
-static void convert_stat(struct fuse *f, nodeid_t nodeid, struct stat *stbuf,
-                         struct fuse_attr *attr)
+static void set_stat(struct fuse *f, fuse_ino_t nodeid, struct stat *stbuf)
 {
-    attr->ino       = (f->flags & FUSE_USE_INO) ? stbuf->st_ino : nodeid;
-    attr->mode      = stbuf->st_mode;
+    if (!(f->flags & FUSE_USE_INO))
+        stbuf->st_ino = nodeid;
     if (f->flags & FUSE_SET_MODE)
-        attr->mode = (attr->mode & S_IFMT) | (0777 & ~f->umask);
-    attr->nlink     = stbuf->st_nlink;
-    attr->uid       = (f->flags & FUSE_SET_UID) ? f->uid : stbuf->st_uid;
-    attr->gid       = (f->flags & FUSE_SET_GID) ? f->gid : stbuf->st_gid;
-    attr->rdev      = stbuf->st_rdev;
-    attr->size      = stbuf->st_size;
-    attr->blocks    = stbuf->st_blocks;
-    attr->atime     = stbuf->st_atime;
-    attr->mtime     = stbuf->st_mtime;
-    attr->ctime     = stbuf->st_ctime;
-#ifdef HAVE_STRUCT_STAT_ST_ATIM
-    attr->atimensec = stbuf->st_atim.tv_nsec;
-    attr->mtimensec = stbuf->st_mtim.tv_nsec;
-    attr->ctimensec = stbuf->st_ctim.tv_nsec;
-#endif
+        stbuf->st_mode = (stbuf->st_mode & S_IFMT) | (0777 & ~f->umask);
+    if (f->flags & FUSE_SET_UID)
+        stbuf->st_uid = f->uid;
+    if (f->flags & FUSE_SET_GID)
+        stbuf->st_gid = f->gid;
 }
 
-static  size_t iov_length(const struct iovec *iov, size_t count)
-{
-    size_t seg;
-    size_t ret = 0;
-
-    for (seg = 0; seg < count; seg++)
-        ret += iov[seg].iov_len;
-    return ret;
-}
-
-static int send_reply_raw(struct fuse *f, const struct iovec iov[],
-                          size_t count)
-{
-    int res;
-    unsigned outsize = iov_length(iov, count);
-    struct fuse_out_header *out = (struct fuse_out_header *) iov[0].iov_base;
-    out->len = outsize;
-
-    if ((f->flags & FUSE_DEBUG)) {
-        printf("   unique: %llu, error: %i (%s), outsize: %i\n",
-               out->unique, out->error, strerror(-out->error), outsize);
-        fflush(stdout);
-    }
-
-    /* This needs to be done before the reply, otherwise the scheduler
-       could play tricks with us, and only let the counter be
-       increased long after the operation is done */
-    fuse_inc_avail(f);
-
-    res = writev(f->fd, iov, count);
-    if (res == -1) {
-        /* ENOENT means the operation was interrupted */
-        if (!f->exited && errno != ENOENT)
-            perror("fuse: writing device");
-        return -errno;
-    }
-    return 0;
-}
-
-static int send_reply(struct fuse *f, struct fuse_in_header *in, int error,
-                      void *arg, size_t argsize)
-{
-    struct fuse_out_header out;
-    struct iovec iov[2];
-    size_t count;
-
-    if (error <= -1000 || error > 0) {
-        fprintf(stderr, "fuse: bad error value: %i\n",  error);
-        error = -ERANGE;
-    }
-
-    out.unique = in->unique;
-    out.error = error;
-    count = 1;
-    iov[0].iov_base = &out;
-    iov[0].iov_len = sizeof(struct fuse_out_header);
-    if (argsize && !error) {
-        count++;
-        iov[1].iov_base = arg;
-        iov[1].iov_len = argsize;
-    }
-    return send_reply_raw(f, iov, count);
-}
-
-static int is_open(struct fuse *f, nodeid_t dir, const char *name)
+static int is_open(struct fuse *f, fuse_ino_t dir, const char *name)
 {
     struct node *node;
     int isopen = 0;
@@ -577,7 +407,7 @@
     return isopen;
 }
 
-static char *hidden_name(struct fuse *f, nodeid_t dir, const char *oldname,
+static char *hidden_name(struct fuse *f, fuse_ino_t dir, const char *oldname,
                         char *newname, size_t bufsize)
 {
     struct stat buf;
@@ -619,7 +449,7 @@
     return newpath;
 }
 
-static int hide_node(struct fuse *f, const char *oldpath, nodeid_t dir,
+static int hide_node(struct fuse *f, const char *oldpath, fuse_ino_t dir,
                      const char *oldname)
 {
     char newname[64];
@@ -638,31 +468,27 @@
     return err;
 }
 
-static int lookup_path(struct fuse *f, nodeid_t nodeid, uint64_t version,
-                       char *name, const char *path,
-                       struct fuse_entry_out *arg)
+static int lookup_path(struct fuse *f, fuse_ino_t nodeid, const char *name,
+                       const char *path, struct fuse_entry_param *e)
 {
     int res;
-    struct stat buf;
 
-    res = f->op.getattr(path, &buf);
+    memset(e, 0, sizeof(struct fuse_entry_param));
+    res = f->op.getattr(path, &e->attr);
     if (res == 0) {
         struct node *node;
 
-        node = find_node(f, nodeid, name, version);
+        node = find_node(f, nodeid, name);
         if (node == NULL)
             res = -ENOMEM;
         else {
-            memset(arg, 0, sizeof(struct fuse_entry_out));
-            convert_stat(f, node->nodeid, &buf, &arg->attr);
-            arg->nodeid = node->nodeid;
-            arg->generation = node->generation;
-            arg->entry_valid = ENTRY_REVALIDATE_TIME;
-            arg->entry_valid_nsec = 0;
-            arg->attr_valid = ATTR_REVALIDATE_TIME;
-            arg->attr_valid_nsec = 0;
+            e->ino = node->nodeid;
+            e->generation = node->generation;
+            e->entry_timeout = ENTRY_REVALIDATE_TIME;
+            e->attr_timeout = ATTR_REVALIDATE_TIME;
+            set_stat(f, e->ino, &e->attr);
             if (f->flags & FUSE_DEBUG) {
-                printf("   NODEID: %lu\n", (unsigned long) arg->nodeid);
+                printf("   NODEID: %lu\n", (unsigned long) e->ino);
                 fflush(stdout);
             }
         }
@@ -670,346 +496,375 @@
     return res;
 }
 
-static void do_lookup(struct fuse *f, struct fuse_in_header *in, char *name)
+static struct fuse *req_fuse(fuse_req_t req)
 {
-    int res;
-    int res2;
-    char *path;
-    struct fuse_entry_out arg;
+    return (struct fuse *) fuse_req_userdata(req);
+}
 
-    res = -ENOENT;
+static struct fuse *req_fuse_prepare(fuse_req_t req)
+{
+    struct fuse_context *c = fuse_get_context();
+    const struct fuse_ctx *ctx = fuse_req_ctx(req);
+    c->fuse = req_fuse(req);
+    c->uid = ctx->uid;
+    c->gid = ctx->gid;
+    c->pid = ctx->pid;
+    c->private_data = c->fuse->user_data;
+
+    return c->fuse;
+}
+
+static inline void reply_err(fuse_req_t req, int err)
+{
+    /* fuse_reply_err() uses non-negated errno values */
+    fuse_reply_err(req, -err);
+}
+
+static void reply_entry(fuse_req_t req, const struct fuse_entry_param *e,
+                        int err)
+{
+    if (!err) {
+        if (fuse_reply_entry(req, e) == -ENOENT) 
+            forget_node(req_fuse(req), e->ino, 1);
+    } else
+        reply_err(req, err);
+}
+
+static void *fuse_data_init(void *data)
+{
+    struct fuse *f = (struct fuse *) data;
+
+    if (f->op.init)
+        f->user_data = f->op.init();
+
+    return f;
+}
+
+static void fuse_data_destroy(void *data)
+{
+    struct fuse *f = (struct fuse *) data;
+
+    if (f->op.destroy)
+        f->op.destroy(f->user_data);
+}
+
+static void fuse_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
+{
+    struct fuse *f = req_fuse_prepare(req);
+    struct fuse_entry_param e;
+    char *path;
+    int err;
+
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path_name(f, in->nodeid, name);
+    path = get_path_name(f, parent, name);
     if (path != NULL) {
         if (f->flags & FUSE_DEBUG) {
             printf("LOOKUP %s\n", path);
             fflush(stdout);
         }
-        res = -ENOSYS;
+        err = -ENOSYS;
         if (f->op.getattr)
-            res = lookup_path(f, in->nodeid, in->unique, name, path, &arg);
+            err = lookup_path(f, parent, name, path, &e);
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    res2 = send_reply(f, in, res, &arg, sizeof(arg));
-    if (res == 0 && res2 == -ENOENT)
-        cancel_lookup(f, arg.nodeid, in->unique);
+    reply_entry(req, &e, err);
 }
 
-static void do_forget(struct fuse *f, struct fuse_in_header *in,
-                      struct fuse_forget_in *arg)
+static void fuse_forget(fuse_req_t req, fuse_ino_t ino, unsigned long nlookup)
 {
+    struct fuse *f = req_fuse(req);
     if (f->flags & FUSE_DEBUG) {
-        printf("FORGET %lu/%llu\n", (unsigned long) in->nodeid,
-               arg->nlookup);
+        printf("FORGET %lu/%lu\n", ino, nlookup);
         fflush(stdout);
     }
-    if (f->major <= 6)
-        forget_node_old(f, in->nodeid, arg->nlookup);
-    else
-        forget_node(f, in->nodeid, arg->nlookup);
+    forget_node(f, ino, nlookup);
+    fuse_reply_none(req);
 }
 
-static void do_getattr(struct fuse *f, struct fuse_in_header *in)
+static void fuse_getattr(fuse_req_t req, fuse_ino_t ino)
 {
-    int res;
-    char *path;
+    struct fuse *f = req_fuse_prepare(req);
     struct stat buf;
-    struct fuse_attr_out arg;
+    char *path;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
+    path = get_path(f, ino);
     if (path != NULL) {
-        res = -ENOSYS;
+        err = -ENOSYS;
         if (f->op.getattr)
-            res = f->op.getattr(path, &buf);
+            err = f->op.getattr(path, &buf);
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-
-    if (res == 0) {
-        memset(&arg, 0, sizeof(struct fuse_attr_out));
-        arg.attr_valid = ATTR_REVALIDATE_TIME;
-        arg.attr_valid_nsec = 0;
-        convert_stat(f, in->nodeid, &buf, &arg.attr);
-    }
-
-    send_reply(f, in, res, &arg, sizeof(arg));
+    if (!err) {
+        set_stat(f, ino, &buf);
+        fuse_reply_attr(req, &buf, ATTR_REVALIDATE_TIME);
+    } else
+        reply_err(req, err);
 }
 
-static int do_chmod(struct fuse *f, const char *path, struct fuse_attr *attr)
+static int do_chmod(struct fuse *f, const char *path, struct stat *attr)
 {
-    int res;
+    int err;
 
-    res = -ENOSYS;
+    err = -ENOSYS;
     if (f->op.chmod)
-        res = f->op.chmod(path, attr->mode);
+        err = f->op.chmod(path, attr->st_mode);
 
-    return res;
+    return err;
 }
 
-static int do_chown(struct fuse *f, const char *path, struct fuse_attr *attr,
+static int do_chown(struct fuse *f, const char *path, struct stat *attr,
                     int valid)
 {
-    int res;
-    uid_t uid = (valid & FATTR_UID) ? attr->uid : (uid_t) -1;
-    gid_t gid = (valid & FATTR_GID) ? attr->gid : (gid_t) -1;
+    int err;
+    uid_t uid = (valid & FUSE_SET_ATTR_UID) ? attr->st_uid : (uid_t) -1;
+    gid_t gid = (valid & FUSE_SET_ATTR_GID) ? attr->st_gid : (gid_t) -1;
 
-    res = -ENOSYS;
+    err = -ENOSYS;
     if (f->op.chown)
-        res = f->op.chown(path, uid, gid);
+        err = f->op.chown(path, uid, gid);
 
-    return res;
+    return err;
 }
 
-static int do_truncate(struct fuse *f, const char *path,
-                       struct fuse_attr *attr)
+static int do_truncate(struct fuse *f, const char *path, struct stat *attr)
 {
-    int res;
+    int err;
 
-    res = -ENOSYS;
+    err = -ENOSYS;
     if (f->op.truncate)
-        res = f->op.truncate(path, attr->size);
+        err = f->op.truncate(path, attr->st_size);
 
-    return res;
+    return err;
 }
 
-static int do_utime(struct fuse *f, const char *path, struct fuse_attr *attr)
+static int do_utime(struct fuse *f, const char *path, struct stat *attr)
 {
-    int res;
+    int err;
     struct utimbuf buf;
-    buf.actime = attr->atime;
-    buf.modtime = attr->mtime;
-    res = -ENOSYS;
+    buf.actime = attr->st_atime;
+    buf.modtime = attr->st_mtime;
+    err = -ENOSYS;
     if (f->op.utime)
-        res = f->op.utime(path, &buf);
+        err = f->op.utime(path, &buf);
 
-    return res;
+    return err;
 }
 
-static void do_setattr(struct fuse *f, struct fuse_in_header *in,
-                       struct fuse_setattr_in *arg)
+static void fuse_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
+                         int valid)
 {
-    int res;
+    struct fuse *f = req_fuse_prepare(req);
+    struct stat buf;
     char *path;
-    int valid = arg->valid;
-    struct fuse_attr *attr = MEMBER_COMPAT(f, arg, attr, fuse_setattr_in);
-    struct fuse_attr_out outarg;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
+    path = get_path(f, ino);
     if (path != NULL) {
-        res = -ENOSYS;
+        err = -ENOSYS;
         if (f->op.getattr) {
-            res = 0;
-            if (!res && (valid & FATTR_MODE))
-                res = do_chmod(f, path, attr);
-            if (!res && (valid & (FATTR_UID | FATTR_GID)))
-                res = do_chown(f, path, attr, valid);
-            if (!res && (valid & FATTR_SIZE))
-                res = do_truncate(f, path, attr);
-            if (!res && (valid & (FATTR_ATIME | FATTR_MTIME)) ==
-               (FATTR_ATIME | FATTR_MTIME))
-                res = do_utime(f, path, attr);
-            if (!res) {
-                struct stat buf;
-                res = f->op.getattr(path, &buf);
-                if (!res) {
-                    memset(&outarg, 0, sizeof(struct fuse_attr_out));
-                    outarg.attr_valid = ATTR_REVALIDATE_TIME;
-                    outarg.attr_valid_nsec = 0;
-                    convert_stat(f, in->nodeid, &buf, &outarg.attr);
-                }
-            }
+            err = 0;
+            if (!err && (valid & FUSE_SET_ATTR_MODE))
+                err = do_chmod(f, path, attr);
+            if (!err && (valid & (FUSE_SET_ATTR_UID | FUSE_SET_ATTR_GID)))
+                err = do_chown(f, path, attr, valid);
+            if (!err && (valid & FUSE_SET_ATTR_SIZE))
+                err = do_truncate(f, path, attr);
+            if (!err && (valid & (FUSE_SET_ATTR_ATIME | FUSE_SET_ATTR_MTIME)) == (FUSE_SET_ATTR_ATIME | FUSE_SET_ATTR_MTIME))
+                err = do_utime(f, path, attr);
+            if (!err)
+                err = f->op.getattr(path, &buf);
         }
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    send_reply(f, in, res, &outarg, sizeof(outarg));
+    if (!err) {
+        set_stat(f, ino, &buf);
+        fuse_reply_attr(req, &buf, ATTR_REVALIDATE_TIME);
+    } else
+        reply_err(req, err);
 }
 
-static void do_readlink(struct fuse *f, struct fuse_in_header *in)
+static void fuse_readlink(fuse_req_t req, fuse_ino_t ino)
 {
-    int res;
+    struct fuse *f = req_fuse_prepare(req);
     char link[PATH_MAX + 1];
     char *path;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
+    path = get_path(f, ino);
     if (path != NULL) {
-        res = -ENOSYS;
+        err = -ENOSYS;
         if (f->op.readlink)
-            res = f->op.readlink(path, link, sizeof(link));
+            err = f->op.readlink(path, link, sizeof(link));
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    link[PATH_MAX] = '\0';
-    send_reply(f, in, res, link, res == 0 ? strlen(link) : 0);
+    if (!err) {
+        link[PATH_MAX] = '\0';
+        fuse_reply_readlink(req, link);
+    } else
+        reply_err(req, err);
 }
 
-static void do_mknod(struct fuse *f, struct fuse_in_header *in,
-                     struct fuse_mknod_in *inarg)
+static void fuse_mknod(fuse_req_t req, fuse_ino_t parent, const char *name,
+                       mode_t mode, dev_t rdev)
 {
-    int res;
-    int res2;
+    struct fuse *f = req_fuse_prepare(req);
+    struct fuse_entry_param e;
     char *path;
-    char *name = PARAM(inarg);
-    struct fuse_entry_out outarg;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path_name(f, in->nodeid, name);
+    path = get_path_name(f, parent, name);
     if (path != NULL) {
         if (f->flags & FUSE_DEBUG) {
             printf("MKNOD %s\n", path);
             fflush(stdout);
         }
-        res = -ENOSYS;
+        err = -ENOSYS;
         if (f->op.mknod && f->op.getattr) {
-            res = f->op.mknod(path, inarg->mode, inarg->rdev);
-            if (res == 0)
-                res = lookup_path(f, in->nodeid, in->unique, name, path, &outarg);
+            err = f->op.mknod(path, mode, rdev);
+            if (!err)
+                err = lookup_path(f, parent, name, path, &e);
         }
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    res2 = send_reply(f, in, res, &outarg, sizeof(outarg));
-    if (res == 0 && res2 == -ENOENT)
-        cancel_lookup(f, outarg.nodeid, in->unique);
+    reply_entry(req, &e, err);
 }
 
-static void do_mkdir(struct fuse *f, struct fuse_in_header *in,
-                     struct fuse_mkdir_in *inarg)
+static void fuse_mkdir(fuse_req_t req, fuse_ino_t parent, const char *name,
+                       mode_t mode)
 {
-    int res;
-    int res2;
+    struct fuse *f = req_fuse_prepare(req);
+    struct fuse_entry_param e;
     char *path;
-    char *name = PARAM_COMPAT(f, inarg, fuse_mkdir_in);
-    struct fuse_entry_out outarg;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path_name(f, in->nodeid, name);
+    path = get_path_name(f, parent, name);
     if (path != NULL) {
         if (f->flags & FUSE_DEBUG) {
             printf("MKDIR %s\n", path);
             fflush(stdout);
         }
-        res = -ENOSYS;
+        err = -ENOSYS;
         if (f->op.mkdir && f->op.getattr) {
-            res = f->op.mkdir(path, inarg->mode);
-            if (res == 0)
-                res = lookup_path(f, in->nodeid, in->unique, name, path, &outarg);
+            err = f->op.mkdir(path, mode);
+            if (!err)
+                err = lookup_path(f, parent, name, path, &e);
         }
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    res2 = send_reply(f, in, res, &outarg, sizeof(outarg));
-    if (res == 0 && res2 == -ENOENT)
-        cancel_lookup(f, outarg.nodeid, in->unique);
+    reply_entry(req, &e, err);
 }
 
-static void do_unlink(struct fuse *f, struct fuse_in_header *in, char *name)
+static void fuse_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
 {
-    int res;
+    struct fuse *f = req_fuse_prepare(req);
     char *path;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_wrlock(&f->tree_lock);
-    path = get_path_name(f, in->nodeid, name);
+    path = get_path_name(f, parent, name);
     if (path != NULL) {
         if (f->flags & FUSE_DEBUG) {
             printf("UNLINK %s\n", path);
             fflush(stdout);
         }
-        res = -ENOSYS;
+        err = -ENOSYS;
         if (f->op.unlink) {
-            if (!(f->flags & FUSE_HARD_REMOVE) && is_open(f, in->nodeid, name))
-                res = hide_node(f, path, in->nodeid, name);
+            if (!(f->flags & FUSE_HARD_REMOVE) && is_open(f, parent, name))
+                err = hide_node(f, path, parent, name);
             else {
-                res = f->op.unlink(path);
-                if (res == 0)
-                    remove_node(f, in->nodeid, name);
-
+                err = f->op.unlink(path);
+                if (!err)
+                    remove_node(f, parent, name);
             }
         }
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    send_reply(f, in, res, NULL, 0);
+    reply_err(req, err);
 }
 
-static void do_rmdir(struct fuse *f, struct fuse_in_header *in, char *name)
+static void fuse_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name)
 {
-    int res;
+    struct fuse *f = req_fuse_prepare(req);
     char *path;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_wrlock(&f->tree_lock);
-    path = get_path_name(f, in->nodeid, name);
+    path = get_path_name(f, parent, name);
     if (path != NULL) {
         if (f->flags & FUSE_DEBUG) {
             printf("RMDIR %s\n", path);
             fflush(stdout);
         }
-        res = -ENOSYS;
+        err = -ENOSYS;
         if (f->op.rmdir) {
-            res = f->op.rmdir(path);
-            if (res == 0)
-                remove_node(f, in->nodeid, name);
+            err = f->op.rmdir(path);
+            if (!err)
+                remove_node(f, parent, name);
         }
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    send_reply(f, in, res, NULL, 0);
+    reply_err(req, err);
 }
 
-static void do_symlink(struct fuse *f, struct fuse_in_header *in, char *name,
-                       char *link)
+static void fuse_symlink(fuse_req_t req, const char *link, fuse_ino_t parent,
+                         const char *name)
 {
-    int res;
-    int res2;
+    struct fuse *f = req_fuse_prepare(req);
+    struct fuse_entry_param e;
     char *path;
-    struct fuse_entry_out outarg;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path_name(f, in->nodeid, name);
+    path = get_path_name(f, parent, name);
     if (path != NULL) {
         if (f->flags & FUSE_DEBUG) {
             printf("SYMLINK %s\n", path);
             fflush(stdout);
         }
-        res = -ENOSYS;
+        err = -ENOSYS;
         if (f->op.symlink && f->op.getattr) {
-            res = f->op.symlink(link, path);
-            if (res == 0)
-                res = lookup_path(f, in->nodeid, in->unique, name, path, &outarg);
+            err = f->op.symlink(link, path);
+            if (!err)
+                err = lookup_path(f, parent, name, path, &e);
         }
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    res2 = send_reply(f, in, res, &outarg, sizeof(outarg));
-    if (res == 0 && res2 == -ENOENT)
-        cancel_lookup(f, outarg.nodeid, in->unique);
-
+    reply_entry(req, &e, err);
 }
 
-static void do_rename(struct fuse *f, struct fuse_in_header *in,
-                      struct fuse_rename_in *inarg)
+static void fuse_rename(fuse_req_t req, fuse_ino_t olddir, const char *oldname,
+                        fuse_ino_t newdir, const char *newname)
 {
-    int res;
-    nodeid_t olddir = in->nodeid;
-    nodeid_t newdir = inarg->newdir;
-    char *oldname = PARAM(inarg);
-    char *newname = oldname + strlen(oldname) + 1;
+    struct fuse *f = req_fuse_prepare(req);
     char *oldpath;
     char *newpath;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_wrlock(&f->tree_lock);
     oldpath = get_path_name(f, olddir, oldname);
     if (oldpath != NULL) {
@@ -1019,16 +874,16 @@
                 printf("RENAME %s -> %s\n", oldpath, newpath);
                 fflush(stdout);
             }
-            res = -ENOSYS;
+            err = -ENOSYS;
             if (f->op.rename) {
-                res = 0;
+                err = 0;
                 if (!(f->flags & FUSE_HARD_REMOVE) &&
                     is_open(f, newdir, newname))
-                    res = hide_node(f, newpath, newdir, newname);
-                if (res == 0) {
-                    res = f->op.rename(oldpath, newpath);
-                    if (res == 0)
-                        res = rename_node(f, olddir, oldname, newdir, newname, 0);
+                    err = hide_node(f, newpath, newdir, newname);
+                if (!err) {
+                    err = f->op.rename(oldpath, newpath);
+                    if (!err)
+                        err = rename_node(f, olddir, oldname, newdir, newname, 0);
                 }
             }
             free(newpath);
@@ -1036,156 +891,211 @@
         free(oldpath);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    send_reply(f, in, res, NULL, 0);
+    reply_err(req, err);
 }
 
-static void do_link(struct fuse *f, struct fuse_in_header *in,
-                    struct fuse_link_in *arg)
+static void fuse_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,
+                      const char *newname)
 {
-    int res;
-    int res2;
+    struct fuse *f = req_fuse_prepare(req);
+    struct fuse_entry_param e;
     char *oldpath;
     char *newpath;
-    char *name = PARAM(arg);
-    struct fuse_entry_out outarg;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    oldpath = get_path(f, arg->oldnodeid);
+    oldpath = get_path(f, ino);
     if (oldpath != NULL) {
-        newpath =  get_path_name(f, in->nodeid, name);
+        newpath =  get_path_name(f, newparent, newname);
         if (newpath != NULL) {
             if (f->flags & FUSE_DEBUG) {
                 printf("LINK %s\n", newpath);
                 fflush(stdout);
             }
-            res = -ENOSYS;
+            err = -ENOSYS;
             if (f->op.link && f->op.getattr) {
-                res = f->op.link(oldpath, newpath);
-                if (res == 0)
-                    res = lookup_path(f, in->nodeid, in->unique, name,
-                                      newpath, &outarg);
+                err = f->op.link(oldpath, newpath);
+                if (!err)
+                    err = lookup_path(f, newparent, newname, newpath, &e);
             }
             free(newpath);
         }
         free(oldpath);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    res2 = send_reply(f, in, res, &outarg, sizeof(outarg));
-    if (res == 0 && res2 == -ENOENT)
-        cancel_lookup(f, outarg.nodeid, in->unique);
+    reply_entry(req, &e, err);
 }
 
-static void do_open(struct fuse *f, struct fuse_in_header *in,
-                    struct fuse_open_in *arg)
+static void fuse_open(fuse_req_t req, fuse_ino_t ino,
+                      struct fuse_file_info *fi)
 {
-    int res;
+    struct fuse *f = req_fuse_prepare(req);
     char *path;
-    struct fuse_open_out outarg;
-    struct fuse_file_info fi;
+    int err;
 
-    memset(&outarg, 0, sizeof(outarg));
-    memset(&fi, 0, sizeof(fi));
-    fi.flags = arg->flags;
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
+    path = get_path(f, ino);
     if (path != NULL) {
-        res = -ENOSYS;
+        err = -ENOSYS;
         if (f->op.open) {
             if (!f->compat)
-                res = f->op.open(path, &fi);
+                err = f->op.open(path, fi);
             else
-                res = ((struct fuse_operations_compat2 *) &f->op)->open(path, fi.flags);
+                err = ((struct fuse_operations_compat2 *) &f->op)->open(path, fi->flags);
         }
     }
-    if (res == 0) {
-        int res2;
-        outarg.fh = fi.fh;
+    if (!err) {
         if (f->flags & FUSE_DEBUG) {
-            printf("OPEN[%lu] flags: 0x%x\n", fi.fh, arg->flags);
+            printf("OPEN[%lu] flags: 0x%x\n", fi->fh, fi->flags);
             fflush(stdout);
         }
 
         pthread_mutex_lock(&f->lock);
-        res2 = send_reply(f, in, res, &outarg, SIZEOF_COMPAT(f, fuse_open_out));
-        if(res2 == -ENOENT) {
+        if (fuse_reply_open(req, fi) == -ENOENT) {
             /* The open syscall was interrupted, so it must be cancelled */
             if(f->op.release) {
                 if (!f->compat)
-                    f->op.release(path, &fi);
+                    f->op.release(path, fi);
                 else
-                    ((struct fuse_operations_compat2 *) &f->op)->release(path, fi.flags);
+                    ((struct fuse_operations_compat2 *) &f->op)->release(path, fi->flags);
             }
         } else {
-            struct node *node = get_node(f, in->nodeid);
+            struct node *node = get_node(f, ino);
             node->open_count ++;
         }
         pthread_mutex_unlock(&f->lock);
     } else
-        send_reply(f, in, res, NULL, 0);
+        reply_err(req, err);
 
     if (path)
         free(path);
     pthread_rwlock_unlock(&f->tree_lock);
 }
 
-static void do_flush(struct fuse *f, struct fuse_in_header *in,
-                     struct fuse_flush_in *arg)
+static void fuse_read(fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
+                      struct fuse_file_info *fi)
 {
+    struct fuse *f = req_fuse_prepare(req);
     char *path;
+    char *buf;
     int res;
-    struct fuse_file_info fi;
 
-    memset(&fi, 0, sizeof(fi));
-    fi.fh = arg->fh;
+    buf = (char *) malloc(size);
+    if (buf == NULL) {
+        reply_err(req, -ENOMEM);
+        return;
+    }
+
     res = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
+    path = get_path(f, ino);
     if (path != NULL) {
         if (f->flags & FUSE_DEBUG) {
-            printf("FLUSH[%lu]\n", (unsigned long) arg->fh);
+            printf("READ[%lu] %u bytes from %llu\n", fi->fh, size, off);
             fflush(stdout);
         }
+
         res = -ENOSYS;
-        if (f->op.flush)
-            res = f->op.flush(path, &fi);
+        if (f->op.read)
+            res = f->op.read(path, buf, size, off, fi);
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    send_reply(f, in, res, NULL, 0);
+
+    if (res >= 0) {
+        if (f->flags & FUSE_DEBUG) {
+            printf("   READ[%lu] %u bytes\n", fi->fh, res);
+            fflush(stdout);
+        }
+        fuse_reply_buf(req, buf, res);
+    } else
+        reply_err(req, res);
+
+    free(buf);
 }
 
-static void do_release(struct fuse *f, struct fuse_in_header *in,
-                       struct fuse_release_in *arg)
+static void fuse_write(fuse_req_t req, fuse_ino_t ino, const char *buf,
+                       size_t size, off_t off, struct fuse_file_info *fi)
 {
-    struct node *node;
+    struct fuse *f = req_fuse_prepare(req);
     char *path;
-    struct fuse_file_info fi;
+    int res;
+
+    res = -ENOENT;
+    pthread_rwlock_rdlock(&f->tree_lock);
+    path = get_path(f, ino);
+    if (path != NULL) {
+        if (f->flags & FUSE_DEBUG) {
+            printf("WRITE%s[%lu] %u bytes to %llu\n",
+                   fi->writepage ? "PAGE" : "", fi->fh, size, off);
+            fflush(stdout);
+        }
+
+        res = -ENOSYS;
+        if (f->op.write)
+            res = f->op.write(path, buf, size, off, fi);
+        free(path);
+    }
+    pthread_rwlock_unlock(&f->tree_lock);
+
+    if (res >= 0)
+        fuse_reply_write(req, res);
+    else
+        reply_err(req, res);
+}
+
+static void fuse_flush(fuse_req_t req, fuse_ino_t ino,
+                       struct fuse_file_info *fi)
+{
+    struct fuse *f = req_fuse_prepare(req);
+    char *path;
+    int err;
+
+    err = -ENOENT;
+    pthread_rwlock_rdlock(&f->tree_lock);
+    path = get_path(f, ino);
+    if (path != NULL) {
+        if (f->flags & FUSE_DEBUG) {
+            printf("FLUSH[%lu]\n", fi->fh);
+            fflush(stdout);
+        }
+        err = -ENOSYS;
+        if (f->op.flush)
+            err = f->op.flush(path, fi);
+        free(path);
+    }
+    pthread_rwlock_unlock(&f->tree_lock);
+    reply_err(req, err);
+}
+
+static void fuse_release(fuse_req_t req, fuse_ino_t ino,
+                         struct fuse_file_info *fi)
+{
+    struct fuse *f = req_fuse_prepare(req);
+    char *path;
+    struct node *node;
     int unlink_hidden;
 
-    memset(&fi, 0, sizeof(fi));
-    fi.flags = arg->flags;
-    fi.fh = arg->fh;
-
     pthread_mutex_lock(&f->lock);
-    node = get_node(f, in->nodeid);
+    node = get_node(f, ino);
     assert(node->open_count > 0);
     --node->open_count;
     unlink_hidden = (node->is_hidden && !node->open_count);
     pthread_mutex_unlock(&f->lock);
 
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
+    path = get_path(f, ino);
     if (f->flags & FUSE_DEBUG) {
-        printf("RELEASE[%lu] flags: 0x%x\n", fi.fh, fi.flags);
+        printf("RELEASE[%lu] flags: 0x%x\n", fi->fh, fi->flags);
         fflush(stdout);
     }
     if (f->op.release) {
         if (!f->compat)
-            f->op.release(path ? path : "-", &fi);
+            f->op.release(path ? path : "-", fi);
         else if (path)
-            ((struct fuse_operations_compat2 *) &f->op)->release(path, fi.flags);
+            ((struct fuse_operations_compat2 *) &f->op)->release(path, fi->flags);
     }
 
     if(unlink_hidden && path)
@@ -1195,96 +1105,268 @@
         free(path);
     pthread_rwlock_unlock(&f->tree_lock);
 
-    send_reply(f, in, 0, NULL, 0);
+    reply_err(req, 0);
 }
 
-static void do_read(struct fuse *f, struct fuse_in_header *in,
-                    struct fuse_read_in *arg)
+static void fuse_fsync(fuse_req_t req, fuse_ino_t ino, int datasync,
+                       struct fuse_file_info *fi)
 {
-    int res;
+    struct fuse *f = req_fuse_prepare(req);
     char *path;
-    size_t size;
-    char *buf;
-    struct fuse_file_info fi;
+    int err;
 
-    buf = (char *) malloc(arg->size);
-    if (buf == NULL) {
-        send_reply(f, in, -ENOMEM, NULL, 0);
+    err = -ENOENT;
+    pthread_rwlock_rdlock(&f->tree_lock);
+    path = get_path(f, ino);
+    if (path != NULL) {
+        if (f->flags & FUSE_DEBUG) {
+            printf("FSYNC[%lu]\n", fi->fh);
+            fflush(stdout);
+        }
+        err = -ENOSYS;
+        if (f->op.fsync)
+            err = f->op.fsync(path, datasync, fi);
+        free(path);
+    }
+    pthread_rwlock_unlock(&f->tree_lock);
+    reply_err(req, err);
+}
+
+static struct fuse_dirhandle *get_dirhandle(const struct fuse_file_info *llfi,
+                                            struct fuse_file_info *fi)
+{
+    struct fuse_dirhandle *dh = (struct fuse_dirhandle *) llfi->fh;
+    memset(fi, 0, sizeof(struct fuse_file_info));
+    fi->fh = dh->fh;
+    return dh;
+}
+
+static void fuse_opendir(fuse_req_t req, fuse_ino_t ino,
+                       struct fuse_file_info *llfi)
+{
+    struct fuse *f = req_fuse_prepare(req);
+    struct fuse_dirhandle *dh;
+
+    dh = (struct fuse_dirhandle *) malloc(sizeof(struct fuse_dirhandle));
+    if (dh == NULL) {
+        reply_err(req, -ENOMEM);
         return;
     }
+    memset(dh, 0, sizeof(struct fuse_dirhandle));
+    dh->fuse = f;
+    dh->contents = NULL;
+    dh->len = 0;
+    dh->filled = 0;
+    dh->nodeid = ino;
+    mutex_init(&dh->lock);
 
-    memset(&fi, 0, sizeof(fi));
-    fi.fh = arg->fh;
+    llfi->fh = (unsigned long) dh;
 
-    res = -ENOENT;
-    pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
-    if (path != NULL) {
-        if (f->flags & FUSE_DEBUG) {
-            printf("READ[%lu] %u bytes from %llu\n",
-                   (unsigned long) arg->fh, arg->size, arg->offset);
-            fflush(stdout);
+    if (f->op.opendir) {
+        struct fuse_file_info fi;
+        char *path;
+        int err;
+
+        memset(&fi, 0, sizeof(fi));
+        fi.flags = llfi->flags;
+
+        err = -ENOENT;
+        pthread_rwlock_rdlock(&f->tree_lock);
+        path = get_path(f, ino);
+        if (path != NULL) {
+            err = f->op.opendir(path, &fi);
+            dh->fh = fi.fh;
         }
-
-        res = -ENOSYS;
-        if (f->op.read)
-            res = f->op.read(path, buf, arg->size, arg->offset, &fi);
+        if (!err) {
+            pthread_mutex_lock(&f->lock);
+            if (fuse_reply_open(req, llfi) == -ENOENT) {
+                /* The opendir syscall was interrupted, so it must be
+                   cancelled */
+                if(f->op.releasedir)
+                    f->op.releasedir(path, &fi);
+                pthread_mutex_destroy(&dh->lock);
+                free(dh);
+            }
+            pthread_mutex_unlock(&f->lock);
+        } else {
+            reply_err(req, err);
+            free(dh);
+        }
         free(path);
-    }
-    pthread_rwlock_unlock(&f->tree_lock);
-
-    size = 0;
-    if (res >= 0) {
-        size = res;
-        res = 0;
-        if (f->flags & FUSE_DEBUG) {
-            printf("   READ[%lu] %u bytes\n", (unsigned long) arg->fh,
-                   size);
-            fflush(stdout);
-        }
-    }
-
-    send_reply(f, in, res, buf, size);
-    free(buf);
+        pthread_rwlock_unlock(&f->tree_lock);
+    } else
+        fuse_reply_open(req, llfi);
 }
 
-static void do_write(struct fuse *f, struct fuse_in_header *in,
-                     struct fuse_write_in *arg)
+static int fill_dir_common(struct fuse_dirhandle *dh, const char *name,
+                           const struct stat *stat, off_t off)
 {
-    int res;
-    char *path;
-    struct fuse_write_out outarg;
-    struct fuse_file_info fi;
+    struct stat stbuf;
+    unsigned namelen = strlen(name);
+    unsigned entsize;
+    unsigned newlen;
+    unsigned char *newptr;
 
-    memset(&fi, 0, sizeof(fi));
-    fi.fh = arg->fh;
-    fi.writepage = arg->write_flags & 1;
+    if (stat)
+        stbuf = *stat;
+    else {
+        memset(&stbuf, 0, sizeof(stbuf));
+        stbuf.st_ino = -1;
+    }
 
-    res = -ENOENT;
-    pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
-    if (path != NULL) {
-        if (f->flags & FUSE_DEBUG) {
-            printf("WRITE%s[%lu] %u bytes to %llu\n",
-                   (arg->write_flags & 1) ? "PAGE" : "",
-                   (unsigned long) arg->fh, arg->size, arg->offset);
-            fflush(stdout);
+    if (!(dh->fuse->flags & FUSE_USE_INO)) {
+        stbuf.st_ino = (ino_t) -1;
+        if (dh->fuse->flags & FUSE_READDIR_INO) {
+            struct node *node;
+            pthread_mutex_lock(&dh->fuse->lock);
+            node = lookup_node(dh->fuse, dh->nodeid, name);
+            if (node)
+                stbuf.st_ino  = (ino_t) node->nodeid;
+            pthread_mutex_unlock(&dh->fuse->lock);
         }
+    }
 
-        res = -ENOSYS;
-        if (f->op.write)
-            res = f->op.write(path, PARAM(arg), arg->size, arg->offset, &fi);
+    entsize = fuse_dirent_size(namelen);
+    newlen = dh->len + entsize;
+
+    if (off) {
+        dh->filled = 0;
+        if (newlen > dh->needlen)
+            return 1;
+    }
+
+    newptr = realloc(dh->contents, newlen);
+    if (!newptr) {
+        dh->error = -ENOMEM;
+        return 1;
+    }
+    dh->contents = newptr;
+    fuse_add_dirent(dh->contents + dh->len, name, &stbuf, off ? off : newlen);
+    dh->len = newlen;
+    return 0;
+}
+
+static int fill_dir(void *buf, const char *name, const struct stat *stat,
+                    off_t off)
+{
+    return fill_dir_common((struct fuse_dirhandle *) buf, name, stat, off);
+}
+
+static int fill_dir_old(struct fuse_dirhandle *dh, const char *name, int type,
+                        ino_t ino)
+{
+    struct stat stbuf;
+
+    memset(&stbuf, 0, sizeof(stbuf));
+    stbuf.st_mode = type << 12;
+    stbuf.st_ino = ino;
+
+    fill_dir_common(dh, name, &stbuf, 0);
+    return dh->error;
+}
+
+static int readdir_fill(struct fuse *f, fuse_ino_t ino, size_t size,
+                        off_t off, struct fuse_dirhandle *dh,
+                        struct fuse_file_info *fi)
+{
+    int err = -ENOENT;
+    char *path;
+    pthread_rwlock_rdlock(&f->tree_lock);
+    path = get_path(f, ino);
+    if (path != NULL) {
+        dh->len = 0;
+        dh->error = 0;
+        dh->needlen = size;
+        dh->filled = 1;
+        err = -ENOSYS;
+        if (f->op.readdir)
+            err = f->op.readdir(path, dh, fill_dir, off, fi);
+        else if (f->op.getdir)
+            err = f->op.getdir(path, dh, fill_dir_old);
+        if (!err)
+            err = dh->error;
+        if (err)
+            dh->filled = 0;
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
+    return err;
+}
 
-    memset(&outarg, 0, sizeof(outarg));
-    if (res >= 0) {
-        outarg.size = res;
-        res = 0;
+static void fuse_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
+                         off_t off, struct fuse_file_info *llfi)
+{
+    struct fuse *f = req_fuse_prepare(req);
+    struct fuse_file_info fi;
+    struct fuse_dirhandle *dh = get_dirhandle(llfi, &fi);
+
+    pthread_mutex_lock(&dh->lock);
+    if (!dh->filled) {
+        int err = readdir_fill(f, ino, size, off, dh, &fi);
+        if (err) {
+            reply_err(req, err);
+            goto out;
+        }
     }
+    if (dh->filled) {
+        if (off < dh->len) {
+            if (off + size > dh->len)
+                size = dh->len - off;
+        } else
+            size = 0;
+    } else {
+        size = dh->len;
+        off = 0;
+    }
+    fuse_reply_buf(req, dh->contents + off, size);
+ out:
+    pthread_mutex_unlock(&dh->lock);
+}
 
-    send_reply(f, in, res, &outarg, SIZEOF_COMPAT(f, fuse_write_out));
+static void fuse_releasedir(fuse_req_t req, fuse_ino_t ino,
+                            struct fuse_file_info *llfi)
+{
+    struct fuse *f = req_fuse_prepare(req);
+    struct fuse_file_info fi;    
+    struct fuse_dirhandle *dh = get_dirhandle(llfi, &fi);
+    if (f->op.releasedir) {
+        char *path;
+
+        pthread_rwlock_rdlock(&f->tree_lock);
+        path = get_path(f, ino);
+        f->op.releasedir(path ? path : "-", &fi);
+        free(path);
+        pthread_rwlock_unlock(&f->tree_lock);
+    }
+    pthread_mutex_lock(&dh->lock);
+    pthread_mutex_unlock(&dh->lock);
+    pthread_mutex_destroy(&dh->lock);
+    free(dh->contents);
+    free(dh);
+    reply_err(req, 0);
+}
+
+static void fuse_fsyncdir(fuse_req_t req, fuse_ino_t ino, int datasync,
+                          struct fuse_file_info *llfi)
+{
+    struct fuse *f = req_fuse_prepare(req);
+    struct fuse_file_info fi;
+    char *path;
+    int err;
+
+    get_dirhandle(llfi, &fi);
+
+    err = -ENOENT;
+    pthread_rwlock_rdlock(&f->tree_lock);
+    path = get_path(f, ino);
+    if (path != NULL) {
+        err = -ENOSYS;
+        if (f->op.fsyncdir)
+            err = f->op.fsyncdir(path, datasync, &fi);
+        free(path);
+    }
+    pthread_rwlock_unlock(&f->tree_lock);
+    reply_err(req, err);
 }
 
 static int default_statfs(struct statfs *buf)
@@ -1306,776 +1388,216 @@
     statfs->f_namelen = compatbuf->namelen;
 }
 
-static void convert_statfs(struct statfs *statfs, struct fuse_kstatfs *kstatfs)
+static void fuse_statfs(fuse_req_t req)
 {
-    kstatfs->bsize	= statfs->f_bsize;
-    kstatfs->blocks	= statfs->f_blocks;
-    kstatfs->bfree	= statfs->f_bfree;
-    kstatfs->bavail	= statfs->f_bavail;
-    kstatfs->files	= statfs->f_files;
-    kstatfs->ffree	= statfs->f_ffree;
-    kstatfs->namelen	= statfs->f_namelen;
-}
-
-static void do_statfs(struct fuse *f, struct fuse_in_header *in)
-{
-    int res;
-    struct fuse_statfs_out arg;
+    struct fuse *f = req_fuse_prepare(req);
     struct statfs buf;
+    int err;
 
     memset(&buf, 0, sizeof(struct statfs));
     if (f->op.statfs) {
         if (!f->compat || f->compat > 11)
-            res = f->op.statfs("/", &buf);
+            err = f->op.statfs("/", &buf);
         else {
             struct fuse_statfs_compat1 compatbuf;
             memset(&compatbuf, 0, sizeof(struct fuse_statfs_compat1));
-            res = ((struct fuse_operations_compat1 *) &f->op)->statfs(&compatbuf);
-            if (res == 0)
+            err = ((struct fuse_operations_compat1 *) &f->op)->statfs(&compatbuf);
+            if (!err)
                 convert_statfs_compat(&compatbuf, &buf);
         }
     }
     else
-        res = default_statfs(&buf);
+        err = default_statfs(&buf);
 
-    if (res == 0)
-        convert_statfs(&buf, &arg.st);
-
-    send_reply(f, in, res, &arg, sizeof(arg));
-}
-
-static void do_fsync(struct fuse *f, struct fuse_in_header *in,
-                     struct fuse_fsync_in *inarg)
-{
-    int res;
-    char *path;
-    struct fuse_file_info fi;
-
-    memset(&fi, 0, sizeof(fi));
-    fi.fh = inarg->fh;
-
-    res = -ENOENT;
-    pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
-    if (path != NULL) {
-        if (f->flags & FUSE_DEBUG) {
-            printf("FSYNC[%lu]\n", (unsigned long) inarg->fh);
-            fflush(stdout);
-        }
-        res = -ENOSYS;
-        if (f->op.fsync)
-            res = f->op.fsync(path, inarg->fsync_flags & 1, &fi);
-        free(path);
-    }
-    pthread_rwlock_unlock(&f->tree_lock);
-    send_reply(f, in, res, NULL, 0);
-}
-
-static void do_setxattr(struct fuse *f, struct fuse_in_header *in,
-                        struct fuse_setxattr_in *arg)
-{
-    int res;
-    char *path;
-    char *name = PARAM(arg);
-    unsigned char *value = name + strlen(name) + 1;
-
-    res = -ENOENT;
-    pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
-    if (path != NULL) {
-        res = -ENOSYS;
-        if (f->op.setxattr)
-            res = f->op.setxattr(path, name, value, arg->size, arg->flags);
-        free(path);
-    }
-    pthread_rwlock_unlock(&f->tree_lock);
-    send_reply(f, in, res, NULL, 0);
-}
-
-static int common_getxattr(struct fuse *f, struct fuse_in_header *in,
-                           const char *name, char *value, size_t size)
-{
-    int res;
-    char *path;
-
-    res = -ENOENT;
-    pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
-    if (path != NULL) {
-        res = -ENOSYS;
-        if (f->op.getxattr)
-            res = f->op.getxattr(path, name, value, size);
-        free(path);
-    }
-    pthread_rwlock_unlock(&f->tree_lock);
-    return res;
-}
-
-static void do_getxattr_read(struct fuse *f, struct fuse_in_header *in,
-                             const char *name, size_t size)
-{
-    int res;
-    char *value = (char *) malloc(size);
-    if (value == NULL) {
-        send_reply(f, in, -ENOMEM, NULL, 0);
-        return;
-    }
-    res = common_getxattr(f, in, name, value, size);
-    size = 0;
-    if (res > 0) {
-        size = res;
-        res = 0;
-    }
-    send_reply(f, in, res, value, size);
-    free(value);
-}
-
-static void do_getxattr_size(struct fuse *f, struct fuse_in_header *in,
-                             const char *name)
-{
-    int res;
-    struct fuse_getxattr_out arg;
-
-    memset(&arg, 0, sizeof(arg));
-    res = common_getxattr(f, in, name, NULL, 0);
-    if (res >= 0) {
-        arg.size = res;
-        res = 0;
-    }
-    send_reply(f, in, res, &arg, SIZEOF_COMPAT(f, fuse_getxattr_out));
-}
-
-static void do_getxattr(struct fuse *f, struct fuse_in_header *in,
-                        struct fuse_getxattr_in *arg)
-{
-    char *name = PARAM(arg);
-
-    if (arg->size)
-        do_getxattr_read(f, in, name, arg->size);
+    if (!err)
+        fuse_reply_statfs(req, &buf);
     else
-        do_getxattr_size(f, in, name);
+        reply_err(req, err);
 }
 
-static int common_listxattr(struct fuse *f, struct fuse_in_header *in,
-                            char *list, size_t size)
+static void fuse_setxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
+                          const char *value, size_t size, int flags)
 {
-    int res;
+    struct fuse *f = req_fuse_prepare(req);
     char *path;
+    int err;
 
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
+    path = get_path(f, ino);
     if (path != NULL) {
-        res = -ENOSYS;
-        if (f->op.listxattr)
-            res = f->op.listxattr(path, list, size);
-        free(path);
-    }
-    pthread_rwlock_unlock(&f->tree_lock);
-    return res;
-}
-
-static void do_listxattr_read(struct fuse *f, struct fuse_in_header *in,
-                              size_t size)
-{
-    int res;
-    char *list = (char *) malloc(size);
-    if (list == NULL) {
-        send_reply(f, in, -ENOMEM, NULL, 0);
-        return;
-    }
-    res = common_listxattr(f, in, list, size);
-    size = 0;
-    if (res > 0) {
-        size = res;
-        res = 0;
-    }
-    send_reply(f, in, res, list, size);
-    free(list);
-}
-
-static void do_listxattr_size(struct fuse *f, struct fuse_in_header *in)
-{
-    int res;
-    struct fuse_getxattr_out arg;
-
-    memset(&arg, 0, sizeof(arg));
-    res = common_listxattr(f, in, NULL, 0);
-    if (res >= 0) {
-        arg.size = res;
-        res = 0;
-    }
-    send_reply(f, in, res, &arg, SIZEOF_COMPAT(f, fuse_getxattr_out));
-}
-
-static void do_listxattr(struct fuse *f, struct fuse_in_header *in,
-                         struct fuse_getxattr_in *arg)
-{
-    if (arg->size)
-        do_listxattr_read(f, in, arg->size);
-    else
-        do_listxattr_size(f, in);
-}
-
-static void do_removexattr(struct fuse *f, struct fuse_in_header *in,
-                           char *name)
-{
-    int res;
-    char *path;
-
-    res = -ENOENT;
-    pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
-    if (path != NULL) {
-        res = -ENOSYS;
-        if (f->op.removexattr)
-            res = f->op.removexattr(path, name);
-        free(path);
-    }
-    pthread_rwlock_unlock(&f->tree_lock);
-    send_reply(f, in, res, NULL, 0);
-}
-
-static void do_init(struct fuse *f, struct fuse_in_header *in,
-                    struct fuse_init_in_out *arg)
-{
-    struct fuse_init_in_out outarg;
-
-    if (in->padding == 5) {
-        arg->minor = arg->major;
-        arg->major = in->padding;
-    }
-
-    if (f->flags & FUSE_DEBUG) {
-        printf("INIT: %u.%u\n", arg->major, arg->minor);
-        fflush(stdout);
-    }
-    f->got_init = 1;
-    if (f->op.init)
-        f->user_data = f->op.init();
-
-    if (arg->major == 5) {
-        f->major = 5;
-        f->minor = 1;
-    } else if (arg->major == 6) {
-        f->major = 6;
-        f->minor = 1;
-    } else {
-        f->major = FUSE_KERNEL_VERSION;
-        f->minor = FUSE_KERNEL_MINOR_VERSION;
-    }
-    memset(&outarg, 0, sizeof(outarg));
-    outarg.major = f->major;
-    outarg.minor = f->minor;
-
-    if (f->flags & FUSE_DEBUG) {
-        printf("   INIT: %u.%u\n", outarg.major, outarg.minor);
-        fflush(stdout);
-    }
-
-    send_reply(f, in, 0, &outarg, sizeof(outarg));
-}
-
-static struct fuse_dirhandle *get_dirhandle(unsigned long fh)
-{
-    return (struct fuse_dirhandle *) fh;
-}
-
-static void do_opendir(struct fuse *f, struct fuse_in_header *in,
-                       struct fuse_open_in *arg)
-{
-    int res;
-    struct fuse_open_out outarg;
-    struct fuse_dirhandle *dh;
-
-    dh = (struct fuse_dirhandle *) malloc(sizeof(struct fuse_dirhandle));
-    if (dh == NULL) {
-        send_reply(f, in, -ENOMEM, NULL, 0);
-        return;
-    }
-    memset(dh, 0, sizeof(struct fuse_dirhandle));
-    dh->fuse = f;
-    dh->contents = NULL;
-    dh->len = 0;
-    dh->filled = 0;
-    dh->nodeid = in->nodeid;
-    mutex_init(&dh->lock);
-
-    memset(&outarg, 0, sizeof(outarg));
-    outarg.fh = (unsigned long) dh;
-
-    if (f->op.opendir) {
-        struct fuse_file_info fi;
-        char *path;
-
-        memset(&fi, 0, sizeof(fi));
-        fi.flags = arg->flags;
-
-        res = -ENOENT;
-        pthread_rwlock_rdlock(&f->tree_lock);
-        path = get_path(f, in->nodeid);
-        if (path != NULL) {
-            res = f->op.opendir(path, &fi);
-            dh->fh = fi.fh;
-        }
-        if (res == 0) {
-            int res2;
-            pthread_mutex_lock(&f->lock);
-            res2 = send_reply(f, in, res, &outarg, SIZEOF_COMPAT(f, fuse_open_out));
-            if(res2 == -ENOENT) {
-                /* The opendir syscall was interrupted, so it must be
-                   cancelled */
-                if(f->op.releasedir)
-                    f->op.releasedir(path, &fi);
-                pthread_mutex_destroy(&dh->lock);
-                free(dh);
-            }
-            pthread_mutex_unlock(&f->lock);
-        } else {
-            send_reply(f, in, res, NULL, 0);
-            free(dh);
-        }
-        free(path);
-        pthread_rwlock_unlock(&f->tree_lock);
-    } else
-        send_reply(f, in, 0, &outarg, SIZEOF_COMPAT(f, fuse_open_out));
-}
-
-static int fill_dir_common(struct fuse_dirhandle *dh, const char *name,
-                           int type, ino_t ino, off_t off)
-{
-    unsigned namelen = strlen(name);
-    unsigned entlen;
-    unsigned entsize;
-    unsigned padlen;
-    unsigned newlen;
-    unsigned char *newptr;
-
-    if (!(dh->fuse->flags & FUSE_USE_INO)) {
-        ino = (ino_t) -1;
-        if (dh->fuse->flags & FUSE_READDIR_INO) {
-            struct node *node;
-            pthread_mutex_lock(&dh->fuse->lock);
-            node = lookup_node(dh->fuse, dh->nodeid, name);
-            if (node)
-                ino  = (ino_t) node->nodeid;
-            pthread_mutex_unlock(&dh->fuse->lock);
-        }
-    }
-
-    if (namelen > FUSE_NAME_MAX)
-        namelen = FUSE_NAME_MAX;
-    else if (!namelen) {
-        dh->error = -EIO;
-        return 1;
-    }
-
-    entlen = (dh->fuse->major == 5 ?
-              FUSE_NAME_OFFSET_COMPAT5 : FUSE_NAME_OFFSET) + namelen;
-    entsize = FUSE_DIRENT_ALIGN(entlen);
-    padlen = entsize - entlen;
-    newlen = dh->len + entsize;
-    if (off && dh->fuse->major != 5) {
-        dh->filled = 0;
-        if (newlen > dh->needlen)
-            return 1;
-    }
-
-    newptr = realloc(dh->contents, newlen);
-    if (!newptr) {
-        dh->error = -ENOMEM;
-        return 1;
-    }
-    dh->contents = newptr;
-    if (dh->fuse->major == 5) {
-        struct fuse_dirent_compat5 *dirent;
-        dirent = (struct fuse_dirent_compat5 *) (dh->contents + dh->len);
-        dirent->ino = ino;
-        dirent->namelen = namelen;
-        dirent->type = type;
-        strncpy(dirent->name, name, namelen);
-    } else {
-        struct fuse_dirent *dirent;
-        dirent = (struct fuse_dirent *) (dh->contents + dh->len);
-        dirent->ino = ino;
-        dirent->off = off ? off : newlen;
-        dirent->namelen = namelen;
-        dirent->type = type;
-        strncpy(dirent->name, name, namelen);
-    }
-    if (padlen)
-        memset(dh->contents + dh->len + entlen, 0, padlen);
-    dh->len = newlen;
-    return 0;
-}
-
-static int fill_dir(void *buf, const char *name, const struct stat *stat,
-                    off_t off)
-{
-    int type = stat ? (stat->st_mode & 0170000) >> 12 : 0;
-    ino_t ino = stat ? stat->st_ino : (ino_t) -1;
-    return fill_dir_common(buf, name, type, ino, off);
-}
-
-static int fill_dir_old(struct fuse_dirhandle *dh, const char *name, int type,
-                        ino_t ino)
-{
-    fill_dir_common(dh, name, type, ino, 0);
-    return dh->error;
-}
-
-static int readdir_fill(struct fuse *f, struct fuse_in_header *in,
-                        struct fuse_read_in *arg, struct fuse_dirhandle *dh)
-{
-    int err = -ENOENT;
-    char *path;
-    pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
-    if (path != NULL) {
-        struct fuse_file_info fi;
-
-        memset(&fi, 0, sizeof(fi));
-        fi.fh = dh->fh;
-
-        dh->len = 0;
-        dh->error = 0;
-        dh->needlen = arg->size;
-        dh->filled = 1;
         err = -ENOSYS;
-        if (f->op.readdir) {
-            off_t offset = f->major == 5 ? 0 : arg->offset;
-            err = f->op.readdir(path, dh, fill_dir, offset, &fi);
-        } else if (f->op.getdir)
-            err = f->op.getdir(path, dh, fill_dir_old);
-        if (!err)
-            err = dh->error;
-        if (err)
-            dh->filled = 0;
+        if (f->op.setxattr)
+            err = f->op.setxattr(path, name, value, size, flags);
+        free(path);
+    }
+    pthread_rwlock_unlock(&f->tree_lock);
+    reply_err(req, err);
+}
+
+static int common_getxattr(struct fuse *f, fuse_ino_t ino, const char *name,
+                           char *value, size_t size)
+{
+    int err;
+    char *path;
+
+    err = -ENOENT;
+    pthread_rwlock_rdlock(&f->tree_lock);
+    path = get_path(f, ino);
+    if (path != NULL) {
+        err = -ENOSYS;
+        if (f->op.getxattr)
+            err = f->op.getxattr(path, name, value, size);
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
     return err;
 }
 
-static void do_readdir(struct fuse *f, struct fuse_in_header *in,
-                       struct fuse_read_in *arg)
+static void fuse_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
+                        size_t size)
 {
-    int err = 0;
-    struct fuse_dirhandle *dh = get_dirhandle(arg->fh);
-    size_t size = 0;
-    unsigned char *buf = NULL;
-
-    pthread_mutex_lock(&dh->lock);
-    if (!dh->filled) {
-        err = readdir_fill(f, in, arg, dh);
-        if (err)
-            goto out;
-    }
-    if (dh->filled) {
-        if (arg->offset < dh->len) {
-            size = arg->size;
-            if (arg->offset + size > dh->len)
-                size = dh->len - arg->offset;
-            buf = dh->contents + arg->offset;
-        }
-    } else {
-        size = dh->len;
-        buf = dh->contents;
-    }
-
- out:
-    send_reply(f, in, err, buf, size);
-    pthread_mutex_unlock(&dh->lock);
-}
-
-static void do_releasedir(struct fuse *f, struct fuse_in_header *in,
-                          struct fuse_release_in *arg)
-{
-    struct fuse_dirhandle *dh = get_dirhandle(arg->fh);
-    if (f->op.releasedir) {
-        char *path;
-        struct fuse_file_info fi;
-
-        memset(&fi, 0, sizeof(fi));
-        fi.fh = dh->fh;
-
-        pthread_rwlock_rdlock(&f->tree_lock);
-        path = get_path(f, in->nodeid);
-        f->op.releasedir(path ? path : "-", &fi);
-        free(path);
-        pthread_rwlock_unlock(&f->tree_lock);
-    }
-    pthread_mutex_lock(&dh->lock);
-    pthread_mutex_unlock(&dh->lock);
-    pthread_mutex_destroy(&dh->lock);
-    free(dh->contents);
-    free(dh);
-    send_reply(f, in, 0, NULL, 0);
-}
-
-static void do_fsyncdir(struct fuse *f, struct fuse_in_header *in,
-                        struct fuse_fsync_in *inarg)
-{
+    struct fuse *f = req_fuse_prepare(req);
     int res;
+
+    if (size) {
+        char *value = (char *) malloc(size);
+        if (value == NULL) {
+            reply_err(req, -ENOMEM);
+            return;
+        }
+        res = common_getxattr(f, ino, name, value, size);
+        if (res > 0)
+            fuse_reply_buf(req, value, res);
+        else
+            reply_err(req, res);
+        free(value);
+    } else {
+        res = common_getxattr(f, ino, name, NULL, 0);
+        if (res >= 0)
+            fuse_reply_xattr(req, res);
+        else
+            reply_err(req, res);
+    }
+}
+
+static int common_listxattr(struct fuse *f, fuse_ino_t ino, char *list,
+                            size_t size)
+{
     char *path;
-    struct fuse_dirhandle *dh = get_dirhandle(inarg->fh);
-    struct fuse_file_info fi;
+    int err;
 
-    memset(&fi, 0, sizeof(fi));
-    fi.fh = dh->fh;
-
-    res = -ENOENT;
+    err = -ENOENT;
     pthread_rwlock_rdlock(&f->tree_lock);
-    path = get_path(f, in->nodeid);
+    path = get_path(f, ino);
     if (path != NULL) {
-        res = -ENOSYS;
-        if (f->op.fsyncdir)
-            res = f->op.fsyncdir(path, inarg->fsync_flags & 1, &fi);
+        err = -ENOSYS;
+        if (f->op.listxattr)
+            err = f->op.listxattr(path, list, size);
         free(path);
     }
     pthread_rwlock_unlock(&f->tree_lock);
-    send_reply(f, in, res, NULL, 0);
+    return err;
 }
 
-static void free_cmd(struct fuse_cmd *cmd)
+static void fuse_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
 {
-    free(cmd->buf);
-    free(cmd);
+    struct fuse *f = req_fuse_prepare(req);
+    int res;
+
+    if (size) {
+        char *list = (char *) malloc(size);
+        if (list == NULL) {
+            reply_err(req, -ENOMEM);
+            return;
+        }
+        res = common_listxattr(f, ino, list, size);
+        if (res > 0)
+            fuse_reply_buf(req, list, res);
+        else
+            reply_err(req, res);
+        free(list);
+    } else {
+        res = common_listxattr(f, ino, NULL, 0);
+        if (res >= 0)
+            fuse_reply_xattr(req, res);
+        else
+            reply_err(req, res);
+    }
 }
 
+static void fuse_removexattr(fuse_req_t req, fuse_ino_t ino, const char *name)
+{
+    struct fuse *f = req_fuse_prepare(req);
+    char *path;
+    int err;
+
+    err = -ENOENT;
+    pthread_rwlock_rdlock(&f->tree_lock);
+    path = get_path(f, ino);
+    if (path != NULL) {
+        err = -ENOSYS;
+        if (f->op.removexattr)
+            err = f->op.removexattr(path, name);
+        free(path);
+    }
+    pthread_rwlock_unlock(&f->tree_lock);
+    reply_err(req, err);
+}
+
+static struct fuse_ll_operations fuse_path_ops = {
+    .init = fuse_data_init,
+    .destroy = fuse_data_destroy,
+    .lookup = fuse_lookup,
+    .forget = fuse_forget,
+    .getattr = fuse_getattr,
+    .setattr = fuse_setattr,
+    .readlink = fuse_readlink,
+    .mknod = fuse_mknod,
+    .mkdir = fuse_mkdir,
+    .unlink = fuse_unlink,
+    .rmdir = fuse_rmdir,
+    .symlink = fuse_symlink,
+    .rename = fuse_rename,
+    .link = fuse_link,
+    .open = fuse_open,
+    .read = fuse_read,
+    .write = fuse_write,
+    .flush = fuse_flush,
+    .release = fuse_release,
+    .fsync = fuse_fsync,
+    .opendir = fuse_opendir,
+    .readdir = fuse_readdir,
+    .releasedir = fuse_releasedir,
+    .fsyncdir = fuse_fsyncdir,
+    .statfs = fuse_statfs,
+    .setxattr = fuse_setxattr,
+    .getxattr = fuse_getxattr,
+    .listxattr = fuse_listxattr,
+    .removexattr = fuse_removexattr,
+};
+
 void fuse_process_cmd(struct fuse *f, struct fuse_cmd *cmd)
 {
-    struct fuse_in_header *in = (struct fuse_in_header *) cmd->buf;
-    void *inarg = cmd->buf + SIZEOF_COMPAT(f, fuse_in_header);
-    struct fuse_context *ctx = fuse_get_context();
-
-    fuse_dec_avail(f);
-
-    if ((f->flags & FUSE_DEBUG)) {
-        printf("unique: %llu, opcode: %s (%i), nodeid: %lu, insize: %i\n",
-               in->unique, opname(in->opcode), in->opcode,
-               (unsigned long) in->nodeid, cmd->buflen);
-        fflush(stdout);
-    }
-
-    if (!f->got_init && in->opcode != FUSE_INIT) {
-        /* Old kernel version probably */
-        send_reply(f, in, -EPROTO, NULL, 0);
-        goto out;
-    }
-
-    if ((f->flags & FUSE_ALLOW_ROOT) && in->uid != f->owner && in->uid != 0 &&
-        in->opcode != FUSE_INIT && in->opcode != FUSE_READ &&
-        in->opcode != FUSE_WRITE && in->opcode != FUSE_FSYNC &&
-        in->opcode != FUSE_RELEASE && in->opcode != FUSE_READDIR &&
-        in->opcode != FUSE_FSYNCDIR && in->opcode != FUSE_RELEASEDIR) {
-        send_reply(f, in, -EACCES, NULL, 0);
-        goto out;
-    }
-
-    ctx->fuse = f;
-    ctx->uid = in->uid;
-    ctx->gid = in->gid;
-    ctx->pid = in->pid;
-    ctx->private_data = f->user_data;
-
-    switch (in->opcode) {
-    case FUSE_LOOKUP:
-        do_lookup(f, in, (char *) inarg);
-        break;
-
-    case FUSE_GETATTR:
-        do_getattr(f, in);
-        break;
-
-    case FUSE_SETATTR:
-        do_setattr(f, in, (struct fuse_setattr_in *) inarg);
-        break;
-
-    case FUSE_READLINK:
-        do_readlink(f, in);
-        break;
-
-    case FUSE_MKNOD:
-        do_mknod(f, in, (struct fuse_mknod_in *) inarg);
-        break;
-
-    case FUSE_MKDIR:
-        do_mkdir(f, in, (struct fuse_mkdir_in *) inarg);
-        break;
-
-    case FUSE_UNLINK:
-        do_unlink(f, in, (char *) inarg);
-        break;
-
-    case FUSE_RMDIR:
-        do_rmdir(f, in, (char *) inarg);
-        break;
-
-    case FUSE_SYMLINK:
-        do_symlink(f, in, (char *) inarg,
-                   ((char *) inarg) + strlen((char *) inarg) + 1);
-        break;
-
-    case FUSE_RENAME:
-        do_rename(f, in, (struct fuse_rename_in *) inarg);
-        break;
-
-    case FUSE_LINK:
-        do_link(f, in, (struct fuse_link_in *) inarg);
-        break;
-
-    case FUSE_OPEN:
-        do_open(f, in, (struct fuse_open_in *) inarg);
-        break;
-
-    case FUSE_FLUSH:
-        do_flush(f, in, (struct fuse_flush_in *) inarg);
-        break;
-
-    case FUSE_RELEASE:
-        do_release(f, in, (struct fuse_release_in *) inarg);
-        break;
-
-    case FUSE_READ:
-        do_read(f, in, (struct fuse_read_in *) inarg);
-        break;
-
-    case FUSE_WRITE:
-        do_write(f, in, (struct fuse_write_in *) inarg);
-        break;
-
-    case FUSE_STATFS:
-        do_statfs(f, in);
-        break;
-
-    case FUSE_FSYNC:
-        do_fsync(f, in, (struct fuse_fsync_in *) inarg);
-        break;
-
-    case FUSE_SETXATTR:
-        do_setxattr(f, in, (struct fuse_setxattr_in *) inarg);
-        break;
-
-    case FUSE_GETXATTR:
-        do_getxattr(f, in, (struct fuse_getxattr_in *) inarg);
-        break;
-
-    case FUSE_LISTXATTR:
-        do_listxattr(f, in, (struct fuse_getxattr_in *) inarg);
-        break;
-
-    case FUSE_REMOVEXATTR:
-        do_removexattr(f, in, (char *) inarg);
-        break;
-
-    case FUSE_INIT:
-        do_init(f, in, (struct fuse_init_in_out *) inarg);
-        break;
-
-    case FUSE_OPENDIR:
-        do_opendir(f, in, (struct fuse_open_in *) inarg);
-        break;
-
-    case FUSE_READDIR:
-        do_readdir(f, in, (struct fuse_read_in *) inarg);
-        break;
-
-    case FUSE_RELEASEDIR:
-        do_releasedir(f, in, (struct fuse_release_in *) inarg);
-        break;
-
-    case FUSE_FSYNCDIR:
-        do_fsyncdir(f, in, (struct fuse_fsync_in *) inarg);
-        break;
-
-    default:
-        send_reply(f, in, -ENOSYS, NULL, 0);
-    }
-
- out:
-    free_cmd(cmd);
+    fuse_ll_process_cmd(f->fll, cmd);
 }
 
-int fuse_exited(struct fuse* f)
+int fuse_exited(struct fuse *f)
 {
-    return f->exited;
+    return fuse_ll_exited(f->fll);
 }
 
 struct fuse_cmd *fuse_read_cmd(struct fuse *f)
 {
-    ssize_t res;
-    struct fuse_cmd *cmd;
-    struct fuse_in_header *in;
-    void *inarg;
-
-    cmd = (struct fuse_cmd *) malloc(sizeof(struct fuse_cmd));
-    if (cmd == NULL) {
-        fprintf(stderr, "fuse: failed to allocate cmd in read\n");
-        return NULL;
-    }
-    cmd->buf = (char *) malloc(FUSE_MAX_IN);
-    if (cmd->buf == NULL) {
-        fprintf(stderr, "fuse: failed to allocate read buffer\n");
-        free(cmd);
-        return NULL;
-    }
-    in = (struct fuse_in_header *) cmd->buf;
-    inarg = cmd->buf + SIZEOF_COMPAT(f, fuse_in_header);
-
-    res = read(f->fd, cmd->buf, FUSE_MAX_IN);
-    if (res == -1) {
-        free_cmd(cmd);
-        if (fuse_exited(f) || errno == EINTR || errno == ENOENT)
-            return NULL;
-
-        /* ENODEV means we got unmounted, so we silenty return failure */
-        if (errno != ENODEV) {
-            /* BAD... This will happen again */
-            perror("fuse: reading device");
-        }
-
-        fuse_exit(f);
-        return NULL;
-    }
-    if ((size_t) res < SIZEOF_COMPAT(f, fuse_in_header)) {
-        free_cmd(cmd);
-        /* Cannot happen */
-        fprintf(stderr, "short read on fuse device\n");
-        fuse_exit(f);
-        return NULL;
-    }
-    cmd->buflen = res;
-
-    /* Forget is special, it can be done without messing with threads. */
-    if (in->opcode == FUSE_FORGET) {
-        do_forget(f, in, (struct fuse_forget_in *) inarg);
-        free_cmd(cmd);
-        return NULL;
-    }
-
-    return cmd;
+    return fuse_ll_read_cmd(f->fll);
 }
 
 int fuse_loop(struct fuse *f)
 {
-    if (f == NULL)
+    if (f)
+        return fuse_ll_loop(f->fll);
+    else
         return -1;
-
-    while (1) {
-        struct fuse_cmd *cmd;
-
-        if (fuse_exited(f))
-            break;
-
-        cmd = fuse_read_cmd(f);
-        if (cmd == NULL)
-            continue;
-
-        fuse_process_cmd(f, cmd);
-    }
-    f->exited = 0;
-    return 0;
 }
 
 int fuse_invalidate(struct fuse *f, const char *path)
@@ -2087,7 +1609,7 @@
 
 void fuse_exit(struct fuse *f)
 {
-    f->exited = 1;
+    fuse_ll_exit(f->fll);
 }
 
 struct fuse_context *fuse_get_context()
@@ -2114,7 +1636,8 @@
 
 int fuse_is_lib_option(const char *opt)
 {
-    if (strcmp(opt, "debug") == 0 ||
+    if (fuse_ll_is_lib_option(opt) ||
+        strcmp(opt, "debug") == 0 ||
         strcmp(opt, "hard_remove") == 0 ||
         strcmp(opt, "use_ino") == 0 ||
         strcmp(opt, "allow_root") == 0 ||
@@ -2127,12 +1650,13 @@
         return 0;
 }
 
-static int parse_lib_opts(struct fuse *f, const char *opts)
+static int parse_lib_opts(struct fuse *f, const char *opts, char **llopts)
 {
     if (opts) {
         char *xopts = strdup(opts);
         char *s = xopts;
         char *opt;
+        char *d = xopts;
 
         if (xopts == NULL) {
             fprintf(stderr, "fuse: memory allocation failed\n");
@@ -2140,14 +1664,17 @@
         }
 
         while((opt = strsep(&s, ","))) {
-            if (strcmp(opt, "debug") == 0)
-                f->flags |= FUSE_DEBUG;
-            else if (strcmp(opt, "hard_remove") == 0)
+            if (fuse_ll_is_lib_option(opt)) {
+                size_t optlen = strlen(opt);
+                if (strcmp(opt, "debug") == 0)
+                    f->flags |= FUSE_DEBUG;                
+                memmove(d, opt, optlen);
+                d += optlen;
+                *d++ = ',';
+            } else if (strcmp(opt, "hard_remove") == 0)
                 f->flags |= FUSE_HARD_REMOVE;
             else if (strcmp(opt, "use_ino") == 0)
                 f->flags |= FUSE_USE_INO;
-            else if (strcmp(opt, "allow_root") == 0)
-                f->flags |= FUSE_ALLOW_ROOT;
             else if (strcmp(opt, "readdir_ino") == 0)
                 f->flags |= FUSE_READDIR_INO;
             else if (sscanf(opt, "umask=%o", &f->umask) == 1)
@@ -2159,7 +1686,12 @@
             else
                 fprintf(stderr, "fuse: warning: unknown option `%s'\n", opt);
         }
-        free(xopts);
+        if (d != xopts) {
+            d[-1] = '\0';
+            *llopts = xopts;
+        }
+        else
+            free(xopts);
     }
     return 0;
 }
@@ -2170,6 +1702,7 @@
 {
     struct fuse *f;
     struct node *root;
+    char *llopts = NULL;
 
     if (sizeof(struct fuse_operations) < op_size) {
         fprintf(stderr, "fuse: warning: library too old, some operations may not not work\n");
@@ -2182,10 +1715,14 @@
         goto out;
     }
 
-    if (parse_lib_opts(f, opts) == -1)
+    if (parse_lib_opts(f, opts, &llopts) == -1)
         goto out_free;
 
-    f->fd = fd;
+    f->fll = fuse_ll_new(fd, llopts, &fuse_path_ops, sizeof(fuse_path_ops), f);
+    free(llopts);
+    if (f->fll == NULL)
+        goto out_free;
+
     f->ctr = 0;
     f->generation = 0;
     /* FIXME: Dynamic hash table */
@@ -2206,12 +1743,8 @@
     }
 
     mutex_init(&f->lock);
-    mutex_init(&f->worker_lock);
-    f->numworker = 0;
-    f->numavail = 0;
     memcpy(&f->op, op, op_size);
     f->compat = compat;
-    f->exited = 0;
 
     root = (struct node *) calloc(1, sizeof(struct node));
     if (root == NULL) {
@@ -2232,8 +1765,6 @@
     root->nlookup = 1;
     hash_id(f, root);
 
-    f->owner = getuid();
-
     return f;
 
  out_free_root:
@@ -2299,9 +1830,7 @@
     free(f->id_table);
     free(f->name_table);
     pthread_mutex_destroy(&f->lock);
-    pthread_mutex_destroy(&f->worker_lock);
-    if (f->op.destroy)
-        f->op.destroy(f->user_data);
+    fuse_ll_destroy(f->fll);
     free(f);
 }