passthrough.c

Go to the documentation of this file.

/*
  FUSE: Filesystem in Userspace
  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
  Copyright (C) 2011       Sebastian Pipping <sebastian@pipping.org>
 
  This program can be distributed under the terms of the GNU GPLv2.
  See the file GPL2.txt.
*/
 
#define FUSE_USE_VERSION FUSE_MAKE_VERSION(3, 18)
 
#define _GNU_SOURCE
 
#ifdef linux
/* For pread()/pwrite()/utimensat() */
#define _XOPEN_SOURCE 700
#endif
 
#include <fuse.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <dirent.h>
#include <errno.h>
#include <sys/time.h>
#ifdef HAVE_SETXATTR
#include <sys/xattr.h>
#endif
 
#include "passthrough_helpers.h"
 
static int fill_dir_plus = 0;
static int readdir_zero_ino;
 
static void *xmp_init(struct fuse_conn_info *conn,
                      struct fuse_config *cfg)
{
        (void) conn;
        cfg->use_ino = !readdir_zero_ino;
 
        /* parallel_direct_writes feature depends on direct_io features.
           To make parallel_direct_writes valid, need either set cfg->direct_io
           in current function (recommended in high level API) or set fi->direct_io
           in xmp_create() or xmp_open(). */
        // cfg->direct_io = 1;
           cfg->parallel_direct_writes = 1;
 
        /* Pick up changes from lower filesystem right away. This is
           also necessary for better hardlink support. When the kernel
           calls the unlink() handler, it does not know the inode of
           the to-be-removed entry and can therefore not invalidate
           the cache of the associated inode - resulting in an
           incorrect st_nlink value being reported for any remaining
           hardlinks to this inode. */
        if (!cfg->auto_cache) {
                cfg->entry_timeout = 0;
                cfg->attr_timeout = 0;
                cfg->negative_timeout = 0;
        }
 
        return NULL;
}
 
static int xmp_getattr(const char *path, struct stat *stbuf,
                       struct fuse_file_info *fi)
{
        (void) fi;
        int res;
 
        res = lstat(path, stbuf);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_access(const char *path, int mask)
{
        int res;
 
        res = access(path, mask);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_readlink(const char *path, char *buf, size_t size)
{
        int res;
 
        res = readlink(path, buf, size - 1);
        if (res == -1)
                return -errno;
 
        buf[res] = '\0';
        return 0;
}
 
 
static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
                       off_t offset, struct fuse_file_info *fi,
                       enum fuse_readdir_flags flags)
{
        DIR *dp;
        struct dirent *de;
 
        (void) offset;
        (void) fi;
        (void) flags;
 
        dp = opendir(path);
        if (dp == NULL)
                return -errno;
 
        while ((de = readdir(dp)) != NULL) {
                struct stat st;
                if (fill_dir_plus) {
                        fstatat(dirfd(dp), de->d_name, &st,
                                AT_SYMLINK_NOFOLLOW);
                } else {
                        memset(&st, 0, sizeof(st));
                        st.st_ino = de->d_ino;
                        st.st_mode = de->d_type << 12;
                }
                if (readdir_zero_ino)
                        st.st_ino = 0;
                if (filler(buf, de->d_name, &st, 0, fill_dir_plus))
                        break;
        }
 
        closedir(dp);
        return 0;
}
 
static int xmp_mknod(const char *path, mode_t mode, dev_t rdev)
{
        int res;
 
        res = mknod_wrapper(AT_FDCWD, path, NULL, mode, rdev);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_mkdir(const char *path, mode_t mode)
{
        int res;
 
        res = mkdir(path, mode);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_unlink(const char *path)
{
        int res;
 
        res = unlink(path);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_rmdir(const char *path)
{
        int res;
 
        res = rmdir(path);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_symlink(const char *from, const char *to)
{
        int res;
 
        res = symlink(from, to);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_rename(const char *from, const char *to, unsigned int flags)
{
        int res;
 
        if (flags)
                return -EINVAL;
 
        res = rename(from, to);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_link(const char *from, const char *to)
{
        int res;
 
        res = link(from, to);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_chmod(const char *path, mode_t mode,
                     struct fuse_file_info *fi)
{
        (void) fi;
        int res;
 
        res = chmod(path, mode);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_chown(const char *path, uid_t uid, gid_t gid,
                     struct fuse_file_info *fi)
{
        (void) fi;
        int res;
 
        res = lchown(path, uid, gid);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_truncate(const char *path, off_t size,
                        struct fuse_file_info *fi)
{
        int res;
 
        if (fi != NULL)
                res = ftruncate(fi->fh, size);
        else
                res = truncate(path, size);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
#ifdef HAVE_UTIMENSAT
static int xmp_utimens(const char *path, const struct timespec ts[2],
                       struct fuse_file_info *fi)
{
        (void) fi;
        int res;
 
        /* don't use utime/utimes since they follow symlinks */
        res = utimensat(0, path, ts, AT_SYMLINK_NOFOLLOW);
        if (res == -1)
                return -errno;
 
        return 0;
}
#endif
 
static int xmp_create(const char *path, mode_t mode,
                      struct fuse_file_info *fi)
{
        int res;
 
        res = open(path, fi->flags, mode);
        if (res == -1)
                return -errno;
 
        fi->fh = res;
        return 0;
}
 
static int xmp_open(const char *path, struct fuse_file_info *fi)
{
        int res;
 
        res = open(path, fi->flags);
        if (res == -1)
                return -errno;
 
        /* Enable direct_io when open has flags O_DIRECT to enjoy the feature
        parallel_direct_writes (i.e., to get a shared lock, not exclusive lock,
        for writes to the same file). */
        if (fi->flags & O_DIRECT) {
                fi->direct_io = 1;
                fi->parallel_direct_writes = 1;
        }
 
        fi->fh = res;
        return 0;
}
 
static int xmp_read(const char *path, char *buf, size_t size, off_t offset,
                    struct fuse_file_info *fi)
{
        int fd;
        int res;
 
        if(fi == NULL)
                fd = open(path, O_RDONLY);
        else
                fd = fi->fh;
        
        if (fd == -1)
                return -errno;
 
        res = pread(fd, buf, size, offset);
        if (res == -1)
                res = -errno;
 
        if(fi == NULL)
                close(fd);
        return res;
}
 
static int xmp_write(const char *path, const char *buf, size_t size,
                     off_t offset, struct fuse_file_info *fi)
{
        int fd;
        int res;
 
        (void) fi;
        if(fi == NULL)
                fd = open(path, O_WRONLY);
        else
                fd = fi->fh;
        
        if (fd == -1)
                return -errno;
 
        res = pwrite(fd, buf, size, offset);
        if (res == -1)
                res = -errno;
 
        if(fi == NULL)
                close(fd);
        return res;
}
 
static int xmp_statfs(const char *path, struct statvfs *stbuf)
{
        int res;
 
        res = statvfs(path, stbuf);
        if (res == -1)
                return -errno;
 
        return 0;
}
 
static int xmp_release(const char *path, struct fuse_file_info *fi)
{
        (void) path;
        close(fi->fh);
        return 0;
}
 
static int xmp_fsync(const char *path, int isdatasync,
                     struct fuse_file_info *fi)
{
        /* Just a stub.  This method is optional and can safely be left
           unimplemented */
 
        (void) path;
        (void) isdatasync;
        (void) fi;
        return 0;
}
 
static int xmp_fallocate(const char *path, int mode,
                        off_t offset, off_t length, struct fuse_file_info *fi)
{
        int fd;
        int res;
 
        (void) fi;
 
        if(fi == NULL)
                fd = open(path, O_WRONLY);
        else
                fd = fi->fh;
        
        if (fd == -1)
                return -errno;
 
        res = do_fallocate(fd, mode, offset, length);
 
        if(fi == NULL)
                close(fd);
        return res;
}
 
#ifdef HAVE_SETXATTR
/* xattr operations are optional and can safely be left unimplemented */
static int xmp_setxattr(const char *path, const char *name, const char *value,
                        size_t size, int flags)
{
        int res = lsetxattr(path, name, value, size, flags);
        if (res == -1)
                return -errno;
        return 0;
}
 
static int xmp_getxattr(const char *path, const char *name, char *value,
                        size_t size)
{
        int res = lgetxattr(path, name, value, size);
        if (res == -1)
                return -errno;
        return res;
}
 
static int xmp_listxattr(const char *path, char *list, size_t size)
{
        int res = llistxattr(path, list, size);
        if (res == -1)
                return -errno;
        return res;
}
 
static int xmp_removexattr(const char *path, const char *name)
{
        int res = lremovexattr(path, name);
        if (res == -1)
                return -errno;
        return 0;
}
#endif /* HAVE_SETXATTR */
 
#ifdef HAVE_COPY_FILE_RANGE
static ssize_t xmp_copy_file_range(const char *path_in,
                                   struct fuse_file_info *fi_in,
                                   off_t offset_in, const char *path_out,
                                   struct fuse_file_info *fi_out,
                                   off_t offset_out, size_t len, int flags)
{
        int fd_in, fd_out;
        ssize_t res;
 
        if(fi_in == NULL)
                fd_in = open(path_in, O_RDONLY);
        else
                fd_in = fi_in->fh;
 
        if (fd_in == -1)
                return -errno;
 
        if(fi_out == NULL)
                fd_out = open(path_out, O_WRONLY);
        else
                fd_out = fi_out->fh;
 
        if (fd_out == -1) {
                close(fd_in);
                return -errno;
        }
 
        res = copy_file_range(fd_in, &offset_in, fd_out, &offset_out, len,
                              flags);
        if (res == -1)
                res = -errno;
 
        if (fi_out == NULL)
                close(fd_out);
        if (fi_in == NULL)
                close(fd_in);
 
        return res;
}
#endif
 
static off_t xmp_lseek(const char *path, off_t off, int whence, struct fuse_file_info *fi)
{
        int fd;
        off_t res;
 
        if (fi == NULL)
                fd = open(path, O_RDONLY);
        else
                fd = fi->fh;
 
        if (fd == -1)
                return -errno;
 
        res = lseek(fd, off, whence);
        if (res == -1)
                res = -errno;
 
        if (fi == NULL)
                close(fd);
        return res;
}
 
#ifdef HAVE_STATX
static int xmp_statx(const char *path, int flags, int mask, struct statx *stxbuf,
                     struct fuse_file_info *fi)
{
        int fd = -1;
        int res;
 
        if (fi)
                fd = fi->fh;
 
        res = statx(fd, path, flags | AT_SYMLINK_NOFOLLOW, mask, stxbuf);
        if (res == -1)
                return -errno;
 
        return 0;
}
#endif
 
static const struct fuse_operations xmp_oper = {
        .init           = xmp_init,
        .getattr        = xmp_getattr,
        .access         = xmp_access,
        .readlink       = xmp_readlink,
        .readdir        = xmp_readdir,
        .mknod          = xmp_mknod,
        .mkdir          = xmp_mkdir,
        .symlink        = xmp_symlink,
        .unlink         = xmp_unlink,
        .rmdir          = xmp_rmdir,
        .rename         = xmp_rename,
        .link           = xmp_link,
        .chmod          = xmp_chmod,
        .chown          = xmp_chown,
        .truncate       = xmp_truncate,
#ifdef HAVE_UTIMENSAT
        .utimens        = xmp_utimens,
#endif
        .open           = xmp_open,
        .create         = xmp_create,
        .read           = xmp_read,
        .write          = xmp_write,
        .statfs         = xmp_statfs,
        .release        = xmp_release,
        .fsync          = xmp_fsync,
        .fallocate      = xmp_fallocate,
#ifdef HAVE_SETXATTR
        .setxattr       = xmp_setxattr,
        .getxattr       = xmp_getxattr,
        .listxattr      = xmp_listxattr,
        .removexattr    = xmp_removexattr,
#endif
#ifdef HAVE_COPY_FILE_RANGE
        .copy_file_range = xmp_copy_file_range,
#endif
        .lseek          = xmp_lseek,
#ifdef HAVE_STATX
        .statx          = xmp_statx,
#endif
};
 
int main(int argc, char *argv[])
{
        enum { MAX_ARGS = 10 };
        int i,new_argc;
        char *new_argv[MAX_ARGS];
 
        umask(0);
                        /* Process the "--plus" option apart */
        for (i=0, new_argc=0; (i<argc) && (new_argc<MAX_ARGS); i++) {
                if (!strcmp(argv[i], "--plus")) {
                        fill_dir_plus = FUSE_FILL_DIR_PLUS;
                } else if (!strcmp(argv[i], "--readdir-zero-inodes")) {
                        // Return zero inodes from readdir
                        readdir_zero_ino = 1;
                } else {
                        new_argv[new_argc++] = argv[i];
                }
        }
        return fuse_main(new_argc, new_argv, &xmp_oper, NULL);
}