int kernel_cmd(int argc, CmdArg* argv) {
char* action = NULL;
unsigned int size = 0;
unsigned int* compressed = 0;
unsigned char* address = NULL;
if(argc < 2) {
puts("usage: kernel <load/patch/boot> [options]\n");
puts(" load <address> <size> \t\tload filesystem kernel to address\n");
puts(" patch <address> <size> \t\tpatches kernel at address in memory\n");
puts(" bootargs <string> \t\treplace current bootargs with another\n");
puts(" boot \t\tboot a loaded kernel\n");
return 0;
}
action = argv[1].string;
size = argv[3].uinteger;
address = (unsigned char*) argv[2].uinteger;
if(!strcmp(action, "load")) {
if(strstr((char*) (IBOOT_BASEADDR + 0x200), "k66ap")) {
printf("Loading AppleTV kernelcache from %s\n", KERNEL_PATH);
kernel_atv_load(KERNEL_PATH, &gKernelAddr);
} else {
printf("Loading kernelcache from 0x%x\n", address);
kernel_load((void*) address, size, &gKernelAddr);
}
printf("kernelcache prepped at %p with phymem %p\n", gKernelAddr, *gKernelPhyMem);
}
else if(!strcmp(action, "patch")) {
printf("patching kernel...\n");
if(gKernelAddr) {
patch_kernel(gKernelAddr, 0xC00000);
}
}
else if(!strcmp(action, "bootargs")) {
kernel_bootargs(argc, argv);
}
else if(!strcmp(action, "boot")) {
if(gKernelAddr) {
printf("booting kernel...\n");
jump_to(3, gKernelAddr, *gKernelPhyMem);
}
}
return 0;
}
object_t *kernel_require(static_context_t *this_context, object_t *self, object_t *filename_obj)
{
object_t *filename_str = coerce_to_s(this_context, filename_obj);
char *filename = STRING_PTR(filename_str);
int i;
for (i = 0; i < ARRAY_LEN(load_path); i++) {
char *path = STRING_PTR(coerce_to_s(this_context, ARRAY_PTR(load_path)[i]));
char buf[strlen(path) + STRING_LEN(filename_str) + 10];
sprintf(buf, "%s/%s.rb", path, filename);
FILE *file = fopen(buf, "rb");
if (!file)
continue;
fclose(file);
/* we've found the file */
kernel_load(this_context, self, string_new_cstr(buf));
return Qnil;
}
raise(LoadError, "no such file to load -- %s", filename);
}
int main(int argc, char *argv[])
{
init();
init2();
static_context_t ctx;
ctx.file = (char *)__FILE__;
ctx.method = (char *)__FUNCTION__;
ctx.line = __LINE__;
ctx.parent = 0;
ctx.block = 0;
static_context_t *this_context = &ctx;
/* awesome hardcoding work here */
load_path = array_new();
array_push(this_context, load_path, string_new_cstr("."));
array_push(this_context, load_path, string_new_cstr("./mspec/lib"));
jump_begin(JUMP_RESCUE)
send3(Kernel, s_define_method, intern("load"), kernel_load, 1);
send3(Kernel, s_define_method, intern("require"), kernel_require, 1);
send3(Kernel, s_define_method, intern("eval"), kernel_eval, -1);
Init_hash(this_context);
Init_regexp(this_context);
init_core(&ctx, g_main);
if (argc > 1) {
set_argv(this_context, argc - 2, argv + 2);
kernel_load(this_context, g_main, string_new_cstr(argv[1]));
}
else {
set_argv(this_context, 0, 0);
simple_irb(this_context, g_main);
}
jump_rescue
object_t *cls = send0(exc, s_class);
printf("%s: %s\n", ((symbol_t *)((class_t *)cls)->name)->string, ((string_t *)((exception_t *)exc)->message)->bytes);
array_t *array = (array_t *)((exception_t *)exc)->backtrace;
int i;
for (i = 0; i < array->used; i++)
printf("\tfrom %s\n", ((string_t *)array->values[i])->bytes);
jump_ensure
jump_end
exit(0);
return 0;
}
int main(int argc, char **argv)
{
printf("\33[0;40;33m\n");
printf(" FemtoForth Copyright (C) 2014 Victor Yurkovsky\n");
printf(" This program comes with ABSOLUTELY NO WARRANTY'.\n");
printf(" This is free software, and you are welcome to redistribute it\n");
printf(" under certain conditions; type 'license' for details.\n\n");
color(COLOR_RESET);color(FORE_WHITE);
//---------------------------------------------------------------------
// Data segment. Houses var at the bottom...
//
// memmap data segment
U8* data_base = mmap((void*)0x04000000,
CODE_SIZE,
PROT_READ+PROT_WRITE+PROT_EXEC,
MAP_ANONYMOUS|MAP_PRIVATE|MAP_FIXED,
0,0);
//var structure is placed into bottom RESERVED (512) bytes of data!
lay = (sMemLayout*)data_base; // HOST_RESERVED bytes
var = (sVar*)(data_base+HOST_RESERVED); // SYS_RESERVED bytes
// install system var structure at bottom
lay->data_bottom = data_base;
lay->data_top = data_base + CODE_SIZE;
//
var->data_ptr = lay->data_bottom + HOST_RESERVED + SYS_RESERVED;
printf("data at %p->%p ",lay->data_bottom,lay->data_top);
//---------------------------------------------------------------------
// Table - runtime
//
lay->table_bottom = mmap((U8**)(CODE_ADDRESS/4),
sizeof(TINDEX)*TABLE_SIZE,
PROT_READ+PROT_WRITE+PROT_EXEC,
MAP_ANONYMOUS|MAP_SHARED|MAP_FIXED,
0,0);
printf("TABLE at %p ",lay->table_bottom);
lay->table_top = (U8*)lay->table_bottom + sizeof(TINDEX)*TABLE_SIZE;
// var->table_ptr = (U8**)var->table_bottom;
// *var->table_ptr++ = 0 ; //first table entry is always 0 !
//---------------------------------------------------------------------
// DSP
//
//
lay->dsp_bottom = (U8*)malloc(DSP_SIZE);
lay->dsp_top = lay->dsp_bottom + DSP_SIZE;
printf("DSP at %p ",lay->dsp_top);
//---------------------------------------------------------------------
// RSP
lay->rsp_bottom = (U8*)malloc(RSP_SIZE);
lay->rsp_top = lay->rsp_bottom + RSP_SIZE;
var->sp_meow = (sRegsMM*)lay->rsp_top;
printf("RSP at %p ",lay->rsp_top);
//---------------------------------------------------------------------
// HEAD
lay->head_bottom = (U8*)malloc(HEAD_SIZE);
lay->head_top = lay->head_bottom + HEAD_SIZE;
var->head_ptr = lay->head_bottom;
printf("HEAD at %p \n",lay->head_bottom);
//---------------------------------------------------------------------
// SRC
lay->src_bottom = (char*)malloc(256);
src_reset();
head_build();
// printf("data pointer is now at %p\n",var->data_ptr);
kernel_load();
// printf("data pointer is now at %p\n",var->data_ptr);
cmd_init();
lang_init();
// int i;
//for(i=0;i<20;i++)
// U32 qqq = xxx(0x3456,0x1234);
// printf("bindings returns %x\n",1);
interpret_init();
// src_error("ass");
// call_meow();
while(1)
interpret_outer();
// line();
// int z = armFunction(99);
// printf("assembly returnst %d\n",z);
exit(0);
}
int sequence(void)
{
static int tick = 0, tack = 0;
switch (gstate) {
case STATE_START:
printf("Waiting for DHCP lease...\n");
gstate = STATE_WAIT_NET;
break;
case STATE_WAIT_NET:
if (!(tick & 0xFFFF))
{
tick = 0;
tack++;
}
tick++;
if (tack == 1000)
{
tftp = tftp_new();
printf("Timed out...\n");
return 1;
}
if (eth.dhcp->state == DHCP_BOUND) {
gstate = STATE_GOT_NET;
}
break;
case STATE_GOT_NET:
printf("Network is up:\n");
printf(" IP address: %d.%d.%d.%d\n", P_IP(eth.ip_addr.addr));
printf(" Netmask: %d.%d.%d.%d\n", P_IP(eth.netmask.addr));
printf(" Gateway: %d.%d.%d.%d\n", P_IP(eth.gw.addr));
printf(" TFTP server: %d.%d.%d.%d\n", P_IP(eth.dhcp->offered_si_addr.addr));
if (eth.dhcp->boot_file_name)
printf(" Bootfile: %s\n", eth.dhcp->boot_file_name);
else
printf(" Bootfile: NONE\n");
#ifdef NETRPC_ENABLE
netrpc_init();
#endif
#ifdef AUTO_TFTP
if (eth.dhcp->offered_si_addr.addr == 0 || !eth.dhcp->boot_file_name) {
tftp = tftp_new();
printf("Missing boot settings, falling back to embedded kernel...\n");
return 1;
}
tftp = tftp_new();
if (!tftp)
fatal("tftp alloc failed");
tftp_connect(tftp, ð.dhcp->offered_si_addr, 69);
printf("Downloading configuration file...\n");
seq_tftp_get((char*)eth.dhcp->boot_file_name, conf_buf, MAX_KBOOTCONF_SIZE-1, STATE_GOT_CONF);
#else
gstate = STATE_IDLE;
#endif
break;
case STATE_GOT_CONF:
if (t_status != TFTP_STATUS_OK) {
printf("Transfer did not complete successfully\n");
printf("Rebooting...\n");
lv1_panic(1);
}
printf("Configuration: %ld bytes\n", t_recvd);
conf_buf[t_recvd] = 0;
kbootconf_parse();
if (conf.num_kernels == 0) {
printf("No kernels found in configuration file. Rebooting...\n");
lv1_panic(1);
}
boot_entry = conf.default_idx;
printf("Starting to boot '%s'\n", conf.kernels[boot_entry].label);
printf("Downloading kernel...\n");
kernel_buf = mm_highmem_freestart();
seq_tftp_get(conf.kernels[boot_entry].kernel, kernel_buf, mm_highmem_freesize(), STATE_GOT_KERNEL);
break;
case STATE_GOT_KERNEL:
if (t_status != TFTP_STATUS_OK) {
printf("Transfer did not complete successfully. Rebooting...\n");
lv1_panic(1);
}
if (kernel_load(kernel_buf, t_recvd) != 0) {
printf("Failed to load kernel. Rebooting...\n");
lv1_panic(1);
}
if (conf.kernels[boot_entry].initrd && conf.kernels[boot_entry].initrd[0]) {
printf("Downloading initrd...\n");
initrd_buf = mm_highmem_freestart();
seq_tftp_get(conf.kernels[boot_entry].initrd, initrd_buf, mm_highmem_freesize(), STATE_GOT_INITRD);
} else {
gstate = STATE_BOOT;
}
break;
case STATE_GOT_INITRD:
if (t_status != TFTP_STATUS_OK) {
printf("Transfer did not complete successfully. Rebooting...\n");
lv1_panic(1);
}
mm_highmem_reserve(t_recvd);
kernel_set_initrd(initrd_buf, t_recvd);
gstate = STATE_BOOT;
break;
case STATE_BOOT:
kernel_build_cmdline(conf.kernels[boot_entry].parameters, conf.kernels[boot_entry].root);
shutdown_and_launch();
break;
case STATE_WAIT_TFTP:
break;
case STATE_IDLE:
break;
}
return 0;
}
int main(void)
{
int res;
udelay(2000000);
debug_init();
printf("\n\nBootOS Stage 2 starting.\n");
printf("Waiting for thread 1...\n");
while(!_thread1_active);
printf("Thread 1 is alive, all systems go.\n");
exceptions_init();
lv2_cleanup();
mm_init();
#ifdef USE_NETWORK
net_init();
gstate = STATE_START;
while(1) {
net_poll();
if(sequence())
break;
}
#endif
#ifdef AUTO_HDD
static FATFS fatfs;
DSTATUS stat;
stat = disk_initialize(0);
if (stat & ~STA_PROTECT)
fatal("disk_initialize() failed");
printf("Mounting filesystem...\n");
res = f_mount(0, &fatfs);
if (res != FR_OK)
fatal("f_mount() failed");
printf("Reading kboot.conf...\n");
res = readfile("/kboot.conf", conf_buf, MAX_KBOOTCONF_SIZE-1);
if (res <= 0) {
printf("Could not read kboot.conf (%d), panicking\n", res);
lv1_panic(0);
}
conf_buf[res] = 0;
kbootconf_parse();
if (conf.num_kernels == 0) {
printf("No kernels found in configuration file. Panicing...\n");
lv1_panic(0);
}
boot_entry = conf.default_idx;
printf("Starting to boot '%s'\n", conf.kernels[boot_entry].label);
printf("Loading kernel (%s)...\n", conf.kernels[boot_entry].kernel);
kernel_buf = mm_highmem_freestart();
res = readfile(conf.kernels[boot_entry].kernel, kernel_buf, mm_highmem_freesize());
if (res <= 0) {
printf("Could not read kernel (%d), panicking\n", res);
lv1_panic(0);
}
printf("Kernel size: %d\n", res);
if (kernel_load(kernel_buf, res) != 0) {
printf("Failed to load kernel. Rebooting...\n");
lv1_panic(1);
}
if (conf.kernels[boot_entry].initrd && conf.kernels[boot_entry].initrd[0]) {
initrd_buf = mm_highmem_freestart();
res = readfile(conf.kernels[boot_entry].initrd, initrd_buf, mm_highmem_freesize());
if (res <= 0) {
printf("Could not read initrd (%d), panicking\n", res);
lv1_panic(0);
}
printf("Initrd size: %d\n", res);
mm_highmem_reserve(res);
kernel_set_initrd(initrd_buf, res);
}
kernel_build_cmdline(conf.kernels[boot_entry].parameters, conf.kernels[boot_entry].root);
f_mount(0, NULL);
disk_shutdown(0);
mm_shutdown();
kernel_launch();
#endif
printf("Loading embedded kernel...\n");
kernel_buf = mm_highmem_freestart();
printf("Decompressing kernel to %lX...\n", (u64) kernel_buf);
res = unzpipe (kernel_buf, __vmlinux, &kernel_sz);
if (res)
{
printf("Cannot decompress kernel, error %d.\n", res);
lv1_panic(1);
}
printf("Kernel size: %ld\n", kernel_sz);
if (kernel_load(kernel_buf, kernel_sz) != 0)
{
printf("Failed to load embedded kernel. Rebooting...\n");
lv1_panic(1);
}
kernel_build_cmdline("video=ps3fb:mode:0 panic=5", "/dev/sda1");
shutdown_and_launch();
printf("End of main() reached! Rebooting...\n");
lv1_panic(1);
return 0;
}
