现在的位置: 首页 > 综合 > 正文

FUSE FS的实现(fuse_operations接口的抽象)

2013年02月05日 ⁄ 综合 ⁄ 共 8090字 ⁄ 字号 评论关闭

fuse提供两种类型的操作接口,fuse lowlevel operations类似于内核文件系统的接口,以inode号作为访问的关键字,而更高级的fuse operations则提供以路径名作为关键字的访问形式,这样即使fuse用户对内核文件系统并不了解,也能编写文件系统程序。

 

高级的接口,其实是对fuse lowlevel operations的一个封装(相当于实现了一个用户空间文件系统fuse_fs,但其数据都放在内存中),它实现了一组lowlevel operations,并通过hash表来组织目录项,实现inode关键字向路径名关键字的转换(逆向路径名查找,索引节点中需要记录父节点的nodeid),封装的实现在fuse源代码包中fuse.c中实现。

 

2011年11月23日补充:

以访问/a/b/c为例,在路径名解析的过程中(根node在初始化时加载),能得到各级目录项的nodeid(递增)及node信息,并将这些信息加入node哈希表及名字哈希表,再根据c的nodeid访问c时(fuse_lowlevel_ops),可以反向解析出c的绝对路径,然后将c的绝对路径传递给外部实现的接口(fuse_operations),从而实现低级接口到高级接口的转换。

 

两个主要的数据结构

 

/* fuse fs 全局信息 */
struct fuse {
    struct fuse_session *se;
    struct node **name_table; /* 路径名hash表 */
    size_t name_table_size; /* 路径名hash表的长度 */
    struct node **id_table; /* nodeid hash表 */
    size_t id_table_size; /* nodeid hash表的长度 */
    fuse_ino_t ctr;
    unsigned int generation;
    unsigned int hidectr;
    pthread_mutex_t lock;
    struct fuse_config conf;
    int intr_installed;
    struct fuse_fs *fs; /* 文件系统ops信息 */
    int nullpath_ok;
    int curr_ticket;
    struct lock_queue_element *lockq;
};

/* 每个目录项的信息 */
struct node {
    struct node *name_next; /* 名字hash链表 */
    struct node *id_next; /* 索引节点hash链表 */
    fuse_ino_t nodeid; /* 索引节点号 */
    unsigned int generation; /* 用于扩展节点数,inode数可到2^64 */
    int refctr;
    struct node *parent; /* 父目录项信息 */
    char *name; /* 本目录项的名称 */
    uint64_t nlookup;
    int open_count;
    struct timespec stat_updated;
    struct timespec mtime;
    off_t size;
    struct lock *locks;
    unsigned int is_hidden : 1;
    unsigned int cache_valid : 1;
    int treelock;
    int ticket;
};

与路径名查找(fuse_lib_lookup)实现相关的一些函数

/* fuse fs的hash函数 */
static unsigned int name_hash(struct fuse *f, fuse_ino_t parent,
             const char *name)
{
    unsigned int hash = *name;

    if (hash)
        for (name += 1; *name != '\0'; name++)
            hash = (hash << 5) - hash + *name;

    return (hash + parent) % f->name_table_size;
}

/* 通过名字hash查找node信息*/
static struct node *lookup_node(struct fuse *f, fuse_ino_t parent,
                const char *name)
{
    size_t hash = name_hash(f, parent, name);
    struct node *node;

    for (node = f->name_table[hash]; node != NULL; node = node->name_next)
        if (node->parent->nodeid == parent &&
         strcmp(node->name, name) == 0)
            return node;

    return NULL;
}

/* 通过nodeid查找node信息*/
static struct node *get_node_nocheck(struct fuse *f, fuse_ino_t nodeid)
{
    size_t hash = nodeid % f->id_table_size;
    struct node *node;

    for (node = f->id_table[hash]; node != NULL; node = node->id_next)
        if (node->nodeid == nodeid)
            return node;

    return NULL;
}

/* 通过某一个目录项,你想递归获取全局路径 */
static int try_get_path(struct fuse *f, fuse_ino_t nodeid, const char *name,
            char **path, struct node **wnodep, int ticket)
{
    unsigned bufsize = 256;
    char *buf;
    char *s;
    struct node *node;
    struct node *wnode = NULL;
    int err;

    *path = NULL;

    buf = malloc(bufsize);
    if (buf == NULL)
        return -ENOMEM;

    s = buf + bufsize - 1;
    *s = '\0';

    if (name != NULL) {
        s = add_name(&buf, &bufsize, s, name);
        err = -ENOMEM;
        if (s == NULL)
            goto out_free;
    }

    if (wnodep) {
        assert(ticket);
        wnode = lookup_node(f, nodeid, name);
        if (wnode) {
            if (wnode->treelock != 0 ||
             (wnode->ticket && wnode->ticket != ticket)) {
                if (!wnode->ticket)
                    wnode->ticket = ticket;
                err = -EAGAIN;
                goto out_free;
            }
            wnode->treelock = -1;
            wnode->ticket = 0;
        }
    }

    /* 逆向遍历目录树,获取目录项的全局路径 */
    err = 0;
    for (node = get_node(f, nodeid); node->nodeid != FUSE_ROOT_ID;
     node = node->parent) {
        err = -ENOENT;
        if (node->name == NULL || node->parent == NULL)
            goto out_unlock;

        err = -ENOMEM;
         /* 长度不够将自动扩张,默认申请长度为256 */
        s = add_name(&buf, &bufsize, s, node->name);
        if (s == NULL)
            goto out_unlock;

        if (ticket) {
            err = -EAGAIN;
            if (node->treelock == -1 ||
             (node->ticket && node->ticket != ticket))
                goto out_unlock;

            node->treelock++;
            node->ticket = 0;
        }
    }

    if (s[0])
        memmove(buf, s, bufsize - (s - buf));
    else
        strcpy(buf, "/");

    *path = buf;
    if (wnodep)
        *wnodep = wnode;

    return 0;

 out_unlock:
    if (ticket)
        unlock_path(f, nodeid, wnode, node, ticket);
 out_free:
    free(buf);

    return err;
}

/* 获取下一个nodeid */
static fuse_ino_t next_id(struct fuse *f)
{
    do {
        f->ctr = (f->ctr + 1) & 0xffffffff;
        if (!f->ctr)
            f->generation ++; /* 如果32bit数以用完,将generation加1 */
    } while (f->ctr == 0 || f->ctr == FUSE_UNKNOWN_INO ||
         get_node_nocheck(f, f->ctr) != NULL);
    return f->ctr;
}

/* 获取目录项的fuse_entry_param信息,如果目录项不存在则新建,并加入hash表
lookup、mknod、create等都调用了该方法 */

static int lookup_path(struct fuse *f, fuse_ino_t nodeid,
         const char *name, const char *path,
         struct fuse_entry_param *e, struct fuse_file_info *fi)
{
    int res;

    memset(e, 0, sizeof(struct fuse_entry_param));
    /* 从这里可以看出 如果getattr接口返回错误,则整个过程将会出现问题,故在实现getattr时,即使获取不到文件的信息,也要填充entry的信息 */
    if (fi)
        res = fuse_fs_fgetattr(f->fs, path, &e->attr, fi);
    else
        res = fuse_fs_getattr(f->fs, path, &e->attr);
    if (res == 0) {
        struct node *node;

        node = find_node(f, nodeid, name);
        if (node == NULL)
            res = -ENOMEM;
        else {
            /* 如果分配子目录项不成功,则返回父目录的信息 */
            e->ino = node->nodeid;
            e->generation = node->generation;
            e->entry_timeout = f->conf.entry_timeout;
            e->attr_timeout = f->conf.attr_timeout;
            if (f->conf.auto_cache) {
                pthread_mutex_lock(&f->lock);
                update_stat(node, &e->attr);
                pthread_mutex_unlock(&f->lock);
            }
            set_stat(f, e->ino, &e->attr);
            if (f->conf.debug)
                fprintf(stderr, " NODEID: %lu\n",
                    (unsigned long) e->ino);
        }
    }
    return res;
}

static struct node *find_node(struct fuse *f, fuse_ino_t parent,
             const char *name)
{
    struct node *node;

    pthread_mutex_lock(&f->lock);
    if (!name)
        node = get_node(f, parent);
    else
        node = lookup_node(f, parent, name);
    if (node == NULL) {
        node = (struct node *) calloc(1, sizeof(struct node));
        if (node == NULL)
            goto out_err;

        if (f->conf.noforget)
            node->nlookup = 1;
        node->refctr = 1;
        node->nodeid = next_id(f); /* 选择下一个使用的nodeid */
        node->generation = f->generation;
        node->open_count = 0;
        node->is_hidden = 0;
        node->treelock = 0;
        node->ticket = 0;
        if (hash_name(f, node, parent, name) == -1) { /* 加入路径名hash表 */
            free(node);
            node = NULL;
            goto out_err;
        }
        hash_id(f, node); /* 加入nodeid hash表 */
    }
    node->nlookup ++;
out_err:
    pthread_mutex_unlock(&f->lock);
    return node;
}

创建fuse_fs环境的函数

/* 创建fuse文件系统的全局环境 */
struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args,
         const struct fuse_operations *op, size_t op_size,
         void *user_data)
{
    return fuse_new_common(ch, args, op, op_size, user_data, 0);
}

/* 创建fuse文件系统的全局环境的内部接口 */
struct fuse *fuse_new_common(struct fuse_chan *ch, struct fuse_args *args,
             const struct fuse_operations *op,
             size_t op_size, void *user_data, int compat)
{
    struct fuse *f;
    struct node *root;
    struct fuse_fs *fs;
    struct fuse_lowlevel_ops llop = fuse_path_ops;

    if (fuse_create_context_key() == -1)
        goto out;

    f = (struct fuse *) calloc(1, sizeof(struct fuse));
    if (f == NULL) {
        fprintf(stderr, "fuse: failed to allocate fuse object\n");
        goto out_delete_context_key;
    }

    fs = fuse_fs_new(op, op_size, user_data); /* 申请fuse fs的空间 */
    if (!fs)
        goto out_free;

    fs->compat = compat;
    f->fs = fs;
    f->nullpath_ok = fs->op.flag_nullpath_ok;

    /* Oh f**k, this is ugly! */
    if (!fs->op.lock) {
        llop.getlk = NULL;
        llop.setlk = NULL;
    }

    f->conf.entry_timeout = 1.0;
    f->conf.attr_timeout = 1.0;
    f->conf.negative_timeout = 0.0;
    f->conf.intr_signal = FUSE_DEFAULT_INTR_SIGNAL;

    if (fuse_opt_parse(args, &f->conf, fuse_lib_opts,
             fuse_lib_opt_proc) == -1)
        goto out_free_fs;

    if (f->conf.modules) {
        char *module;
        char *next;

        for (module = f->conf.modules; module; module = next) {
            char *p;
            for (p = module; *p && *p != ':'; p++);
            next = *p ? p + 1 : NULL;
            *p = '\0';
            if (module[0] &&
             fuse_push_module(f, module, args) == -1)
                goto out_free_fs;
        }
    }

    if (!f

抱歉!评论已关闭.