398 lines
12 KiB
C++
398 lines
12 KiB
C++
/*
|
|
* Copyright (c) 2011-2016, 2023 Jonas 'Sortie' Termansen.
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* initrd.cpp
|
|
* Extracts initrds into the initial memory filesystem.
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <libgen.h>
|
|
#include <stdarg.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <timespec.h>
|
|
|
|
#include <sortix/dirent.h>
|
|
#include <sortix/fcntl.h>
|
|
#include <sortix/mman.h>
|
|
#include <sortix/stat.h>
|
|
#include <sortix/tar.h>
|
|
|
|
#include <sortix/kernel/addralloc.h>
|
|
#include <sortix/kernel/descriptor.h>
|
|
#include <sortix/kernel/fsfunc.h>
|
|
#include <sortix/kernel/ioctx.h>
|
|
#include <sortix/kernel/kernel.h>
|
|
#include <sortix/kernel/memorymanagement.h>
|
|
#include <sortix/kernel/string.h>
|
|
#include <sortix/kernel/syscall.h>
|
|
#include <sortix/kernel/vnode.h>
|
|
|
|
#include "initrd.h"
|
|
#include "multiboot.h"
|
|
|
|
namespace Sortix {
|
|
|
|
struct initrd_context
|
|
{
|
|
uint8_t* initrd;
|
|
size_t initrd_size;
|
|
addr_t initrd_unmap_start;
|
|
addr_t initrd_unmap_end;
|
|
ioctx_t ioctx;
|
|
};
|
|
|
|
// TODO: GRUB is currently buggy and doesn't ensure that other things are placed
|
|
// at the end of a module, i.e. that the module doesn't own all the bugs
|
|
// that it spans. It's thus risky to actually recycle the last page if the
|
|
// module doesn't use all of it. Remove this compatibility when this has
|
|
// been fixed in GRUB and a few years have passed such that most GRUB
|
|
// systems have this fixed.
|
|
static void UnmapInitrdPage(struct initrd_context* ctx, addr_t vaddr)
|
|
{
|
|
if ( !Memory::LookUp(vaddr, NULL, NULL) )
|
|
return;
|
|
addr_t addr = Memory::Unmap(vaddr);
|
|
if ( !(ctx->initrd_unmap_start <= addr && addr < ctx->initrd_unmap_end) )
|
|
return;
|
|
Page::Put(addr, PAGE_USAGE_WASNT_ALLOCATED);
|
|
}
|
|
|
|
struct TAR
|
|
{
|
|
unsigned char* tar_file;
|
|
size_t tar_file_size;
|
|
size_t next_offset;
|
|
size_t offset;
|
|
size_t data_offset;
|
|
char* name;
|
|
char* linkname;
|
|
unsigned char* data;
|
|
size_t size;
|
|
mode_t mode;
|
|
char typeflag;
|
|
};
|
|
|
|
static void OpenTar(TAR* TAR, unsigned char* tar_file, size_t tar_file_size)
|
|
{
|
|
memset(TAR, 0, sizeof(*TAR));
|
|
TAR->tar_file = tar_file;
|
|
TAR->tar_file_size = tar_file_size;
|
|
}
|
|
|
|
static void CloseTar(TAR* TAR)
|
|
{
|
|
free(TAR->name);
|
|
free(TAR->linkname);
|
|
memset(TAR, 0, sizeof(*TAR));
|
|
}
|
|
|
|
static bool ReadTar(TAR* TAR)
|
|
{
|
|
free(TAR->name);
|
|
free(TAR->linkname);
|
|
TAR->name = NULL;
|
|
TAR->linkname = NULL;
|
|
while ( true )
|
|
{
|
|
if ( TAR->tar_file_size - TAR->next_offset < sizeof(struct TAR) )
|
|
return false;
|
|
TAR->offset = TAR->next_offset;
|
|
struct tar* tar = (struct tar*) (TAR->tar_file + TAR->offset);
|
|
if ( tar->size[sizeof(tar->size) - 1] != '\0' &&
|
|
tar->size[sizeof(tar->size) - 1] != ' ' )
|
|
return false;
|
|
size_t size = strtoul(tar->size, NULL, 8);
|
|
size_t dist = sizeof(struct tar) + -(-size & ~((size_t) 512 - 1));
|
|
if ( TAR->tar_file_size - TAR->offset < dist )
|
|
return false;
|
|
TAR->next_offset = TAR->offset + dist;
|
|
TAR->data_offset = TAR->offset + 512;
|
|
TAR->data = TAR->tar_file + TAR->data_offset;
|
|
TAR->size = size;
|
|
if ( tar->mode[sizeof(tar->mode) - 1] != '\0' &&
|
|
tar->mode[sizeof(tar->mode) - 1] != ' ' )
|
|
return false;
|
|
TAR->mode = strtoul(tar->mode, NULL, 8) & 07777;
|
|
TAR->typeflag = tar->typeflag;
|
|
// TODO: Things like modified time and other meta data!
|
|
if ( tar->typeflag == 'L' )
|
|
{
|
|
free(TAR->name);
|
|
if ( !(TAR->name = (char*) malloc(size + 1)) )
|
|
Panic("initrd tar malloc failure");
|
|
memcpy(TAR->name, TAR->data, size);
|
|
TAR->name[size] = '\0';
|
|
continue;
|
|
}
|
|
else if ( tar->typeflag == 'g' )
|
|
{
|
|
// TODO: Implement pax extensions.
|
|
continue;
|
|
}
|
|
else if ( tar->typeflag == 'x' )
|
|
{
|
|
// TODO: Implement pax extensions.
|
|
continue;
|
|
}
|
|
if ( !tar->name[0] )
|
|
continue;
|
|
if ( !TAR->name )
|
|
{
|
|
if ( tar->prefix[0] )
|
|
{
|
|
size_t prefix_len = strnlen(tar->prefix, sizeof(tar->prefix));
|
|
size_t name_len = strnlen(tar->name, sizeof(tar->name));
|
|
size_t name_size = prefix_len + 1 + name_len + 1;
|
|
if ( !(TAR->name = (char*) malloc(name_size)) )
|
|
Panic("initrd tar malloc failure");
|
|
memcpy(TAR->name, tar->prefix, prefix_len);
|
|
TAR->name[prefix_len] = '/';
|
|
memcpy(TAR->name + prefix_len + 1, tar->name, name_len);
|
|
TAR->name[prefix_len + 1 + name_len] = '\0';
|
|
}
|
|
else
|
|
{
|
|
TAR->name = (char*) strndup(tar->name, sizeof(tar->name));
|
|
if ( !TAR->name )
|
|
Panic("initrd tar malloc failure");
|
|
}
|
|
}
|
|
if ( !TAR->linkname )
|
|
{
|
|
TAR->linkname = (char*) strndup(tar->linkname, sizeof(tar->linkname));
|
|
if ( !TAR->linkname )
|
|
Panic("initrd tar malloc failure");
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
static void ExtractTarObject(Ref<Descriptor> desc,
|
|
struct initrd_context* ctx,
|
|
TAR* TAR)
|
|
{
|
|
if ( TAR->typeflag == '0' || TAR->typeflag == 0 )
|
|
{
|
|
int oflags = O_WRITE | O_CREATE | O_TRUNC;
|
|
Ref<Descriptor> file(desc->open(&ctx->ioctx, TAR->name, oflags, TAR->mode));
|
|
if ( !file )
|
|
PanicF("%s: %m", TAR->name);
|
|
if ( file->truncate(&ctx->ioctx, TAR->size) != 0 )
|
|
PanicF("truncate: %s: %m", TAR->name);
|
|
size_t sofar = 0;
|
|
while ( sofar < TAR->size )
|
|
{
|
|
size_t left = TAR->size - sofar;
|
|
size_t chunk = 1024 * 1024;
|
|
size_t count = left < chunk ? left : chunk;
|
|
ssize_t numbytes = file->write(&ctx->ioctx, TAR->data + sofar, count);
|
|
if ( numbytes <= 0 )
|
|
PanicF("write: %s: %m", TAR->name);
|
|
sofar += numbytes;
|
|
}
|
|
}
|
|
else if ( TAR->typeflag == '1' )
|
|
{
|
|
Ref<Descriptor> dest(desc->open(&ctx->ioctx, TAR->linkname, O_READ, 0));
|
|
if ( !dest )
|
|
PanicF("%s: %m", TAR->linkname);
|
|
if ( desc->link(&ctx->ioctx, TAR->name, dest) != 0 )
|
|
PanicF("link: %s -> %s: %m", TAR->linkname, TAR->name);
|
|
}
|
|
else if ( TAR->typeflag == '2' )
|
|
{
|
|
if ( desc->symlink(&ctx->ioctx, TAR->linkname, TAR->name) != 0 )
|
|
PanicF("symlink: %s: %m", TAR->name);
|
|
}
|
|
else if ( TAR->typeflag == '5' )
|
|
{
|
|
if ( desc->mkdir(&ctx->ioctx, TAR->name, TAR->mode) && errno != EEXIST )
|
|
PanicF("mkdir: %s: %m", TAR->name);
|
|
}
|
|
else
|
|
{
|
|
Log::PrintF("kernel: initrd: %s: Unsupported tar filetype '%c'\n",
|
|
TAR->name, TAR->typeflag);
|
|
}
|
|
}
|
|
|
|
static void ExtractTar(Ref<Descriptor> desc, struct initrd_context* ctx)
|
|
{
|
|
TAR TAR;
|
|
OpenTar(&TAR, ctx->initrd, ctx->initrd_size);
|
|
while ( ReadTar(&TAR) )
|
|
ExtractTarObject(desc, ctx, &TAR);
|
|
CloseTar(&TAR);
|
|
}
|
|
|
|
static int ExtractTo_mkdir(Ref<Descriptor> desc, ioctx_t* ctx,
|
|
const char* path, mode_t mode)
|
|
{
|
|
int saved_errno = errno;
|
|
if ( !desc->mkdir(ctx, path, mode) )
|
|
return 0;
|
|
if ( errno == ENOENT )
|
|
{
|
|
char* prev = strdup(path);
|
|
if ( !prev )
|
|
return -1;
|
|
int status = ExtractTo_mkdir(desc, ctx, dirname(prev), mode | 0500);
|
|
free(prev);
|
|
if ( status < 0 )
|
|
return -1;
|
|
errno = saved_errno;
|
|
if ( !desc->mkdir(ctx, path, mode) )
|
|
return 0;
|
|
}
|
|
if ( errno == EEXIST )
|
|
return errno = saved_errno, 0;
|
|
return -1;
|
|
}
|
|
|
|
static void ExtractTo(Ref<Descriptor> desc,
|
|
struct initrd_context* ctx,
|
|
const char* path,
|
|
int extra_oflags)
|
|
{
|
|
int oflags = O_WRITE | O_CREATE | extra_oflags;
|
|
Ref<Descriptor> file(desc->open(&ctx->ioctx, path, oflags, 0644));
|
|
if ( !file && errno == ENOENT )
|
|
{
|
|
char* prev = strdup(path);
|
|
if ( !prev )
|
|
PanicF("%s: strdup: %m", path);
|
|
if ( ExtractTo_mkdir(desc, &ctx->ioctx, dirname(prev), 0755) < 0 )
|
|
PanicF("%s: mkdir -p: %s: %m", path, prev);
|
|
free(prev);
|
|
file = desc->open(&ctx->ioctx, path, oflags, 0644);
|
|
}
|
|
if ( !file )
|
|
{
|
|
if ( errno == EEXIST && (oflags & O_EXCL) )
|
|
return;
|
|
PanicF("%s: %m", path);
|
|
}
|
|
if ( !(oflags & O_APPEND) )
|
|
{
|
|
if ( file->truncate(&ctx->ioctx, ctx->initrd_size) != 0 )
|
|
PanicF("truncate: %s: %m", path);
|
|
}
|
|
size_t sofar = 0;
|
|
while ( sofar < ctx->initrd_size )
|
|
{
|
|
size_t left = ctx->initrd_size - sofar;
|
|
size_t chunk = 1024 * 1024;
|
|
size_t count = left < chunk ? left : chunk;
|
|
ssize_t numbytes = file->write(&ctx->ioctx, ctx->initrd + sofar, count);
|
|
if ( numbytes <= 0 )
|
|
PanicF("write: %s: %m", path);
|
|
sofar += numbytes;
|
|
}
|
|
}
|
|
|
|
static void ExtractModule(struct multiboot_mod_list* module,
|
|
Ref<Descriptor> desc,
|
|
struct initrd_context* ctx)
|
|
{
|
|
size_t mod_size = module->mod_end - module->mod_start;
|
|
const char* cmdline = (const char*) (uintptr_t) module->cmdline;
|
|
|
|
// Ignore the random seed.
|
|
if ( !strcmp(cmdline, "--random-seed") )
|
|
return;
|
|
|
|
// Allocate the needed kernel virtual address space.
|
|
addralloc_t initrd_addr_alloc;
|
|
if ( !AllocateKernelAddress(&initrd_addr_alloc, mod_size) )
|
|
PanicF("Failed to allocate kernel address space for the initrd");
|
|
|
|
// Map the physical frames onto our address space.
|
|
addr_t physfrom = module->mod_start;
|
|
addr_t mapat = initrd_addr_alloc.from;
|
|
for ( size_t i = 0; i < mod_size; i += Page::Size() )
|
|
{
|
|
if ( !Memory::Map(physfrom + i, mapat + i, PROT_KREAD | PROT_KWRITE) )
|
|
PanicF("Unable to map the initrd into virtual memory");
|
|
}
|
|
Memory::Flush();
|
|
|
|
ctx->initrd = (uint8_t*) initrd_addr_alloc.from;
|
|
ctx->initrd_size = mod_size;
|
|
ctx->initrd_unmap_start = module->mod_start;
|
|
ctx->initrd_unmap_end = Page::AlignDown(module->mod_end);
|
|
|
|
const unsigned char xz_magic[] = { 0xFD, '7', 'z', 'X', 'Z', 0x00 };
|
|
const unsigned char bzip2_magic[] = { 'B', 'Z' };
|
|
const unsigned char gz_magic[] = { 0x1F, 0x8B };
|
|
|
|
if ( !strncmp(cmdline, "--to ", strlen("--to ")) ||
|
|
!strncmp(cmdline, "--to=", strlen("--to=")) )
|
|
ExtractTo(desc, ctx, cmdline + strlen("--to "), O_TRUNC);
|
|
else if ( !strncmp(cmdline, "--append-to ", strlen("--append-to ")) ||
|
|
!strncmp(cmdline, "--append-to=", strlen("--append-to=")) )
|
|
ExtractTo(desc, ctx, cmdline + strlen("--append-to "), O_APPEND);
|
|
else if ( !strncmp(cmdline, "--create-to ", strlen("--create-to ")) ||
|
|
!strncmp(cmdline, "--create-to=", strlen("--create-to=")) )
|
|
ExtractTo(desc, ctx, cmdline + strlen("--create-to "), O_EXCL);
|
|
// TODO: After releasing Sortix 1.1, remove this nice error message.
|
|
else if ( strlen("sortix-initrd-2") <= ctx->initrd_size &&
|
|
!memcmp(ctx->initrd, "sortix-initrd-2", strlen("sortix-initrd-2")) )
|
|
Panic("The sortix-initrd-2 format is no longer supported");
|
|
else if ( sizeof(struct tar) <= ctx->initrd_size &&
|
|
!memcmp(ctx->initrd + offsetof(struct tar, magic), "ustar", 5) )
|
|
ExtractTar(desc, ctx);
|
|
else if ( sizeof(xz_magic) <= ctx->initrd_size &&
|
|
!memcmp(ctx->initrd, xz_magic, sizeof(xz_magic)) )
|
|
Panic("Bootloader failed to decompress an xz initrd, "
|
|
"or try the --to <path> option");
|
|
else if ( sizeof(gz_magic) <= ctx->initrd_size &&
|
|
!memcmp(ctx->initrd, gz_magic, sizeof(gz_magic)) )
|
|
Panic("Bootloader failed to decompress a gzip initrd, "
|
|
"or try the --to <path> option");
|
|
else if ( sizeof(bzip2_magic) <= ctx->initrd_size &&
|
|
!memcmp(ctx->initrd, bzip2_magic, sizeof(bzip2_magic)) )
|
|
Panic("Bootloader failed to decompress a bzip2 initrd, "
|
|
"or try the --to <path> option");
|
|
else
|
|
Panic("Unsupported initrd format, or try the --to <path> option");
|
|
|
|
// Unmap the pages and return the physical frames for reallocation.
|
|
for ( size_t i = 0; i < mod_size; i += Page::Size() )
|
|
UnmapInitrdPage(ctx, mapat + i);
|
|
Memory::Flush();
|
|
|
|
// Free the used virtual address space.
|
|
FreeKernelAddress(&initrd_addr_alloc);
|
|
}
|
|
|
|
void ExtractModules(struct multiboot_info* bootinfo, Ref<Descriptor> root)
|
|
{
|
|
struct multiboot_mod_list* modules =
|
|
(struct multiboot_mod_list*) (uintptr_t) bootinfo->mods_addr;
|
|
struct initrd_context ctx;
|
|
memset(&ctx, 0, sizeof(ctx));
|
|
SetupKernelIOCtx(&ctx.ioctx);
|
|
for ( uint32_t i = 0; i < bootinfo->mods_count; i++ )
|
|
ExtractModule(&modules[i], root, &ctx);
|
|
}
|
|
|
|
} // namespace Sortix
|