unixfs.c

#include "fs.h"
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <fuse_lowlevel.h>

#include "args.h"

uint8 *fsdata;
int fslen;

void
panic(char *fmt, ...)
{
        va_list ap;
        va_start(ap, fmt);
        vfprintf(stderr, fmt, ap);
        fprintf(stderr, "\n");
        va_end(ap);
        exit(1);
}

void*
emalloc(int size)
{
        void *p;
        p = malloc(size);
        if(p == nil)
                panic("error: no memory");
        return p;
}

FILE*
mustopen(const char *name, const char *mode)
{
        FILE *f;
        if(f = fopen(name, mode), f == nil)
                panic("couldn't open file: %s", name);
        return f;
}


typedef struct Options Options;
struct Options
{
        int singlethread;
        int foreground;
        int debug;
        int nodefault_subtype;
        char *device;
        char *mountpoint;
        int show_version;
        int show_help;
        int clone_fd;
        unsigned int max_idle_threads;
};
static Options options;

#define offsetof(type, field) ((long)&((type*)0)->field)
#define OPTION(t, p) \
        { t, offsetof(Options, p), 1 }

static const struct fuse_opt myopts[] = {
        OPTION("-h",            show_help),
        OPTION("--help",        show_help),
        OPTION("-V",            show_version),
        OPTION("--version",     show_version),
        OPTION("-d",            debug),
        OPTION("debug", debug),
        OPTION("-d",            foreground),
        OPTION("debug", foreground),
        FUSE_OPT_KEY("-d",              FUSE_OPT_KEY_KEEP),
        FUSE_OPT_KEY("debug",           FUSE_OPT_KEY_KEEP),
        OPTION("-f",            foreground),
        OPTION("-s",            singlethread),
        OPTION("clone_fd",      clone_fd),
        OPTION("max_idle_threads=%u", max_idle_threads),
        FUSE_OPT_END
};

static int
opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs)
{
        (void)data; (void)outargs;
        switch(key){
        case FUSE_OPT_KEY_NONOPT:
                if(options.device == nil){
                        options.device = strdup(arg);
                        return 0;
                }
                if(options.mountpoint == nil){
                        options.mountpoint = strdup(arg);
                        return 0;
                }
                return -1;
        default:
                panic("invalid option");
        }
        return -1;
}

void
usage(void)
{
        fprintf(stderr,
                " usage: asdf [options] filesystem mountpoint\n"
                "    -h   --help            print help\n"
                "    -V   --version         print version\n"
                "    -d   -o debug          enable debug output (implies -f)\n"
                "    -f                     foreground operation\n"
                "    -s                     disable multi-threaded operation\n"
                "    -o clone_fd            use separate fuse device fd for each thread\n"
                "                           (may improve performance)\n"
                "    -o max_idle_threads    the maximum number of idle worker threads\n"
                "                           allowed (default: 10)\n");
        exit(1);
}


void
dirbuf_add(fuse_req_t req, Dirbuf *b, const char *name, fuse_ino_t ino)
{
        struct stat stbuf;
        size_t oldsize = b->size;
        b->size += fuse_add_direntry(req, NULL, 0, name, NULL, 0);
        b->p = (char *) realloc(b->p, b->size);
        memset(&stbuf, 0, sizeof(stbuf));
        stbuf.st_ino = ino;
        fuse_add_direntry(req, b->p + oldsize, b->size - oldsize, name, &stbuf,
                          b->size);
}

#define min(x, y) ((x) < (y) ? (x) : (y))

int
reply_buf_limited(fuse_req_t req, const char *buf, size_t bufsize,
        off_t off, size_t maxsize)
{
        if(off < bufsize)
                return fuse_reply_buf(req, buf + off,
                                      min(bufsize - off, maxsize));
        else
                return fuse_reply_buf(req, NULL, 0);
}

static void
vfs_getattr(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
        struct stat stbuf;
        USED(fi);

        memset(&stbuf, 0, sizeof(stbuf));
        if(fs_stat(ino, &stbuf) == -1)
                fuse_reply_err(req, ENOENT);
        else
                fuse_reply_attr(req, &stbuf, 1.0);
}

static void
vfs_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr, int to_set, struct fuse_file_info *fi)
{
        int ret = 0;
        USED(fi);

        if(to_set & FUSE_SET_ATTR_ATIME)
                ret = fs_atime(ino, attr->st_atime);
        if(to_set & FUSE_SET_ATTR_MTIME)
                ret = fs_mtime(ino, attr->st_mtime);
        if(to_set & FUSE_SET_ATTR_GID)
                ret = fs_gid(ino, attr->st_gid);
        if(to_set & FUSE_SET_ATTR_UID)
                ret = fs_uid(ino, attr->st_uid);

        if(ret)
                fuse_reply_err(req, ret);
        else
                vfs_getattr(req, ino, fi);
}

void
vfs_open(fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
        int e;

        e = fs_open(ino, fi->flags);
        if(e)
                fuse_reply_err(req, e);
        else
                fuse_reply_open(req, fi);
}

void
vfs_read(fuse_req_t req, fuse_ino_t ino, size_t size,
        off_t off, struct fuse_file_info *fi)
{
        USED(fi);
        char *buf;
        int n;

        buf = malloc(size);
        n = fs_read(ino, buf, off, size);
        reply_buf_limited(req, buf, n, off, size);
        free(buf);
}

void
vfs_write(fuse_req_t req, fuse_ino_t ino, const char *buf,
        size_t size, off_t off, struct fuse_file_info *fi)
{
        int n;
        USED(fi);
        n = fs_write(ino, (void*)buf, off, size);
        fuse_reply_write(req, n);
}

void
vfs_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
        off_t off, struct fuse_file_info *fi)
{
        struct dirent *dirs, *dp;
        Dirbuf b;

        USED(fi);
        dirs = fs_readdir(ino);
        if(dirs == nil){
                fuse_reply_err(req, ENOTDIR);
                return;
        }
        memset(&b, 0, sizeof(b));
        for(dp = dirs; dp->d_ino; dp++)
                dirbuf_add(req, &b, dp->d_name, dp->d_ino);
        free(dirs);
        reply_buf_limited(req, b.p, b.size, off, size);
        free(b.p);
}

/* returns static pointer! */
struct dirent*
lookup(uint ino, const char *name)
{
        struct dirent *dirs, *dp;
        static struct dirent de;

        dirs = fs_readdir(ino);
        if(dirs == nil)
                return nil;
        for(dp = dirs; dp->d_ino; dp++)
                if(strcmp(dp->d_name, name) == 0){
                        de = *dp;
                        free(dirs);
                        return &de;
                }
        free(dirs);
        return nil;
}

void
vfs_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
{
        struct fuse_entry_param e;
        struct dirent *de;

        de = lookup(parent, name);
        if(de == nil){
                fuse_reply_err(req, ENOENT);
                return;
        }
        memset(&e, 0, sizeof(e));
        e.ino = de->d_ino;
        e.attr_timeout = 1.0;
        e.entry_timeout = 1.0;
        fs_stat(e.ino, &e.attr);

        /* increment ref count */
        fs_iget(e.ino);
        fuse_reply_entry(req, &e);
}

void
vfs_forget(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
{
        Inode *ip;

        printf("forgetting %d\n", nlookup);
        ip = fs_iget(ino);
        fs_iput(ip);
        while(nlookup--)
                fs_iput(ip);
        fuse_reply_none(req);
}

void
vfs_mknod(fuse_req_t req, fuse_ino_t parent, const char *name, mode_t mode, dev_t rdev)
{
        int ret;

        ret = fs_mknod(parent, name, mode, rdev, nil);
        if(ret)
                fuse_reply_err(req, ret);
        else
                vfs_lookup(req, parent, name);
}

void
vfs_mkdir(fuse_req_t req, fuse_ino_t parent, const char *name, mode_t mode)
{
        int ret;

        ret = fs_mkdir(parent, name, mode);
        if(ret)
                fuse_reply_err(req, ret);
        else
                vfs_lookup(req, parent, name);
}

void
vfs_unlink(fuse_req_t req, fuse_ino_t parent, const char *name)
{
        int ret;

        ret = fs_unlink(parent, name);
        fuse_reply_err(req, ret);
}

int
isdirempty(struct dirent *de)
{
        for(; de->d_ino; de++)
                if(strcmp(de->d_name, ".") != 0 &&
                   strcmp(de->d_name, "..") != 0)
                        return 0;
        return 1;
}

void
vfs_rmdir(fuse_req_t req, fuse_ino_t parent, const char *name)
{
        struct dirent *dir, *de;
        int ret;
        int dino;

        ret = 0;
        de = lookup(parent, name);
        /* this shouldn't happen */
        if(de == nil)
                return;
        dino = de->d_ino;
        dir = fs_readdir(dino);
        assert(dir);
        if(!isdirempty(dir)){
                free(dir);
                fuse_reply_err(req, ENOTEMPTY);
                return;
        }
printf("dir to delete: %d %s\n", dino, name);
        for(de = dir; de->d_ino; de++)
                fs_unlink(dino, de->d_name);
        free(dir);
        fs_unlink(parent, name);

        fuse_reply_err(req, ret);
}

void
vfs_link(fuse_req_t req, fuse_ino_t ino,
        fuse_ino_t newparent, const char *newname)
{
        int ret;

        ret = fs_link(ino, newparent, newname);
        if(ret)
                fuse_reply_err(req, ret);
        else
                vfs_lookup(req, newparent, newname);
}

static struct fuse_lowlevel_ops hello_ll_oper = {
        .lookup         = vfs_lookup,
        .getattr        = vfs_getattr,
        .setattr        = vfs_setattr,
        .readdir        = vfs_readdir,
        .open           = vfs_open,
        .read           = vfs_read,
        .write          = vfs_write,
        .mknod          = vfs_mknod,
        .mkdir          = vfs_mkdir,
        .unlink         = vfs_unlink,
        .rmdir          = vfs_rmdir,
        .link           = vfs_link,
        .forget         = vfs_forget,
        // TODO
        // rename
};


void
fsload(const char *filename)
{
        FILE *f = mustopen(filename, "rb");
        fseek(f, 0, SEEK_END);
        fslen = ftell(f);
        fseek(f, 0, SEEK_SET);
        fsdata = emalloc(fslen);
        fread(fsdata, 1, fslen, f);
        fclose(f);
}

int
main(int argc, char *argv[])
{
        struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
        struct fuse_session *se;
        char *m;
        int ret = -1;

        if(fuse_opt_parse(&args, &options, myopts, opt_proc) == -1 ||
           options.device == nil || options.mountpoint == nil)
                usage();

        m = options.mountpoint;
        options.mountpoint = realpath(m, nil);
        if(options.mountpoint == nil)
                panic("bad mount point %s", m);

        printf("device: %s\n", options.device);
        printf("mountpoint: %s\n", options.mountpoint);

        if(options.show_help){
                usage();
                return 0;
        }
        if(options.show_version){
                printf("FUSE library version %s\n", fuse_pkgversion());
                fuse_lowlevel_version();
                return 0;
        }

        fsload(options.device);
        fs_init();
        dcheck();

        se = fuse_session_new(&args, &hello_ll_oper,
                              sizeof(hello_ll_oper), NULL);
        if(se == NULL)
                return 1;

        if(fuse_set_signal_handlers(se) != 0)
                goto err_out2;

        if(fuse_session_mount(se, options.mountpoint) != 0)
                goto err_out3;

        fuse_daemonize(options.foreground);

        /* Block until ctrl+c or fusermount -u */
        if(options.singlethread)
                ret = fuse_session_loop(se);
        else
                ret = fuse_session_loop_mt(se, options.clone_fd);

        fuse_session_unmount(se);
err_out3:
        fuse_remove_signal_handlers(se);
err_out2:
        fuse_session_destroy(se);
        free(options.mountpoint);
        fuse_opt_free_args(&args);

        return ret ? 1 : 0;
}