kernel.c

be文件系统实现的源码

        goto error1;
    op = vn->ns->fs->ops.wstat;
    if (!op) {
        err = EINVAL;
        goto error2;
    }
    err = (*op)(vn->ns->data, vn->data, st, mask);
    if (err)
        goto error2;
    dec_vnode(vn, FALSE);

    return 0;

error2:
    dec_vnode(vn, FALSE);
error1:
    return err;
}


/*
 * sys_mount
 */

void *
sys_mount(bool kernel, const char *filesystem, int fd, const char *where,
        const char *device, ulong flags, void *parms, size_t len)
{
    int                 err;
    int                 i;
    vnode_id            vnid;
    vnode               *mount;
    fsystem             *fs;
    nspace              *ns, *ans;
    void                *data;
    struct stat         st;
    struct my_stat      mst;
    my_dev_t            dev;
    my_ino_t            ino;
    
    dev = -1;
    ino = -1;
    if (device) {
        err = stat(device, &st);
        if (err)
            return NULL;
        dev = st.st_dev;
        ino = st.st_ino;
    }

    err = get_file_fd(TRUE, fd, where, TRUE, &mount);
    if (err)
        goto error1;

    err = (*mount->ns->fs->ops.rstat)(mount->ns->data, mount->data, &mst);
    if (err)
        goto error2;
    if (!MY_S_ISDIR(mst.mode)) {
        err = ENOTDIR;
        goto error2;
    }

    ns = (nspace *) malloc(sizeof(nspace));
    if (!ns) {
        err = ENOMEM;
        goto error2;
    }

    fs = inc_file_system(filesystem);
    if (!fs) {
        err = ENODEV;
        goto error3;
    }

    LOCK(vnlock);

    if (device) {
        for(ans=nshead; ans; ans=ans->next)
            if ((ans->dev == dev) && (ans->ino == ino)) {
                UNLOCK(vnlock);
printf("KERNEL: trying to mount %s twice (already mounted as %s)\n", device, ans->fs->name);
                err = ENODEV;
                goto error4;
            }
    }

    for(i=0; i<nns; i++, nxnsid++)
        if (!nstab[nxnsid % nns]) {
            nstab[nxnsid % nns] = ns;
            ns->nsid = nxnsid;
            nxnsid++;
            break;
        }
    if (i == nns) {
        UNLOCK(vnlock);
        err = EMFILE;
        goto error4;
    }
    nstab[ns->nsid % nns] = ns;
    ns->fs = fs;
    ns->vnodes.head = ns->vnodes.tail = NULL;
    ns->data = NULL;
    ns->root = NULL;
    ns->mount = NULL;
    ns->prev = NULL;
    ns->next = nshead;
    ns->shutdown = FALSE;
    ns->dev = dev;
    ns->ino = ino;
    if (nshead)
        nshead->prev = ns;
    nshead = ns;

    UNLOCK(vnlock);

    err = (*fs->ops.mount)(ns->nsid, device, flags, parms, len, &data, &vnid);
    if (err)
        goto error5;
        
    LOCK(vnlock);
    ns->root = lookup_vnode(ns->nsid, vnid);
    ns->data = data;
    
    if ((mount == rootvn) || (mount->mounted)) {
        err = EBUSY;
        goto error6;
    }
    mount->mounted = ns;
    ns->mount = mount;


    UNLOCK(vnlock);

    return data;

error6:
    dec_vnode(ns->root, FALSE);
    (*fs->ops.unmount)(data);
error5:
    LOCK(vnlock);
    nstab[ns->nsid % nns] = NULL;
    if (ns->prev)
        ns->prev->next = ns->next;
    else
        nshead = ns->next;
    if (ns->next)
        ns->next->prev = ns->prev;
    UNLOCK(vnlock);
error4:
    dec_file_system(fs);
error3:
    free(ns);
error2:
    dec_vnode(mount, FALSE);
error1:
    errno = err;
    return NULL;
}


/*
 * sys_unmount
 */

int
sys_unmount(bool kernel, int fd, const char *where)
{
    int             err;
    nspace          *ns;
    fsystem         *fs;
    vnode           *root, *vn, *mount;
    
    err = get_file_fd(TRUE, fd, where, TRUE, &root);
    if (err)
        goto error1;

    LOCK(vnlock);

    ns = root->ns;
    fs = ns->fs;
    if (ns->root != root) {
        err = EINVAL;
        goto error2;
    }


    /*
    don't allow to unmount the root file system
    */

    if (root == rootvn) {
        err = EBUSY;
        goto error2;
    }

    /*
    decrement twice root: one for the mount, one for the get_file.
    */

    root->rcnt -= 2;

    for(vn = ns->vnodes.head; vn; vn = vn->nspace.next)
        if (vn->busy || (vn->rcnt != 0)) {
            err = EBUSY;
            goto error3;
        }

    mount = ns->mount;
    mount->mounted = NULL;

    ns->shutdown = TRUE;
    for(vn = ns->vnodes.head; vn; vn = vn->nspace.next)
        vn->busy = TRUE;
        
    while (ns->vnodes.head) {
        vn = ns->vnodes.head;
        UNLOCK(vnlock);
        err = (*fs->ops.release_vnode)(vn->ns->data, vn->data, FALSE);
        LOCK(vnlock);
        if (err)
            PANIC("ERROR WRITING VNODE!!!\n");
        vn->busy = FALSE;
        clear_vnode(vn);
        move_vnode(vn, FREE_LIST);
    }

    if (ns->prev)
        ns->prev->next = ns->next;
    else
        nshead = ns->next;
    if (ns->next)
        ns->next->prev = ns->prev;

    nstab[ns->nsid % nns] = NULL;
    UNLOCK(vnlock);

    (*fs->ops.unmount)(ns->data);

    free(ns);

    dec_file_system(fs);
    dec_vnode(mount, FALSE);

    return 0;

error3:
    root->rcnt++;
error2:
    UNLOCK(vnlock);
error1:
    return err;
}


/*
 * get_dir and get_file: basic functions to parse a path and get the vnode
 * for either the parent directory or the file itself.
 */

static int
get_dir_fd(bool kernel, int fd, const char *path, char *filename, vnode **dvn)
{
    int         err;
    char        *p, *np;

    err = new_path(path, &p);
    if (err)
        goto error1;
    np = strrchr(p, '/');
    if (!np) {
        strcpy(filename, p);
        strcpy(p, ".");
    } else {
        strcpy(filename, np+1);
        np[1] = '.';
        np[2] = '\0';
    }
    err = parse_path_fd(kernel, fd, &p, TRUE, dvn);
    if (err)
        goto error2;
    free_path(p);
    return 0;
    
error2:
    free_path(p);
error1:
    return err;
}

static int
get_file_fd(bool kernel, int fd, const char *path, int eatsymlink, vnode **vn)
{
    int         err;
    char        *p;

    err = new_path(path, &p);
    if (err)
        goto error1;
    err = parse_path_fd(kernel, fd, &p, eatsymlink, vn);
    if (err)
        goto error2;
    free_path(p);
    return 0;
    
error2:
    free_path(p);
error1:
    return err;
}

static int
get_file_vn(nspace_id nsid, vnode_id vnid, const char *path, int eatsymlink,
        vnode **vn)
{
    int         err;
    char        *p;

    err = new_path(path, &p);
    if (err)
        goto error1;
    err = parse_path_vn(nsid, vnid, &p, eatsymlink, vn);
    if (err)
        goto error2;
    free_path(p);
    return 0;
    
error2:
    free_path(p);
error1:
    return err;
}

static int
parse_path_fd(bool kernel, int fd, char **pstart, int eatsymlink, vnode **vnp)
{
    vnode           *bvn;
    ofile           *f;
    ioctx           *io;
    char            *path;

    path = *pstart;
    if (path && (*path == '/')) {
        do
            path++;
        while (*path == '/');
        bvn = rootvn;
        inc_vnode(bvn);
    } else
        if (fd >= 0) {
            f = get_fd(kernel, fd, FD_ALL);
            if (!f)
                return EBADF;
            bvn = f->vn;
            inc_vnode(bvn);
            put_fd(f);
        } else {
            io = get_cur_ioctx();
            LOCK(io->lock);
            bvn = io->cwd;
            inc_vnode(bvn);
            UNLOCK(io->lock);
        }
    return parse_path(bvn, pstart, path, eatsymlink, vnp);
}

static int
parse_path_vn(nspace_id nsid, vnode_id vnid, char **pstart, int eatsymlink,
    vnode **vnp)
{
    int             err;
    vnode           *bvn;
    char            *path;

    path = *pstart;
    if (path && (*path == '/')) {
        do
            path++;
        while (*path == '/');
        bvn = rootvn;
        inc_vnode(bvn);
    } else {
        err = load_vnode(nsid, vnid, FALSE, &bvn);
        if (err)
            return err;
    }
    return parse_path(bvn, pstart, path, eatsymlink, vnp);

error1:
    dec_vnode(bvn, FALSE);
    return err;
}

static int
parse_path(vnode *bvn, char **pstart, char *path, int eatsymlink, vnode **vnp)
{
    int             err;
    int             iter;
    char            *p, *np, *newpath, **fred;
    vnode_id        vnid;
    vnode           *vn;

    if (!path) {
        *vnp = bvn;
        return 0;
    }

    iter = 0;
    p = path;
    vn = NULL;

    while(TRUE) {

    /*
    exit if we're done
    */

        if (*p == '\0') {
            err = 0;
            break;
        }

    /*
    isolate the next component
    */

        np = strchr(p+1, '/');
        if (np) {
            *np = '\0';
            do
                np++;
            while (*np == '/');
        } else
            np = strchr(p+1, '\0');
        
    /*
    filter '..' if at the root of a namespace
    */

        if (!strcmp(p, "..") && is_root(bvn, &vn)) {
            dec_vnode(bvn, FALSE);
            bvn = vn;
        }

    /*
    ask the file system to eat this component
    */

        newpath = NULL;
        fred = &newpath;
        if (!eatsymlink && (*np == '\0'))
            fred = NULL;

        err = (*bvn->ns->fs->ops.walk)(bvn->ns->data, bvn->data, p, fred,
                &vnid);
        p = np;
        if (!err) {
            if (newpath)
                vn = bvn;
            else {
                LOCK(vnlock);
                vn = lookup_vnode(bvn->ns->nsid, vnid);
                UNLOCK(vnlock);
                dec_vnode(bvn, FALSE);
            }
        } else {
            dec_vnode(bvn, FALSE);
            break;
        }

    /*
    deal with symbolic links
    */

        if (newpath) {

    /*
    protection against cyclic graphs (with bad symbolic links).
    */

            iter++;
            if (iter > MAX_SYM_LINKS) {
                dec_vnode(vn, FALSE);
                err = ELOOP;
                break;
            }

            p = cat_paths(newpath, np);
            if (!p) {
                dec_vnode(vn, FALSE);
                err = ENOMEM;
                break;
            }
            free_path(*pstart);
            *pstart = p;
            if (*p == '/') {
                do
                    p++;
                while (*p == '/');
                dec_vnode(vn, FALSE);
                bvn = rootvn;
                inc_vnode(bvn);
            } else
                bvn = vn;
            continue;
        }

    /*
    reached a mounting point
    */

        if (is_mount_vnode(vn, &bvn)) {
            dec_vnode(vn, FALSE);
            continue;
        }

        bvn = vn;
    }

    if (!err)
        *vnp = bvn;

    return err;
}



/*
 * get_vnode
 */

int
get_vnode(nspace_id nsid, vnode_id vnid, void **data)
{
    int         err;
    vnode       *vn;

    err = load_vnode(nsid, vnid, TRUE, &vn);
    if (err)
        return err;
    *data = vn->data;
    return 0;
}


/*
 * put_vnode
 */

int
put_vnode(nspace_id nsid, vnode_id vnid)
{
    vnode           *vn;

    LOCK(vnlock);
    vn = lookup_vnode(nsid, vnid);
    if (!vn) {
        UNLOCK(vnlock);
        return ENOENT;
    }
    UNLOCK(vnlock);
    dec_vnode(vn, TRUE);
    return 0;
}

/*
 * new_vnode
 */

int
new_vnode(nspace_id nsid, vnode_id vnid, void *data)
{
    int         err;
    vnode       *vn;

    LOCK(vnlock);
    vn = steal_vnode(FREE_LIST);
    if (!vn) {
        vn = steal_vnode(USED_LIST);
        if (!vn) {
            PANIC("OUT OF VNODE!!!\n");
            UNLOCK(vnlock);
            return ENOMEM;
        }
        flush_vnode(vn, TRUE);
    }

    vn->ns = nsidtons(nsid);
    if (!vn->ns) {
        UNLOCK(vnlock);
        return ENOENT;
    }
    vn->vnid = vnid;
    vn->data = data;
    vn->rcnt = 1;
    err = sort_vnode(vn);
    UNLOCK(vnlock);
    return err;
}

/*
 * remove_vnode
 */

int
remove_vnode(nspace_id nsid, vnode_id vnid)
{
    vnode       *vn;

    LOCK(vnlock);
    vn = lookup_vnode(nsid, vnid);
    if (!vn || (vn->rcnt == 0)) {
        UNLOCK(vnlock);
        return ENOENT;
    }
    vn->remove = TRUE;
    UNLOCK(vnlock);
    return 0;
}

/*
 * unremove_vnode
 */

int
unremove_vnode(nspace_id nsid, vnode_id vnid)
{
    vnode       *vn;

    LOCK(vnlock);
    vn = lookup_vnode(nsid, vnid);
    if (!vn || (vn->rcnt == 0)) {
        UNLOCK(vnlock);
        return ENOENT;
    }
    vn->remove = FALSE;
    UNLOCK(vnlock);
    return 0;
}

/*
 * is_vnode_removed
 */

int
is_vnode_removed(nspace_id nsid, vnode_id vnid)
{
    vnode       *vn;
    int         res;

    LOCK(vnlock);
    vn = lookup_vnode(nsid, vnid);
    if (!vn) {
        UNLOCK(vnlock);
        return ENOENT;
    }
    res = vn->remove;
    UNLOCK(vnlock);
    return res;
}

/*
 * miscelleanous vnode functions
 */


static void
inc_vnode(vnode *vn)
{
    LOCK(vnlock);
    vn->rcnt++;
    UNLOCK(vnlock);
}

static void
dec_vnode(vnode *vn, char r)
{
    vnode       *ovn;

    LOCK(vnlock);
    vn->rcnt--;
    if (vn->rcnt == 0)
        if (vn->remove) {
            vn->busy = TRUE;
            move_vnode(vn, LOCKED_LIST);
            UNLOCK(vnlock);
            (*vn->ns->fs->ops.remove_vnode)(vn->ns->data, vn->data, r);
            LOCK(vnlock);
            clear_vnode(vn);
            move_vnode(vn, FREE_LIST);
        } else {
            move_vnode(vn, USED_LIST);
            if (lists[USED_LIST].num > usdvnnum) {
                ovn = steal_vnode(USED_LIST);
                flush_vnode(ovn, r);
                move_vnode(ovn, FREE_LIST);
            }
        }
    UNLOCK(vnlock);

    return;
}

static void
clear_vnode(vnode *vn)
{
    DeleteSL(skiplist, vn);

    if (vn->nspace.prev)
        vn->nspace.prev->nspace.next = vn->nspace.next;
    else
        vn->ns->vnodes.head = vn->nspace.next;
    if (vn->nspace.next)
        vn->nspace.next->nspace.prev = vn->nspace.prev;
    else
        vn->ns->vnodes.tail = vn->nspace.prev;
    vn->nspace.next = vn->nspace.prev = NULL;

    vn->vnid = invalid_vnid;
    vn->ns = NULL;
    vn->remove = FALSE;
    vn->data = NULL;
    vn->rcnt = 0;
    vn->busy = FALSE;
    vn->mounted = NULL;
}

static int
sort_vnode(vnode *vn)
{
    if (!InsertSL(skiplist, vn))
        return ENOMEM;

    vn->nspace.next = vn->ns->vnodes.head;
    vn->nspace.prev = NULL;
    if (vn->ns->vnodes.head)
        vn->ns->vnodes.head->nspace.prev = vn;
    else
        vn->ns->vnodes.tail = vn;