unsigned int generation;
unsigned int hidectr;
pthread_mutex_t lock;
- pthread_rwlock_t tree_lock;
struct fuse_config conf;
int intr_installed;
struct fuse_fs *fs;
int nullpath_ok;
+ pthread_cond_t treecond;
};
struct lock {
char *name;
uint64_t nlookup;
int open_count;
- int is_hidden;
struct timespec stat_updated;
struct timespec mtime;
off_t size;
- int cache_valid;
struct lock *locks;
+ unsigned int is_hidden : 1;
+ unsigned int cache_valid : 1;
+ int treelock;
};
struct fuse_dh {
fprintf(stderr, "delete: %llu\n",
(unsigned long long) node->nodeid);
+ assert(node->treelock == 0);
assert(!node->name);
unhash_id(f, node);
free_node(node);
node->refctr = 1;
node->nodeid = next_id(f);
+ node->generation = f->generation;
node->open_count = 0;
node->is_hidden = 0;
- node->generation = f->generation;
+ node->treelock = 0;
if (hash_name(f, node, parent, name) == -1) {
free(node);
node = NULL;
return s;
}
-static char *get_path_name(struct fuse *f, fuse_ino_t nodeid, const char *name)
+static void unlock_path(struct fuse *f, fuse_ino_t nodeid, struct node *wnode,
+ struct node *end)
+{
+ struct node *node;
+
+ if (wnode) {
+ assert(wnode->treelock == -1);
+ wnode->treelock = 0;
+ }
+
+ for (node = get_node(f, nodeid);
+ node != end && node->nodeid != FUSE_ROOT_ID;
+ node = node->parent) {
+ assert(node->treelock > 0);
+ node->treelock--;
+ }
+}
+
+static int try_get_path(struct fuse *f, fuse_ino_t nodeid, const char *name,
+ int lock, char **path, struct node **wnodep)
{
char buf[FUSE_MAX_PATH];
char *s = buf + FUSE_MAX_PATH - 1;
struct node *node;
+ struct node *wnode = NULL;
+ int err;
+ *path = NULL;
*s = '\0';
if (name != NULL) {
s = add_name(buf, s, name);
if (s == NULL)
- return NULL;
+ return -ENAMETOOLONG;
}
- pthread_mutex_lock(&f->lock);
- for (node = get_node(f, nodeid); node && node->nodeid != FUSE_ROOT_ID;
+ if (wnodep) {
+ assert(lock);
+ wnode = lookup_node(f, nodeid, name);
+ if (wnode) {
+ if (wnode->treelock != 0)
+ return -EAGAIN;
+
+ wnode->treelock = -1;
+ }
+ }
+
+ err = 0;
+ for (node = get_node(f, nodeid); node->nodeid != FUSE_ROOT_ID;
node = node->parent) {
- if (node->name == NULL) {
- s = NULL;
+ err = -ENOENT;
+ if (node->name == NULL || node->parent == NULL)
break;
- }
+ err = -ENAMETOOLONG;
s = add_name(buf, s, node->name);
if (s == NULL)
break;
+
+ if (lock) {
+ err = -EAGAIN;
+ if (node->treelock == -1)
+ break;
+ node->treelock++;
+ }
+ err = 0;
+ }
+
+ if (!err) {
+ s = strdup(s[0] ? s : "/");
+ if (s != NULL)
+ *path = s;
+ else
+ err = -ENOMEM;
+ }
+
+ if (err && lock)
+ unlock_path(f, nodeid, wnode, node);
+
+ if (wnodep && !err)
+ *wnodep = wnode;
+
+ return err;
+}
+
+static int get_path_common(struct fuse *f, fuse_ino_t nodeid, const char *name,
+ char **path, struct node **wnode)
+{
+ int err;
+
+ pthread_mutex_lock(&f->lock);
+ while (1) {
+ err = try_get_path(f, nodeid, name, 1, path, wnode);
+ if (err != -EAGAIN)
+ break;
+
+ pthread_cond_wait(&f->treecond, &f->lock);
}
pthread_mutex_unlock(&f->lock);
- if (node == NULL || s == NULL)
- return NULL;
- else if (*s == '\0')
- return strdup("/");
- else
- return strdup(s);
+ return err;
+}
+
+static int get_path(struct fuse *f, fuse_ino_t nodeid, char **path)
+{
+ return get_path_common(f, nodeid, NULL, path, NULL);
+}
+
+static int get_path_nullok(struct fuse *f, fuse_ino_t nodeid, char **path)
+{
+ int err = get_path_common(f, nodeid, NULL, path, NULL);
+
+ if (err == -ENOENT && f->nullpath_ok)
+ err = 0;
+
+ return err;
+}
+
+static int get_path_name(struct fuse *f, fuse_ino_t nodeid, const char *name,
+ char **path)
+{
+ return get_path_common(f, nodeid, name, path, NULL);
+}
+
+static int get_path_wrlock(struct fuse *f, fuse_ino_t nodeid, const char *name,
+ char **path, struct node **wnode)
+{
+ return get_path_common(f, nodeid, name, path, wnode);
+}
+
+static int get_path2(struct fuse *f, fuse_ino_t nodeid1, const char *name1,
+ fuse_ino_t nodeid2, const char *name2,
+ char **path1, char **path2,
+ struct node **wnode1, struct node **wnode2)
+{
+ int err;
+
+ pthread_mutex_lock(&f->lock);
+ while (1) {
+ char *tmppath;
+
+ /* FIXME: locking two paths needs deadlock checking */
+ err = try_get_path(f, nodeid1, name1, 1, &tmppath, wnode1);
+ if (!err) {
+ err = try_get_path(f, nodeid2, name2, 1, path2, wnode2);
+ if (!err)
+ *path1 = tmppath;
+ else
+ unlock_path(f, nodeid1, wnode1 ? *wnode1 : NULL, NULL);
+ }
+ if (err != -EAGAIN)
+ break;
+
+ pthread_cond_wait(&f->treecond, &f->lock);
+ }
+ pthread_mutex_unlock(&f->lock);
+
+ return err;
+}
+
+static void free_path_wrlock(struct fuse *f, fuse_ino_t nodeid,
+ struct node *wnode, char *path)
+{
+ pthread_mutex_lock(&f->lock);
+ unlock_path(f, nodeid, wnode, NULL);
+ pthread_cond_broadcast(&f->treecond);
+ pthread_mutex_unlock(&f->lock);
+ free(path);
+}
+
+static void free_path(struct fuse *f, fuse_ino_t nodeid, char *path)
+{
+ if (path)
+ free_path_wrlock(f, nodeid, NULL, path);
}
-static char *get_path(struct fuse *f, fuse_ino_t nodeid)
+static void free_path2(struct fuse *f, fuse_ino_t nodeid1, fuse_ino_t nodeid2,
+ struct node *wnode1, struct node *wnode2,
+ char *path1, char *path2)
{
- return get_path_name(f, nodeid, NULL);
+ pthread_mutex_lock(&f->lock);
+ unlock_path(f, nodeid1, wnode1, NULL);
+ unlock_path(f, nodeid2, wnode2, NULL);
+ pthread_cond_broadcast(&f->treecond);
+ pthread_mutex_unlock(&f->lock);
+ free(path1);
+ free(path2);
}
static void forget_node(struct fuse *f, fuse_ino_t nodeid, uint64_t nlookup)
return;
pthread_mutex_lock(&f->lock);
node = get_node(f, nodeid);
+
+ /*
+ * Node may still be locked due to interrupt idiocy in open,
+ * create and opendir
+ */
+ while (node->nlookup == nlookup && node->treelock)
+ pthread_cond_wait(&f->treecond, &f->lock);
+
assert(node->nlookup >= nlookup);
node->nlookup -= nlookup;
if (!node->nlookup) {
(unsigned int) node->nodeid, f->hidectr);
newnode = lookup_node(f, dir, newname);
} while(newnode);
+
+ try_get_path(f, dir, newname, 0, &newpath, NULL);
pthread_mutex_unlock(&f->lock);
- newpath = get_path_name(f, dir, newname);
if (!newpath)
break;
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path_name(f, parent, name);
- if (path != NULL) {
+ err = get_path_name(f, parent, name, &path);
+ if (!err) {
struct fuse_intr_data d;
if (f->conf.debug)
fprintf(stderr, "LOOKUP %s\n", path);
err = 0;
}
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, parent, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_entry(req, &e, err);
}
memset(&buf, 0, sizeof(buf));
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL || (fi && f->nullpath_ok)) {
+ if (fi != NULL)
+ err = get_path_nullok(f, ino, &path);
+ else
+ err = get_path(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
fuse_prepare_interrupt(f, req, &d);
if (fi)
else
err = fuse_fs_getattr(f->fs, path, &buf);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
if (!err) {
if (f->conf.auto_cache) {
pthread_mutex_lock(&f->lock);
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL) {
+ err = get_path(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
fuse_prepare_interrupt(f, req, &d);
err = 0;
if (!err)
err = fuse_fs_getattr(f->fs, path, &buf);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
if (!err) {
if (f->conf.auto_cache) {
pthread_mutex_lock(&f->lock);
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL) {
+ err = get_path(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
if (f->conf.debug)
fprintf(stderr, "ACCESS %s 0%o\n", path, mask);
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_access(f->fs, path, mask);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_err(req, err);
}
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL) {
+ err = get_path(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_readlink(f->fs, path, linkname, sizeof(linkname));
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
if (!err) {
linkname[PATH_MAX] = '\0';
fuse_reply_readlink(req, linkname);
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path_name(f, parent, name);
- if (path) {
+ err = get_path_name(f, parent, name, &path);
+ if (!err) {
struct fuse_intr_data d;
if (f->conf.debug)
fprintf(stderr, "MKNOD %s\n", path);
NULL);
}
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, parent, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_entry(req, &e, err);
}
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path_name(f, parent, name);
- if (path != NULL) {
+ err = get_path_name(f, parent, name, &path);
+ if (!err) {
struct fuse_intr_data d;
if (f->conf.debug)
fprintf(stderr, "MKDIR %s\n", path);
if (!err)
err = lookup_path(f, parent, name, path, &e, NULL);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, parent, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_entry(req, &e, err);
}
const char *name)
{
struct fuse *f = req_fuse_prepare(req);
+ struct node *wnode;
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_wrlock(&f->tree_lock);
- path = get_path_name(f, parent, name);
- if (path != NULL) {
+ err = get_path_wrlock(f, parent, name, &path, &wnode);
+ if (!err) {
struct fuse_intr_data d;
if (f->conf.debug)
fprintf(stderr, "UNLINK %s\n", path);
fuse_prepare_interrupt(f, req, &d);
- if (!f->conf.hard_remove && is_open(f, parent, name))
+ if (!f->conf.hard_remove && is_open(f, parent, name)) {
err = hide_node(f, path, parent, name);
- else {
+ } else {
err = fuse_fs_unlink(f->fs, path);
if (!err)
remove_node(f, parent, name);
}
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path_wrlock(f, parent, wnode, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_err(req, err);
}
static void fuse_lib_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name)
{
struct fuse *f = req_fuse_prepare(req);
+ struct node *wnode;
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_wrlock(&f->tree_lock);
- path = get_path_name(f, parent, name);
- if (path != NULL) {
+ err = get_path_wrlock(f, parent, name, &path, &wnode);
+ if (!err) {
struct fuse_intr_data d;
if (f->conf.debug)
fprintf(stderr, "RMDIR %s\n", path);
fuse_finish_interrupt(f, req, &d);
if (!err)
remove_node(f, parent, name);
- free(path);
+ free_path_wrlock(f, parent, wnode, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_err(req, err);
}
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path_name(f, parent, name);
- if (path != NULL) {
+ err = get_path_name(f, parent, name, &path);
+ if (!err) {
struct fuse_intr_data d;
if (f->conf.debug)
fprintf(stderr, "SYMLINK %s\n", path);
if (!err)
err = lookup_path(f, parent, name, path, &e, NULL);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, parent, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_entry(req, &e, err);
}
struct fuse *f = req_fuse_prepare(req);
char *oldpath;
char *newpath;
+ struct node *wnode1;
+ struct node *wnode2;
int err;
- err = -ENOENT;
- pthread_rwlock_wrlock(&f->tree_lock);
- oldpath = get_path_name(f, olddir, oldname);
- if (oldpath != NULL) {
- newpath = get_path_name(f, newdir, newname);
- if (newpath != NULL) {
- struct fuse_intr_data d;
- if (f->conf.debug)
- fprintf(stderr, "RENAME %s -> %s\n", oldpath,
- newpath);
- err = 0;
- fuse_prepare_interrupt(f, req, &d);
- if (!f->conf.hard_remove && is_open(f, newdir, newname))
- err = hide_node(f, newpath, newdir, newname);
- if (!err) {
- err = fuse_fs_rename(f->fs, oldpath, newpath);
- if (!err)
- err = rename_node(f, olddir, oldname,
- newdir, newname, 0);
- }
- fuse_finish_interrupt(f, req, &d);
- free(newpath);
+ err = get_path2(f, olddir, oldname, newdir, newname,
+ &oldpath, &newpath, &wnode1, &wnode2);
+ if (!err) {
+ struct fuse_intr_data d;
+ if (f->conf.debug)
+ fprintf(stderr, "RENAME %s -> %s\n", oldpath, newpath);
+ err = 0;
+ fuse_prepare_interrupt(f, req, &d);
+ if (!f->conf.hard_remove && is_open(f, newdir, newname))
+ err = hide_node(f, newpath, newdir, newname);
+ if (!err) {
+ err = fuse_fs_rename(f->fs, oldpath, newpath);
+ if (!err)
+ err = rename_node(f, olddir, oldname, newdir,
+ newname, 0);
}
- free(oldpath);
+ fuse_finish_interrupt(f, req, &d);
+ free_path2(f, olddir, newdir, wnode1, wnode2, oldpath, newpath);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_err(req, err);
}
char *newpath;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- oldpath = get_path(f, ino);
- if (oldpath != NULL) {
- newpath = get_path_name(f, newparent, newname);
- if (newpath != NULL) {
- struct fuse_intr_data d;
- if (f->conf.debug)
- fprintf(stderr, "LINK %s\n", newpath);
- fuse_prepare_interrupt(f, req, &d);
- err = fuse_fs_link(f->fs, oldpath, newpath);
- if (!err)
- err = lookup_path(f, newparent, newname,
- newpath, &e, NULL);
- fuse_finish_interrupt(f, req, &d);
- free(newpath);
- }
- free(oldpath);
+ err = get_path2(f, ino, NULL, newparent, newname,
+ &oldpath, &newpath, NULL, NULL);
+ if (!err) {
+ struct fuse_intr_data d;
+ if (f->conf.debug)
+ fprintf(stderr, "LINK %s\n", newpath);
+ fuse_prepare_interrupt(f, req, &d);
+ err = fuse_fs_link(f->fs, oldpath, newpath);
+ if (!err)
+ err = lookup_path(f, newparent, newname, newpath,
+ &e, NULL);
+ fuse_finish_interrupt(f, req, &d);
+ free_path2(f, ino, newparent, NULL, NULL, oldpath, newpath);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_entry(req, &e, err);
}
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path_name(f, parent, name);
- if (path) {
+ err = get_path_name(f, parent, name, &path);
+ if (!err) {
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_create(f->fs, path, mode, fi);
if (!err) {
} else
reply_err(req, err);
- if (path)
- free(path);
-
- pthread_rwlock_unlock(&f->tree_lock);
+ free_path(f, parent, path);
}
static double diff_timespec(const struct timespec *t1,
{
struct fuse *f = req_fuse_prepare(req);
struct fuse_intr_data d;
- char *path = NULL;
- int err = 0;
+ char *path;
+ int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path) {
+ err = get_path(f, ino, &path);
+ if (!err) {
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_open(f->fs, path, fi);
if (!err) {
} else
reply_err(req, err);
- if (path)
- free(path);
- pthread_rwlock_unlock(&f->tree_lock);
+ free_path(f, ino, path);
}
static void fuse_lib_read(fuse_req_t req, fuse_ino_t ino, size_t size,
return;
}
- res = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL || f->nullpath_ok) {
+ res = get_path_nullok(f, ino, &path);
+ if (res == 0) {
struct fuse_intr_data d;
if (f->conf.debug)
fprintf(stderr, "READ[%llu] %lu bytes from %llu\n",
fuse_prepare_interrupt(f, req, &d);
res = fuse_fs_read(f->fs, path, buf, size, off, fi);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
if (res >= 0) {
if (f->conf.debug)
char *path;
int res;
- res = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL || f->nullpath_ok) {
+ res = get_path_nullok(f, ino, &path);
+ if (res == 0) {
struct fuse_intr_data d;
if (f->conf.debug)
fprintf(stderr, "WRITE%s[%llu] %lu bytes to %llu\n",
fuse_prepare_interrupt(f, req, &d);
res = fuse_fs_write(f->fs, path, buf, size, off, fi);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
if (res >= 0) {
if (f->conf.debug)
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL || f->nullpath_ok) {
+ err = get_path_nullok(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
if (f->conf.debug)
fprintf(stderr, "FSYNC[%llu]\n",
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_fsync(f->fs, path, datasync, fi);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_err(req, 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 = get_path(f, ino, &path);
+ if (!err) {
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_opendir(f->fs, path, &fi);
fuse_finish_interrupt(f, req, &d);
reply_err(req, err);
free(dh);
}
- free(path);
- pthread_rwlock_unlock(&f->tree_lock);
+ free_path(f, ino, path);
}
static int extend_contents(struct fuse_dh *dh, unsigned minsize)
size_t size, off_t off, struct fuse_dh *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) {
+ int err;
+
+ err = get_path(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
dh->len = 0;
err = dh->error;
if (err)
dh->filled = 0;
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
return err;
}
struct fuse_dh *dh = get_dirhandle(llfi, &fi);
char *path;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
+ get_path(f, ino, &path);
fuse_prepare_interrupt(f, req, &d);
fuse_fs_releasedir(f->fs, (path || f->nullpath_ok) ? path : "-", &fi);
fuse_finish_interrupt(f, req, &d);
- if (path)
- free(path);
- pthread_rwlock_unlock(&f->tree_lock);
+ free_path(f, ino, path);
+
pthread_mutex_lock(&dh->lock);
pthread_mutex_unlock(&dh->lock);
pthread_mutex_destroy(&dh->lock);
get_dirhandle(llfi, &fi);
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL) {
+ err = get_path(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_fsyncdir(f->fs, path, datasync, &fi);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_err(req, err);
}
{
struct fuse *f = req_fuse_prepare(req);
struct statvfs buf;
- char *path;
- int err;
+ char *path = NULL;
+ int err = 0;
memset(&buf, 0, sizeof(buf));
- pthread_rwlock_rdlock(&f->tree_lock);
- if (!ino) {
- err = -ENOMEM;
- path = strdup("/");
- } else {
- err = -ENOENT;
- path = get_path(f, ino);
- }
- if (path) {
+ if (ino)
+ err = get_path(f, ino, &path);
+
+ if (!err) {
struct fuse_intr_data d;
fuse_prepare_interrupt(f, req, &d);
- err = fuse_fs_statfs(f->fs, path, &buf);
+ err = fuse_fs_statfs(f->fs, path ? path : "/", &buf);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
if (!err)
fuse_reply_statfs(req, &buf);
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL) {
+ err = get_path(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_setxattr(f->fs, path, name, value, size, flags);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_err(req, err);
}
int err;
char *path;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL) {
+ err = get_path(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_getxattr(f->fs, path, name, value, size);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
return err;
}
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL) {
+ err = get_path(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_listxattr(f->fs, path, list, size);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
return err;
}
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL) {
+ err = get_path(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_removexattr(f->fs, path, name);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
reply_err(req, err);
}
char *path;
int err = 0;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
+ get_path(f, ino, &path);
if (f->conf.debug)
fprintf(stderr, "RELEASE%s[%llu] flags: 0x%x\n",
fi->flush ? "+FLUSH" : "",
fuse_prepare_interrupt(f, req, &d);
fuse_do_release(f, ino, path, fi);
fuse_finish_interrupt(f, req, &d);
- free(path);
- pthread_rwlock_unlock(&f->tree_lock);
+ free_path(f, ino, path);
reply_err(req, err);
}
char *path;
int err;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
+ get_path(f, ino, &path);
if (f->conf.debug)
fprintf(stderr, "FLUSH[%llu]\n", (unsigned long long) fi->fh);
err = fuse_flush_common(f, req, ino, path, fi);
- free(path);
- pthread_rwlock_unlock(&f->tree_lock);
+ free_path(f, ino, path);
+
reply_err(req, err);
}
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL || f->nullpath_ok) {
+ err = get_path_nullok(f, ino, &path);
+ if (!err) {
struct fuse_intr_data d;
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_lock(f->fs, path, fi, cmd, lock);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
return err;
}
char *path;
int err;
- err = -ENOENT;
- pthread_rwlock_rdlock(&f->tree_lock);
- path = get_path(f, ino);
- if (path != NULL) {
+ err = get_path(f, ino, &path);
+ if (!err) {
fuse_prepare_interrupt(f, req, &d);
err = fuse_fs_bmap(f->fs, path, blocksize, &idx);
fuse_finish_interrupt(f, req, &d);
- free(path);
+ free_path(f, ino, path);
}
- pthread_rwlock_unlock(&f->tree_lock);
if (!err)
fuse_reply_bmap(req, idx);
else
" -o readdir_ino try to fill in d_ino in readdir\n"
" -o direct_io use direct I/O\n"
" -o kernel_cache cache files in kernel\n"
-" -o [no]auto_cache enable caching based on modification times\n"
+" -o [no]auto_cache enable caching based on modification times (off)\n"
" -o umask=M set file permissions (octal)\n"
" -o uid=N set file owner\n"
" -o gid=N set file group\n"
}
fuse_mutex_init(&f->lock);
- pthread_rwlock_init(&f->tree_lock, NULL);
+ pthread_cond_init(&f->treecond, NULL);
root = (struct node *) calloc(1, sizeof(struct node));
if (root == NULL) {
for (node = f->id_table[i]; node != NULL;
node = node->id_next) {
if (node->is_hidden) {
- char *path = get_path(f, node->nodeid);
- if (path) {
+ char *path;
+ if (try_get_path(f, node->nodeid, NULL,
+ 0, &path, NULL) == 0) {
fuse_fs_unlink(f->fs, path);
free(path);
}
free(f->id_table);
free(f->name_table);
pthread_mutex_destroy(&f->lock);
- pthread_rwlock_destroy(&f->tree_lock);
+ pthread_cond_destroy(&f->treecond);
fuse_session_destroy(f->se);
free(f->conf.modules);
free(f);
projects / qemu-gpiodev / libfuse.git / commitdiff