vfs.c

Go to the documentation of this file.

#include <slibc.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <errno.h>
#include <string.h>
#include <assert.h>

#include <object.h>
#include <list.h>
#include <vfs.h>
#include <vfs0.h>

#include <debug.h>

static struct sinfo s_sinfo;
static struct ninfo s_root;

int vfs_init(void)
{
        s_root.type = NINFO_TYPE_FOLDER;

        s_root.head_sibling = 0;
        s_root.si = &s_sinfo;
        s_root.id = 0;
        s_root.size = 0;
        s_root.refcnt = 0;
        s_root.deleted = 0;
        s_root.priv = NULL;

        s_root.nops.open = NULL;
        s_root.nops.close = NULL;
        s_root.nops.read = NULL;
        s_root.nops.write = NULL;
        s_root.nops.lseek = NULL;
        s_root.nops.ioctl = NULL;

        INIT_LIST_HEAD(&s_root.sibling);
        INIT_LIST_HEAD(&s_root.child);
        INIT_LIST_HEAD(&s_root.sinfo);

        INIT_LIST_HEAD(&s_sinfo.head);
        s_sinfo.get_ninfo = NULL;
        s_sinfo.fill_ninfo = NULL;
        s_sinfo.del_ninfo = NULL;
        s_sinfo.refresh_children = NULL;
        s_sinfo.refcnt = 0;
        s_sinfo.priv = NULL;

        return 0;
}

int vfs_attach_storage(struct ninfo *node, struct sinfo *sb)
{
        list_add_tail(&sb->head, &node->sinfo);
        return 0;
}

int vfs_detach_storage(struct ninfo *node)
{
        return 0;
}

static inline void vfs_free_ninfo(struct ninfo *node)
{
        struct sinfo *si;

        if (node == &s_root) {
                return;
        }

        si = node->si;

        if (si && si->del_ninfo) {
                si->del_ninfo(si, node);
        }

        list_del(&node->child);
        list_del(&node->sibling);
        free(node->name);
        free(node);
}

int vfs_del_ninfo(struct ninfo *root)
{
        struct list_head *pos;
        struct list_head *n;
        struct ninfo *tmp;
        struct ninfo *node;
        struct sinfo *sinfo;
        struct stack {
                struct list_head head;
                struct ninfo *node;
        } *item;
        LIST_HEAD(stack);

        if (root == &s_root) {
                return -EINVAL;
        }

        sinfo = root->si;

        if (sinfo->get_ninfo) {
                tmp = sinfo->get_ninfo(sinfo, ROOT_NINFO);
        } else {
                tmp = NULL;
        }

        if (root == tmp) {
                return -EINVAL;
        }

        node = vfs_get_ninfo_child(root);
        while (node) {
                tmp = vfs_get_ninfo_child(node);
                if (tmp) {
                        item = malloc(sizeof(*item));
                        if (!item) {
                                goto nomem;
                        }

                        item->node = node;
                        list_add_tail(&item->head, &stack);

                        node = tmp;
                        continue;
                }

                tmp = vfs_get_ninfo_next_sibling(node);
                if (tmp) {
                        if (node->head_sibling) {
                                struct ninfo *parent;
                                parent = vfs_get_ninfo_parent(node);
                                list_link(&tmp->child, &parent->child);
                                tmp->head_sibling = 1;
                        }

                        vfs_free_ninfo(node);
                        node = tmp;
                        continue;
                }

                vfs_free_ninfo(node);

                node = NULL;
                while (!node) {
                        if (stack.prev == &stack) {
                                node = NULL; 
                                break;
                        }

                        item = list_entry(stack.prev, struct stack, head);
                        list_del(&item->head);
                        node = item->node;
                        free(item);

                        tmp = vfs_get_ninfo_next_sibling(node);
                        vfs_free_ninfo(node);
                        node = tmp;
                }
        }

        vfs_free_ninfo(root);
        return 0;

nomem:
        list_for_each_safe(pos, n, &stack) {
                item = list_entry(pos, struct stack, head);
                list_del(pos);
                free(item);
        }
        return -ENOMEM;
}

static inline struct ninfo *get_root_if_attached(struct ninfo *node)
{
        struct sinfo *si;

        si = vfs_get_last_sinfo(node);
        if (!si || !si->get_ninfo) {
                return NULL;
        }

        node = si->get_ninfo(si, ROOT_NINFO);
        if (!node) {
                return NULL;
        }

        if (si->refresh_children) {
                si->refresh_children(si, node);
        }

        return node;
}

struct ninfo *vfs_get_ninfo(struct sinfo *sinfo, struct ninfo *node,
                const char *path)
{
        const char *p;
        int idx;
        struct ninfo *tmp;
        struct list_head *pos;
        enum {
                DOT,
                DOTDOT,
                NAME,
        } state;

        if (!path) {
                return NULL;
        }

        idx = 0;
        p = path;
        state = NAME;

        if (!node) {
                if (sinfo && sinfo->get_ninfo) {
                        node = sinfo->get_ninfo(sinfo, ROOT_NINFO);
                }

                if (!node) {
                        node = &s_root;
                }
        }

        do {
                switch (p[idx]) {
                case '\0':
                case '/':
                        if (state == DOT) {
                                break;
                        }
                        
                        if (state == DOTDOT) {
                                tmp = vfs_get_ninfo_parent(node);
                                if (tmp) {
                                        node = tmp;
                                }
                                break;
                        }

                        if (!idx) {
                                struct ninfo *root;

                                /* Skip empty */
                                idx--;
                                p++;

                                if (*p == '/') {
                                        break;
                                }

                                root = get_root_if_attached(node);
                                if (root) {
                                        node = root;
                                }

                                /* Ignore last '/' and '///...' */
                                if (*p == '\0') {
                                        return node;
                                }

                                /* Get the children of current node */
                                node = vfs_get_ninfo_child(node);
                                break;
                        }


                        /* Check the siblings */
                        tmp = NULL;
                        list_for_each(pos, &node->sibling) {
                                tmp = list_entry(pos, struct ninfo, sibling);
                                if (!strncmp(tmp->name, p, idx)) {
                                        if (!tmp->name[idx]) {
                                                break;
                                        }
                                }

                                tmp = NULL;
                        }

                        if (!tmp && !strncmp(node->name, p, idx)) {
                                /* Check the current node first */
                                if (!node->name[idx]) {
                                        tmp = node;
                                }
                        }

                        if (!p[idx]) {
                                return tmp;
                        }

                        p += (idx + 1); /* +1 = counting '/' */
                        idx = -1; /* It will be increased to ZERO */

                        node = vfs_get_ninfo_child(tmp);
                        break;

                case '.':
                        if (!idx) {
                                state = DOT;
                                break;
                        }

                        if (state == DOT) {
                                state = DOTDOT;
                                break;
                        }
                default:
                        state = NAME;
                        break;
                }

                idx++;
        } while (node);

        /* Get the root node of the attached storage on this node */
        if (node) {
                tmp = get_root_if_attached(node);
                if (tmp) {
                        node = tmp;
                }
        }

        return node;
}

struct ninfo *vfs_new_ninfo(struct sinfo *sinfo, struct ninfo *parent,
                const char *name, void *info)
{
        struct ninfo *ninfo;
        char *dup_name;

        if (!name) {
                return NULL;
        }

        if (parent) {
                if (parent->type != NINFO_TYPE_FOLDER) {
                        return NULL;
                }

                if (!sinfo) {
                        sinfo = parent->si;
                }
        }

        if (!sinfo) {
                return NULL;
        }

        dup_name = NULL;
        if (name) {
                dup_name = strdup(name);
                if (!dup_name) {
                        return NULL;
                }
        }

        ninfo = malloc(sizeof(*ninfo));
        if (!ninfo) {
                free(dup_name);
                return NULL;
        }

        ninfo->name = dup_name;
        ninfo->si = sinfo;
        ninfo->refcnt = 0;
        ninfo->deleted = 0;
        ninfo->priv = NULL;
        ninfo->head_sibling = 0;
        INIT_LIST_HEAD(&ninfo->sibling);
        INIT_LIST_HEAD(&ninfo->child);
        INIT_LIST_HEAD(&ninfo->sinfo);

        if (sinfo->fill_ninfo && sinfo->fill_ninfo(sinfo, parent, ninfo, info) < 0) {
                free(dup_name);
                free(ninfo);
                return NULL;
        }

        if (parent) {
                struct ninfo *child;

                child = vfs_get_ninfo_child(parent);
                if (!child) {
                        ninfo->head_sibling = 1;
                        list_add(&ninfo->child, &parent->child);
                } else {
                        list_add_tail(&ninfo->sibling, &child->sibling);
                }
        }

        return ninfo;
}

struct ninfo *vfs_get_ninfo_child(struct ninfo *node)
{
        struct sinfo *si;
        struct ninfo *child;
        struct ninfo *root;

        if (!node || node->type != NINFO_TYPE_FOLDER) {
                return NULL;
        }

        root = node;

        si = node->si;
        if (si) {
                if (si->refresh_children) {
                        si->refresh_children(si, node);
                }

                if (si->get_ninfo) {
                        root = si->get_ninfo(si, ROOT_NINFO);
                }
        }

        child = list_entry(node->child.next, struct ninfo, child);
        if (child == root || child == node || !child->head_sibling) {
                return NULL;
        }

        return child;
}

struct ninfo *vfs_get_ninfo_parent(struct ninfo *node)
{
        struct sinfo *si;
        struct ninfo *parent;

        si = node->si;
        if (si && si->get_ninfo) {
                if (si->get_ninfo(si, ROOT_NINFO) == node) {
                        return NULL;
                }
        }

        parent = list_entry(node->child.prev, struct ninfo, child);
        if (parent == node) {
                return NULL;
        }

        return parent;
}

struct ninfo *vfs_get_ninfo_next_sibling(struct ninfo *node)
{
        struct ninfo *next;

        next = list_entry(node->sibling.next, struct ninfo, sibling);
        if (next == node || next->head_sibling) {
                return NULL;
        }

        return next;
}

struct ninfo *vfs_get_ninfo_prev_sibling(struct ninfo *node)
{
        struct ninfo *prev;

        if (node->head_sibling) {
                return NULL;
        }
        
        prev = list_entry(node->sibling.prev, struct ninfo, sibling);
        if (prev == node) {
                return NULL;
        }

        return prev;
}

struct sinfo *vfs_get_last_sinfo(struct ninfo *node)
{
        if (node->type != NINFO_TYPE_FOLDER) {
                return NULL;
        }

        if (node->sinfo.prev == &node->sinfo) {
                return NULL;
        }

        return list_entry(node->sinfo.prev, struct sinfo, head);
}

struct ninfo *vfs_new_dev_ninfo(struct sinfo *sinfo, struct ninfo *parent,
                const char *name, dev_t device, struct ninfo_ops *nops)
{
        struct ninfo *ninfo;
        struct ninfo_dev *priv;
        char *dup_name;

        if (!name) {
                return NULL;
        }

        if (parent) {
                if (parent->type != NINFO_TYPE_FOLDER) {
                        return NULL;
                }

                if (!sinfo) {
                        sinfo = parent->si;
                }
        }

        if (!sinfo) {
                return NULL;
        }

        dup_name = NULL;
        if (name) {
                dup_name = strdup(name);
                if (!dup_name) {
                        return NULL;
                }
        }

        ninfo = malloc(sizeof(*ninfo));
        if (!ninfo) {
                free(dup_name);
                return NULL;
        }

        priv = malloc(sizeof(*priv));
        if (!priv) {
                free(dup_name);
                free(ninfo);
                return NULL;
        }

        priv->device = device;

        ninfo->name = dup_name;
        ninfo->si = sinfo;
        ninfo->refcnt = 0;
        ninfo->deleted = 0;
        ninfo->priv = priv;
        ninfo->head_sibling = 0;
        ninfo->type = NINFO_TYPE_DEVICE;
        ninfo->nops = *nops;
        INIT_LIST_HEAD(&ninfo->sibling);
        INIT_LIST_HEAD(&ninfo->child);
        INIT_LIST_HEAD(&ninfo->sinfo);

        if (parent) {
                struct ninfo *child;

                child = vfs_get_ninfo_child(parent);
                if (!child) {
                        ninfo->head_sibling = 1;
                        list_add(&ninfo->child, &parent->child);
                } else {
                        list_add_tail(&ninfo->sibling, &child->sibling);
                }
        }

        return ninfo;
}

/* End of a file */