148 lines
3.0 KiB
C
148 lines
3.0 KiB
C
#include "tar.h"
|
|
|
|
#include <launch.h>
|
|
#include <mango/log.h>
|
|
#include <mango/msg.h>
|
|
#include <mango/task.h>
|
|
#include <mango/types.h>
|
|
#include <rosetta/msg.h>
|
|
#include <rosetta/msg/fs.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
|
|
#define INIT_PATH "/usr/bin/test"
|
|
|
|
static enum launch_status resolve_dependency(
|
|
struct launch_ctx *ctx,
|
|
const char *name,
|
|
kern_handle_t *out,
|
|
void *arg)
|
|
{
|
|
char s[128];
|
|
while (*name == '/') {
|
|
name++;
|
|
}
|
|
|
|
snprintf(s, sizeof s, "searching for library %s", name);
|
|
kern_log(s);
|
|
|
|
struct tar *fs = arg;
|
|
struct tar_file file = {0};
|
|
if (tar_open(fs, name, &file) != 0) {
|
|
snprintf(s, sizeof s, "cannot find library %s", name);
|
|
kern_log(s);
|
|
return LAUNCH_ERR_CANNOT_RESOLVE_DEPENDENCY;
|
|
}
|
|
|
|
kern_handle_t image = KERN_HANDLE_INVALID;
|
|
int err = tar_file_create_vm_object(&file, &image);
|
|
if (err != 0) {
|
|
snprintf(s, sizeof s, "cannot load library %s", name);
|
|
kern_log(s);
|
|
return -1;
|
|
}
|
|
|
|
*out = image;
|
|
return LAUNCH_OK;
|
|
}
|
|
|
|
int main(
|
|
int argc,
|
|
const char **argv,
|
|
kern_handle_t task,
|
|
kern_handle_t address_space,
|
|
uintptr_t bsp_base)
|
|
{
|
|
struct tar bsp = {0};
|
|
if (tar_init(&bsp, bsp_base) != 0) {
|
|
kern_log("cannot access bsp");
|
|
return -1;
|
|
}
|
|
|
|
struct tar_file init = {0};
|
|
if (tar_open(&bsp, INIT_PATH, &init) != 0) {
|
|
kern_log("cannot find init program " INIT_PATH);
|
|
return -1;
|
|
}
|
|
|
|
kern_trace("loading " INIT_PATH);
|
|
|
|
kern_handle_t image = KERN_HANDLE_INVALID;
|
|
int err = tar_file_create_vm_object(&init, &image);
|
|
if (err != 0) {
|
|
kern_log("cannot load executable " INIT_PATH);
|
|
return -1;
|
|
}
|
|
|
|
kern_trace("loaded executable vm-object " INIT_PATH);
|
|
|
|
kern_tracef("task=%x, region=%x", task, address_space);
|
|
|
|
struct launch_ctx launch;
|
|
struct launch_result result;
|
|
struct launch_parameters params = {
|
|
.p_executable = image,
|
|
.p_parent_task = task,
|
|
.p_task_name = "init",
|
|
.p_local_address_space = address_space,
|
|
.p_resolver_arg = &bsp,
|
|
};
|
|
|
|
kern_handle_t channel;
|
|
channel_create(0, 0, &channel);
|
|
|
|
launch_ctx_init(&launch);
|
|
launch.ctx_resolve_library = resolve_dependency;
|
|
|
|
enum launch_status status
|
|
= launch_ctx_execute(&launch, ¶ms, LAUNCH_F_NONE, &result);
|
|
kern_logf("launch result: %d", status);
|
|
|
|
#if 1
|
|
|
|
while (1) {
|
|
msgid_t id;
|
|
struct rosetta_msg msg;
|
|
kern_status_t status = rosetta_msg_recv(channel, &id, &msg);
|
|
if (status != KERN_OK) {
|
|
kern_logf("message recv error %d", status);
|
|
continue;
|
|
}
|
|
|
|
if (msg.msg_protocol != ROSETTA_MSG_FS) {
|
|
kern_logf(
|
|
"unknown message protocol %u",
|
|
msg.msg_protocol);
|
|
continue;
|
|
}
|
|
|
|
if (msg.msg_id != ROSETTA_MSG_FS_OPEN) {
|
|
kern_logf("unknown message function %u", msg.msg_id);
|
|
continue;
|
|
}
|
|
|
|
char path[4096];
|
|
int flags;
|
|
struct rosetta_msg_string path_str = {
|
|
.s_buf = path,
|
|
.s_max = sizeof path,
|
|
};
|
|
status = rosetta_msg_fs_open_recv(
|
|
channel,
|
|
id,
|
|
&path_str,
|
|
&flags);
|
|
if (status != KERN_OK) {
|
|
kern_logf("rosetta.fs.open recv error %d", status);
|
|
continue;
|
|
}
|
|
|
|
kern_logf("open(%s, %d)", path, flags);
|
|
|
|
rosetta_msg_fs_open_reply(channel, id, 0);
|
|
}
|
|
#endif
|
|
|
|
return 102;
|
|
}
|