mount.c

Go to the documentation of this file.

 
#include <core/system.h>
#include <core/string.h>
#include <fs/vfs.h>
#include <fs/devfs.h>
#include <dev/dev.h>
#include <ds/queue.h>
 
/* the mounts, for /proc/mounts */
struct queue *mounts = QUEUE_NEW();
 
MALLOC_DEFINE(M_MOUNTPOINT, "mountpoint", "mount point structure");

int vfs_mount(const char *type, const char *dir, int flags, void *data, struct uio *uio)
{
    struct fs *fs = NULL;
 
    /* find the filesystem */
    for (struct fs_list *entry = registered_fs; entry; entry = entry->next) {
        if (!strcmp(entry->name, type)) {
            fs = entry->fs;
            break;
        }
    }
 
    if (!fs)
        return -EINVAL;
 
    /* the directory it goes on */
    struct vnode *covered = NULL;
    int err;
 
    if ((err = vfs_lookup(dir, uio, &covered)))
        return err;
 
    if (!S_ISDIR(covered->mode)) {
        vfs_close(covered);
        return -ENOTDIR;
    }
 
    if (covered->mounted) {
        vfs_close(covered);
        return -EBUSY;
    }
 
    /* where it is, for /proc/mounts */
    char *path = kmalloc(1024, &M_BUFFER, 0);
 
    if (!path || vfs_vnode_path(covered, NULL, path, 1024))
        err = path ? -ENAMETOOLONG : -ENOMEM;
    else
        err = fs->mount(covered, flags, data);
 
    /* record the mount for /proc/mounts; with no memory for that, the
     * mount stays but isn't listed, and a name that couldn't be copied
     * shows as "?" */
    struct mountpoint *mp;
 
    if (err == 0 && (mp = kmalloc(sizeof(struct mountpoint), &M_MOUNTPOINT, 0))) {
        struct {
            char *dev;
            char *opt;
        } *args = data;
 
        const char *dev = (args && args->dev) ? strdup(args->dev) : "none";
        const char *t = strdup(type), *p = strdup(path);
 
        mp->dev  = dev ? dev : "?";
        mp->type = t ? t : "?";
        mp->path = p ? p : "?";
        mp->options = "";
 
        if (!enqueue(mounts, mp))
            kfree(mp);
    }
 
    kfree(path);
    vfs_close(covered);
 
    return err;
}

static int root_dev(const char *name, dev_t *dev)
{
    if (strncmp(name, "/dev/hd", 7) || name[7] < 'a' || name[7] > 'd' ||
        name[8] < '1' || name[8] > '4' || name[9])
        return -ENODEV;
 
    *dev = DEV(3, (name[7] - 'a') * 64 + name[8] - '0');
    return 0;
}

int vfs_mount_root_dev(const char *name, const char *type)
{
    struct fs *fs = NULL;
    dev_t rdev;
    int err;
 
    if ((err = root_dev(name, &rdev)))
        return err;
 
    if (!type)
        type = "ext2";
 
    for (struct fs_list *entry = registered_fs; entry; entry = entry->next) {
        if (!strcmp(entry->name, type)) {
            fs = entry->fs;
            break;
        }
    }
 
    if (!fs || !fs->load)
        return -EINVAL;
 
    struct vnode *dev = kmalloc(sizeof(struct vnode), &M_VNODE, M_ZERO);
    if (!dev) return -ENOMEM;
 
    dev->mode = S_IFBLK;
    dev->rdev = rdev;
    dev->fs   = &devfs;
    dev->ref  = 1;
 
    struct vnode *root = NULL;
 
    if ((err = fs->load(dev, &root))) {
        kfree(dev);
        return err;
    }
 
    printk("kernel: root is %s (%s)\n", name, type);
    return vfs_mount_root(root);
}