使用fuse编写文件系统 (1)_writing a fuse filesystem: a tutorial

#define FUSE_USE_VERSION 26
 
#include <stdio.h>
#include <string.h>
#include <fuse.h>
 
static int ou_readdir(const char* path, void* buf, fuse_fill_dir_t filler,
                      off_t offset, struct fuse_file_info* fi)
{
    return filler(buf, "hello-world", NULL, 0);
}
 
static int ou_getattr(const char* path, struct stat* st)
{
    memset(st, 0, sizeof(struct stat));
 
    if (strcmp(path, "/") == 0)
        st->st_mode = 0755 | S_IFDIR;
    else
        st->st_mode = 0644 | S_IFREG;
 
    return 0;
}
 
static struct fuse_operations oufs_ops = {
    .readdir    =   ou_readdir,
    .getattr    =   ou_getattr,
};
 
int main(int argc, char* argv[])
{
    return fuse_main(argc, argv, &oufs_ops, NULL);
}

CC := gcc
CFLAGS := -g -Wall -D_FILE_OFFSET_BITS=64
OBJS := $(patsubst %.c, %.o, $(wildcard *.c))
 
LIBS := -lfuse
 
TARGET := oufs
 
.PHONY: all clean
 
all: $(TARGET)
 
$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) -o $@ $^ $(LIBS)
 
.c.o:
	$(CC) $(CFLAGS) -c $<
 
clean:
	rm -f $(TARGET) $(OBJS)

./oufs /tmp/mnt

/** Function to add an entry in a readdir() operation
 *
 * @param buf the buffer passed to the readdir() operation
 * @param name the file name of the directory entry
 * @param stat file attributes, can be NULL
 * @param off offset of the next entry or zero
 * @return 1 if buffer is full, zero otherwise
 */
typedef int (*fuse_fill_dir_t) (void *buf, const char *name,
                                const struct stat *stbuf, off_t off);
 
struct fuse_operations {
        /** Get file attributes.
         *
         * Similar to stat().  The 'st_dev' and 'st_blksize' fields are
         * ignored.      The 'st_ino' field is ignored except if the 'use_ino'
         * mount option is given.
         */
        int (*getattr) (const char *, struct stat *);
 
        /** Read directory
         *
         * This supersedes the old getdir() interface.  New applications
         * should use this.
         *
         * The filesystem may choose between two modes of operation:
         *
         * 1) The readdir implementation ignores the offset parameter, and
         * passes zero to the filler function's offset.  The filler
         * function will not return '1' (unless an error happens), so the
         * whole directory is read in a single readdir operation.  This
         * works just like the old getdir() method.
         *
         * 2) The readdir implementation keeps track of the offsets of the
         * directory entries.  It uses the offset parameter and always
         * passes non-zero offset to the filler function.  When the buffer
         * is full (or an error happens) the filler function will return
         * '1'.
         *
         * Introduced in version 2.3
         */
        int (*readdir) (const char *, void *, fuse_fill_dir_t, off_t,
                        struct fuse_file_info *); 
 
        ......
};

#define FUSE_USE_VERSION 26
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <fuse.h>
 
#include "list.h"
 
#define MAX_NAMELEN 255
 
struct ou_entry {
    mode_t mode;
    struct list_node node;
    char name[MAX_NAMELEN + 1];
};
 
static struct list_node entries;
 
static int ou_readdir(const char* path, void* buf, fuse_fill_dir_t filler,
                      off_t offset, struct fuse_file_info* fi)
{
    struct list_node* n;
 
    filler(buf, ".", NULL, 0);
    filler(buf, "..", NULL, 0);
 
    list_for_each (n, &entries) {
        struct ou_entry* o = list_entry(n, struct ou_entry, node);
        filler(buf, o->name, NULL, 0);
    }
 
    return 0;
}
 
static int ou_getattr(const char* path, struct stat* st)
{
    struct list_node* n;
 
    memset(st, 0, sizeof(struct stat));
 
    if (strcmp(path, "/") == 0) {
        st->st_mode = 0755 | S_IFDIR;
        st->st_nlink = 2;
        st->st_size = 0;
 
        list_for_each (n, &entries) {
            struct ou_entry* o = list_entry(n, struct ou_entry, node);
            ++st->st_nlink;
            st->st_size += strlen(o->name);
        }
 
        return 0;
    }
 
    list_for_each (n, &entries) {
        struct ou_entry* o = list_entry(n, struct ou_entry, node);
        if (strcmp(path + 1, o->name) == 0) {
            st->st_mode = o->mode;
            st->st_nlink = 1;
            return 0;
        }
    }
 
    return -ENOENT;
}
 
static int ou_create(const char* path, mode_t mode, struct fuse_file_info* fi)
{
    struct ou_entry* o;
    struct list_node* n;
 
    if (strlen(path + 1) > MAX_NAMELEN)
        return -ENAMETOOLONG;
 
    list_for_each (n, &entries) {
        o = list_entry(n, struct ou_entry, node);
        if (strcmp(path + 1, o->name) == 0)
            return -EEXIST;
    }
 
    o = malloc(sizeof(struct ou_entry));
    strcpy(o->name, path + 1); /* skip leading '/' */
    o->mode = mode | S_IFREG;
    list_add_prev(&o->node, &entries);
 
    return 0;
}
 
static int ou_unlink(const char* path)
{
    struct list_node *n, *p;
 
    list_for_each_safe (n, p, &entries) {
        struct ou_entry* o = list_entry(n, struct ou_entry, node);
        if (strcmp(path + 1, o->name) == 0) {
            __list_del(n);
            free(o);
            return 0;
        }
    }
 
    return -ENOENT;
}
 
static struct fuse_operations oufs_ops = {
    .getattr    =   ou_getattr,
    .readdir    =   ou_readdir,
    .create     =   ou_create,
    .unlink     =   ou_unlink,
};
 
int main(int argc, char* argv[])
{
    list_init(&entries);
 
    return fuse_main(argc, argv, &oufs_ops, NULL);
}

#ifndef __LIST_H__
#define __LIST_H__
 
/* doubly linked list implementation from linux kernel */
 
#define offset_of(type, member) \
    ((unsigned long)(&(((type*)0)->member)))
 
#define container_of(ptr, type, member) \
    ((type*)((unsigned long)(ptr) - offset_of(type, member)))
 
#define list_entry(ptr, type, member) container_of(ptr, type, member)
 
struct list_node {
    struct list_node *prev, *next;
};
 
static inline void list_init(struct list_node* list)
{
    list->prev = list;
    list->next = list;
}
 
static inline void list_add_prev(struct list_node* node,
                                 struct list_node* next)
{
    node->next = next;
    node->prev = next->prev;
    next->prev = node;
    node->prev->next = node;
}
 
static inline void __list_del(struct list_node* node)
{
    node->prev->next = node->next;
    node->next->prev = node->prev;
}
 
static inline void list_del(struct list_node* node)
{
    __list_del(node);
    list_init(node);
}
 
#define list_for_each(p, head) \
    for ((p) = (head)->next; (p) != (head); (p) = (p)->next)
 
#define list_for_each_safe(p, n, head) \
    for ((p) = (head)->next, (n) = (p)->next; \
         (p) != (head); \
         (p) = (n), (n) = (p)->next)
 
#endif