Archives
/
fuse-friends_fuse-native
mirror of https://github.com/fuse-friends/fuse-native
1
0
Fork 0
Code Issues Releases Wiki Activity

working getattr

Browse Source
reimpl
Andrew Osheroff 5 years ago
parent 5a2c2b5d03
commit a01ebc477d
2 changed files with 485 additions and 41 deletions
Show Stats Download Patch File Download Diff File

348
fuse-native.c
Unescape View File

@ -17,25 +17,75 @@
#include <sys/wait.h>
#include <pthread.h>
static const uint32_t op_init = 0;
static const uint32_t op_error = 1;
static const uint32_t op_access = 2;
static const uint32_t op_statfs = 3;
static const uint32_t op_fgetattr = 4;
static const uint32_t op_getattr = 5;
static const uint32_t op_flush = 6;
static const uint32_t op_fsync = 7;
static const uint32_t op_fsyncdir = 8;
static const uint32_t op_readdir = 9;
static const uint32_t op_truncate = 10;
static const uint32_t op_ftruncate = 11;
static const uint32_t op_utimens = 12;
static const uint32_t op_readlink = 13;
static const uint32_t op_chown = 14;
static const uint32_t op_chmod = 15;
static const uint32_t op_mknod = 16;
static const uint32_t op_setxattr = 17;
static const uint32_t op_getxattr = 18;
static const uint32_t op_listxattr = 19;
static const uint32_t op_removexattr = 20;
static const uint32_t op_open = 21;
static const uint32_t op_opendir = 22;
static const uint32_t op_read = 23;
static const uint32_t op_write = 24;
static const uint32_t op_release = 25;
static const uint32_t op_releasedir = 26;
static const uint32_t op_create = 27;
static const uint32_t op_unlink = 28;
static const uint32_t op_rename = 29;
static const uint32_t op_link = 30;
static const uint32_t op_symlink = 31;
static const uint32_t op_mkdir = 32;
static const uint32_t op_rmdir = 33;
static const uint32_t op_destroy = 34;
typedef struct {
napi_env env;
pthread_t thread;
pthread_attr_t attr;
napi_ref ctx;
napi_ref on_op;
// Operation handlers
napi_ref on_path_op;
napi_ref on_stat_op;
napi_ref on_statfs_op;
napi_ref on_buffer_op;
napi_ref on_readdir;
napi_ref on_symlink;
struct fuse *fuse;
uv_async_t async;
} fuse_thread_t;
typedef struct {
uint32_t ints[32];
// Opcode
uint32_t op;
// Payloads
struct stat *stat;
struct statvfs *statvfs;
const char *path;
int32_t res;
// Internal bookkeeping
fuse_thread_t *fuse;
fuse_native_semaphore_t sem;
uv_async_t async;
// char *reply;
} fuse_thread_locals_t;
static pthread_key_t thread_locals_key;
@ -45,10 +95,53 @@ static void fin (napi_env env, void *fin_data, void* fin_hint) {
// exit(0);
}
static void fuse_native_dispatch (uv_async_t* handle, int status) {
fuse_thread_locals_t *l = (fuse_thread_locals_t *) handle->data;
fuse_thread_t *ft = l->fuse;
static void fuse_native_dispatch_stat(uv_async_t* handle, int status, fuse_thread_locals_t* l, fuse_thread_t* ft) {
napi_env env = ft->env;
napi_handle_scope scope;
napi_open_handle_scope(env, &scope);
napi_value ctx;
napi_get_reference_value(env, ft->ctx, &ctx);
napi_value callback;
napi_get_reference_value(env, ft->on_stat_op, &callback);
napi_value argv[3];
napi_create_external_buffer(env, sizeof(fuse_thread_locals_t), l, &fin, NULL, &(argv[0]));
napi_create_uint32(env, l->op, &(argv[1]));
napi_create_string_utf8(env, l->path, NAPI_AUTO_LENGTH, &(argv[2]));
NAPI_MAKE_CALLBACK(env, NULL, ctx, callback, 3, argv, NULL)
napi_close_handle_scope(env, scope);
}
static void fuse_native_dispatch_path(uv_async_t* handle, int status, fuse_thread_locals_t* l, fuse_thread_t* ft) {
napi_env env = ft->env;
napi_handle_scope scope;
napi_open_handle_scope(env, &scope);
napi_value ctx;
napi_get_reference_value(env, ft->ctx, &ctx);
napi_value callback;
napi_get_reference_value(env, ft->on_path_op, &callback);
napi_value argv[3];
napi_create_external_buffer(env, sizeof(fuse_thread_locals_t), l, &fin, NULL, &(argv[0]));
napi_create_uint32(env, l->op, &(argv[1]));
napi_create_string_utf8(env, l->path, NAPI_AUTO_LENGTH, &(argv[2]));
NAPI_MAKE_CALLBACK(env, NULL, ctx, callback, 3, argv, NULL)
napi_close_handle_scope(env, scope);
}
static void fuse_native_dispatch_buffer(uv_async_t* handle, int status, fuse_thread_locals_t* l, fuse_thread_t* ft) {
napi_env env = ft->env;
napi_handle_scope scope;
@ -58,19 +151,29 @@ static void fuse_native_dispatch (uv_async_t* handle, int status) {
napi_get_reference_value(env, ft->ctx, &ctx);
napi_value callback;
napi_get_reference_value(env, ft->on_op, &callback);
napi_get_reference_value(env, ft->on_buffer_op, &callback);
// int ptr = get_free_thread_id()
// thread_local_map[ptr] = l
napi_value argv[4];
napi_value argv[1];
napi_create_external_buffer(env, sizeof(fuse_thread_locals_t), l, &fin, NULL, &(argv[0]));
napi_create_uint32(env, l->op, &(argv[1]));
napi_create_string_utf8(env, l->path, NAPI_AUTO_LENGTH, &(argv[2]));
NAPI_MAKE_CALLBACK(env, NULL, ctx, callback, 1, argv, NULL)
NAPI_MAKE_CALLBACK(env, NULL, ctx, callback, 4, argv, NULL)
napi_close_handle_scope(env, scope);
}
static void fuse_native_dispatch (uv_async_t* handle, int status) {
fuse_thread_locals_t *l = (fuse_thread_locals_t *) handle->data;
fuse_thread_t *ft = l->fuse;
switch (l->op) {
case (op_getattr):
return fuse_native_dispatch_stat(handle, status, l, ft);
}
}
static fuse_thread_locals_t* get_thread_locals () {
void *data = pthread_getspecific(thread_locals_key);
@ -109,31 +212,140 @@ static void* start_fuse_thread (void *data) {
}
static int fuse_native_getattr (const char *path, struct stat *stat) {
printf("hi\n");
struct fuse_context *ctx = fuse_get_context();
fuse_thread_t *ft = (fuse_thread_t *) ctx->private_data;
fuse_thread_locals_t *l = get_thread_locals();
l->fuse = ft;
// b->op = OP_GETATTR;
// b->path = (char *) path;
// b->data = stat;
l->stat = stat;
l->op = op_getattr;
l->path = path;
uv_async_send(&(l->async));
fuse_native_semaphore_wait(&(l->sem));
printf("l->res: %i\n", l->res);
printf("l->ints[0]: %u\n", l->ints[0]);
printf("l->ints[1]: %u\n", l->ints[1]);
printf("l->ints[2]: %u\n", l->ints[2]);
return l->res;
}
static int fuse_native_statfs (struct statvfs *statvfs) {
struct fuse_context *ctx = fuse_get_context();
fuse_thread_t *ft = (fuse_thread_t *) ctx->private_data;
fuse_thread_locals_t *l = get_thread_locals();
l->fuse = ft;
l->statvfs = statvfs;
l->op = op_statfs;
uv_async_send(&(l->async));
fuse_native_semaphore_wait(&(l->sem));
return -1;
}
NAPI_METHOD(fuse_native_signal) {
NAPI_METHOD(fuse_native_signal_path) {
NAPI_ARGV(3)
NAPI_ARGV_BUFFER_CAST(fuse_thread_locals_t *, l, 0);
NAPI_ARGV_INT32(res, 1)
l->res = res;
fuse_native_semaphore_signal(&(l->sem));
return NULL;
}
static void to_timespec (struct timespec* ts, uint32_t ms) {
ts->tv_sec = ms / 1000;
ts->tv_nsec = (ms % 1000) * 1000000;
}
NAPI_METHOD(fuse_native_signal_stat) {
NAPI_ARGV(15)
NAPI_ARGV_BUFFER_CAST(fuse_thread_locals_t *, l, 0);
NAPI_ARGV_INT32(res, 1)
NAPI_ARGV_INT32(mode, 2)
NAPI_ARGV_INT32(uid, 3)
NAPI_ARGV_INT32(gid, 4)
NAPI_ARGV_INT32(size, 5)
NAPI_ARGV_INT32(dev, 6)
NAPI_ARGV_INT32(nlink, 7)
NAPI_ARGV_INT32(ino, 8)
NAPI_ARGV_INT32(rdev, 9)
NAPI_ARGV_INT32(blksize, 10)
NAPI_ARGV_INT32(blocks, 11)
NAPI_ARGV_INT32(atim, 12)
NAPI_ARGV_INT32(mtim, 13)
NAPI_ARGV_INT32(ctim, 14)
l->stat->st_mode = mode;
l->stat->st_uid = uid;
l->stat->st_gid = gid;
l->stat->st_size = size;
l->stat->st_dev = dev;
l->stat->st_nlink = nlink;
l->stat->st_ino = ino;
l->stat->st_rdev = rdev;
l->stat->st_blksize = blksize;
l->stat->st_blocks = blocks;
to_timespec(&l->stat->st_atim, atim);
to_timespec(&l->stat->st_mtim, mtim);
to_timespec(&l->stat->st_ctim, ctim);
l->res = res;
fuse_native_semaphore_signal(&(l->sem));
return NULL;
}
NAPI_METHOD(fuse_native_signal_statfs) {
NAPI_ARGV(15)
NAPI_ARGV_BUFFER_CAST(fuse_thread_locals_t *, l, 0);
NAPI_ARGV_INT32(res, 1)
NAPI_ARGV_INT32(bsize, 2)
NAPI_ARGV_INT32(frsize, 3)
NAPI_ARGV_INT32(blocks, 4)
NAPI_ARGV_INT32(bfree, 5)
NAPI_ARGV_INT32(bavail, 6)
NAPI_ARGV_INT32(files, 7)
NAPI_ARGV_INT32(ffree, 8)
NAPI_ARGV_INT32(favail, 9)
NAPI_ARGV_INT32(fsid, 10)
NAPI_ARGV_INT32(flag, 11)
NAPI_ARGV_INT32(namemax, 12)
l->statvfs->f_bsize = bsize;
l->statvfs->f_frsize = frsize;
l->statvfs->f_blocks = blocks;
l->statvfs->f_bfree = bfree;
l->statvfs->f_bavail = bavail;
l->statvfs->f_files = files;
l->statvfs->f_ffree = ffree;
l->statvfs->f_favail = favail;
l->statvfs->f_fsid = fsid;
l->statvfs->f_flag = flag;
l->statvfs->f_namemax = namemax;
l->res = res;
fuse_native_semaphore_signal(&(l->sem));
return NULL;
}
NAPI_METHOD(fuse_native_signal_buffer) {
NAPI_ARGV(2)
NAPI_ARGV_BUFFER_CAST(fuse_thread_locals_t *, l, 0);
NAPI_ARGV_INT32(res, 1)
l->res = res;
fuse_native_semaphore_signal(&(l->sem));
return NULL;
}
NAPI_METHOD(fuse_native_signal_readdir) {
NAPI_ARGV(2)
NAPI_ARGV_BUFFER_CAST(fuse_thread_locals_t *, l, 0);
NAPI_ARGV_INT32(res, 1)
@ -145,18 +357,60 @@ NAPI_METHOD(fuse_native_signal) {
}
NAPI_METHOD(fuse_native_mount) {
NAPI_ARGV(5)
NAPI_ARGV(10)
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_create_reference(env, argv[4], 1, &(ft->on_op));
napi_create_reference(env, argv[4], 1, &(ft->on_path_op));
napi_create_reference(env, argv[5], 1, &(ft->on_statfs_op));
napi_create_reference(env, argv[6], 1, &(ft->on_stat_op));
napi_create_reference(env, argv[7], 1, &(ft->on_buffer_op));
napi_create_reference(env, argv[8], 1, &(ft->on_readdir));
napi_create_reference(env, argv[9], 1, &(ft->on_symlink));
ft->env = env;
struct fuse_operations ops = {
.getattr = fuse_native_getattr
.getattr = fuse_native_getattr,
.statfs = fuse_native_statfs,
/*
.init = fuse_native_init,
.error = fuse_native_error,
.access = fuse_native_access,
.fgetattr = fuse_native_fgetattr,
.flush = fuse_native_flush,
.fsync = fuse_native_fsync,
.fsyncdir = fuse_native_fsyncdir,
.readdir = fuse_native_readdir,
.truncate = fuse_native_truncate,
.ftruncate = fuse_native_ftruncate,
.utimens = fuse_native_utimens,
.readlink = fuse_native_readlink,
.chown = fuse_native_chown,
.chmod = fuse_native_chmod,
.mknod = fuse_native_mknod,
.setxattr = fuse_native_setxattr,
.getxattr = fuse_native_getxattr,
.listxattr = fuse_native_listxattr,
.removexattr = fuse_native_removexattr,
.open = fuse_native_open,
.opendir = fuse_native_opendir,
.read = fuse_native_read,
.write = fuse_native_write,
.release = fuse_native_release,
.releasedir = fuse_native_releasedir,
.create = fuse_native_create,
.unlink = fuse_native_unlink,
.rename = fuse_native_rename,
.link = fuse_native_link,
.symlink = fuse_native_symlink,
.mkdir = fuse_native_mkdir,
.rmdir = fuse_native_rmdir,
.destroy = fuse_native_destroy,
*/
};
int _argc = 2;
@ -192,6 +446,46 @@ NAPI_INIT() {
pthread_key_create(&(thread_locals_key), NULL); // TODO: add destructor
NAPI_EXPORT_FUNCTION(fuse_native_mount)
NAPI_EXPORT_FUNCTION(fuse_native_signal)
NAPI_EXPORT_FUNCTION(fuse_native_signal_path)
NAPI_EXPORT_FUNCTION(fuse_native_signal_stat)
NAPI_EXPORT_FUNCTION(fuse_native_signal_statfs)
NAPI_EXPORT_FUNCTION(fuse_native_signal_buffer)
NAPI_EXPORT_FUNCTION(fuse_native_signal_readdir)
NAPI_EXPORT_SIZEOF(fuse_thread_t)
NAPI_EXPORT_UINT32(op_getattr)
NAPI_EXPORT_UINT32(op_init)
NAPI_EXPORT_UINT32(op_error)
NAPI_EXPORT_UINT32(op_access)
NAPI_EXPORT_UINT32(op_statfs)
NAPI_EXPORT_UINT32(op_fgetattr)
NAPI_EXPORT_UINT32(op_getattr)
NAPI_EXPORT_UINT32(op_flush)
NAPI_EXPORT_UINT32(op_fsync)
NAPI_EXPORT_UINT32(op_fsyncdir)
NAPI_EXPORT_UINT32(op_readdir)
NAPI_EXPORT_UINT32(op_truncate)
NAPI_EXPORT_UINT32(op_ftruncate)
NAPI_EXPORT_UINT32(op_utimens)
NAPI_EXPORT_UINT32(op_readlink)
NAPI_EXPORT_UINT32(op_chown)
NAPI_EXPORT_UINT32(op_chmod)
NAPI_EXPORT_UINT32(op_mknod)
NAPI_EXPORT_UINT32(op_setxattr)
NAPI_EXPORT_UINT32(op_getxattr)
NAPI_EXPORT_UINT32(op_listxattr)
NAPI_EXPORT_UINT32(op_removexattr)
NAPI_EXPORT_UINT32(op_open)
NAPI_EXPORT_UINT32(op_opendir)
NAPI_EXPORT_UINT32(op_read)
NAPI_EXPORT_UINT32(op_write)
NAPI_EXPORT_UINT32(op_release)
NAPI_EXPORT_UINT32(op_releasedir)
NAPI_EXPORT_UINT32(op_create)
NAPI_EXPORT_UINT32(op_unlink)
NAPI_EXPORT_UINT32(op_rename)
NAPI_EXPORT_UINT32(op_link)
NAPI_EXPORT_UINT32(op_symlink)
NAPI_EXPORT_UINT32(op_mkdir)
NAPI_EXPORT_UINT32(op_rmdir)
NAPI_EXPORT_UINT32(op_destroy)
}

178
index.js
Unescape View File

@ -1,35 +1,185 @@
const binding = require('node-gyp-build')(__dirname)
console.log(binding)
const Opcodes = new Map([
[ 'init', 0 ],
[ 'error', 1 ],
[ 'access', 2 ],
[ 'statfs', 3 ],
[ 'fgetattr', 4 ],
[ 'getattr', 5 ],
[ 'flush', 6 ],
[ 'fsync', 7 ],
[ 'fsyncdir', 8 ],
[ 'readdir', 9 ],
[ 'truncate', 10 ],
[ 'ftruncate', 11 ],
[ 'utimens', 12 ],
[ 'readlink', 13 ],
[ 'chown', 14 ],
[ 'chmod', 15 ],
[ 'mknod', 16 ],
[ 'setxattr', 17 ],
[ 'getxattr', 18 ],
[ 'listxattr', 19 ],
[ 'removexattr', 20 ],
[ 'open', 21 ],
[ 'opendir', 22 ],
[ 'read', 23 ],
[ 'write', 24 ],
[ 'release', 25 ],
[ 'releasedir', 26 ],
[ 'create', 27 ],
[ 'unlink', 28 ],
[ 'rename', 29 ],
[ 'link', 30 ],
[ 'symlink', 31 ],
[ 'mkdir', 32 ],
[ 'rmdir', 33 ],
[ 'destroy', 34 ]
])
class Fuse {
constructor () {
constructor (mnt, ops, opts = {}) {
this.opts = opts
this.ops = ops
this.mnt = mnt
this._thread = Buffer.alloc(binding.sizeof_fuse_thread_t)
const implemented = []
if (ops) {
for (const [name, code] of Opcodes) {
if (ops[name]) implemented.push(code)
}
}
this._implemented = new Set(implemented)
// Used to determine if the user-defined callback needs to be nextTick'd.
this._sync = true
}
_signal (signalFunc, args) {
/*
if (this._sync) process.nextTick(() => signalFunc.apply(null, args))
else signalFunc.apply(null, args)
*/
process.nextTick(() => signalFunc.apply(null, args))
}
mount () {
binding.fuse_native_mount(this.mnt, '-odebug', this._thread, this,
this.on_path_op, this.on_statfs_op, this.on_stat_op,
this.on_buffer_op, this.on_readdir, this.on_symlink)
}
mount (mnt) {
binding.fuse_native_mount(mnt, '-odebug', this._thread, this, this.onop)
unmount () {
binding.fuse_native_unmount(this.mnt)
}
onop (handle) {
const ints = new Uint32Array(handle.buffer, handle.byteOffset, 32)
on_symlink (handle, op, path, target) {
const signalFunc = binding.fuse_native_signal_path.bind(binding)
if (!this._implemented.has(op)) return this._signal(signalFunc, [handle, -1])
}
on_readdir (handle, op, path) {
const signalFunc = binding.fuse_native_signal_readdir.bind(binding)
if (!this._implemented.has(op)) return this._signal(signalFunc, [handle, -1])
}
ints[0] = 1
ints[1] = 42
ints[2] = 10
on_buffer_op (handle, op, path, buf) {
const signalFunc = binding.fuse_native_signal_buffer.bind(binding)
if (!this._implemented.has(op)) return this._signal(signalFunc, [handle, -1])
}
process.nextTick(function () {
binding.fuse_native_signal(handle, -1)
on_statfs_op (handle, op, path) {
const signalFunc = binding.fuse_native_signal_statfs.bind(binding)
if (!this._implemented.has(op)) return this._signal(signalFunc, [handle, -1])
this.ops.statfs((err, statfs) => {
const arr = getStatfsArray(statfs)
return this._signal(signalFunc, [handle, err, ...arr])
})
}
on_stat_op (handle, op, path) {
const signalFunc = binding.fuse_native_signal_stat.bind(binding)
if (!this._implemented.has(op)) return this._signal(signalFunc, [handle, -1, ...getStatArray()])
switch (op) {
case (binding.op_getattr):
this.ops.getattr(path, (err, stat) => {
const arrs = getStatArray(stat)
return this._signal(signalFunc, [handle, err, ...arrs])
})
break
default:
return this._signal(signalFunc, [handle, -1, ...getStatArray()])
}
}
on_path_op (handle, op, path) {
const signalFunc = binding.fuse_native_signal_path.bind(binding)
if (!this._implemented.has(op)) return this._signal(signalFunc, [handle, -1])
}
}
function getStatfsArray (statfs) {
const ints = Array(11)
ints[0] = (statfs && statfs.bsize) || 0
ints[1] = (statfs && statfs.frsize) || 0
ints[2] = (statfs && statfs.blocks) || 0
ints[3] = (statfs && statfs.bfree) || 0
ints[4] = (statfs && statfs.bavail) || 0
ints[5] = (statfs && statfs.files) || 0
ints[6] = (statfs && statfs.ffree) || 0
ints[7] = (statfs && statfs.favail) || 0
ints[8] = (statfs && statfs.fsid) || 0
ints[9] = (statfs && statfs.flag) || 0
ints[10] = (statfs && statfs.namemax) || 0
return ints
}
const f = new Fuse()
function getStatArray (stat) {
const ints = Array(13)
f.mount('mnt')
ints[0] = (stat && stat.mode) || 0
ints[1] = (stat && stat.uid) || 0
ints[2] = (stat && stat.gid) || 0
ints[3] = (stat && stat.size) || 0
ints[4] = (stat && stat.dev) || 0
ints[5] = (stat && stat.nlink) || 1
ints[6] = (stat && stat.ino) || 0
ints[7] = (stat && stat.rdev) || 0
ints[8] = (stat && stat.blksize) || 0
ints[9] = (stat && stat.blocks) || 0
ints[10] = (stat && stat.atim) || Date.now()
ints[11] = (stat && stat.mtim) || Date.now()
ints[12] = (stat && stat.ctim) || Date.now()
return ints
}
const f = new Fuse('mnt', {
getattr: (path, cb) => {
return cb(0, {
mtime: new Date(),
atime: new Date(),
ctime: new Date(),
nlink: 1,
size: 100,
mode: 16877,
uid: process.getuid ? process.getuid() : 0,
gid: process.getgid ? process.getgid() : 0
})
}
})
f.mount()
setInterval(() => {
console.log(!!(f))
if (global.gc) gc()
}, 1000)

Write Preview
Loading…
Cancel
Save