2.2.6

* malloc and track thread_local buffers from js to avoid crashes when multiple external buffers are made from the same pointer

* make tests pass on 14.3.0

* disable npm cache

* debug log

* detach array buffer on read free as a test

* fix detatch

* detach arraybuffer asap, to avoid crashes

* reset test

* add secure travis key

* missing arraybuffer pass

* bump all the flags

* no linux 32

.travis.yml

@@ -33,5 +33,19 @@ before_deploy:
 - ARCHIVE_NAME="${TRAVIS_TAG:-latest}-$TRAVIS_OS_NAME.tar"
 - npm run prebuild
 - if [[ "$TRAVIS_OS_NAME" == "windows" ]]; then PREBUILD_ARCH=ia32 npm run prebuild; fi
-- if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then PREBUILD_ARCH=ia32 npm run prebuild; fi
 - cd prebuilds && tar cvf "../$ARCHIVE_NAME" . && cd ..
+
+cache:
+  npm: false
+
+deploy:
+  provider: releases
+  draft: false
+  prerelease: true
+  api_key:
+    secure: "KPn3xR4LWcg/H259aSZh26XX0eapR88xSNUkBmEri/sCJSyZ0+asLZSv/HDD3KJP4HeuIKsQc0v8fcebD83fkvaSvlUzSppMQgniwuGC1cAefbrgZDwmJJ/n+lE8Wr9x4adOBTgICS5Uc8LlZ1PuJGm4mmequVs29BEw9738LzN4+3NpoCoWd0FAgGF0tDTsaYL1tJqERAyNIxHS+adUPe0F2r0d2UJ7mOrW7s8Ai6e6QryFsFvA2m0Xn/pQmNO/mcq+LPcw57pWuI3Hm3Cu3W8VPJXYp/yJaFqTAn3D9Fwz4tkmbfmca4ETwZYOS3lvL/rjLQ+69SJlRRu/QfPECkZven+wwsLX/DmyGHgEWqeGWjKj/NxYOIKUKEZZCVrF8cy4j9mac+LK6bAeDZERKSxUJ9GT5WsjvV3RNKgp3MZF7mtmj4IWXfgcuwFX49oIqhzSJsucBBXlB74J7Qua5VJPEAo/7X7Q+Y9IT9JHwxXsXVF5ZNj1PMlJicVD6oKi4XCFOVxSE9wdzlBwMOlUyBGhAIzS6lmxHOELYO9C7l8t/8Zvi4a+YGvOwn0dzLb9zuA1bzqJmEB1fkQMZXHvcEY1o5jSTQ0cNn1Wx4Ck9zyLyhnZ5KRXKzGQ1du55iVOThcbl/8j6zT218SiZMMtv8ZwPy4pJt4skMGsoOZtYlE="
+  file: "$ARCHIVE_NAME"
+  skip_cleanup: true
+  on:
+    tags: true
+    node: 'node'

README.md

@@ -1,5 +1,5 @@
 # fuse-native
-[![Build Status](https://travis-ci.com/fuse-friends/fuse-native.svg?branch=master)](https://travis-ci.com/fuse-friends/fuse-native)
+[![Build Status](https://travis-ci.org/fuse-friends/fuse-native.svg?branch=master)](https://travis-ci.org/fuse-friends/fuse-native)
 
 Multithreaded FUSE bindings for Node JS.
 

binding.gyp

@@ -11,7 +11,18 @@
     "sources": [
       "fuse-native.c"
     ],
-    "cflags": ["-rdynamic"]
+    'xcode_settings': {
+      'OTHER_CFLAGS': [
+        '-g',
+        '-O3',
+        '-Wall'
+      ]
+    },
+    'cflags': [
+      '-g',
+      '-O3',
+      '-Wall'
+    ],
   }, {
     "target_name": "postinstall",
     "type": "none",

fuse-native.c

@@ -18,6 +18,10 @@
 #include <sys/wait.h>
 #include <pthread.h>
 
+static int IS_ARRAY_BUFFER_DETACH_SUPPORTED = 0;
+
+napi_status napi_detach_arraybuffer(napi_env env, napi_value buf);
+
 #define FUSE_NATIVE_CALLBACK(fn, blk)\
   napi_env env = ft->env;\
   napi_handle_scope scope;\
@@ -43,7 +47,7 @@
     uint32_t op = op_##name;\
     FUSE_NATIVE_CALLBACK(ft->handlers[op], {\
       napi_value argv[callbackArgs + 2];\
-      napi_create_external_buffer(env, sizeof(fuse_thread_locals_t), l, &fin, NULL, &(argv[0]));\
+      napi_get_reference_value(env, l->self, &(argv[0]));\
       napi_create_uint32(env, l->op, &(argv[1]));\
       callbackBlk\
       NAPI_MAKE_CALLBACK(env, NULL, ctx, callback, callbackArgs + 2, argv, NULL)\
@@ -116,6 +120,7 @@ typedef struct {
   pthread_t thread;
   pthread_attr_t attr;
   napi_ref ctx;
+  napi_ref malloc;
 
   // Operation handlers
   napi_ref handlers[35];
@@ -132,6 +137,8 @@ typedef struct {
 } fuse_thread_t;
 
 typedef struct {
+  napi_ref self;
+
   // Opcode
   uint32_t op;
   void *op_fn;
@@ -175,15 +182,11 @@ typedef struct {
 } fuse_thread_locals_t;
 
 static pthread_key_t thread_locals_key;
-static fuse_thread_locals_t* get_thread_locals ();
+static fuse_thread_locals_t* get_thread_locals();
 
 // Helpers
 // TODO: Extract into a separate file.
 
-static void fin (napi_env env, void *fin_data, void* fin_hint) {
-  // noop
-}
-
 static uint64_t uint32s_to_uint64 (uint32_t **ints) {
   uint64_t low = *((*ints)++);
   uint64_t high = *((*ints)++);
@@ -367,7 +370,7 @@ FUSE_METHOD_VOID(releasedir, 2, 0, (const char *path, struct fuse_file_info *inf
   }
 })
 
-FUSE_METHOD(read, 6, 1, (const char *path, char *buf, size_t len, off_t offset, struct fuse_file_info *info), {
+FUSE_METHOD(read, 6, 2, (const char *path, char *buf, size_t len, off_t offset, struct fuse_file_info *info), {
   l->path = path;
   l->buf = buf;
   l->len = len;
@@ -376,14 +379,14 @@ FUSE_METHOD(read, 6, 1, (const char *path, char *buf, size_t len, off_t offset,
 }, {
   napi_create_string_utf8(env, l->path, NAPI_AUTO_LENGTH, &(argv[2]));
   napi_create_uint32(env, l->info->fh, &(argv[3]));
-  napi_create_external_buffer(env, l->len, (char *) l->buf, &fin, NULL, &(argv[4]));
+  napi_create_external_buffer(env, l->len, (char *) l->buf, NULL, NULL, &(argv[4]));
   napi_create_uint32(env, l->len, &(argv[5]));
   FUSE_UINT64_TO_INTS_ARGV(l->offset, 6)
 }, {
-  // TODO: handle bytes processed?
+  if (IS_ARRAY_BUFFER_DETACH_SUPPORTED == 1) assert(napi_detach_arraybuffer(env, argv[3]) == napi_ok);
 })
 
-FUSE_METHOD(write, 6, 1, (const char *path, const char *buf, size_t len, off_t offset, struct fuse_file_info *info), {
+FUSE_METHOD(write, 6, 2, (const char *path, const char *buf, size_t len, off_t offset, struct fuse_file_info *info), {
   l->path = path;
   l->buf = buf;
   l->len = len;
@@ -392,11 +395,11 @@ FUSE_METHOD(write, 6, 1, (const char *path, const char *buf, size_t len, off_t o
 }, {
   napi_create_string_utf8(env, l->path, NAPI_AUTO_LENGTH, &(argv[2]));
   napi_create_uint32(env, l->info->fh, &(argv[3]));
-  napi_create_external_buffer(env, l->len, (char *) l->buf, &fin, NULL, &(argv[4]));
+  napi_create_external_buffer(env, l->len, (char *) l->buf, NULL, NULL, &(argv[4]));
   napi_create_uint32(env, l->len, &(argv[5]));
   FUSE_UINT64_TO_INTS_ARGV(l->offset, 6)
 }, {
-  // TODO: handle bytes processed?
+  if (IS_ARRAY_BUFFER_DETACH_SUPPORTED == 1) assert(napi_detach_arraybuffer(env, argv[3]) == napi_ok);
 })
 
 FUSE_METHOD(readdir, 1, 2, (const char *path, void *buf, fuse_fill_dir_t filler, off_t offset, struct fuse_file_info *info), {
@@ -446,7 +449,7 @@ FUSE_METHOD(readdir, 1, 2, (const char *path, void *buf, fuse_fill_dir_t filler,
 
 #ifdef __APPLE__
 
-FUSE_METHOD_VOID(setxattr, 5, 0, (const char *path, const char *name, const char *value, size_t size, int flags, uint32_t position), {
+FUSE_METHOD(setxattr, 5, 1, (const char *path, const char *name, const char *value, size_t size, int flags, uint32_t position), {
   l->path = path;
   l->name = name;
   l->value = value;
@@ -456,12 +459,14 @@ FUSE_METHOD_VOID(setxattr, 5, 0, (const char *path, const char *name, const char
 }, {
   napi_create_string_utf8(env, l->path, NAPI_AUTO_LENGTH, &(argv[2]));
   napi_create_string_utf8(env, l->name, NAPI_AUTO_LENGTH, &(argv[3]));
-  napi_create_external_buffer(env, l->size, (char *) l->value, &fin, NULL, &(argv[4]));
+  napi_create_external_buffer(env, l->size, (char *) l->value, NULL, NULL, &(argv[4]));
   napi_create_uint32(env, l->position, &(argv[5]));
   napi_create_uint32(env, l->flags, &(argv[6]));
+}, {
+  if (IS_ARRAY_BUFFER_DETACH_SUPPORTED == 1) assert(napi_detach_arraybuffer(env, argv[2]) == napi_ok);
 })
 
-FUSE_METHOD_VOID(getxattr, 4, 0, (const char *path, const char *name, char *value, size_t size, uint32_t position), {
+FUSE_METHOD(getxattr, 4, 1, (const char *path, const char *name, char *value, size_t size, uint32_t position), {
   l->path = path;
   l->name = name;
   l->value = value;
@@ -470,13 +475,15 @@ FUSE_METHOD_VOID(getxattr, 4, 0, (const char *path, const char *name, char *valu
 }, {
   napi_create_string_utf8(env, l->path, NAPI_AUTO_LENGTH, &(argv[2]));
   napi_create_string_utf8(env, l->name, NAPI_AUTO_LENGTH, &(argv[3]));
-  napi_create_external_buffer(env, l->size, (char *) l->value, &fin, NULL, &(argv[4]));
+  napi_create_external_buffer(env, l->size, (char *) l->value, NULL, NULL, &(argv[4]));
   napi_create_uint32(env, l->position, &(argv[5]));
+}, {
+  if (IS_ARRAY_BUFFER_DETACH_SUPPORTED == 1) assert(napi_detach_arraybuffer(env, argv[2]) == napi_ok);
 })
 
 #else
 
-FUSE_METHOD_VOID(setxattr, 5, 0, (const char *path, const char *name, const char *value, size_t size, int flags), {
+FUSE_METHOD(setxattr, 5, 1, (const char *path, const char *name, const char *value, size_t size, int flags), {
   l->path = path;
   l->name = name;
   l->value = value;
@@ -485,12 +492,14 @@ FUSE_METHOD_VOID(setxattr, 5, 0, (const char *path, const char *name, const char
 }, {
   napi_create_string_utf8(env, l->path, NAPI_AUTO_LENGTH, &(argv[2]));
   napi_create_string_utf8(env, l->name, NAPI_AUTO_LENGTH, &(argv[3]));
-  napi_create_external_buffer(env, l->size, (char *) l->value, &fin, NULL, &(argv[4]));
+  napi_create_external_buffer(env, l->size, (char *) l->value, NULL, NULL, &(argv[4]));
   napi_create_uint32(env, 0, &(argv[5])); // normalize apis between mac and linux
   napi_create_uint32(env, l->flags, &(argv[6]));
+}, {
+  if (IS_ARRAY_BUFFER_DETACH_SUPPORTED == 1) assert(napi_detach_arraybuffer(env, argv[2]) == napi_ok);
 })
 
-FUSE_METHOD_VOID(getxattr, 4, 0, (const char *path, const char *name, char *value, size_t size), {
+FUSE_METHOD(getxattr, 4, 1, (const char *path, const char *name, char *value, size_t size), {
   l->path = path;
   l->name = name;
   l->value = value;
@@ -498,19 +507,23 @@ FUSE_METHOD_VOID(getxattr, 4, 0, (const char *path, const char *name, char *valu
 }, {
   napi_create_string_utf8(env, l->path, NAPI_AUTO_LENGTH, &(argv[2]));
   napi_create_string_utf8(env, l->name, NAPI_AUTO_LENGTH, &(argv[3]));
-  napi_create_external_buffer(env, l->size, (char *) l->value, &fin, NULL, &(argv[4]));
+  napi_create_external_buffer(env, l->size, (char *) l->value, NULL, NULL, &(argv[4]));
   napi_create_uint32(env, 0, &(argv[5]));
+}, {
+  if (IS_ARRAY_BUFFER_DETACH_SUPPORTED == 1) assert(napi_detach_arraybuffer(env, argv[2]) == napi_ok);
 })
 
 #endif
 
-FUSE_METHOD_VOID(listxattr, 2, 0, (const char *path, char *list, size_t size), {
+FUSE_METHOD(listxattr, 2, 1, (const char *path, char *list, size_t size), {
   l->path = path;
   l->list = list;
   l->size = size;
 }, {
   napi_create_string_utf8(env, l->path, NAPI_AUTO_LENGTH, &(argv[2]));
-  napi_create_external_buffer(env, l->size, l->list, &fin, NULL, &(argv[3]));
+  napi_create_external_buffer(env, l->size, l->list, NULL, NULL, &(argv[3]));
+}, {
+  if (IS_ARRAY_BUFFER_DETACH_SUPPORTED == 1) assert(napi_detach_arraybuffer(env, argv[2]) == napi_ok);
 })
 
 FUSE_METHOD_VOID(removexattr, 2, 0, (const char *path, const char *name), {
@@ -670,8 +683,10 @@ FUSE_METHOD_VOID(rmdir, 1, 0, (const char *path), {
 static void fuse_native_dispatch_init (uv_async_t* handle, fuse_thread_locals_t* l, fuse_thread_t* ft) {\
   FUSE_NATIVE_CALLBACK(ft->handlers[op_init], {
     napi_value argv[2];
-    napi_create_external_buffer(env, sizeof(fuse_thread_locals_t), l, &fin, NULL, &(argv[0]));
+
+    napi_get_reference_value(env, l->self, &(argv[0]));
     napi_create_uint32(env, l->op, &(argv[1]));
+
     NAPI_MAKE_CALLBACK(env, NULL, ctx, callback, 2, argv, NULL);
   })
 }
@@ -687,10 +702,13 @@ NAPI_METHOD(fuse_native_signal_init) {
 
 static void * fuse_native_init (struct fuse_conn_info *conn) {
   fuse_thread_locals_t *l = get_thread_locals();
+
   l->op = op_init;
   l->op_fn = fuse_native_dispatch_init;
+
   uv_async_send(&(l->async));
   uv_sem_wait(&(l->sem));
+
   return l->fuse;
 }
 
@@ -700,12 +718,27 @@ static void fuse_native_dispatch (uv_async_t* handle) {
   fuse_thread_locals_t *l = (fuse_thread_locals_t *) handle->data;
   fuse_thread_t *ft = l->fuse;
   void (*fn)(uv_async_t *, fuse_thread_locals_t *, fuse_thread_t *) = l->op_fn;
+
   fn(handle, l, ft);
 }
 
 static void fuse_native_async_init (uv_async_t* handle) {
-  fuse_thread_locals_t *l = (fuse_thread_locals_t *) handle->data;
-  fuse_thread_t *ft = l->fuse;
+  fuse_thread_t *ft = (fuse_thread_t *) handle->data;
+  fuse_thread_locals_t *l;
+
+  FUSE_NATIVE_CALLBACK(ft->malloc, {
+    napi_value argv[1];
+    napi_create_uint32(ft->env, (uint32_t) sizeof(fuse_thread_locals_t), &(argv[0]));
+
+    napi_value buf;
+    NAPI_MAKE_CALLBACK(ft->env, NULL, ctx, callback, 1, argv, &buf);
+
+    size_t l_len;
+
+    napi_get_buffer_info(env, buf, (void **) &l, &l_len);
+    napi_create_reference(env, buf, 1, &(l->self));
+  })
+
 
   int err = uv_async_init(uv_default_loop(), &(l->async), (uv_async_cb) fuse_native_dispatch);
   assert(err >= 0);
@@ -714,6 +747,8 @@ static void fuse_native_async_init (uv_async_t* handle) {
 
   uv_sem_init(&(l->sem), 0);
   l->async.data = l;
+  ft->async.data = l;
+  l->fuse = ft;
 
   uv_sem_post(&(ft->sem));
 }
@@ -725,21 +760,18 @@ static fuse_thread_locals_t* get_thread_locals () {
   void *data = pthread_getspecific(thread_locals_key);
 
   if (data != NULL) {
-    return (fuse_thread_locals_t *)data;
+    return (fuse_thread_locals_t *) data;
   }
 
-  fuse_thread_locals_t* l = (fuse_thread_locals_t *) malloc(sizeof(fuse_thread_locals_t));
-  l->fuse = ft;
-
   // Need to lock the mutation of l->async.
   uv_mutex_lock(&(ft->mut));
-  ft->async.data = l;
+  ft->async.data = ft;
 
   // Notify the main thread to uv_async_init l->async.
   uv_async_send(&(ft->async));
   uv_sem_wait(&(ft->sem));
 
-  l->async.data = l;
+  fuse_thread_locals_t *l = (fuse_thread_locals_t*) ft->async.data;
 
   pthread_setspecific(thread_locals_key, (void *) l);
   uv_mutex_unlock(&(ft->mut));
@@ -759,14 +791,15 @@ static void* start_fuse_thread (void *data) {
 }
 
 NAPI_METHOD(fuse_native_mount) {
-  NAPI_ARGV(6)
+  NAPI_ARGV(7)
 
   NAPI_ARGV_UTF8(mnt, 1024, 0);
   NAPI_ARGV_UTF8(mntopts, 1024, 1);
   NAPI_ARGV_BUFFER_CAST(fuse_thread_t *, ft, 2);
   napi_create_reference(env, argv[3], 1, &(ft->ctx));
-  napi_value handlers = argv[4];
-  NAPI_ARGV_BUFFER_CAST(uint32_t *, implemented, 5)
+  napi_create_reference(env, argv[4], 1, &(ft->malloc));
+  napi_value handlers = argv[5];
+  NAPI_ARGV_BUFFER_CAST(uint32_t *, implemented, 6)
 
   for (int i = 0; i < 35; i++) {
     ft->handlers[i] = NULL;
@@ -869,6 +902,13 @@ NAPI_METHOD(fuse_native_unmount) {
 }
 
 NAPI_INIT() {
+  const napi_node_version* version;
+  assert(napi_get_node_version(env, &version) == napi_ok);
+
+  if (version->major > 12 || (version->major == 12 && version->minor >= 16)) {
+    IS_ARRAY_BUFFER_DETACH_SUPPORTED = 1;
+  }
+
   pthread_key_create(&(thread_locals_key), NULL); // TODO: add destructor
 
   NAPI_EXPORT_SIZEOF(fuse_thread_t)

index.js

@@ -12,8 +12,7 @@ const IS_OSX = os.platform() === 'darwin'
 const OSX_FOLDER_ICON = '/System/Library/CoreServices/CoreTypes.bundle/Contents/Resources/GenericFolderIcon.icns'
 const HAS_FOLDER_ICON = IS_OSX && fs.existsSync(OSX_FOLDER_ICON)
 const DEFAULT_TIMEOUT = 15 * 1000
-const TIMEOUT_ERRNO = IS_OSX ? -110 : -60
-
+const TIMEOUT_ERRNO = IS_OSX ? -60 : -110
 const ENOTCONN = IS_OSX ? -57 : -107
 
 const OpcodesAndDefaults = new Map([
@@ -139,12 +138,13 @@ class Fuse extends Nanoresource {
     this.opts = opts
     this.mnt = path.resolve(mnt)
     this.ops = ops
-    this.timeout = opts.timeout || DEFAULT_TIMEOUT
+    this.timeout = opts.timeout === false ? 0 : (opts.timeout || DEFAULT_TIMEOUT)
 
     this._force = !!opts.force
     this._mkdir = !!opts.mkdir
     this._thread = null
     this._handlers = this._makeHandlerArray()
+    this._threads = new Set()
 
     const implemented = [binding.op_init, binding.op_error, binding.op_getattr]
     if (ops) {
@@ -201,10 +201,15 @@ class Fuse extends Nanoresource {
     return options.length ? '-o' + options.join(',') : ''
   }
 
+  _malloc (size) {
+    const buf = Buffer.alloc(size)
+    this._threads.add(buf)
+    return buf
+  }
+
   _makeHandlerArray () {
     const self = this
     const handlers = new Array(OpcodesAndDefaults.size)
-    const to = this.timeout || DEFAULT_TIMEOUT
 
     for (const [name, { op, defaults }] of OpcodesAndDefaults) {
       const nativeSignal = binding[`fuse_native_signal_${name}`]
@@ -216,8 +221,17 @@ class Fuse extends Nanoresource {
     return handlers
 
     function makeHandler (name, op, defaults, nativeSignal) {
+      let to = self.timeout
+      if (typeof to === 'object' && to) {
+        const defaultTimeout = to.default || DEFAULT_TIMEOUT
+        to = to[name]
+        if (!to && to !== false) to = defaultTimeout
+      }
+
       return function (nativeHandler, opCode, ...args) {
-        const boundSignal = autoTimeout(signal.bind(null, nativeHandler))
+        const sig = signal.bind(null, nativeHandler)
+        const input = [...args]
+        const boundSignal = to ? autoTimeout(sig, input) : sig
         const funcName = `_op_${name}`
         if (!self[funcName] || !self._implemented.has(op)) return boundSignal(-1, ...defaults)
         return self[funcName].apply(self, [boundSignal, ...args])
@@ -225,24 +239,42 @@ class Fuse extends Nanoresource {
 
       function signal (nativeHandler, err, ...args) {
         var arr = [nativeHandler, err, ...args]
+
         if (defaults) {
           while (arr.length > 2 && arr[arr.length - 1] === undefined) arr.pop()
           if (arr.length === 2) arr = arr.concat(defaults)
         }
+
         return process.nextTick(nativeSignal, ...arr)
       }
-    }
 
-    function autoTimeout (cb) {
-      let called = false
-      const timeout = setTimeout(timeoutWrap, to, TIMEOUT_ERRNO)
-      return timeoutWrap
+      function autoTimeout (cb, input) {
+        let called = false
+        const timeout = setTimeout(timeoutWrap, to, TIMEOUT_ERRNO)
+        return timeoutWrap
 
-      function timeoutWrap (...args) {
-        if (called) return
-        called = true
-        clearTimeout(timeout)
-        cb(...args)
+        function timeoutWrap (err, ...args) {
+          if (called) return
+          called = true
+
+          clearTimeout(timeout)
+
+          if (err === TIMEOUT_ERRNO) {
+            switch (name) {
+              case 'write':
+              case 'read':
+                return cb(TIMEOUT_ERRNO, 0, input[2].buffer)
+              case 'setxattr':
+                return cb(TIMEOUT_ERRNO, input[2].buffer)
+              case 'getxattr':
+                return cb(TIMEOUT_ERRNO, input[2].buffer)
+              case 'listxattr':
+                return cb(TIMEOUT_ERRNO, input[1].buffer)
+            }
+          }
+
+          cb(err, ...args)
+        }
       }
     }
   }
@@ -251,7 +283,7 @@ class Fuse extends Nanoresource {
 
   static unmount (mnt, cb) {
     mnt = JSON.stringify(mnt)
-    const cmd = IS_OSX ? `diskutil umount ${mnt}` : `fusermount -uz ${mnt}`
+    const cmd = IS_OSX ? `diskutil unmount force ${mnt}` : `fusermount -uz ${mnt}`
     exec(cmd, err => {
       if (err) return cb(err)
       return cb(null)
@@ -302,7 +334,7 @@ class Fuse extends Nanoresource {
           if (parent && parent.dev !== stat.dev) return cb(new Error('Mountpoint in use'))
           try {
             // TODO: asyncify
-            binding.fuse_native_mount(self.mnt, opts, self._thread, self, self._handlers, implemented)
+            binding.fuse_native_mount(self.mnt, opts, self._thread, self, self._malloc, self._handlers, implemented)
           } catch (err) {
             return cb(err)
           }
@@ -314,8 +346,11 @@ class Fuse extends Nanoresource {
   _close (cb) {
     const self = this
 
-    Fuse.unmount(this.mnt, () => {
-      // Even if the unmount command fails, do the native unmount.
+    Fuse.unmount(this.mnt, err => {
+      if (err) {
+        err.unmountFailure = true
+        return cb(err)
+      }
       nativeUnmount()
     })
 
@@ -372,6 +407,7 @@ class Fuse extends Nanoresource {
       }
       return
     }
+
     this.ops.getattr(path, (err, stat) => {
       if (err) return signal(err, getStatArray())
       return signal(0, getStatArray(stat))
@@ -439,13 +475,13 @@ class Fuse extends Nanoresource {
 
   _op_read (signal, path, fd, buf, len, offsetLow, offsetHigh) {
     this.ops.read(path, fd, buf, len, getDoubleArg(offsetLow, offsetHigh), (err, bytesRead) => {
-      return signal(err, bytesRead)
+      return signal(err, bytesRead || 0, buf.buffer)
     })
   }
 
   _op_write (signal, path, fd, buf, len, offsetLow, offsetHigh) {
     this.ops.write(path, fd, buf, len, getDoubleArg(offsetLow, offsetHigh), (err, bytesWritten) => {
-      return signal(err, bytesWritten)
+      return signal(err, bytesWritten || 0, buf.buffer)
     })
   }
 
@@ -459,18 +495,18 @@ class Fuse extends Nanoresource {
 
   _op_setxattr (signal, path, name, value, position, flags) {
     this.ops.setxattr(path, name, value, position, flags, err => {
-      return signal(err)
+      return signal(err, value.buffer)
     })
   }
 
   _op_getxattr (signal, path, name, valueBuf, position) {
     this.ops.getxattr(path, name, position, (err, value) => {
       if (!err) {
-        if (!value) return signal(IS_OSX ? -93 : -61)
+        if (!value) return signal(IS_OSX ? -93 : -61, valueBuf.buffer)
         value.copy(valueBuf)
-        return signal(value.length)
+        return signal(value.length, valueBuf.buffer)
       }
-      return signal(err)
+      return signal(err, valueBuf.buffer)
     })
   }
 
@@ -481,7 +517,7 @@ class Fuse extends Nanoresource {
           let size = 0
           for (const name of list) size += Buffer.byteLength(name) + 1
           size += 128 // fuse yells if we do not signal room for some mac stuff also
-          return signal(size)
+          return signal(size, listBuf.buffer)
         }
 
         let ptr = 0
@@ -491,9 +527,9 @@ class Fuse extends Nanoresource {
           listBuf[ptr++] = 0
         }
 
-        return signal(ptr)
+        return signal(ptr, listBuf.buffer)
       }
-      return signal(err)
+      return signal(err, listBuf.buffer)
     })
   }
 
@@ -503,8 +539,8 @@ class Fuse extends Nanoresource {
     })
   }
 
-  _op_flush (signal, path, datasync, fd) {
-    this.ops.flush(path, datasync, fd, err => {
+  _op_flush (signal, path, fd) {
+    this.ops.flush(path, fd, err => {
       return signal(err)
     })
   }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "fuse-native",
-  "version": "2.1.1",
+  "version": "2.2.6",
   "description": "Fully maintained fuse bindings for Node that aims to cover the entire FUSE api",
   "main": "index.js",
   "bin": {

test/fixtures/simple-fs.js

@@ -0,0 +1,34 @@
+const stat = require('./stat')
+const Fuse = require('../../')
+
+module.exports = function (tests = {}) {
+  return {
+    readdir: function (path, cb) {
+      if (tests.readdir) tests.readdir(path)
+      if (path === '/') return process.nextTick(cb, null, ['test'])
+      return process.nextTick(cb, Fuse.ENOENT)
+    },
+    getattr: function (path, cb) {
+      if (tests.getattr) tests.getattr(path)
+      if (path === '/') return process.nextTick(cb, null, stat({ mode: 'dir', size: 4096 }))
+      if (path === '/test') return process.nextTick(cb, null, stat({ mode: 'file', size: 11 }))
+      return process.nextTick(cb, Fuse.ENOENT)
+    },
+    open: function (path, flags, cb) {
+      if (tests.open) tests.open(path, flags)
+      return process.nextTick(cb, 0, 42)
+    },
+    release: function (path, fd, cb) {
+      if (tests.release) tests.release(path, fd)
+      return process.nextTick(cb, 0)
+    },
+    read: function (path, fd, buf, len, pos, cb) {
+      if (tests.read) tests.read(path, fd, buf, len, pos)
+      var str = 'hello world'.slice(pos, pos + len)
+      if (!str) return process.nextTick(cb, 0)
+      buf.write(str)
+      return process.nextTick(cb, str.length)
+    }
+  }
+}
+

test/misc.js

@@ -1,9 +1,13 @@
-const createMountpoint = require('./fixtures/mnt')
+const os = require('os')
+const fs = require('fs')
 const tape = require('tape')
-const { spawnSync } = require('child_process')
+const { spawnSync, exec } = require('child_process')
+
+const createMountpoint = require('./fixtures/mnt')
 
 const Fuse = require('../')
 const { unmount } = require('./helpers')
+const simpleFS = require('./fixtures/simple-fs')
 
 const mnt = createMountpoint()
 
@@ -135,6 +139,56 @@ tape('mounting with mkdir option and a nonexistent mountpoint succeeds', functio
   })
 })
 
+tape('(osx only) unmount with Finder open succeeds', function (t) {
+  if (os.platform() !== 'darwin') return t.end()
+  const fuse = new Fuse(mnt, simpleFS(), { force: true, debug: false })
+  fuse.mount(function (err) {
+    t.error(err, 'no error')
+    exec(`open ${mnt}`, err => {
+      t.error(err, 'no error')
+      setTimeout(() => {
+        fs.readdir(mnt, (err, list) => {
+          t.error(err, 'no error')
+          t.same(list, ['test'])
+          unmount(fuse, err => {
+            t.error(err, 'no error')
+            fs.readdir(mnt, (err, list) => {
+              t.error(err, 'no error')
+              t.same(list, [])
+              t.end()
+            })
+          })
+        })
+      }, 1000)
+    })
+  })
+})
+
+tape('(osx only) unmount with Terminal open succeeds', function (t) {
+  if (os.platform() !== 'darwin') return t.end()
+  const fuse = new Fuse(mnt, simpleFS(), { force: true, debug: false })
+  fuse.mount(function (err) {
+    t.error(err, 'no error')
+    exec(`open -a Terminal ${mnt}`, err => {
+      t.error(err, 'no error')
+      setTimeout(() => {
+        fs.readdir(mnt, (err, list) => {
+          t.error(err, 'no error')
+          t.same(list, ['test'])
+          unmount(fuse, err => {
+            t.error(err, 'no error')
+            fs.readdir(mnt, (err, list) => {
+              t.error(err, 'no error')
+              t.same(list, [])
+              t.end()
+            })
+          })
+        })
+      }, 1000)
+    })
+  })
+})
+
 tape('static unmounting', function (t) {
   t.end()
 })

test/read.js

@@ -6,38 +6,18 @@ const concat = require('concat-stream')
 const Fuse = require('../')
 const createMountpoint = require('./fixtures/mnt')
 const stat = require('./fixtures/stat')
-const { unmount } = require('./helpers')
+const simpleFS = require('./fixtures/simple-fs')
 
+const { unmount } = require('./helpers')
 const mnt = createMountpoint()
 
 tape('read', function (t) {
-  var ops = {
-    force: true,
-    readdir: function (path, cb) {
-      if (path === '/') return process.nextTick(cb, null, ['test'])
-      return process.nextTick(cb, Fuse.ENOENT)
-    },
-    getattr: function (path, cb) {
-      if (path === '/') return process.nextTick(cb, null, stat({ mode: 'dir', size: 4096 }))
-      if (path === '/test') return process.nextTick(cb, null, stat({ mode: 'file', size: 11 }))
-      return process.nextTick(cb, Fuse.ENOENT)
-    },
-    open: function (path, flags, cb) {
-      return process.nextTick(cb, 0, 42)
-    },
-    release: function (path, fd, cb) {
+  const testFS = simpleFS({
+    release: function (path, fd) {
       t.same(fd, 42, 'fd was passed to release')
-      return process.nextTick(cb, 0)
-    },
-    read: function (path, fd, buf, len, pos, cb) {
-      var str = 'hello world'.slice(pos, pos + len)
-      if (!str) return process.nextTick(cb, 0)
-      buf.write(str)
-      return process.nextTick(cb, str.length)
     }
-  }
-
-  const fuse = new Fuse(mnt, ops, { debug: true })
+  })
+  const fuse = new Fuse(mnt, testFS, { debug: true })
   fuse.mount(function (err) {
     t.error(err, 'no error')