Mirror
/
mergerfs
mirror of https://github.com/trapexit/mergerfs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

checkpoint

libfuse-cxx
Antonio SJ Musumeci 4 years ago
parent
eaa2593a4b
commit
a5a6b45463
18 changed files with 584 additions and 648 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      libfuse/Makefile
  2. 92
      libfuse/include/fuse_common.h
  3. 10
      libfuse/include/fuse_lowlevel.h
  4. 138
      libfuse/lib/buffer.c
  5. 553
      libfuse/lib/fuse.c
  6. 16
      libfuse/lib/fuse_dirents.c
  7. 11
      libfuse/lib/fuse_kern_chan.c
  8. 12
      libfuse/lib/fuse_loop_mt.c
  9. 318
      libfuse/lib/fuse_lowlevel.c
  10. 16
      libfuse/lib/fuse_mt.c
  11. 19
      libfuse/lib/fuse_opt.c
  12. 4
      libfuse/lib/fuse_session.c
  13. 2
      libfuse/lib/helper.c
  14. 10
      libfuse/lib/mount_generic.c
  15. 8
      libfuse/util/fusermount.c
  16. 4
      libfuse/util/mount.mergerfs.c
  17. 2
      src/fuse_read_buf.cpp
  18. 5
      src/fuse_write_buf.cpp

12
libfuse/Makefile
View File

@ -46,10 +46,10 @@ SRC = \
lib/mount.c
OBJS = $(SRC:lib/%.c=build/%.o)
DEPS = $(SRC:lib/%.c=build/%.d)
CFLAGS ?= \
CXXFLAGS ?= \
$(OPT_FLAGS)
CFLAGS := \
${CFLAGS} \
CXXFLAGS := \
${CXXFLAGS} \
-Wall \
-pipe \
-MMD
@ -85,17 +85,17 @@ build/libfuse.a: objects
utils: mergerfs-fusermount mount.mergerfs
build/mergerfs-fusermount: build/config.h util/fusermount.c lib/mount_util.c
$(CC) $(CFLAGS) $(FUSE_FLAGS) -Ilib -o build/mergerfs-fusermount util/fusermount.c lib/mount_util.c
$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) -Ilib -o build/mergerfs-fusermount util/fusermount.c lib/mount_util.c
mergerfs-fusermount: build/mergerfs-fusermount
build/mount.mergerfs: build/libfuse.a util/mount.mergerfs.c
$(CC) $(CFLAGS) $(FUSE_FLAGS) -o build/mount.mergerfs util/mount.mergerfs.c build/libfuse.a $(LDFLAGS)
$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) -o build/mount.mergerfs util/mount.mergerfs.c build/libfuse.a $(LDFLAGS)
mount.mergerfs: build/mount.mergerfs
build/%.o: lib/%.c
$(CC) $(CFLAGS) $(FUSE_FLAGS) -c $< -o $@
$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) -c $< -o $@
clean:
rm -rf build

92
libfuse/include/fuse_common.h
View File

@ -280,14 +280,15 @@ void fuse_pollhandle_destroy(struct fuse_pollhandle *ph);
/**
* Buffer flags
*/
enum fuse_buf_flags {
/**
#define FUSE_BUF_FLAG_NONE (1 << 0)
/**
* Buffer contains a file descriptor
*
* If this flag is set, the .fd field is valid, otherwise the
* .mem fields is valid.
*/
FUSE_BUF_IS_FD = (1 << 1),
#define FUSE_BUF_FLAG_IS_FD (1 << 1)
/**
* Seek on the file descriptor
@ -296,7 +297,7 @@ enum fuse_buf_flags {
* used to seek to the given offset before performing
* operation on file descriptor.
*/
FUSE_BUF_FD_SEEK = (1 << 2),
#define FUSE_BUF_FLAG_FD_SEEK (1 << 2)
/**
* Retry operation on file descriptor
@ -305,50 +306,50 @@ enum fuse_buf_flags {
* until .size bytes have been copied or an error or EOF is
* detected.
*/
FUSE_BUF_FD_RETRY = (1 << 3),
};
#define FUSE_BUF_FLAG_FD_RETRY (1 << 3)
/**
* Buffer copy flags
*/
enum fuse_buf_copy_flags {
/**
* Don't use splice(2)
*
* Always fall back to using read and write instead of
* splice(2) to copy data from one file descriptor to another.
*
* If this flag is not set, then only fall back if splice is
* unavailable.
*/
FUSE_BUF_NO_SPLICE = (1 << 1),
#define FUSE_BUF_COPY_FLAG_NONE 0
/**
* Force splice
*
* Always use splice(2) to copy data from one file descriptor
* to another. If splice is not available, return -EINVAL.
*/
FUSE_BUF_FORCE_SPLICE = (1 << 2),
/**
* Don't use splice(2)
*
* Always fall back to using read and write instead of
* splice(2) to copy data from one file descriptor to another.
*
* If this flag is not set, then only fall back if splice is
* unavailable.
*/
#define FUSE_BUF_COPY_FLAG_NO_SPLICE (1 << 1)
/**
* Try to move data with splice.
*
* If splice is used, try to move pages from the source to the
* destination instead of copying. See documentation of
* SPLICE_F_MOVE in splice(2) man page.
*/
FUSE_BUF_SPLICE_MOVE = (1 << 3),
/**
* Force splice
*
* Always use splice(2) to copy data from one file descriptor
* to another. If splice is not available, return -EINVAL.
*/
#define FUSE_BUF_COPY_FLAG_FORCE_SPLICE (1 << 2)
/**
* Try to move data with splice.
*
* If splice is used, try to move pages from the source to the
* destination instead of copying. See documentation of
* SPLICE_F_MOVE in splice(2) man page.
*/
#define FUSE_BUF_COPY_FLAG_SPLICE_MOVE (1 << 3)
/**
* Don't block on the pipe when copying data with splice
*
* Makes the operations on the pipe non-blocking (if the pipe
* is full or empty). See SPLICE_F_NONBLOCK in the splice(2)
* man page.
*/
#define FUSE_BUF_COPY_FLAG_SPLICE_NONBLOCK (1 << 4)
/**
* Don't block on the pipe when copying data with splice
*
* Makes the operations on the pipe non-blocking (if the pipe
* is full or empty). See SPLICE_F_NONBLOCK in the splice(2)
* man page.
*/
FUSE_BUF_SPLICE_NONBLOCK= (1 << 4),
};
/**
* Single data buffer
@ -365,14 +366,14 @@ struct fuse_buf {
/**
* Buffer flags
*/
enum fuse_buf_flags flags;
int flags;
/**
* Memory pointer
*
* Used unless FUSE_BUF_IS_FD flag is set.
*/
void *mem;
char *mem;
/**
* File descriptor
@ -427,7 +428,7 @@ struct fuse_bufvec {
/* .off = */ 0, \
/* .buf = */ { /* [0] = */ { \
/* .size = */ (size__), \
/* .flags = */ (enum fuse_buf_flags) 0, \
/* .flags = */ 0, \
/* .mem = */ NULL, \
/* .fd = */ -1, \
/* .pos = */ 0, \
@ -450,8 +451,7 @@ size_t fuse_buf_size(const struct fuse_bufvec *bufv);
* @param flags flags controlling the copy
* @return actual number of bytes copied or -errno on error
*/
ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src,
enum fuse_buf_copy_flags flags);
ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src, int flags);
/* ----------------------------------------------------------- *
* Signal handling *

10
libfuse/include/fuse_lowlevel.h
View File

@ -1202,8 +1202,7 @@ int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size);
* @param flags flags controlling the copy
* @return zero for success, -errno for failure to send reply
*/
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
enum fuse_buf_copy_flags flags);
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv, int flags);
/**
* Reply with data vector
@ -1406,7 +1405,7 @@ int fuse_lowlevel_notify_delete(struct fuse_chan *ch,
*/
int fuse_lowlevel_notify_store(struct fuse_chan *ch, fuse_ino_t ino,
off_t offset, struct fuse_bufvec *bufv,
enum fuse_buf_copy_flags flags);
int flags);
/**
* Retrieve data from the kernel buffers
*
@ -1486,7 +1485,7 @@ int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[]);
* @param req interrupted request
* @param data user data
*/
typedef void (*fuse_interrupt_func_t)(fuse_req_t req, void *data);
typedef void (*fuse_interrupt_func_t)(fuse_req_t req, struct fuse_intr_data *data);
/**
* Register/unregister callback for an interrupt
@ -1499,7 +1498,8 @@ typedef void (*fuse_interrupt_func_t)(fuse_req_t req, void *data);
* @param func the callback function or NULL for unregister
* @param data user data passed to the callback function
*/
void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
void fuse_req_interrupt_func(fuse_req_t req,
fuse_interrupt_func_t func,
void *data);
/**

138
libfuse/lib/buffer.c
View File

@ -6,15 +6,16 @@
See the file COPYING.LIB
*/
#define _GNU_SOURCE
#include "config.h"
#include "fuse_i.h"
#include "fuse_lowlevel.h"
#include <limits>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <assert.h>
size_t fuse_buf_size(const struct fuse_bufvec *bufv)
{
@ -22,8 +23,8 @@ size_t fuse_buf_size(const struct fuse_bufvec *bufv)
size_t size = 0;
for (i = 0; i < bufv->count; i++) {
if (bufv->buf[i].size == SIZE_MAX)
size = SIZE_MAX;
if (bufv->buf[i].size == std::numeric_limits<size_t>::max())
size = std::numeric_limits<size_t>::max();
else
size += bufv->buf[i].size;
}
@ -44,7 +45,7 @@ static ssize_t fuse_buf_write(const struct fuse_buf *dst, size_t dst_off,
size_t copied = 0;
while (len) {
if (dst->flags & FUSE_BUF_FD_SEEK) {
if (dst->flags & FUSE_BUF_FLAG_FD_SEEK) {
res = pwrite(dst->fd, src->mem + src_off, len,
dst->pos + dst_off);
} else {
@ -59,7 +60,7 @@ static ssize_t fuse_buf_write(const struct fuse_buf *dst, size_t dst_off,
break;
copied += res;
if (!(dst->flags & FUSE_BUF_FD_RETRY))
if (!(dst->flags & FUSE_BUF_FLAG_FD_RETRY))
break;
src_off += res;
@ -78,7 +79,7 @@ static ssize_t fuse_buf_read(const struct fuse_buf *dst, size_t dst_off,
size_t copied = 0;
while (len) {
if (src->flags & FUSE_BUF_FD_SEEK) {
if (src->flags & FUSE_BUF_FLAG_FD_SEEK) {
res = pread(src->fd, dst->mem + dst_off, len,
src->pos + src_off);
} else {
@ -93,7 +94,7 @@ static ssize_t fuse_buf_read(const struct fuse_buf *dst, size_t dst_off,
break;
copied += res;
if (!(src->flags & FUSE_BUF_FD_RETRY))
if (!(src->flags & FUSE_BUF_FLAG_FD_RETRY))
break;
dst_off += res;
@ -104,52 +105,56 @@ static ssize_t fuse_buf_read(const struct fuse_buf *dst, size_t dst_off,
return copied;
}
static ssize_t fuse_buf_fd_to_fd(const struct fuse_buf *dst, size_t dst_off,
const struct fuse_buf *src, size_t src_off,
size_t len)
static
ssize_t
fuse_buf_fd_to_fd(const struct fuse_buf *dst,
size_t dst_off,
const struct fuse_buf *src,
size_t src_off,
size_t len)
{
char buf[4096];
struct fuse_buf tmp = {
.size = sizeof(buf),
.flags = 0,
};
ssize_t res;
size_t copied = 0;
struct fuse_buf tmp;
tmp.mem = buf;
tmp.size = sizeof(buf);
tmp.flags = FUSE_BUF_FLAG_NONE;
tmp.mem = buf;
while (len) {
size_t this_len = min_size(tmp.size, len);
size_t read_len;
while(len)
{
ssize_t this_len = min_size(tmp.size, len);
ssize_t read_len;
res = fuse_buf_read(&tmp, 0, src, src_off, this_len);
if (res < 0) {
if (!copied)
return res;
break;
}
if (res == 0)
break;
res = fuse_buf_read(&tmp, 0, src, src_off, this_len);
if (res < 0) {
if (!copied)
return res;
break;
}
if (res == 0)
break;
read_len = res;
res = fuse_buf_write(dst, dst_off, &tmp, 0, read_len);
if (res < 0) {
if (!copied)
return res;
break;
}
if (res == 0)
break;
read_len = res;
res = fuse_buf_write(dst, dst_off, &tmp, 0, read_len);
if (res < 0) {
if (!copied)
return res;
break;
}
if (res == 0)
break;
copied += res;
copied += res;
if (res < this_len)
break;
if (res < this_len)
break;
dst_off += res;
src_off += res;
len -= res;
}
dst_off += res;
src_off += res;
len -= res;
}
return copied;
}
@ -157,7 +162,7 @@ static ssize_t fuse_buf_fd_to_fd(const struct fuse_buf *dst, size_t dst_off,
#ifdef HAVE_SPLICE
static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,
const struct fuse_buf *src, size_t src_off,
size_t len, enum fuse_buf_copy_flags flags)
size_t len, int flags)
{
int splice_flags = 0;
off_t *srcpos = NULL;
@ -167,16 +172,16 @@ static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,
ssize_t res;
size_t copied = 0;
if (flags & FUSE_BUF_SPLICE_MOVE)
if (flags & FUSE_BUF_COPY_FLAG_SPLICE_MOVE)
splice_flags |= SPLICE_F_MOVE;
if (flags & FUSE_BUF_SPLICE_NONBLOCK)
if (flags & FUSE_BUF_COPY_FLAG_SPLICE_NONBLOCK)
splice_flags |= SPLICE_F_NONBLOCK;
if (src->flags & FUSE_BUF_FD_SEEK) {
if (src->flags & FUSE_BUF_FLAG_FD_SEEK) {
srcpos_val = src->pos + src_off;
srcpos = &srcpos_val;
}
if (dst->flags & FUSE_BUF_FD_SEEK) {
if (dst->flags & FUSE_BUF_FLAG_FD_SEEK) {
dstpos_val = dst->pos + dst_off;
dstpos = &dstpos_val;
}
@ -188,7 +193,7 @@ static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,
if (copied)
break;
if (errno != EINVAL || (flags & FUSE_BUF_FORCE_SPLICE))
if (errno != EINVAL || (flags & FUSE_BUF_COPY_FLAG_FORCE_SPLICE))
return -errno;
/* Maybe splice is not supported for this combination */
@ -199,8 +204,8 @@ static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,
break;
copied += res;
if (!(src->flags & FUSE_BUF_FD_RETRY) &&
!(dst->flags & FUSE_BUF_FD_RETRY)) {
if (!(src->flags & FUSE_BUF_FLAG_FD_RETRY) &&
!(dst->flags & FUSE_BUF_FLAG_FD_RETRY)) {
break;
}
@ -223,10 +228,10 @@ static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,
static ssize_t fuse_buf_copy_one(const struct fuse_buf *dst, size_t dst_off,
const struct fuse_buf *src, size_t src_off,
size_t len, enum fuse_buf_copy_flags flags)
size_t len, int flags)
{
int src_is_fd = src->flags & FUSE_BUF_IS_FD;
int dst_is_fd = dst->flags & FUSE_BUF_IS_FD;
int src_is_fd = src->flags & FUSE_BUF_FLAG_IS_FD;
int dst_is_fd = dst->flags & FUSE_BUF_FLAG_IS_FD;
if (!src_is_fd && !dst_is_fd) {
char *dstmem = dst->mem + dst_off;
@ -244,7 +249,7 @@ static ssize_t fuse_buf_copy_one(const struct fuse_buf *dst, size_t dst_off,
return fuse_buf_write(dst, dst_off, src, src_off, len);
} else if (!dst_is_fd) {
return fuse_buf_read(dst, dst_off, src, src_off, len);
} else if (flags & FUSE_BUF_NO_SPLICE) {
} else if (flags & FUSE_BUF_COPY_FLAG_NO_SPLICE) {
return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
} else {
return fuse_buf_splice(dst, dst_off, src, src_off, len, flags);
@ -275,23 +280,26 @@ static int fuse_bufvec_advance(struct fuse_bufvec *bufv, size_t len)
return 1;
}
ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv,
enum fuse_buf_copy_flags flags)
ssize_t
fuse_buf_copy(struct fuse_bufvec *dstv,
struct fuse_bufvec *srcv,
int flags)
{
size_t copied = 0;
if (dstv == srcv)
if(dstv == srcv)
return fuse_buf_size(dstv);
for (;;) {
for (;;)
{
const struct fuse_buf *src = fuse_bufvec_current(srcv);
const struct fuse_buf *dst = fuse_bufvec_current(dstv);
size_t src_len;
size_t dst_len;
size_t len;
ssize_t src_len;
ssize_t dst_len;
ssize_t len;
ssize_t res;
if (src == NULL || dst == NULL)
if(src == NULL || dst == NULL)
break;
src_len = src->size - srcv->off;

553
libfuse/lib/fuse.c
View File

@ -8,7 +8,6 @@
/* For pthread_rwlock_t */
#define _GNU_SOURCE
#include "config.h"
#include "fuse_i.h"
@ -18,6 +17,8 @@
#include "fuse_kernel.h"
#include "fuse_dirents.h"
#include <limits>
#include <assert.h>
#include <dlfcn.h>
#include <errno.h>
@ -39,15 +40,9 @@
#include <time.h>
#include <unistd.h>
#define FUSE_NODE_SLAB 1
#ifndef MAP_ANONYMOUS
#undef FUSE_NODE_SLAB
#endif
#define FUSE_DEFAULT_INTR_SIGNAL SIGUSR1
#define FUSE_UNKNOWN_INO UINT64_MAX
#define FUSE_UNKNOWN_INO std::numeric_limits<uint64_t>::max()
#define OFFSET_MAX 0x7fffffffffffffffLL
#define NODE_TABLE_MIN_SIZE 8192
@ -102,13 +97,6 @@ struct node_table
size_t split;
};
#define container_of(ptr, type, member) ({ \
const typeof( ((type *)0)->member ) *__mptr = (ptr); \
(type *)( (char *)__mptr - offsetof(type,member) );})
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
struct list_head
{
struct list_head *next;
@ -216,32 +204,32 @@ list_empty(const struct list_head *head)
static
void
list_add(struct list_head *new,
struct list_head *prev,
struct list_head *next)
list_add(struct list_head *new_,
struct list_head *prev_,
struct list_head *next_)
{
next->prev = new;
new->next = next;
new->prev = prev;
prev->next = new;
next_->prev = new_;
new_->next = next_;
new_->prev = prev_;
prev_->next = new_;
}
static
inline
void
list_add_head(struct list_head *new,
struct list_head *head)
list_add_head(struct list_head *new_,
struct list_head *head_)
{
list_add(new, head, head->next);
list_add(new_,head_,head_->next);
}
static
inline
void
list_add_tail(struct list_head *new,
struct list_head *head)
list_add_tail(struct list_head *new_,
struct list_head *head_)
{
list_add(new, head->prev, head);
list_add(new_,head_->prev,head_);
}
static
@ -282,113 +270,6 @@ get_node_size(struct fuse *f)
return sizeof(struct node);
}
#ifdef FUSE_NODE_SLAB
static
struct node_slab*
list_to_slab(struct list_head *head)
{
return (struct node_slab *) head;
}
static
struct node_slab*
node_to_slab(struct fuse *f, struct node *node)
{
return (struct node_slab *) (((uintptr_t) node) & ~((uintptr_t) f->pagesize - 1));
}
static
int
alloc_slab(struct fuse *f)
{
void *mem;
struct node_slab *slab;
char *start;
size_t num;
size_t i;
size_t node_size = get_node_size(f);
mem = mmap(NULL, f->pagesize, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
if (mem == MAP_FAILED)
return -1;
slab = mem;
init_list_head(&slab->freelist);
slab->used = 0;
num = (f->pagesize - sizeof(struct node_slab)) / node_size;
start = (char *) mem + f->pagesize - num * node_size;
for (i = 0; i < num; i++) {
struct list_head *n;
n = (struct list_head *) (start + i * node_size);
list_add_tail(n, &slab->freelist);
}
list_add_tail(&slab->list, &f->partial_slabs);
return 0;
}
static
struct node*
alloc_node(struct fuse *f)
{
struct node_slab *slab;
struct list_head *node;
if (list_empty(&f->partial_slabs)) {
int res = alloc_slab(f);
if (res != 0)
return NULL;
}
slab = list_to_slab(f->partial_slabs.next);
slab->used++;
node = slab->freelist.next;
list_del(node);
if (list_empty(&slab->freelist)) {
list_del(&slab->list);
list_add_tail(&slab->list, &f->full_slabs);
}
memset(node, 0, sizeof(struct node));
return (struct node *) node;
}
static
void
free_slab(struct fuse *f,
struct node_slab *slab)
{
int res;
list_del(&slab->list);
res = munmap(slab, f->pagesize);
if (res == -1)
fprintf(stderr, "fuse warning: munmap(%p) failed\n", slab);
}
static
void
free_node_mem(struct fuse *f,
struct node *node)
{
struct node_slab *slab = node_to_slab(f, node);
struct list_head *n = (struct list_head *) node;
slab->used--;
if (slab->used) {
if (list_empty(&slab->freelist)) {
list_del(&slab->list);
list_add_tail(&slab->list, &f->partial_slabs);
}
list_add_head(n, &slab->freelist);
} else {
free_slab(f, slab);
}
}
#else
static
struct node*
alloc_node(struct fuse *f)
@ -404,7 +285,6 @@ free_node_mem(struct fuse *f,
(void) f;
free(node);
}
#endif
static
size_t
@ -496,13 +376,13 @@ void
node_table_reduce(struct node_table *t)
{
size_t newsize = t->size / 2;
void *newarray;
node **newarray;
if (newsize < NODE_TABLE_MIN_SIZE)
return;
newarray = realloc(t->array, sizeof(struct node *) * newsize);
if (newarray != NULL)
newarray = (node**)realloc(t->array,sizeof(struct node*)*newsize);
if(newarray != NULL)
t->array = newarray;
t->size = newsize;
@ -557,14 +437,14 @@ unhash_id(struct fuse *f, struct node *node)
static int node_table_resize(struct node_table *t)
{
size_t newsize = t->size * 2;
void *newarray;
node **newarray;
newarray = realloc(t->array, sizeof(struct node *) * newsize);
if (newarray == NULL)
newarray = (node**)realloc(t->array,sizeof(struct node*)*newsize);
if(newarray == NULL)
return -1;
t->array = newarray;
memset(t->array + t->size, 0, t->size * sizeof(struct node *));
memset(t->array + t->size,0,t->size*sizeof(struct node*));
t->size = newsize;
t->split = 0;
@ -780,7 +660,7 @@ next_id(struct fuse *f)
{
do
{
f->ctr = ((f->ctr + 1) & UINT64_MAX);
f->ctr = ((f->ctr + 1) & std::numeric_limits<uint64_t>::max());
if(f->ctr == 0)
f->generation++;
} while((f->ctr == 0) ||
@ -850,7 +730,12 @@ static struct node *find_node(struct fuse *f, fuse_ino_t parent,
return node;
}
static char *add_name(char **buf, unsigned *bufsize, char *s, const char *name)
static
char *
add_name(char **buf,
unsigned *bufsize,
char *s,
const char *name)
{
size_t len = strlen(name);
@ -866,7 +751,7 @@ static char *add_name(char **buf, unsigned *bufsize, char *s, const char *name)
newbufsize *= 2;
}
newbuf = realloc(*buf, newbufsize);
newbuf = (char*)realloc(*buf, newbufsize);
if (newbuf == NULL)
return NULL;
@ -917,7 +802,7 @@ static int try_get_path(struct fuse *f, fuse_ino_t nodeid, const char *name,
*path = NULL;
err = -ENOMEM;
buf = malloc(bufsize);
buf = (char*)malloc(bufsize);
if (buf == NULL)
goto out_err;
@ -1124,17 +1009,19 @@ static int get_path_common(struct fuse *f, fuse_ino_t nodeid, const char *name,
pthread_mutex_lock(&f->lock);
err = try_get_path(f, nodeid, name, path, wnode, true);
if (err == -EAGAIN) {
struct lock_queue_element qe = {
.nodeid1 = nodeid,
.name1 = name,
.path1 = path,
.wnode1 = wnode,
};
debug_path(f, "QUEUE PATH", nodeid, name, !!wnode);
err = wait_path(f, &qe);
debug_path(f, "DEQUEUE PATH", nodeid, name, !!wnode);
}
if(err == -EAGAIN)
{
struct lock_queue_element qe;
qe.nodeid1 = nodeid;
qe.name1 = name;
qe.path1 = path;
qe.wnode1 = wnode;
debug_path(f, "QUEUE PATH", nodeid, name, !!wnode);
err = wait_path(f, &qe);
debug_path(f, "DEQUEUE PATH", nodeid, name, !!wnode);
}
pthread_mutex_unlock(&f->lock);
return err;
@ -1188,24 +1075,25 @@ static int get_path2(struct fuse *f, fuse_ino_t nodeid1, const char *name1,
pthread_mutex_lock(&f->lock);
err = try_get_path2(f, nodeid1, name1, nodeid2, name2,
path1, path2, wnode1, wnode2);
if (err == -EAGAIN) {
struct lock_queue_element qe = {
.nodeid1 = nodeid1,
.name1 = name1,
.path1 = path1,
.wnode1 = wnode1,
.nodeid2 = nodeid2,
.name2 = name2,
.path2 = path2,
.wnode2 = wnode2,
};
debug_path(f, "QUEUE PATH1", nodeid1, name1, !!wnode1);
debug_path(f, " PATH2", nodeid2, name2, !!wnode2);
err = wait_path(f, &qe);
debug_path(f, "DEQUEUE PATH1", nodeid1, name1, !!wnode1);
debug_path(f, " PATH2", nodeid2, name2, !!wnode2);
}
if(err == -EAGAIN)
{
struct lock_queue_element qe;
qe.nodeid1 = nodeid1;
qe.name1 = name1;
qe.path1 = path1;
qe.wnode1 = wnode1;
qe.nodeid2 = nodeid2;
qe.name2 = name2;
qe.path2 = path2;
qe.wnode2 = wnode2;
debug_path(f, "QUEUE PATH1", nodeid1, name1, !!wnode1);
debug_path(f, " PATH2", nodeid2, name2, !!wnode2);
err = wait_path(f, &qe);
debug_path(f, "DEQUEUE PATH1", nodeid1, name1, !!wnode1);
debug_path(f, " PATH2", nodeid2, name2, !!wnode2);
}
pthread_mutex_unlock(&f->lock);
return err;
@ -1261,9 +1149,9 @@ forget_node(struct fuse *f,
*/
while(node->nlookup == nlookup && node->treelock)
{
struct lock_queue_element qe = {
.nodeid1 = nodeid,
};
struct lock_queue_element qe;
qe.nodeid1 = nodeid;
debug_path(f, "QUEUE PATH (forget)", nodeid, NULL, false);
queue_path(f, &qe);
@ -1366,16 +1254,20 @@ struct fuse_intr_data {
int finished;
};
static void fuse_interrupt(fuse_req_t req, void *d_)
static
void
fuse_interrupt(fuse_req_t req_,
fuse_intr_data *d_)
{
struct fuse_intr_data *d = d_;
struct fuse *f = req_fuse(req);
struct fuse *f = req_fuse(req_);
if (d->id == pthread_self())
if(d->id == pthread_self())
return;
pthread_mutex_lock(&f->lock);
while (!d->finished) {
while (!d->finished)
{
struct timeval now;
struct timespec timeout;
@ -1395,7 +1287,7 @@ static void fuse_do_finish_interrupt(struct fuse *f, fuse_req_t req,
d->finished = 1;
pthread_cond_broadcast(&d->cond);
pthread_mutex_unlock(&f->lock);
fuse_req_interrupt_func(req, NULL, NULL);
fuse_req_interrupt_func(req,NULL,NULL);
pthread_cond_destroy(&d->cond);
}
@ -1404,7 +1296,7 @@ static void fuse_do_prepare_interrupt(fuse_req_t req, struct fuse_intr_data *d)
d->id = pthread_self();
pthread_cond_init(&d->cond, NULL);
d->finished = 0;
fuse_req_interrupt_func(req, fuse_interrupt, d);
fuse_req_interrupt_func(req,fuse_interrupt,d);
}
static inline void fuse_finish_interrupt(struct fuse *f, fuse_req_t req,
@ -1617,9 +1509,12 @@ static void fuse_free_buf(struct fuse_bufvec *buf)
}
}
int fuse_fs_read_buf(struct fuse_fs *fs,
struct fuse_bufvec **bufp, size_t size, off_t off,
struct fuse_file_info *fi)
int
fuse_fs_read_buf(struct fuse_fs *fs,
struct fuse_bufvec **bufp,
size_t size,
off_t off,
struct fuse_file_info *fi)
{
fuse_get_context()->private_data = fs->user_data;
if (fs->op.read || fs->op.read_buf) {
@ -1635,13 +1530,13 @@ int fuse_fs_read_buf(struct fuse_fs *fs,
res = fs->op.read_buf(bufp, size, off, fi);
} else {
struct fuse_bufvec *buf;
void *mem;
char *mem;
buf = malloc(sizeof(struct fuse_bufvec));
if (buf == NULL)
buf = (struct fuse_bufvec*)malloc(sizeof(struct fuse_bufvec));
if(buf == NULL)
return -ENOMEM;
mem = malloc(size);
mem = (char*)malloc(size);
if (mem == NULL) {
free(buf);
return -ENOMEM;
@ -1660,7 +1555,7 @@ int fuse_fs_read_buf(struct fuse_fs *fs,
(unsigned long long) fi->fh,
fuse_buf_size(*bufp),
(unsigned long long) off);
if (res >= 0 && fuse_buf_size(*bufp) > (int) size)
if ((res >= 0) && fuse_buf_size(*bufp) > size)
fprintf(stderr, "fuse: read too many bytes\n");
if (res < 0)
@ -1683,83 +1578,98 @@ int fuse_fs_read(struct fuse_fs *fs, char *mem, size_t size,
struct fuse_bufvec dst = FUSE_BUFVEC_INIT(size);
dst.buf[0].mem = mem;
res = fuse_buf_copy(&dst, buf, 0);
res = fuse_buf_copy(&dst, buf, FUSE_BUF_FLAG_NONE);
}
fuse_free_buf(buf);
return res;
}
int fuse_fs_write_buf(struct fuse_fs *fs,
struct fuse_bufvec *buf, off_t off,
struct fuse_file_info *fi)
int
fuse_fs_write_buf(struct fuse_fs *fs,
struct fuse_bufvec *buf,
off_t off,
struct fuse_file_info *fi)
{
fuse_get_context()->private_data = fs->user_data;
if (fs->op.write_buf || fs->op.write) {
int res;
size_t size = fuse_buf_size(buf);
assert(buf->idx == 0 && buf->off == 0);
if (fs->debug)
fprintf(stderr,
"write%s[%llu] %zu bytes to %llu flags: 0x%x\n",
fi->writepage ? "page" : "",
(unsigned long long) fi->fh,
size,
(unsigned long long) off,
fi->flags);
if(fs->op.write_buf || fs->op.write)
{
int res;
size_t size = fuse_buf_size(buf);
assert(buf->idx == 0 && buf->off == 0);
if (fs->debug)
fprintf(stderr,
"write%s[%llu] %zu bytes to %llu flags: 0x%x\n",
fi->writepage ? "page" : "",
(unsigned long long) fi->fh,
size,
(unsigned long long) off,
fi->flags);
if (fs->op.write_buf)
{
res = fs->op.write_buf(buf, off, fi);
}
else
{
char *mem = NULL;
struct fuse_buf *flatbuf;
struct fuse_bufvec tmp = FUSE_BUFVEC_INIT(size);
if (fs->op.write_buf) {
res = fs->op.write_buf(buf, off, fi);
} else {
void *mem = NULL;
struct fuse_buf *flatbuf;
struct fuse_bufvec tmp = FUSE_BUFVEC_INIT(size);
if((buf->count == 1) &&
!(buf->buf[0].flags & FUSE_BUF_FLAG_IS_FD))
{
flatbuf = &buf->buf[0];
}
else
{
res = -ENOMEM;
mem = (char*)malloc(size);
if (mem == NULL)
goto out;
tmp.buf[0].mem = mem;
res = fuse_buf_copy(&tmp, buf, FUSE_BUF_FLAG_NONE);
if (res <= 0)
goto out_free;
tmp.buf[0].size = res;
flatbuf = &tmp.buf[0];
}
if (buf->count == 1 &&
!(buf->buf[0].flags & FUSE_BUF_IS_FD)) {
flatbuf = &buf->buf[0];
} else {
res = -ENOMEM;
mem = malloc(size);
if (mem == NULL)
goto out;
tmp.buf[0].mem = mem;
res = fuse_buf_copy(&tmp, buf, 0);
if (res <= 0)
goto out_free;
tmp.buf[0].size = res;
flatbuf = &tmp.buf[0];
}
res = fs->op.write(flatbuf->mem, flatbuf->size,
off, fi);
out_free:
free(mem);
}
out:
if (fs->debug && res >= 0)
fprintf(stderr, " write%s[%llu] %u bytes to %llu\n",
fi->writepage ? "page" : "",
(unsigned long long) fi->fh, res,
(unsigned long long) off);
if (res > (int) size)
fprintf(stderr, "fuse: wrote too many bytes\n");
res = fs->op.write(flatbuf->mem, flatbuf->size,
off, fi);
out_free:
free(mem);
return res;
}
else
{
return -ENOSYS;
}
out:
if (fs->debug && res >= 0)
fprintf(stderr, " write%s[%llu] %u bytes to %llu\n",
fi->writepage ? "page" : "",
(unsigned long long) fi->fh, res,
(unsigned long long) off);
if (res > (int) size)
fprintf(stderr, "fuse: wrote too many bytes\n");
return res;
} else {
return -ENOSYS;
}
}
int fuse_fs_write(struct fuse_fs *fs, const char *mem,
size_t size, off_t off, struct fuse_file_info *fi)
int
fuse_fs_write(struct fuse_fs *fs,
const char *mem,
size_t size,
off_t off,
struct fuse_file_info *fi)
{
struct fuse_bufvec bufv = FUSE_BUFVEC_INIT(size);
bufv.buf[0].mem = (void *) mem;
bufv.buf[0].mem = (char*)mem;
return fuse_fs_write_buf(fs, &bufv, off, fi);
}
@ -3199,7 +3109,7 @@ static void fuse_lib_read(fuse_req_t req, fuse_ino_t ino, size_t size,
fuse_finish_interrupt(f, req, &d);
if (res == 0)
fuse_reply_data(req, buf, FUSE_BUF_SPLICE_MOVE);
fuse_reply_data(req, buf, FUSE_BUF_COPY_FLAG_SPLICE_MOVE);
else
reply_err(req, res);
@ -3338,7 +3248,7 @@ readdir_buf_size(fuse_dirents_t *d_,
size_t size_,
off_t off_)
{
if(off_ >= kv_size(d_->offs))
if(off_ >= (off_t)kv_size(d_->offs))
return 0;
if((kv_A(d_->offs,off_) + size_) > d_->data_len)
return (d_->data_len - kv_A(d_->offs,off_));
@ -3694,16 +3604,18 @@ static int locks_insert(struct node *node, struct lock *lock)
struct lock *newl2 = NULL;
if (lock->type != F_UNLCK || lock->start != 0 ||
lock->end != OFFSET_MAX) {
newl1 = malloc(sizeof(struct lock));
newl2 = malloc(sizeof(struct lock));
if (!newl1 || !newl2) {
free(newl1);
free(newl2);
return -ENOLCK;
lock->end != OFFSET_MAX)
{
newl1 = (struct lock*)malloc(sizeof(struct lock));
newl2 = (struct lock*)malloc(sizeof(struct lock));
if(!newl1 || !newl2)
{
free(newl1);
free(newl2);
return -ENOLCK;
}
}
}
for (lp = &node->locks; *lp;) {
struct lock *l = *lp;
@ -3721,14 +3633,14 @@ static int locks_insert(struct node *node, struct lock *lock)
lock->start = l->start;
if (lock->end < l->end)
lock->end = l->end;
goto delete;
goto _delete;
} else {
if (l->end < lock->start)
goto skip;
if (lock->end < l->start)
break;
if (lock->start <= l->start && l->end <= lock->end)
goto delete;
goto _delete;
if (l->end <= lock->end) {
l->end = lock->start - 1;
goto skip;
@ -3747,7 +3659,7 @@ static int locks_insert(struct node *node, struct lock *lock)
lp = &l->next;
continue;
delete:
_delete:
delete_lock(lp);
}
if (lock->type != F_UNLCK) {
@ -3958,12 +3870,13 @@ static void fuse_lib_ioctl(fuse_req_t req, fuse_ino_t ino, unsigned long cmd, vo
else
fi = *llfi;
if (out_bufsz) {
err = -ENOMEM;
out_buf = malloc(out_bufsz);
if (!out_buf)
goto err;
}
if(out_bufsz)
{
err = -ENOMEM;
out_buf = (char*)malloc(out_bufsz);
if (!out_buf)
goto err;
}
assert(!in_bufsz || !out_bufsz || in_bufsz == out_bufsz);
if (out_buf)
@ -4049,7 +3962,8 @@ int fuse_clean_cache(struct fuse *f)
double age;
next = curr->next;
lnode = list_entry(curr, struct node_lru, lru);
lnode = ({ const list_head *__mptr = (curr); (struct node_lru*)((char*)__mptr - offsetof(struct node_lru,lru));});
//lnode = list_entry(curr, struct node_lru, lru);
node = &lnode->node;
age = diff_timespec(&now, &lnode->forget_time);
@ -4071,49 +3985,52 @@ int fuse_clean_cache(struct fuse *f)
return clean_delay(f);
}
static struct fuse_lowlevel_ops fuse_path_ops = {
.init = fuse_lib_init,
.destroy = fuse_lib_destroy,
.lookup = fuse_lib_lookup,
.forget = fuse_lib_forget,
.forget_multi = fuse_lib_forget_multi,
.getattr = fuse_lib_getattr,
.setattr = fuse_lib_setattr,
.access = fuse_lib_access,
.readlink = fuse_lib_readlink,
.mknod = fuse_lib_mknod,
.mkdir = fuse_lib_mkdir,
.unlink = fuse_lib_unlink,
.rmdir = fuse_lib_rmdir,
.symlink = fuse_lib_symlink,
.rename = fuse_lib_rename,
.link = fuse_lib_link,
.create = fuse_lib_create,
.open = fuse_lib_open,
.read = fuse_lib_read,
.write_buf = fuse_lib_write_buf,
.flush = fuse_lib_flush,
.release = fuse_lib_release,
.fsync = fuse_lib_fsync,
.opendir = fuse_lib_opendir,
.readdir = fuse_lib_readdir,
.readdir_plus = fuse_lib_readdir_plus,
.releasedir = fuse_lib_releasedir,
.fsyncdir = fuse_lib_fsyncdir,
.statfs = fuse_lib_statfs,
.setxattr = fuse_lib_setxattr,
.getxattr = fuse_lib_getxattr,
.listxattr = fuse_lib_listxattr,
.removexattr = fuse_lib_removexattr,
.getlk = fuse_lib_getlk,
.setlk = fuse_lib_setlk,
.flock = fuse_lib_flock,
.bmap = fuse_lib_bmap,
.ioctl = fuse_lib_ioctl,
.poll = fuse_lib_poll,
.fallocate = fuse_lib_fallocate,
.copy_file_range = fuse_lib_copy_file_range,
};
static struct fuse_lowlevel_ops fuse_path_ops =
{
fuse_lib_init,
fuse_lib_destroy,
fuse_lib_lookup,
fuse_lib_forget,
fuse_lib_getattr,
fuse_lib_setattr,
fuse_lib_readlink,
fuse_lib_mknod,
fuse_lib_mkdir,
fuse_lib_unlink,
fuse_lib_rmdir,
fuse_lib_symlink,
fuse_lib_rename,
fuse_lib_link,
fuse_lib_open,
fuse_lib_read,
NULL,
fuse_lib_flush,
fuse_lib_release,
fuse_lib_fsync,
fuse_lib_opendir,
fuse_lib_readdir,
fuse_lib_readdir_plus,
fuse_lib_releasedir,
fuse_lib_fsyncdir,
fuse_lib_statfs,
fuse_lib_setxattr,
fuse_lib_getxattr,
fuse_lib_listxattr,
fuse_lib_removexattr,
fuse_lib_access,
fuse_lib_create,
fuse_lib_getlk,
fuse_lib_setlk,
fuse_lib_bmap,
fuse_lib_ioctl,
fuse_lib_poll,
fuse_lib_write_buf,
NULL,
fuse_lib_forget_multi,
fuse_lib_flock,
fuse_lib_fallocate,
fuse_lib_copy_file_range
};
int fuse_notify_poll(struct fuse_pollhandle *ph)
{
@ -4342,7 +4259,7 @@ static int node_table_init(struct node_table *t)
static void *fuse_prune_nodes(void *fuse)
{
struct fuse *f = fuse;
struct fuse *f = (struct fuse*)fuse;
int sleep_time;
while(1) {

16
libfuse/lib/fuse_dirents.c
View File

@ -57,11 +57,11 @@ int
fuse_dirents_buf_resize(fuse_dirents_t *d_,
uint64_t size_)
{
void *p;
char *p;
if((d_->data_len + size_) >= d_->buf_len)
{
p = realloc(d_->buf,(d_->buf_len * 2));
p = (char*)realloc(d_->buf,(d_->buf_len * 2));
if(p == NULL)
return -errno;
@ -73,7 +73,7 @@ fuse_dirents_buf_resize(fuse_dirents_t *d_,
}
static
void*
fuse_dirent_t*
fuse_dirents_dirent_alloc(fuse_dirents_t *d_,
uint64_t namelen_)
{
@ -95,13 +95,13 @@ fuse_dirents_dirent_alloc(fuse_dirents_t *d_,
}
static
void*
fuse_direntplus_t*
fuse_dirents_direntplus_alloc(fuse_dirents_t *d_,
uint64_t namelen_)
{
int rv;
uint64_t size;
fuse_dirent_t *d;
fuse_direntplus_t *d;
size = fuse_direntplus_size(namelen_);
@ -109,7 +109,7 @@ fuse_dirents_direntplus_alloc(fuse_dirents_t *d_,
if(rv)
return NULL;
d = (fuse_dirent_t*)&d_->buf[d_->data_len];
d = (fuse_direntplus_t*)&d_->buf[d_->data_len];
d_->data_len += size;
@ -379,9 +379,9 @@ fuse_dirents_reset(fuse_dirents_t *d_)
int
fuse_dirents_init(fuse_dirents_t *d_)
{
void *buf;
char *buf;
buf = calloc(DEFAULT_SIZE,1);
buf = (char*)calloc(DEFAULT_SIZE,1);
if(buf == NULL)
return -ENOMEM;

11
libfuse/lib/fuse_kern_chan.c
View File

@ -88,12 +88,11 @@ fuse_kern_chan_new(int fd_)
{
long pagesize;
size_t bufsize;
struct fuse_chan_ops op =
{
.receive = fuse_kern_chan_receive,
.send = fuse_kern_chan_send,
.destroy = fuse_kern_chan_destroy,
};
struct fuse_chan_ops op;
op.receive = fuse_kern_chan_receive;
op.send = fuse_kern_chan_send;
op.destroy = fuse_kern_chan_destroy;
pagesize = sysconf(_SC_PAGESIZE);

12
libfuse/lib/fuse_loop_mt.c
View File

@ -68,12 +68,12 @@ static void *fuse_do_work(void *data)
while (!fuse_session_exited(mt->se)) {
struct fuse_chan *ch = mt->prevch;
struct fuse_buf fbuf = {
.mem = w->buf,
.size = w->bufsize,
};
struct fuse_buf fbuf;
int res;
fbuf.mem = w->buf;
fbuf.size = w->bufsize;
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
res = fuse_session_receive_buf(mt->se, &fbuf, &ch);
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
@ -134,14 +134,14 @@ int fuse_start_thread(pthread_t *thread_id, void *(*func)(void *), void *arg)
static int fuse_loop_start_thread(struct fuse_mt *mt)
{
int res;
struct fuse_worker *w = malloc(sizeof(struct fuse_worker));
struct fuse_worker *w = (struct fuse_worker*)malloc(sizeof(struct fuse_worker));
if (!w) {
fprintf(stderr, "fuse: failed to allocate worker structure\n");
return -1;
}
memset(w, 0, sizeof(struct fuse_worker));
w->bufsize = fuse_chan_bufsize(mt->prevch);
w->buf = calloc(w->bufsize,1);
w->buf = (char*)calloc(w->bufsize,1);
w->mt = mt;
if (!w->buf) {
fprintf(stderr, "fuse: failed to allocate read buffer\n");

318
libfuse/lib/fuse_lowlevel.c
View File

@ -6,8 +6,6 @@
See the file COPYING.LIB
*/
#define _GNU_SOURCE
#include "config.h"
#include "fuse_i.h"
#include "fuse_kernel.h"
@ -166,7 +164,7 @@ static struct fuse_req *fuse_ll_alloc_req(struct fuse_ll *f)
static int fuse_send_msg(struct fuse_ll *f, struct fuse_chan *ch,
struct iovec *iov, int count)
{
struct fuse_out_header *out = iov[0].iov_base;
struct fuse_out_header *out = (fuse_out_header*)iov[0].iov_base;
out->len = iov_length(iov, count);
if (f->debug) {
@ -235,7 +233,7 @@ int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count)
int res;
struct iovec *padded_iov;
padded_iov = malloc((count + 1) * sizeof(struct iovec));
padded_iov = (struct iovec*)malloc((count + 1) * sizeof(struct iovec));
if (padded_iov == NULL)
return fuse_reply_err(req, ENOMEM);
@ -434,7 +432,7 @@ static int fuse_send_data_iov_fallback(struct fuse_ll *f, struct fuse_chan *ch,
/* Optimize common case */
if (buf->count == 1 && buf->idx == 0 && buf->off == 0 &&
!(buf->buf[0].flags & FUSE_BUF_IS_FD)) {
!(buf->buf[0].flags & FUSE_BUF_FLAG_IS_FD)) {
/* FIXME: also avoid memory copy if there are multiple buffers
but none of them contain an fd */
@ -448,8 +446,8 @@ static int fuse_send_data_iov_fallback(struct fuse_ll *f, struct fuse_chan *ch,
if (res != 0)
return res;
mem_buf.buf[0].mem = mbuf;
res = fuse_buf_copy(&mem_buf, buf, 0);
mem_buf.buf[0].mem = (char*)mbuf;
res = fuse_buf_copy(&mem_buf,buf,FUSE_BUF_FLAG_NONE);
if (res < 0) {
free(mbuf);
return -res;
@ -481,11 +479,11 @@ static void fuse_ll_pipe_free(struct fuse_ll_pipe *llp)
#ifdef HAVE_SPLICE
static struct fuse_ll_pipe *fuse_ll_get_pipe(struct fuse_ll *f)
{
struct fuse_ll_pipe *llp = pthread_getspecific(f->pipe_key);
struct fuse_ll_pipe *llp = (fuse_ll_pipe*)pthread_getspecific(f->pipe_key);
if (llp == NULL) {
int res;
llp = malloc(sizeof(struct fuse_ll_pipe));
llp = (struct fuse_ll_pipe*)malloc(sizeof(struct fuse_ll_pipe));
if (llp == NULL)
return NULL;
@ -518,24 +516,30 @@ static struct fuse_ll_pipe *fuse_ll_get_pipe(struct fuse_ll *f)
static void fuse_ll_clear_pipe(struct fuse_ll *f)
{
struct fuse_ll_pipe *llp = pthread_getspecific(f->pipe_key);
if (llp) {
pthread_setspecific(f->pipe_key, NULL);
fuse_ll_pipe_free(llp);
}
struct fuse_ll_pipe *llp = (struct fuse_ll_pipe*)pthread_getspecific(f->pipe_key);
if(llp)
{
pthread_setspecific(f->pipe_key,NULL);
fuse_ll_pipe_free(llp);
}
}
#if defined(HAVE_SPLICE) && defined(HAVE_VMSPLICE)
static int read_back(int fd, char *buf, size_t len)
static
int
read_back(int fd,
void *buf_,
size_t len)
{
int res;
char *buf = (char*)buf_;
res = read(fd, buf, len);
if (res == -1) {
fprintf(stderr, "fuse: internal error: failed to read back from pipe: %s\n", strerror(errno));
return -EIO;
}
if (res != len) {
if (res != (int)len) {
fprintf(stderr, "fuse: internal error: short read back from pipe: %i from %zi\n", res, len);
return -EIO;
}
@ -548,7 +552,7 @@ static int fuse_send_data_iov(struct fuse_ll *f, struct fuse_chan *ch,
{
int res;
size_t len = fuse_buf_size(buf);
struct fuse_out_header *out = iov[0].iov_base;
struct fuse_out_header *out = (struct fuse_out_header*)iov[0].iov_base;
struct fuse_ll_pipe *llp;
int splice_flags;
size_t pipesize;
@ -560,12 +564,12 @@ static int fuse_send_data_iov(struct fuse_ll *f, struct fuse_chan *ch,
if (f->broken_splice_nonblock)
goto fallback;
if (flags & FUSE_BUF_NO_SPLICE)
if (flags & FUSE_BUF_COPY_FLAG_NO_SPLICE)
goto fallback;
total_fd_size = 0;
for (idx = buf->idx; idx < buf->count; idx++) {
if (buf->buf[idx].flags & FUSE_BUF_IS_FD) {
if (buf->buf[idx].flags & FUSE_BUF_FLAG_IS_FD) {
total_fd_size = buf->buf[idx].size;
if (idx == buf->idx)
total_fd_size -= buf->off;
@ -611,18 +615,18 @@ static int fuse_send_data_iov(struct fuse_ll *f, struct fuse_chan *ch,
if (res == -1)
goto fallback;
if (res != headerlen) {
if (res != (int)headerlen) {
res = -EIO;
fprintf(stderr, "fuse: short vmsplice to pipe: %u/%zu\n", res,
headerlen);
goto clear_pipe;
}
pipe_buf.buf[0].flags = FUSE_BUF_IS_FD;
pipe_buf.buf[0].flags = FUSE_BUF_FLAG_IS_FD;
pipe_buf.buf[0].fd = llp->pipe[1];
res = fuse_buf_copy(&pipe_buf, buf,
FUSE_BUF_FORCE_SPLICE | FUSE_BUF_SPLICE_NONBLOCK);
FUSE_BUF_COPY_FLAG_FORCE_SPLICE | FUSE_BUF_COPY_FLAG_SPLICE_NONBLOCK);
if (res < 0) {
if (res == -EAGAIN || res == -EINVAL) {
/*
@ -646,7 +650,7 @@ static int fuse_send_data_iov(struct fuse_ll *f, struct fuse_chan *ch,
goto clear_pipe;
}
if (res != 0 && res < len) {
if (res != 0 && (res < (int)len)) {
struct fuse_bufvec mem_buf = FUSE_BUFVEC_INIT(len);
void *mbuf;
size_t now_len = res;
@ -663,9 +667,9 @@ static int fuse_send_data_iov(struct fuse_ll *f, struct fuse_chan *ch,
if (res != 0)
goto clear_pipe;
mem_buf.buf[0].mem = mbuf;
mem_buf.buf[0].mem = (char*)mbuf;
mem_buf.off = now_len;
res = fuse_buf_copy(&mem_buf, buf, 0);
res = fuse_buf_copy(&mem_buf, buf, FUSE_BUF_FLAG_NONE);
if (res > 0) {
char *tmpbuf;
size_t extra_len = res;
@ -674,7 +678,7 @@ static int fuse_send_data_iov(struct fuse_ll *f, struct fuse_chan *ch,
* back the data from the pipe and then fall
* back to regular write.
*/
tmpbuf = malloc(headerlen);
tmpbuf = (char*)malloc(headerlen);
if (tmpbuf == NULL) {
free(mbuf);
res = ENOMEM;
@ -686,7 +690,7 @@ static int fuse_send_data_iov(struct fuse_ll *f, struct fuse_chan *ch,
free(mbuf);
goto clear_pipe;
}
res = read_back(llp->pipe[0], mbuf, now_len);
res = read_back(llp->pipe[0],mbuf,now_len);
if (res != 0) {
free(mbuf);
goto clear_pipe;
@ -712,7 +716,7 @@ static int fuse_send_data_iov(struct fuse_ll *f, struct fuse_chan *ch,
}
splice_flags = 0;
if ((flags & FUSE_BUF_SPLICE_MOVE) &&
if ((flags & FUSE_BUF_COPY_FLAG_SPLICE_MOVE) &&
(f->conn.want & FUSE_CAP_SPLICE_MOVE))
splice_flags |= SPLICE_F_MOVE;
@ -723,7 +727,7 @@ static int fuse_send_data_iov(struct fuse_ll *f, struct fuse_chan *ch,
perror("fuse: splice from pipe");
goto clear_pipe;
}
if (res != out->len) {
if (res != (int)out->len) {
res = -EIO;
fprintf(stderr, "fuse: short splice from pipe: %u/%u\n",
res, out->len);
@ -750,8 +754,10 @@ static int fuse_send_data_iov(struct fuse_ll *f, struct fuse_chan *ch,
}
#endif
int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv,
enum fuse_buf_copy_flags flags)
int
fuse_reply_data(fuse_req_t req,
struct fuse_bufvec *bufv,
int flags)
{
struct iovec iov[2];
struct fuse_out_header out;
@ -827,7 +833,7 @@ static struct fuse_ioctl_iovec *fuse_ioctl_iovec_copy(const struct iovec *iov,
struct fuse_ioctl_iovec *fiov;
size_t i;
fiov = malloc(sizeof(fiov[0]) * count);
fiov = (struct fuse_ioctl_iovec*)malloc(sizeof(fiov[0]) * count);
if (!fiov)
return NULL;
@ -942,7 +948,7 @@ int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov,
struct fuse_ioctl_out arg;
int res;
padded_iov = malloc((count + 2) * sizeof(struct iovec));
padded_iov = (struct iovec*)malloc((count + 2) * sizeof(struct iovec));
if (padded_iov == NULL)
return fuse_reply_err(req, ENOMEM);
@ -992,8 +998,8 @@ static void do_forget(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
static void do_batch_forget(fuse_req_t req, fuse_ino_t nodeid,
const void *inarg)
{
struct fuse_batch_forget_in *arg = (void *) inarg;
struct fuse_forget_one *param = (void *) PARAM(arg);
struct fuse_batch_forget_in *arg = (struct fuse_batch_forget_in*)inarg;
struct fuse_forget_one *param = (struct fuse_forget_one*)PARAM(arg);
unsigned int i;
(void) nodeid;
@ -1270,13 +1276,12 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
const struct fuse_buf *ibuf)
{
struct fuse_ll *f = req->f;
struct fuse_bufvec bufv = {
.buf[0] = *ibuf,
.count = 1,
};
struct fuse_bufvec bufv;
struct fuse_write_in *arg = (struct fuse_write_in *) inarg;
struct fuse_file_info fi;
bufv.buf[0] = *ibuf;
bufv.count = 1;
memset(&fi, 0, sizeof(fi));
fi.fh = arg->fh;
fi.writepage = arg->write_flags & 1;
@ -1285,11 +1290,11 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
bufv.buf[0].mem = ((char *) arg) + FUSE_COMPAT_WRITE_IN_SIZE;
bufv.buf[0].size -= sizeof(struct fuse_in_header) +
FUSE_COMPAT_WRITE_IN_SIZE;
assert(!(bufv.buf[0].flags & FUSE_BUF_IS_FD));
assert(!(bufv.buf[0].flags & FUSE_BUF_FLAG_IS_FD));
} else {
fi.lock_owner = arg->lock_owner;
fi.flags = arg->flags;
if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))
if (!(bufv.buf[0].flags & FUSE_BUF_FLAG_IS_FD))
bufv.buf[0].mem = PARAM(arg);
bufv.buf[0].size -= sizeof(struct fuse_in_header) +
@ -1306,7 +1311,7 @@ static void do_write_buf(fuse_req_t req, fuse_ino_t nodeid, const void *inarg,
out:
/* Need to reset the pipe if ->write_buf() didn't consume all data */
if ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)
if ((ibuf->flags & FUSE_BUF_FLAG_IS_FD) && bufv.idx < bufv.count)
fuse_ll_clear_pipe(f);
}
@ -1447,10 +1452,9 @@ static void do_statfs(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
if (req->f->op.statfs)
req->f->op.statfs(req, nodeid);
else {
struct statvfs buf = {
.f_namemax = 255,
.f_bsize = 512,
};
struct statvfs buf;
buf.f_namemax = 255;
buf.f_bsize = 512;
fuse_reply_statfs(req, &buf);
}
}
@ -1600,7 +1604,7 @@ static int find_interrupted(struct fuse_ll *f, struct fuse_req *req)
data = curr->u.ni.data;
pthread_mutex_unlock(&f->lock);
if (func)
func(curr, data);
func(curr,(fuse_intr_data*)data);
pthread_mutex_unlock(&curr->lock);
pthread_mutex_lock(&f->lock);
@ -1717,7 +1721,7 @@ static void do_poll(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
struct fuse_pollhandle *ph = NULL;
if (arg->flags & FUSE_POLL_SCHEDULE_NOTIFY) {
ph = malloc(sizeof(struct fuse_pollhandle));
ph = (struct fuse_pollhandle*)malloc(sizeof(struct fuse_pollhandle));
if (ph == NULL) {
fuse_reply_err(req, ENOMEM);
return;
@ -2146,7 +2150,7 @@ int fuse_lowlevel_notify_delete(struct fuse_chan *ch,
int fuse_lowlevel_notify_store(struct fuse_chan *ch, fuse_ino_t ino,
off_t offset, struct fuse_bufvec *bufv,
enum fuse_buf_copy_flags flags)
int flags)
{
struct fuse_out_header out;
struct fuse_notify_store_out outarg;
@ -2198,13 +2202,12 @@ static void fuse_ll_retrieve_reply(struct fuse_notify_req *nreq,
struct fuse_ll *f = req->f;
struct fuse_retrieve_req *rreq =
container_of(nreq, struct fuse_retrieve_req, nreq);
const struct fuse_notify_retrieve_in *arg = inarg;
struct fuse_bufvec bufv = {
.buf[0] = *ibuf,
.count = 1,
};
const struct fuse_notify_retrieve_in *arg = (struct fuse_notify_retrieve_in*)inarg;
struct fuse_bufvec bufv;
if (!(bufv.buf[0].flags & FUSE_BUF_IS_FD))
bufv.buf[0] = *ibuf;
bufv.count = 1;
if (!(bufv.buf[0].flags & FUSE_BUF_FLAG_IS_FD))
bufv.buf[0].mem = PARAM(arg);
bufv.buf[0].size -= sizeof(struct fuse_in_header) +
@ -2225,7 +2228,7 @@ static void fuse_ll_retrieve_reply(struct fuse_notify_req *nreq,
}
out:
free(rreq);
if ((ibuf->flags & FUSE_BUF_IS_FD) && bufv.idx < bufv.count)
if ((ibuf->flags & FUSE_BUF_FLAG_IS_FD) && bufv.idx < bufv.count)
fuse_ll_clear_pipe(f);
}
@ -2248,7 +2251,7 @@ int fuse_lowlevel_notify_retrieve(struct fuse_chan *ch, fuse_ino_t ino,
if (f->conn.proto_minor < 15)
return -ENOSYS;
rreq = malloc(sizeof(*rreq));
rreq = (struct fuse_retrieve_req*)malloc(sizeof(*rreq));
if (rreq == NULL)
return -ENOMEM;
@ -2297,7 +2300,7 @@ void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func,
req->u.ni.data = data;
pthread_mutex_unlock(&req->f->lock);
if (req->interrupted && func)
func(req, data);
func(req,(fuse_intr_data*)data);
pthread_mutex_unlock(&req->lock);
}
@ -2312,55 +2315,12 @@ int fuse_req_interrupted(fuse_req_t req)
return interrupted;
}
typedef void (*fuse_ll_func_t)(fuse_req_t,fuse_ino_t,const void*);
static struct {
void (*func)(fuse_req_t, fuse_ino_t, const void *);
fuse_ll_func_t func;
const char *name;
} fuse_ll_ops[] =
{
[FUSE_LOOKUP] = { do_lookup, "LOOKUP" },
[FUSE_FORGET] = { do_forget, "FORGET" },
[FUSE_GETATTR] = { do_getattr, "GETATTR" },
[FUSE_SETATTR] = { do_setattr, "SETATTR" },
[FUSE_READLINK] = { do_readlink, "READLINK" },
[FUSE_SYMLINK] = { do_symlink, "SYMLINK" },
[FUSE_MKNOD] = { do_mknod, "MKNOD" },
[FUSE_MKDIR] = { do_mkdir, "MKDIR" },
[FUSE_UNLINK] = { do_unlink, "UNLINK" },
[FUSE_RMDIR] = { do_rmdir, "RMDIR" },
[FUSE_RENAME] = { do_rename, "RENAME" },
[FUSE_LINK] = { do_link, "LINK" },
[FUSE_OPEN] = { do_open, "OPEN" },
[FUSE_READ] = { do_read, "READ" },
[FUSE_WRITE] = { do_write, "WRITE" },
[FUSE_STATFS] = { do_statfs, "STATFS" },
[FUSE_RELEASE] = { do_release, "RELEASE" },
[FUSE_FSYNC] = { do_fsync, "FSYNC" },
[FUSE_SETXATTR] = { do_setxattr, "SETXATTR" },
[FUSE_GETXATTR] = { do_getxattr, "GETXATTR" },
[FUSE_LISTXATTR] = { do_listxattr, "LISTXATTR" },
[FUSE_REMOVEXATTR] = { do_removexattr, "REMOVEXATTR" },
[FUSE_FLUSH] = { do_flush, "FLUSH" },
[FUSE_INIT] = { do_init, "INIT" },
[FUSE_OPENDIR] = { do_opendir, "OPENDIR" },
[FUSE_READDIR] = { do_readdir, "READDIR" },
[FUSE_READDIRPLUS] = { do_readdir_plus, "READDIR_PLUS" },
[FUSE_RELEASEDIR] = { do_releasedir, "RELEASEDIR" },
[FUSE_FSYNCDIR] = { do_fsyncdir, "FSYNCDIR" },
[FUSE_GETLK] = { do_getlk, "GETLK" },
[FUSE_SETLK] = { do_setlk, "SETLK" },
[FUSE_SETLKW] = { do_setlkw, "SETLKW" },
[FUSE_ACCESS] = { do_access, "ACCESS" },
[FUSE_CREATE] = { do_create, "CREATE" },
[FUSE_INTERRUPT] = { do_interrupt, "INTERRUPT" },
[FUSE_BMAP] = { do_bmap, "BMAP" },
[FUSE_IOCTL] = { do_ioctl, "IOCTL" },
[FUSE_POLL] = { do_poll, "POLL" },
[FUSE_FALLOCATE] = { do_fallocate, "FALLOCATE" },
[FUSE_DESTROY] = { do_destroy, "DESTROY" },
[FUSE_NOTIFY_REPLY] = { (void *) 1, "NOTIFY_REPLY" },
[FUSE_BATCH_FORGET] = { do_batch_forget, "BATCH_FORGET" },
[FUSE_COPY_FILE_RANGE] = { do_copy_file_range, "COPY_FILE_RANGE" },
};
} fuse_ll_ops[FUSE_REMOVEMAPPING];
#define FUSE_MAXOP (sizeof(fuse_ll_ops) / sizeof(fuse_ll_ops[0]))
@ -2380,7 +2340,7 @@ static int fuse_ll_copy_from_pipe(struct fuse_bufvec *dst,
fprintf(stderr, "fuse: copy from pipe: %s\n", strerror(-res));
return res;
}
if (res < fuse_buf_size(dst)) {
if (res < (int)fuse_buf_size(dst)) {
fprintf(stderr, "fuse: copy from pipe: short read\n");
return -1;
}
@ -2393,33 +2353,35 @@ static void fuse_ll_process_buf(void *data, const struct fuse_buf *buf,
struct fuse_ll *f = (struct fuse_ll *) data;
const size_t write_header_size = sizeof(struct fuse_in_header) +
sizeof(struct fuse_write_in);
struct fuse_bufvec bufv = { .buf[0] = *buf, .count = 1 };
struct fuse_bufvec bufv;
struct fuse_bufvec tmpbuf = FUSE_BUFVEC_INIT(write_header_size);
struct fuse_in_header *in;
const void *inarg;
struct fuse_req *req;
void *mbuf = NULL;
char *mbuf = NULL;
int err;
int res;
if (buf->flags & FUSE_BUF_IS_FD) {
bufv.buf[0] = *buf;
bufv.count = 1;
if (buf->flags & FUSE_BUF_FLAG_IS_FD) {
if (buf->size < tmpbuf.buf[0].size)
tmpbuf.buf[0].size = buf->size;
mbuf = malloc(tmpbuf.buf[0].size);
mbuf = (char*)malloc(tmpbuf.buf[0].size);
if (mbuf == NULL) {
fprintf(stderr, "fuse: failed to allocate header\n");
goto clear_pipe;
}
tmpbuf.buf[0].mem = mbuf;
tmpbuf.buf[0].mem = (char*)mbuf;
res = fuse_ll_copy_from_pipe(&tmpbuf, &bufv);
if (res < 0)
goto clear_pipe;
in = mbuf;
in = (fuse_in_header*)mbuf;
} else {
in = buf->mem;
in = (fuse_in_header*)buf->mem;
}
if (f->debug) {
@ -2431,19 +2393,20 @@ static void fuse_ll_process_buf(void *data, const struct fuse_buf *buf,
}
req = fuse_ll_alloc_req(f);
if (req == NULL) {
struct fuse_out_header out = {
.unique = in->unique,
.error = -ENOMEM,
};
struct iovec iov = {
.iov_base = &out,
.iov_len = sizeof(struct fuse_out_header),
};
fuse_send_msg(f, ch, &iov, 1);
goto clear_pipe;
}
if (req == NULL)
{
struct fuse_out_header out;
struct iovec iov;
out.unique = in->unique;
out.error = -ENOMEM;
iov.iov_base = &out;
iov.iov_len = sizeof(struct fuse_out_header);
fuse_send_msg(f, ch, &iov, 1);
goto clear_pipe;
}
req->unique = in->unique;
req->ctx.uid = in->uid;
@ -2492,7 +2455,7 @@ static void fuse_ll_process_buf(void *data, const struct fuse_buf *buf,
fuse_reply_err(intr, EAGAIN);
}
if ((buf->flags & FUSE_BUF_IS_FD) && write_header_size < buf->size &&
if ((buf->flags & FUSE_BUF_FLAG_IS_FD) && write_header_size < buf->size &&
(in->opcode != FUSE_WRITE || !f->op.write_buf) &&
in->opcode != FUSE_NOTIFY_REPLY) {
void *newmbuf;
@ -2501,7 +2464,7 @@ static void fuse_ll_process_buf(void *data, const struct fuse_buf *buf,
newmbuf = realloc(mbuf, buf->size);
if (newmbuf == NULL)
goto reply_err;
mbuf = newmbuf;
mbuf = (char*)newmbuf;
tmpbuf = FUSE_BUFVEC_INIT(buf->size - write_header_size);
tmpbuf.buf[0].mem = mbuf + write_header_size;
@ -2511,7 +2474,7 @@ static void fuse_ll_process_buf(void *data, const struct fuse_buf *buf,
if (res < 0)
goto reply_err;
in = mbuf;
in = (fuse_in_header*)mbuf;
}
inarg = (void *) &in[1];
@ -2529,7 +2492,7 @@ static void fuse_ll_process_buf(void *data, const struct fuse_buf *buf,
reply_err:
fuse_reply_err(req, err);
clear_pipe:
if (buf->flags & FUSE_BUF_IS_FD)
if (buf->flags & FUSE_BUF_FLAG_IS_FD)
fuse_ll_clear_pipe(f);
goto out_free;
}
@ -2537,10 +2500,10 @@ static void fuse_ll_process_buf(void *data, const struct fuse_buf *buf,
static void fuse_ll_process(void *data, const char *buf, size_t len,
struct fuse_chan *ch)
{
struct fuse_buf fbuf = {
.mem = (void *) buf,
.size = len,
};
struct fuse_buf fbuf;
fbuf.mem = (char*)buf;
fbuf.size = len;
fuse_ll_process_buf(data, &fbuf, ch);
}
@ -2632,7 +2595,7 @@ static void fuse_ll_destroy(void *data)
if (f->op.destroy)
f->op.destroy(f->userdata);
}
llp = pthread_getspecific(f->pipe_key);
llp = (fuse_ll_pipe*)pthread_getspecific(f->pipe_key);
if (llp != NULL)
fuse_ll_pipe_free(llp);
pthread_key_delete(f->pipe_key);
@ -2642,7 +2605,7 @@ static void fuse_ll_destroy(void *data)
static void fuse_ll_pipe_destructor(void *data)
{
struct fuse_ll_pipe *llp = data;
struct fuse_ll_pipe *llp = (fuse_ll_pipe*)data;
fuse_ll_pipe_free(llp);
}
@ -2651,7 +2614,7 @@ static int fuse_ll_receive_buf(struct fuse_session *se, struct fuse_buf *buf,
struct fuse_chan **chp)
{
struct fuse_chan *ch = *chp;
struct fuse_ll *f = fuse_session_data(se);
struct fuse_ll *f = (fuse_ll*)fuse_session_data(se);
size_t bufsize = buf->size;
struct fuse_ll_pipe *llp;
struct fuse_buf tmpbuf;
@ -2694,26 +2657,28 @@ static int fuse_ll_receive_buf(struct fuse_session *se, struct fuse_buf *buf,
return -err;
}
if (res < sizeof(struct fuse_in_header)) {
if (res < (int)sizeof(struct fuse_in_header)) {
fprintf(stderr, "short splice from fuse device\n");
return -EIO;
}
tmpbuf = (struct fuse_buf) {
.size = res,
.flags = FUSE_BUF_IS_FD,
.fd = llp->pipe[0],
};
tmpbuf.size = (size_t)res;
tmpbuf.flags = FUSE_BUF_FLAG_IS_FD;
tmpbuf.fd = llp->pipe[0];
/*
* Don't bother with zero copy for small requests.
* fuse_loop_mt() needs to check for FORGET so this more than
* just an optimization.
*/
if (res < sizeof(struct fuse_in_header) +
sizeof(struct fuse_write_in) + pagesize) {
struct fuse_bufvec src = { .buf[0] = tmpbuf, .count = 1 };
struct fuse_bufvec dst = { .buf[0] = *buf, .count = 1 };
if (res < (int)(sizeof(struct fuse_in_header) + sizeof(struct fuse_write_in) + pagesize)) {
struct fuse_bufvec src;
struct fuse_bufvec dst;
src.buf[0] = tmpbuf;
src.count = 1;
dst.buf[0] = *buf;
dst.count = 1;
res = fuse_buf_copy(&dst, &src, 0);
if (res < 0) {
@ -2722,7 +2687,7 @@ static int fuse_ll_receive_buf(struct fuse_session *se, struct fuse_buf *buf,
fuse_ll_clear_pipe(f);
return res;
}
if (res < tmpbuf.size) {
if (res < (int)tmpbuf.size) {
fprintf(stderr, "fuse: copy from pipe: short read\n");
fuse_ll_clear_pipe(f);
return -EIO;
@ -2760,6 +2725,53 @@ static int fuse_ll_receive_buf(struct fuse_session *se, struct fuse_buf *buf,
}
#endif
static
void
fuse_lowlevel_setup_ops(void)
{
fuse_ll_ops[FUSE_ACCESS] = { do_access, "ACCESS" };
fuse_ll_ops[FUSE_BATCH_FORGET] = { do_batch_forget, "BATCH_FORGET" };
fuse_ll_ops[FUSE_BMAP] = { do_bmap, "BMAP" };
fuse_ll_ops[FUSE_COPY_FILE_RANGE] = { do_copy_file_range, "COPY_FILE_RANGE" };
fuse_ll_ops[FUSE_CREATE] = { do_create, "CREATE" };
fuse_ll_ops[FUSE_DESTROY] = { do_destroy, "DESTROY" };
fuse_ll_ops[FUSE_FALLOCATE] = { do_fallocate, "FALLOCATE" };
fuse_ll_ops[FUSE_FLUSH] = { do_flush, "FLUSH" };
fuse_ll_ops[FUSE_FORGET] = { do_forget, "FORGET" };
fuse_ll_ops[FUSE_FSYNCDIR] = { do_fsyncdir, "FSYNCDIR" };
fuse_ll_ops[FUSE_FSYNC] = { do_fsync, "FSYNC" };
fuse_ll_ops[FUSE_GETATTR] = { do_getattr, "GETATTR" };
fuse_ll_ops[FUSE_GETLK] = { do_getlk, "GETLK" };
fuse_ll_ops[FUSE_GETXATTR] = { do_getxattr, "GETXATTR" };
fuse_ll_ops[FUSE_INIT] = { do_init, "INIT" };
fuse_ll_ops[FUSE_INTERRUPT] = { do_interrupt, "INTERRUPT" };
fuse_ll_ops[FUSE_IOCTL] = { do_ioctl, "IOCTL" };
fuse_ll_ops[FUSE_LINK] = { do_link, "LINK" };
fuse_ll_ops[FUSE_LISTXATTR] = { do_listxattr, "LISTXATTR" };
fuse_ll_ops[FUSE_LOOKUP] = { do_lookup, "LOOKUP" };
fuse_ll_ops[FUSE_MKDIR] = { do_mkdir, "MKDIR" };
fuse_ll_ops[FUSE_MKNOD] = { do_mknod, "MKNOD" };
fuse_ll_ops[FUSE_OPENDIR] = { do_opendir, "OPENDIR" };
fuse_ll_ops[FUSE_OPEN] = { do_open, "OPEN" };
fuse_ll_ops[FUSE_POLL] = { do_poll, "POLL" };
fuse_ll_ops[FUSE_READDIR] = { do_readdir, "READDIR" };
fuse_ll_ops[FUSE_READDIRPLUS] = { do_readdir_plus, "READDIRPLUS" };
fuse_ll_ops[FUSE_READLINK] = { do_readlink, "READLINK" };
fuse_ll_ops[FUSE_READ] = { do_read, "READ" };
fuse_ll_ops[FUSE_RELEASEDIR] = { do_releasedir, "RELEASEDIR" };
fuse_ll_ops[FUSE_RELEASE] = { do_release, "RELEASE" };
fuse_ll_ops[FUSE_REMOVEXATTR] = { do_removexattr, "REMOVEXATTR" };
fuse_ll_ops[FUSE_RENAME] = { do_rename, "RENAME" };
fuse_ll_ops[FUSE_RMDIR] = { do_rmdir, "RMDIR" };
fuse_ll_ops[FUSE_SETATTR] = { do_setattr, "SETATTR" };
fuse_ll_ops[FUSE_SETLKW] = { do_setlkw, "SETLKW" };
fuse_ll_ops[FUSE_SETLK] = { do_setlk, "SETLK" };
fuse_ll_ops[FUSE_SETXATTR] = { do_setxattr, "SETXATTR" };
fuse_ll_ops[FUSE_STATFS] = { do_statfs, "STATFS" };
fuse_ll_ops[FUSE_SYMLINK] = { do_symlink, "SYMLINK" };
fuse_ll_ops[FUSE_UNLINK] = { do_unlink, "UNLINK" };
fuse_ll_ops[FUSE_WRITE] = { do_write, "WRITE" };
}
/*
* always call fuse_lowlevel_new_common() internally, to work around a
@ -2773,10 +2785,12 @@ struct fuse_session *fuse_lowlevel_new_common(struct fuse_args *args,
int err;
struct fuse_ll *f;
struct fuse_session *se;
struct fuse_session_ops sop = {
.process = fuse_ll_process,
.destroy = fuse_ll_destroy,
};
struct fuse_session_ops sop;
fuse_lowlevel_setup_ops();
sop.process = fuse_ll_process;
sop.destroy = fuse_ll_destroy;
if (sizeof(struct fuse_lowlevel_ops) < op_size) {
fprintf(stderr, "fuse: warning: library too old, some operations may not work\n");

16
libfuse/lib/fuse_mt.c
View File

@ -75,14 +75,14 @@ int fuse_loop_mt_proc(struct fuse *f, fuse_processor_t proc, void *data)
struct fuse_session *se;
struct fuse_chan *prevch = fuse_session_next_chan(prevse, NULL);
struct fuse_chan *ch;
struct fuse_session_ops sop = {
.exit = mt_session_exit,
.exited = mt_session_exited,
.process = mt_session_proc,
};
struct fuse_chan_ops cop = {
.receive = mt_chan_receive,
};
struct fuse_session_ops sop;
struct fuse_chan_ops cop;
sop.exit = mt_session_exit;
sop.exited = mt_session_exited;
sop.process = mt_session_proc;
cop.receive = mt_chan_receive;
pd.f = f;
pd.prevch = prevch;

19
libfuse/lib/fuse_opt.c
View File

@ -63,7 +63,7 @@ fuse_opt_add_arg(struct fuse_args *args, const char *arg)
if (!newarg)
return alloc_failed();
newargv = realloc(args->argv, (args->argc + 2) * sizeof(char *));
newargv = (char**)realloc(args->argv, (args->argc + 2) * sizeof(char *));
if (!newargv) {
free(newarg);
return alloc_failed();
@ -115,7 +115,7 @@ static int add_arg(struct fuse_opt_context *ctx, const char *arg)
static int add_opt_common(char **opts, const char *opt, int esc)
{
unsigned oldlen = *opts ? strlen(*opts) : 0;
char *d = realloc(*opts, oldlen + 1 + strlen(opt) * 2 + 1);
char *d = (char*)realloc(*opts, oldlen + 1 + strlen(opt) * 2 + 1);
if (!d)
return alloc_failed();
@ -231,7 +231,7 @@ static int process_opt(struct fuse_opt_context *ctx,
if (call_proc(ctx, arg, opt->value, iso) == -1)
return -1;
} else {
void *var = ctx->data + opt->offset;
void *var = (char*)ctx->data + opt->offset;
if (sep && opt->templ[sep + 1]) {
const char *param = arg + sep;
if (opt->templ[sep] == '=')
@ -257,7 +257,7 @@ static int process_opt_sep_arg(struct fuse_opt_context *ctx,
return -1;
param = ctx->argv[ctx->argctr];
newarg = malloc(sep + strlen(param) + 1);
newarg = (char*)malloc(sep + strlen(param) + 1);
if (!newarg)
return alloc_failed();
@ -397,15 +397,14 @@ int fuse_opt_parse(struct fuse_args *args, void *data,
const struct fuse_opt opts[], fuse_opt_proc_t proc)
{
int res;
struct fuse_opt_context ctx = {
.data = data,
.opt = opts,
.proc = proc,
};
struct fuse_opt_context ctx;
if (!args || !args->argv || !args->argc)
if(!args || !args->argv || !args->argc)
return 0;
ctx.data = data;
ctx.opt = opts;
ctx.proc = proc;
ctx.argc = args->argc;
ctx.argv = args->argv;

4
libfuse/lib/fuse_session.c
View File

@ -79,8 +79,8 @@ void fuse_session_process_buf(struct fuse_session *se,
if (se->process_buf) {
se->process_buf(se->data, buf, ch);
} else {
assert(!(buf->flags & FUSE_BUF_IS_FD));
fuse_session_process(se->data, buf->mem, buf->size, ch);
assert(!(buf->flags & FUSE_BUF_FLAG_IS_FD));
fuse_session_process((fuse_session*)se->data, buf->mem, buf->size, ch);
}
}

2
libfuse/lib/helper.c
View File

@ -87,7 +87,7 @@ static void helper_version(void)
static int fuse_helper_opt_proc(void *data, const char *arg, int key,
struct fuse_args *outargs)
{
struct helper_opts *hopts = data;
struct helper_opts *hopts = (helper_opts*)data;
switch (key) {
case KEY_HELP:

10
libfuse/lib/mount_generic.c
View File

@ -205,7 +205,7 @@ static void set_mount_flag(const char *s, int *flags)
static int fuse_mount_opt_proc(void *data, const char *arg, int key,
struct fuse_args *outargs)
{
struct mount_opts *mo = data;
struct mount_opts *mo = (mount_opts*)data;
switch (key) {
case KEY_ALLOW_ROOT:
@ -465,11 +465,11 @@ static int fuse_mount_sys(const char *mnt, struct mount_opts *mo,
if (res == -1)
goto out_close;
source = malloc((mo->fsname ? strlen(mo->fsname) : 0) +
(mo->subtype ? strlen(mo->subtype) : 0) +
strlen(devname) + 32);
source = (char*)malloc((mo->fsname ? strlen(mo->fsname) : 0) +
(mo->subtype ? strlen(mo->subtype) : 0) +
strlen(devname) + 32);
type = malloc((mo->subtype ? strlen(mo->subtype) : 0) + 32);
type = (char*)malloc((mo->subtype ? strlen(mo->subtype) : 0) + 32);
if (!type || !source) {
fprintf(stderr, "fuse: failed to allocate memory\n");
goto out_close;

8
libfuse/util/fusermount.c
View File

@ -235,7 +235,7 @@ static int may_unmount(const char *mnt, int quiet)
*/
static int check_is_mount_child(void *p)
{
const char **a = p;
const char **a = (const char**)p;
const char *last = a[0];
const char *mnt = a[1];
int res;
@ -817,10 +817,10 @@ static int do_mount(const char *mnt, char **typep, mode_t rootmode,
fuse_mnt_check_empty(progname, mnt, rootmode, rootsize) == -1)
goto err;
source = malloc((fsname ? strlen(fsname) : 0) +
(subtype ? strlen(subtype) : 0) + strlen(dev) + 32);
source = (char*)malloc((fsname ? strlen(fsname) : 0) +
(subtype ? strlen(subtype) : 0) + strlen(dev) + 32);
type = malloc((subtype ? strlen(subtype) : 0) + 32);
type = (char*)malloc(((subtype != NULL) ? strlen(subtype) : 0) + 32);
if (!type || !source) {
fprintf(stderr, "%s: failed to allocate memory\n", progname);
goto err;

4
libfuse/util/mount.mergerfs.c
View File

@ -38,7 +38,7 @@ static void add_arg(char **cmdp, const char *opt)
{
size_t optlen = strlen(opt);
size_t cmdlen = *cmdp ? strlen(*cmdp) : 0;
char *cmd = xrealloc(*cmdp, cmdlen + optlen * 4 + 4);
char *cmd = (char*)xrealloc(*cmdp, cmdlen + optlen * 4 + 4);
char *s;
s = cmd + cmdlen;
if (*cmdp)
@ -63,7 +63,7 @@ static char *add_option(const char *opt, char *options)
{
int oldlen = options ? strlen(options) : 0;
options = xrealloc(options, oldlen + 1 + strlen(opt) + 1);
options = (char*)xrealloc(options, oldlen + 1 + strlen(opt) + 1);
if (!oldlen)
strcpy(options, opt);
else {

2
src/fuse_read_buf.cpp
View File

@ -41,7 +41,7 @@ namespace l
*src = FUSE_BUFVEC_INIT(size_);
src->buf->flags = (fuse_buf_flags)(FUSE_BUF_IS_FD|FUSE_BUF_FD_SEEK|FUSE_BUF_FD_RETRY);
src->buf->flags = (FUSE_BUF_FLAG_IS_FD|FUSE_BUF_FLAG_FD_SEEK|FUSE_BUF_FLAG_FD_RETRY);
src->buf->fd = fd_;
src->buf->pos = offset_;

5
src/fuse_write_buf.cpp
View File

@ -49,10 +49,9 @@ namespace l
{
size_t size = fuse_buf_size(src_);
fuse_bufvec dst = FUSE_BUFVEC_INIT(size);
const fuse_buf_copy_flags cpflags =
(fuse_buf_copy_flags)(FUSE_BUF_SPLICE_MOVE|FUSE_BUF_SPLICE_NONBLOCK);
const int cpflags = (FUSE_BUF_COPY_FLAG_SPLICE_MOVE|FUSE_BUF_COPY_FLAG_SPLICE_NONBLOCK);
dst.buf->flags = (fuse_buf_flags)(FUSE_BUF_IS_FD|FUSE_BUF_FD_SEEK);
dst.buf->flags = (FUSE_BUF_FLAG_IS_FD|FUSE_BUF_FLAG_FD_SEEK);
dst.buf->fd = fd_;
dst.buf->pos = offset_;

Write Preview
Loading…
Cancel
Save