lsfs_fuse/lsfs_fuse.c

/*
TODO(jakob): we have a lot of memory leaks
TODO(jakob): handle multiple files with the same name!!!
*/

#include <fuse.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include "lsfs_disk_controller.h"

int lsfs_getattr( const char *, struct stat * );
int lsfs_mkdir(const char *path, mode_t mode);
int lsfs_mknod(const char *path, mode_t mode, dev_t device);
int lsfs_open( const char *, struct fuse_file_info * );
int lsfs_read( const char *, char *, size_t, off_t, struct fuse_file_info * );
int lsfs_readdir( const char *, void *, fuse_fill_dir_t, off_t, struct fuse_file_info * );
int lsfs_release(const char *path, struct fuse_file_info *fi);
int lsfs_rename(const char *from, const char *to);
int lsfs_rmdir(const char *path);
int lsfs_truncate(const char *path, off_t offset);
int lsfs_unlink(const char *);
int lsfs_write(const char *, const char *, size_t, off_t, struct fuse_file_info *);

static inline int lsfs_utime_STUB(const char *path, struct utimbuf *buf) {
    (void)path;
    (void)buf;
    return 0;
}

static struct fuse_operations lsfs_oper = {
    .getattr    = lsfs_getattr,
    .readdir    = lsfs_readdir,
    .mknod = lsfs_mknod,
    .mkdir = lsfs_mkdir,
    .link = NULL,
    .unlink = lsfs_unlink,
    .rmdir = lsfs_rmdir,
    .truncate = lsfs_truncate,
    .open   = lsfs_open,
    .read   = lsfs_read,
    .release = lsfs_release,
    .write = lsfs_write,
    .rename = NULL,
    .utime = lsfs_utime_STUB,
};

int lsfs_mkdir(const char *path, mode_t mode) {
    (void)mode;

    // Call to the disk controller make the dir
    return 0;
}


int lsfs_rmdir(const char *path) {

    // call to the disk controller to remove a dir

    return 0;
}

int lsfs_unlink(const char *path) {

    // remove / delete a file 

    return 0;
}

int lsfs_truncate(const char *path, off_t offset) {
    (void)offset;


    //found_file->modification_time = modification_time

    // Truncate a file 

    return 0;
}


int lsfs_rename(const char *path, const char *to) {
    (void)path;
    (void)to;
    return 0;
}

int lsfs_getattr( const char *path, struct stat *stbuf ) {
    int res = 0;
    printf("getattr: (path=%s)\n", path);

    memset(stbuf, 0, sizeof(struct stat));
    if( strcmp( path, "/" ) == 0 ) {
        stbuf->st_mode = S_IFDIR | 0755;
        stbuf->st_nlink = 2;
    } else if( strcmp( path, "/hello" ) == 0 ) {
        stbuf->st_mode = S_IFREG | 0777;
        stbuf->st_nlink = 1;
        stbuf->st_size = 12;
    } else
        res = -ENOENT;

    return res;
    // printf("getattr: (path=%s)\n", path);
    
    /*memset(stbuf, 0, sizeof(struct stat));

    if( strcmp( path, "/" ) == 0 ) {
        stbuf->st_mode = S_IFDIR | 0755;
        stbuf->st_nlink = 3;
        return res;
    }

    lsfs_string_array split_path = lsfs_string_split_c(path, '/', false);

    lsfs_string filename = split_path.strings[split_path.length-1];

    lsfs_tag *filename_tag = lsfs_hash_find(globals.tag_table, filename);

    if (filename_tag) {
        if (filename_tag->is_filename) {
            lsfs_file *found_file = lsfs_find_unique_file(filename_tag, split_path);

            if (found_file) {
                if (found_file == &dummy_ambiguous_file) {
                    // stbuf->st_mode = S_IFDIR | 0755; // @Hardcode
                    // stbuf->st_nlink = 3; // @Hardcode
                    res = -ENOENT;
                }
                else {
                    stbuf->st_mode = S_IFREG | 0777; // @Hardcode
                    stbuf->st_nlink = 1; // @Hardcode
                    
                    stbuf->st_size = found_file->size; // @Hardcode
                    stbuf->st_uid = found_file->owner_id;
                    stbuf->st_gid = found_file->owner_id;
                    stbuf->st_atime = found_file->access_time;
                    stbuf->st_mtime = found_file->modification_time;
                }
            }
            else {
                res = -ENOENT;
            }
        }
        else {
            stbuf->st_mode = S_IFDIR | 0755; // @Hardcode
            stbuf->st_nlink = 3; // @Hardcode
        }
    }
    else {
        res = -ENOENT;
    }

    lsfs_destroy_string_array(split_path);
    */
    //return res;
}

int lsfs_write(const char *path, const char *content, size_t content_length, off_t offset_to_next_entry, struct fuse_file_info *file_info) {
    (void) offset_to_next_entry;
    //(void) file_info;
    int res;
    // printf("read: (path=%s)\n", path);
    
    time_t current_time;
    time ( &current_time );
    
    //res = lsfs_disk_write_data_to_file(((lsfs_file*) file_info->fh)->file_id, content_length, (void*) content);

    //((lsfs_file*) file_info->fh)->size += res;
    //((lsfs_file*) file_info->fh)->access_time = current_time;
    //((lsfs_file*) file_info->fh)->modification_time = current_time;
    return res;
}

int lsfs_readdir( const char *path, void *buf, fuse_fill_dir_t filler, off_t offset_to_next_entry, struct fuse_file_info *fi ) {
    //(void) offset;
    (void) fi;
    printf("readdir: (path=%s)\n", path);

    if(strcmp(path, "/") != 0)
        return -ENOENT;

    filler(buf, ".", NULL, 0);
    filler(buf, "..", NULL, 0);
    filler(buf, "hello", NULL, 0);

    return 0;
}

//Permission
int lsfs_open( const char *path, struct fuse_file_info *fi ) {
    // printf("open: (path=%s)\n", path);
    // We can store a pinter in the *fi, this pointer can be used in both read and write. 
    // https://libfuse.github.io/doxygen/structfuse__operations.html
    // printf("read: (path=%s)\n", path);

    /*
    lsfs_string_array split_path = lsfs_string_split_c(path, '/', false);

    lsfs_string filename = split_path.strings[split_path.length-1];

    lsfs_tag *filename_tag = lsfs_hash_find(globals.tag_table, filename);

    if (filename_tag) {
        if (filename_tag->is_filename) {
            lsfs_file *found_file = lsfs_find_unique_file(filename_tag, split_path);

            if (found_file) {               
                if (found_file != &dummy_ambiguous_file) {
                    //(void*) file_data_buffer = calloc(1, SECTOR_SIZE);
                    fi->fh = (uint64_t) found_file;
                    //lsfs_disk_read_data_from_file(found_file->file_id, (256*4096), buf);
                }
            }
        }
    }

    lsfs_destroy_string_array(split_path);
    */
    return 0;
}

int lsfs_read( const char *path, char *buf, size_t size, off_t offset_to_next_entry, struct fuse_file_info *fi ) {
    // printf("read: (path=%s)\n", path);
    
    time_t current_time;
    time ( &current_time );

    //int res = lsfs_disk_read_data_from_file( ((lsfs_file*) fi->fh)->file_id, size, buf);
    //((lsfs_file*) fi->fh)->access_time = current_time;
    return 0;
}

int lsfs_release(const char *path, struct fuse_file_info *fi) {
    // printf("release: (path=%s)\n", path);
    return 0;
}

int lsfs_mknod(const char *path, mode_t mode, dev_t device) {
    /*(void)mode;
    (void)device;
    int res = 0;

    lsfs_string_array split_path = lsfs_string_split_c(path, '/', false);

    lsfs_string filename = split_path.strings[split_path.length-1];
    if(filename.chars[0] == '@') {
        res = -EINVAL;
        goto end;
    }

    lsfs_file *file = NULL;
    
    lsfs_tag *filename_tag = lsfs_hash_find(globals.tag_table, filename);
    if (filename_tag) {
        file = lsfs_find_unique_file(filename_tag, split_path);
        if (file == &dummy_ambiguous_file) file = NULL;
    }

    if (file) {
        res = -EINVAL;
        goto end;
    }

    lsfs_file_id file_id = lsfs_disk_create_file(filename.chars, NULL, NULL );
    lsfs_set *tagset = lsfs_create_set(split_path.length - 1);
    filename_tag = lsfs_get_or_create_tag(filename, true, true);

    file = lsfs_create_file(filename, file_id, tagset, filename_tag);
    
    lsfs_hash_table_index *index = malloc(sizeof(*index));
    *index = lsfs_hash_insert(globals.file_table, lsfs_create_id_string(file_id), file);
    lsfs_set_insert(&filename_tag->fileset, file->file_id, index);
    lsfs_disk_tag_file(filename_tag->tag_id, file->file_id);

    for (unsigned int i = 0; i < split_path.length - 1; ++i) {
        lsfs_string tag_name = split_path.strings[i];
        lsfs_tag *tag = lsfs_get_or_create_tag(tag_name, true, false);
        lsfs_tag_file(tag, file);
    }

    lsfs_set_insert(&globals.all_files, file_id, index);

end:
    lsfs_destroy_string_array(split_path);
    return res;*/
}

int main( int argc, char *argv[] ) {

    disk = fopen ( "~/Documents/github/SingOS/bin/SingOS.img" , "r+b" );
    p_control.fsci = malloc(sizeof(FSCI));
    p_control.master_table = malloc(sizeof(global_tag) * DEFAULT_MASTER_TAG_TABLE_SIZE);
    lsfs_disk_load_disk(disk, &p_control);
    
    //tag_record *tag_table = calloc(1, SECTOR_SIZE);
    //mif* mif_data = calloc(1, SECTOR_SIZE);

    //free(mif_data);
    //free(tag_table);
    //free(seen_file_ids);

    return fuse_main( argc, argv, &lsfs_oper );
}