cpio.c

Go to the documentation of this file.

 
#include <core/system.h>
#include <core/module.h>
#include <core/panic.h>
#include <core/time.h>
 
#include <fs/vfs.h>
#include <fs/initramfs.h>
#include <fs/iobuf.h>
#include <fs/posix.h>
#include <fs/rofs.h>
 
#include <cpio.h>
 
MALLOC_DEFINE(M_CPIO, "cpio", "CPIO structure");

static void cpio_dirent_name(struct dirent *dirent, const char *name)
{
    size_t len = strlen(name);
 
    if (len >= MAXNAMELEN)
        len = MAXNAMELEN - 1;
 
    memcpy(dirent->d_name, name, len);
    dirent->d_name[len] = '\0';
}

static int cpio_root_node(struct vnode *super, struct vnode **ref)
{
    int err = 0;
    struct vnode *vnode = NULL;
    struct cpio *p = NULL;
 
    vnode = kmalloc(sizeof(struct vnode), &M_VNODE, M_ZERO);
    if (vnode == NULL) {
        err = -ENOMEM;
        goto error;
    }
 
    p = kmalloc(sizeof(struct cpio), &M_CPIO, 0);
    if (p == NULL) {
        err = -ENOMEM;
        goto error;
    }
 
    vnode->ino   = (ino_t) vnode;
    vnode->size  = 0;
    vnode->mode  = S_IFDIR | 0775;
    vnode->uid   = 0;
    vnode->gid   = 0;
    vnode->nlink = 2;
    vnode->ref   = 1;
 
    struct timespec ts;
    gettime(&ts);
 
    vnode->ctime = ts;
    vnode->atime = ts;
    vnode->mtime = ts;
 
    vnode->fs    = &cpiofs;
    vnode->p     = p;
 
    p->super     = super;
    p->parent    = NULL;
    p->dir       = NULL;
    p->count     = 0;
    p->data      = 0;
    p->next      = NULL;
 
    if (ref) *ref = vnode;
 
    return 0;
 
error:
    if (p)
        kfree(p);
    if (vnode)
        kfree(vnode);
 
    return err;
}

static int cpio_new_node(const char *name, struct cpio_hdr *hdr, size_t sz, size_t data, struct vnode *sp, struct vnode **ref)
{
    int err = 0;
    struct vnode *vnode = NULL;
    struct cpio *p = NULL;
 
    vnode = kmalloc(sizeof(struct vnode), &M_VNODE, M_ZERO);
 
    if (vnode == NULL) {
        err = -ENOMEM;
        goto error;
    }
 
    p = kmalloc(sizeof(struct cpio), &M_CPIO, 0);
    if (p == NULL) {
        err = -ENOMEM;
        goto error;
    }
 
    vnode->ino   = (vino_t) vnode;
    vnode->size  = sz;
    vnode->uid   = 0;
    vnode->gid   = 0;
    vnode->mode  = hdr->mode;
    vnode->nlink = hdr->nlink;
    vnode->mtime = (struct timespec) {.tv_sec  = hdr->mtime[0] * 0x10000 + hdr->mtime[1], .tv_nsec = 0};
    vnode->rdev  = hdr->rdev;
 
    vnode->fs   = &cpiofs;
    vnode->p    = p;
 
    p->super  = sp;
    p->parent = NULL;
    p->dir    = NULL;
    p->count  = 0;
    p->data   = data;
    p->next   = NULL;
 
    /* its own copy of the name */
    if (!(p->name = strdup(name))) {
        err = -ENOMEM;
        goto error;
    }
 
    if (ref) *ref = vnode;
 
    return 0;
 
error:
    if (p)
        kfree(p);
    if (vnode)
        kfree(vnode);
    return err;
}

static struct vnode *cpio_new_child_node(struct vnode *parent, struct vnode *child)
{
    if (!parent || !child)
        return NULL;
 
    if (!S_ISDIR(parent->mode))
        return NULL;
 
    struct cpio *pp = (struct cpio *) parent->p;
    struct cpio *cp = (struct cpio *) child->p;
 
    struct vnode *tmp = pp->dir;
 
    cp->next = tmp;
    pp->dir = child;
 
    pp->count++;
    cp->parent = parent;
 
    return child;
}

static struct vnode *cpio_find(struct vnode *root, const char *path)
{
    /* the path's components; NULL for an empty path (or no memory) */
    char **tokens = tokenize(path, '/');
    struct vnode *cur = NULL;
 
    if (!S_ISDIR(root->mode))
        goto done;
 
    cur = root;
    struct vnode *dir = ((struct cpio *) cur->p)->dir;
 
    if (!dir) { /* the root has no entries yet */
        if (tokens && *tokens)
            cur = NULL;
 
        goto done;
    }
 
    for (char **token_p = tokens; token_p && *token_p; ++token_p) {
        char *token = *token_p;
        int found = 0;
 
        for (struct vnode *e = dir; e; e = ((struct cpio *) e->p)->next) {
            if (((struct cpio *) e->p)->name &&
                    !strcmp(((struct cpio *) e->p)->name, token)) {
                cur = e;
                dir = ((struct cpio *) e->p)->dir;
                found = 1;
                break;
            }
        }
 
        if (!found) {   /* no such entry */
            cur = NULL;
            goto done;
        }
    }
 
done:
    free_tokens(tokens);
    return cur;
}

static int cpio_finddir(struct vnode *root, const char *name, struct dirent *dirent)
{
    if (!S_ISDIR(root->mode))
        return -ENOTDIR;
 
    /* its parent (the root has none) */
    if (!strcmp(name, "..")) {
        struct vnode *parent = ((struct cpio *) root->p)->parent;
 
        if (!parent)
            return -ENOENT;
 
        if (dirent) {
            dirent->d_ino = (vino_t) parent;
            cpio_dirent_name(dirent, name);
        }
 
        return 0;
    }
 
    struct vnode *dir = ((struct cpio *) root->p)->dir;
 
    if (!dir)   /* the directory is empty */
        return -ENOENT;
 
    for (struct vnode *e = dir; e; e = ((struct cpio *) e->p)->next) {
        if (((struct cpio *) e->p)->name &&
                !strcmp(((struct cpio *) e->p)->name, name)) {
            if (dirent) {
                dirent->d_ino = (vino_t) e;
                cpio_dirent_name(dirent, name);
            }
 
            return 0;
        }
    }
 
    return -ENOENT;
}

static int cpio_vget(struct vnode *super, ino_t ino, struct vnode **vnode)
{
    *vnode = (struct vnode *) ino;
    return 0;
}
 
#define MAX_NAMESIZE    1024

static int cpio_load(struct vnode *dev, struct vnode **super)
{
    /* the root directory */
    struct vnode *rootfs = NULL;
    int err = cpio_root_node(dev, &rootfs);
 
    if (err)
        return err;
 
    struct cpio_hdr hdr;
    size_t offset = 0;
    size_t size = 0;
 
    for (; offset < dev->size; 
          offset += sizeof(struct cpio_hdr) + (hdr.namesize+1)/2*2 + (size+1)/2*2) {
 
        size_t data_offset = offset;
        vfs_read(dev, data_offset, sizeof(struct cpio_hdr), &hdr);
 
        if (hdr.magic != CPIO_BIN_MAGIC) {
            panic("Invalid CPIO archive\n");
        }
 
        size = hdr.filesize[0] * 0x10000 + hdr.filesize[1];
        
        data_offset += sizeof(struct cpio_hdr);
        
        /* namesize comes from the archive: don't trust it */
        size_t namesize = MIN(hdr.namesize, MAX_NAMESIZE - 1);
 
        char path[MAX_NAMESIZE];
        vfs_read(dev, data_offset, namesize, path);
        path[namesize] = '\0';
 
        if (!strcmp(path, ".")) continue;
        if (!strcmp(path, "TRAILER!!!")) break; /* the end of the archive */
 
        char *dir  = NULL;
        char *name = NULL;
 
        /* split the path at its last '/': the directory, and the name */
        for (int i = (int) namesize - 1; i >= 0; --i) {
            if (path[i] == '/') {
                path[i] = '\0';
                name = &path[i+1];
                dir  = path;
                break;
            }
        }
 
        if (!name) {
            name = path;
            dir  = "/";
        }
        
        data_offset += hdr.namesize + (hdr.namesize % 2);
 
        /* its directory comes before it in the archive */
        struct vnode *parent = cpio_find(rootfs, dir);
 
        if (!parent) {
            printk("cpio: %s/%s: its directory isn't in the archive\n", dir, name);
            continue;
        }
 
        struct vnode *_node = NULL;
 
        if ((err = cpio_new_node(name, &hdr, size, data_offset, dev, &_node)))
            return err;
 
        cpio_new_child_node(parent, _node);
    }
 
    if (super)
        *super = rootfs;
 
    return 0;
}

static ssize_t cpio_read(struct vnode *vnode, off_t offset, struct iobuf *io)
{
    if ((size_t) offset >= vnode->size)
        return 0;
 
    struct cpio *p = vnode->p;
    struct vnode *super = p->super;
 
    /* read no further than the file's end */
    size_t cut = iobuf_limit(io, vnode->size - offset);
    ssize_t ret = vfs_read_io(super, p->data + offset, io);
    iobuf_unlimit(io, cut);
 
    return ret;
}

static ssize_t cpio_readdir(struct vnode *node, off_t offset, struct dirent *dirent)
{
    if (offset == 0) {
        strcpy(dirent->d_name, ".");
        return 1;
    }
 
    if (offset == 1) {
        strcpy(dirent->d_name, "..");
        return 1;
    }
 
    offset -= 2;
 
    struct cpio *p = (struct cpio *) node->p;
 
    if ((size_t) offset == p->count)
        return 0;
 
    int i = 0;
    struct vnode *dir = p->dir;
 
    for (struct vnode *e = dir; e; e = ((struct cpio *) e->p)->next) {
        if (i == offset) {
            dirent->d_ino = (size_t) e;
            cpio_dirent_name(dirent, ((struct cpio *) e->p)->name);
            break;
        }
        ++i;
    }
 
    return i == offset;
}

static int cpio_close(struct vnode *vnode)
{
    return 0;
}

static int cpio_eof(struct file *file)
{
    if (S_ISDIR(file->vnode->mode)) {
        return (size_t) file->offset >= ((struct cpio *) file->vnode->p)->count + 2;
    } else {
        return (size_t) file->offset >= file->vnode->size;
    }
}

static int cpio_init()
{
    return initramfs_archiver_register(&cpiofs);
}
 
struct fs cpiofs = {
    .name = "cpio",
    .load = cpio_load,
 
    .vops = {
        .read    = cpio_read,
        .readdir = cpio_readdir,
        .finddir = cpio_finddir,
        .vget    = cpio_vget,
        .close   = cpio_close,
 
        .write   = rofs_write,
        .trunc   = rofs_trunc,
        .vmknod  = rofs_vmknod,
        .vunlink = rofs_vunlink,
        .vlink   = rofs_vlink,
        .vrename = rofs_vrename,
        .setattr = rofs_setattr,
    },
    
    .fops = {
        .open    = posix_file_open,
        .close   = posix_file_close,
        .read    = posix_file_read,
        .write   = posix_file_write,
        .readdir = posix_file_readdir,
        .lseek   = posix_file_lseek,
 
        .eof     = cpio_eof,
    },
};
 
MODULE_INIT(initramfs_cpio, cpio_init, NULL)