void bootminix(void)
/* Load Minix and run it. (Given the size of this program it is surprising
* that it ever gets to that.)
*/
{
char *image;
if ((image= select_image(b_value("image"))) == nil) return;
if(serial_line >= 0) {
char linename[2];
linename[0] = serial_line + '0';
linename[1] = '\0';
b_setvar(E_VAR, SERVARNAME, linename);
}
exec_image(image);
switch (errno) {
case ENOEXEC:
printf("%s contains a bad program header\n", image);
break;
case ENOMEM:
printf("Not enough memory to load %s\n", image);
break;
case EIO:
printf("Unsuspected EOF on %s\n", image);
case 0:
/* No error or error already reported. */;
}
free(image);
if(serial_line >= 0)
b_unset(SERVARNAME);
}
void bootminix(void)
/* Load Minix and run it. (Given the size of this program it is surprising
* that it ever gets to that.)
*/
{
char *image;
if ((image= select_image(b_value("image"))) == nil) return;
exec_image(image);
switch (errno) {
case ENOEXEC:
printf("%s contains a bad program header\n", image);
break;
case ENOMEM:
printf("Not enough memory to load %s\n", image);
break;
case EIO:
printf("Unsuspected EOF on %s\n", image);
case 0:
/* No error or error already reported. */
;
}
free(image);
}
void call_start_cpu(void)
{
// 1. Hardware initialization
if(bootloader_init() != ESP_OK){
return;
}
// 2. Select image to boot
esp_image_metadata_t image_data;
if(select_image(&image_data) != ESP_OK){
return;
}
// 3. Loading the selected image
bootloader_utility_load_image(&image_data);
}
static void
display_entry (MetaTabPopup *popup,
TabEntry *te)
{
GdkRectangle rect;
GdkRegion *region;
GdkRegion *inner_region;
GdkWindow *window;
if (popup->current_selected_entry)
{
if (popup->outline)
unselect_image (popup->current_selected_entry->widget);
else
unselect_workspace (popup->current_selected_entry->widget);
}
gtk_label_set_markup (GTK_LABEL (popup->label), te->title);
if (popup->outline)
select_image (te->widget);
else
select_workspace (te->widget);
if (popup->outline)
{
/* Do stuff behind gtk's back */
gdk_window_hide (gtk_widget_get_window(popup->outline_window));
meta_core_increment_event_serial (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
rect = te->rect;
rect.x = 0;
rect.y = 0;
window = gtk_widget_get_window(GTK_WIDGET(popup->outline_window));
gdk_window_move_resize (window,
te->rect.x, te->rect.y,
te->rect.width, te->rect.height);
#if GTK_CHECK_VERSION(3, 0, 0)
GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
gdk_window_set_background_rgba (window, &black);
#else
gdk_window_set_background (window,
&popup->outline_window->style->black);
#endif
region = gdk_region_rectangle (&rect);
inner_region = gdk_region_rectangle (&te->inner_rect);
gdk_region_subtract (region, inner_region);
gdk_region_destroy (inner_region);
gdk_window_shape_combine_region (window,
region,
0, 0);
gdk_region_destroy (region);
/* This should piss off gtk a bit, but we don't want to raise
* above the tab popup. So, instead of calling gtk_widget_show,
* we manually set the window as mapped and then manually map it
* with gdk functions.
*/
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_set_mapped (popup->outline_window, TRUE);
#else
GTK_WIDGET_SET_FLAGS (popup->outline_window, GTK_MAPPED);
#endif
gdk_window_show_unraised (window);
}
/* Must be before we handle an expose for the outline window */
popup->current_selected_entry = te;
}
void exec_mb(char *kernel, char* modules)
/* Get a Minix image into core, patch it up and execute. */
{
int i;
static char hdr[SECTOR_SIZE];
char *buf;
u32_t vsec, addr, limit, n, totalmem = 0;
u16_t kmagic, mode;
char *console;
char params[SECTOR_SIZE];
extern char *sbrk(int);
char *verb;
u32_t text_vaddr, text_paddr, text_filebytes, text_membytes;
u32_t data_vaddr, data_paddr, data_filebytes, data_membytes;
u32_t pc;
u32_t text_offset, data_offset;
i32_t segsize;
int r;
u32_t cs, ds;
char *modstring, *mod;
multiboot_info_t *mbinfo;
multiboot_module_t *mbmodinfo;
u32_t mbinfo_size, mbmodinfo_size;
char *memvar;
memory *mp;
u32_t mod_cmdline_start, kernel_cmdline_start;
u32_t modstringlen;
int modnr;
/* The stack is pretty deep here, so check if heap and stack collide. */
(void) sbrk(0);
if ((verb= b_value(VERBOSEBOOTVARNAME)) != nil)
verboseboot = a2l(verb);
printf("\nLoading %s\n", kernel);
vsec= 0; /* Load this sector from kernel next. */
addr= mem[0].base; /* Into this memory block. */
limit= mem[0].base + mem[0].size;
if (limit > caddr) limit= caddr;
/* set click size for get_segment */
click_size = PAGE_SIZE;
k_flags = K_KHIGH|K_BRET|K_MEML|K_INT86|K_RET|K_HDR
|K_HIGH|K_CHMEM|K_I386;
/* big kernels must be loaded into extended memory */
addr= mem[1].base;
limit= mem[1].base + mem[1].size;
/* Get first sector */
DEBUGEXTRA(("get_sector\n"));
if ((buf= get_sector(vsec++)) == nil) {
DEBUGEXTRA(("get_sector failed\n"));
return;
}
memcpy(hdr, buf, SECTOR_SIZE);
/* Get ELF header */
DEBUGEXTRA(("read_header_elf\n"));
r = read_header_elf(hdr, &text_vaddr, &text_paddr,
&text_filebytes, &text_membytes,
&data_vaddr, &data_paddr,
&data_filebytes, &data_membytes,
&pc, &text_offset, &data_offset);
if (r < 0) { errno= ENOEXEC; return; }
/* Read the text segment. */
addr = text_paddr;
segsize = (i32_t) text_filebytes;
vsec = text_offset / SECTOR_SIZE;
DEBUGEXTRA(("get_segment(0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
vsec, segsize, addr, limit));
if (!get_segment(&vsec, &segsize, &addr, limit)) return;
DEBUGEXTRA(("get_segment done vsec=0x%lx size=0x%lx "
"addr=0x%lx\n",
vsec, segsize, addr));
/* Read the data segment. */
addr = data_paddr;
segsize = (i32_t) data_filebytes;
vsec = data_offset / SECTOR_SIZE;
DEBUGEXTRA(("get_segment(0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
vsec, segsize, addr, limit));
if (!get_segment(&vsec, &segsize, &addr, limit)) return;
DEBUGEXTRA(("get_segment done vsec=0x%lx size=0x%lx "
"addr=0x%lx\n",
vsec, segsize, addr));
n = data_membytes - align(data_filebytes, click_size);
/* Zero out bss. */
DEBUGEXTRA(("\nraw_clear(0x%lx, 0x%lx); limit=0x%lx... ", addr, n, limit));
if (addr + n > limit) { errno= ENOMEM; return; }
raw_clear(addr, n);
DEBUGEXTRA(("done\n"));
addr+= n;
/* Check the kernel magic number. */
raw_copy(mon2abs(&kmagic),
data_paddr + MAGIC_OFF, sizeof(kmagic));
if (kmagic != KERNEL_D_MAGIC) {
printf("Kernel magic number is incorrect (0x%x@0x%lx)\n",
kmagic, data_paddr + MAGIC_OFF);
errno= 0;
return;
}
/* Translate the boot parameters to what Minix likes best. */
DEBUGEXTRA(("params2params(0x%x, 0x%x)... ", params, sizeof(params)));
if (!params2params(params, sizeof(params))) { errno= 0; return; }
DEBUGEXTRA(("done\n"));
/* Create multiboot info struct */
mbinfo = malloc(sizeof(multiboot_info_t));
if (mbinfo == nil) { errno= ENOMEM; return; }
memset(mbinfo, 0, sizeof(multiboot_info_t));
/* Module info structs start where kernel ends */
mbinfo->mods_addr = addr;
modstring = strdup(modules);
if (modstring == nil) {errno = ENOMEM; return; }
modstringlen = strlen(modules);
mbinfo->mods_count = split_module_list(modules);
mbmodinfo_size = sizeof(multiboot_module_t) * mbinfo->mods_count;
mbmodinfo = malloc(mbmodinfo_size);
if (mbmodinfo == nil) { errno= ENOMEM; return; }
addr+= mbmodinfo_size;
addr= align(addr, click_size);
mod_cmdline_start = mbinfo->mods_addr + sizeof(multiboot_module_t) *
mbinfo->mods_count;
raw_copy(mod_cmdline_start, mon2abs(modules),
modstringlen+1);
mbmodinfo[0].cmdline = mod_cmdline_start;
modnr = 1;
for (i= 0; i < modstringlen; ++i) {
if (modules[i] == '\0') {
mbmodinfo[modnr].cmdline = mod_cmdline_start + i + 1;
++modnr;
}
}
kernel_cmdline_start = mod_cmdline_start + modstringlen + 1;
mbinfo->cmdline = kernel_cmdline_start;
raw_copy(kernel_cmdline_start, mon2abs(kernel),
strlen(kernel)+1);
mbinfo->flags = MULTIBOOT_INFO_MODS|MULTIBOOT_INFO_CMDLINE|
MULTIBOOT_INFO_BOOTDEV|MULTIBOOT_INFO_MEMORY;
mbinfo->boot_device = mbdev;
mbinfo->mem_lower = mem[0].size/1024;
mbinfo->mem_upper = mem[1].size/1024;
for (i = 0, mod = strtok(modstring, " "); mod != nil;
mod = strtok(nil, " "), i++) {
mod = select_image(mod);
if (mod == nil) {errno = 0; return; }
mbmodinfo[i].mod_start = addr;
mbmodinfo[i].mod_end = addr + image_bytes;
mbmodinfo[i].pad = 0;
segsize= image_bytes;
vsec= 0;
DEBUGEXTRA(("get_segment(0x%lx, 0x%lx, 0x%lx, 0x%lx)\n",
vsec, segsize, addr, limit));
if (!get_segment(&vsec, &segsize, &addr, limit)) return;
DEBUGEXTRA(("get_segment done vsec=0x%lx size=0x%lx "
"addr=0x%lx\n",
vsec, segsize, addr));
addr+= segsize;
addr= align(addr, click_size);
}
free(modstring);
DEBUGEXTRA(("modinfo raw_copy: dst 0x%lx src 0x%lx sz 0x%lx\n",
mbinfo->mods_addr, mon2abs(mbmodinfo),
mbmodinfo_size));
raw_copy(mbinfo->mods_addr, mon2abs(mbmodinfo),
mbmodinfo_size);
free(mbmodinfo);
raw_copy(MULTIBOOT_INFO_ADDR, mon2abs(mbinfo),
sizeof(multiboot_info_t));
free(mbinfo);
/* Run the trailer function just before starting Minix. */
DEBUGEXTRA(("run_trailer()... "));
if (!run_trailer()) { errno= 0; return; }
DEBUGEXTRA(("done\n"));
/* Set the video to the required mode. */
if ((console= b_value("console")) == nil || (mode= a2x(console)) == 0) {
mode= strcmp(b_value("chrome"), "color") == 0 ? COLOR_MODE :
MONO_MODE;
}
DEBUGEXTRA(("set_mode(%d)... ", mode));
set_mode(mode);
DEBUGEXTRA(("done\n"));
/* Close the disk. */
DEBUGEXTRA(("dev_close()... "));
(void) dev_close();
DEBUGEXTRA(("done\n"));
/* Minix. */
cs = ds = text_paddr;
DEBUGEXTRA(("minix(0x%lx, 0x%lx, 0x%lx, 0x%x, 0x%x, 0x%lx)\n",
pc, cs, ds, params, sizeof(params), 0));
minix(pc, cs, ds, params, sizeof(params), 0);
if (!(k_flags & K_BRET)) {
extern u32_t reboot_code;
raw_copy(mon2abs(params), reboot_code, sizeof(params));
}
parse_code(params);
/* Return from Minix. Things may have changed, so assume nothing. */
fsok= -1;
errno= 0;
/* Read leftover character, if any. */
scan_keyboard();
/* Restore screen contents. */
restore_screen();
}
void bootminix(void)
/* Load Minix and run it. (Given the size of this program it is surprising
* that it ever gets to that.)
*/
{
char *image;
char *mb;
char *kernel;
/* FIXME: modules should come from environment */
char modules[] = "boot/ds boot/rs boot/pm boot/sched boot/vfs boot/memory boot/log boot/tty boot/mfs boot/vm boot/pfs boot/init";
if ((mb = b_value("mb")) != nil) {
do_multiboot = a2l(mb);
kernel = b_value("kernel");
if (kernel == nil) {
printf("kernel not set\n");
return;
}
}
if (do_multiboot) {
if ((kernel= select_image(b_value("kernel"))) == nil) return;
} else {
if ((image= select_image(b_value("image"))) == nil) return;
}
if(serial_line >= 0) {
char linename[2];
linename[0] = serial_line + '0';
linename[1] = '\0';
b_setvar(E_VAR, SERVARNAME, linename);
}
if (do_multiboot)
exec_mb(kernel, modules);
else
exec_image(image);
switch (errno) {
case ENOEXEC:
printf("%s contains a bad program header\n",
do_multiboot ? kernel : image);
break;
case ENOMEM:
printf("Not enough memory to load %s\n",
do_multiboot ? kernel : image);
break;
case EIO:
printf("Unexpected EOF on %s\n",
do_multiboot ? kernel : image);
case 0:
/* No error or error already reported. */;
}
if (do_multiboot)
free(kernel);
else
free(image);
if(serial_line >= 0)
b_unset(SERVARNAME);
}
