int main(int argc, char **argv, char **envp)
{
int fd_stdin=-1, fd_stdout=-1;
pid_t pid;
int retries = 0;
int rootmounted = 0;
char *rootdev = NULL;
char *rootfstype = "unknown";
char *rootfslabel = ROOTFSLABEL;
char *initprg = "/sbin/init";
conf.mountflags = MS_SYNCHRONOUS;
open_console();
/* create mountpoints /dev and /proc /rootfs */
mkmountpoint("/dev");
mkmountpoint("/proc");
mkmountpoint("/rootfs");
open_console();
/* make sure /dev is mounted */
if(mount("devtmpfs", "/dev",
"devtmpfs", 0,
"")) {
if(fstdout) {
if(fstdout) {
fprintf(fstdout, "INIT: could not mount devtmpfs on /dev: %s\n", strerror(errno));
fprintf(fstdout, "INIT: waiting 10 seconds ..\n");
sleep(5);
sleep(5);
}
}
}
open_console();
/* mount /proc */
if(mount("proc", "/proc",
"proc", 0,
"")) {
if(fstdout) {
fprintf(fstdout, "INIT: could not mount proc on /proc: %s\n", strerror(errno));
fprintf(fstdout, "INIT: waiting 10 seconds ..\n");
sleep(5);
sleep(5);
}
}
/* parse kernel commandline options */
cmdline.autoresize = 1;
cmdline_parse();
if(cmdline.init) {
initprg = cmdline.init;
}
if(cmdline.async) {
conf.mountflags ^= MS_SYNCHRONOUS;
}
if(cmdline.usbreset) {
usbreset();
sleep(1);
}
if(cmdline.rootdelay > 0) {
if(fstdout) fprintf(fstdout, "INIT: rootdelay, waiting %d seconds\n", cmdline.rootdelay);
sleep(cmdline.rootdelay);
}
if(cmdline.rootdev) {
struct stat statb;
if(fstdout) fprintf(fstdout, "INIT: rootdev %s given on commandline\n", cmdline.rootdev);
rootdev = cmdline.rootdev;
if(stat(rootdev, &statb)) {
if(fstdout) fprintf(fstdout, "INIT: rootdev %s not found!\n", rootdev);
rootdev = NULL;
}
}
if(!rootdev) {
if(cmdline.rootfslabel) {
if(strncmp(cmdline.rootfslabel, "LABEL=", 6)) {
rootfslabel = malloc(strlen("LABEL=") + strlen(cmdline.rootfslabel) + 1);
strcpy(rootfslabel, "LABEL=");
strcat(rootfslabel, cmdline.rootfslabel);
} else {
rootfslabel = cmdline.rootfslabel;
}
}
if(fstdout) fprintf(fstdout, "INIT: probing for rootdev labeled '%s'\n", rootfslabel);
fsprobe_init();
while( (rootdev = fsprobe_get_devname_by_spec(rootfslabel)) == NULL ) {
retries++;
if(retries == 15) usbreset();
if(retries > 25) break;
if(fstdout) fprintf(fstdout, "INIT: waiting for rootdevice to be available\n");
sleep(2);
fsprobe_init();
}
}
if(!rootdev) {
if(fstdout) {
fprintf(fstdout, "INIT: could not find rootdevice\n");
listdevices();
fprintf(fstdout, "INIT: waiting 10 seconds ..\n");
sleep(5);
sleep(5);
fprintf(fstdout, "INIT: guessing that rootdev is /dev/sda1\n\n");
}
rootdev="/dev/sda1";
} else {
if(fstdout) fprintf(fstdout, "INIT: using rootdev %s\n", rootdev);
}
sleep(1);
/* if filesystem is of the ext family */
if((!cmdline.rootfstype) || (!strncmp(cmdline.rootfstype, "ext", 3))) {
int status = 0;
int fsckok = 0;
/* e2fsck -y rootdev */
/* fork + exec("/e2fsck", "/e2fsck"-y", rootdev) */
if((pid=fork())==0) {
execl("/e2fsck", "/e2fsck", "-y", rootdev, NULL);
exit(0);
}
if(pid != -1) {
wait(&status);
if(WIFEXITED(status)) {
fprintf(fstdout, "INIT: e2fsck exited normally with exit code: %d\n", WEXITSTATUS(status));
if(WEXITSTATUS(status)==0) fsckok=1;
} else {
fprintf(fstdout, "INIT: e2fsck exited abnormally\n");
}
}
if(fsckok) {
if(cmdline.autoresize) {
sync();
if((pid=fork())==0) {
execl("/resize2fs", "/resize2fs", "-f", rootdev, NULL);
exit(0);
}
if(pid != -1) wait(NULL);
sync();
}
}
}
/* unlink /e2sck and /resize2fs to save some memory */
if(unlink("/e2fsck")) {
fprintf(fstdout, "INIT: unlink(\"/e2fsck\") failed: %s\n", strerror(errno));
}
if(unlink("/resize2fs")) {
fprintf(fstdout, "INIT: unlink(\"/resize2fs\") failed: %s\n", strerror(errno));
}
if(cmdline.rootfstype) {
/* mount /rootfs, try fstype supplied on kernel commandline */
if(mount(rootdev, "/rootfs", cmdline.rootfstype, MS_NOATIME|MS_RDONLY|conf.mountflags, "")) {
if(fstdout) fprintf(fstdout, "INIT: failed to mount (%s) %s: %s\n",
cmdline.rootfstype, rootdev, strerror(errno));
} else {
rootmounted = 1;
rootfstype = cmdline.rootfstype;
}
}
if(!rootmounted) {
/* mount /rootfs, try ext2 */
if(mount(rootdev, "/rootfs", "ext2", MS_NOATIME|MS_RDONLY|conf.mountflags, "")) {
if(fstdout) fprintf(fstdout, "INIT: failed to mount (ext2) %s: %s\n", rootdev, strerror(errno));
goto forever;
}
rootfstype = "ext2";
}
if(fstdout) fprintf(fstdout, "INIT: (%s) %s mounted.\n", rootfstype, rootdev);
sleep(1);
if(cmdline.install) {
if(fstdout) {
fprintf(fstdout, "INIT: INSTALL INVOKED!\nINSTALL: PROCEEDING IN 5 SECONDS!\n");
sleep(5);
}
/* unpack install archive in initramfs root */
{
int fd;
fd = open("/rootfs/install.tar", O_RDONLY);
if(fd == -1) {
if(fstdout) fprintf(fstdout, "INSTALL: failed to open '/rootfs/install.tar'\n");
} else {
if(fstdout) fprintf(fstdout, "INSTALL: '/rootfs/install.tar' opened ok\n");
tar_extract(fd);
close(fd);
}
}
/* Be nice and prepare stdin and stdout for the install program */
fd_stdin = open("/dev/console", O_RDONLY|O_NOCTTY);
if(fd_stdin == -1) {
if(fstdout)
fprintf(fstdout, "INSTALL: open(\"/dev/console\", O_RDONLY) failed: %s\n", strerror(errno));
} else {
if(fd_stdin != 0) {
dup2(fd_stdin, 0);
close(fd_stdin);
}
}
fd_stdout = open("/dev/console", O_WRONLY|O_NOCTTY);
if(fd_stdout == -1) {
if(fstdout)
fprintf(fstdout, "INSTALL: open(\"/dev/console\", O_WRONLY) failed: %s\n", strerror(errno));
} else {
if(fd_stdout != 1) {
dup2(fd_stdout, 1);
dup2(fd_stdout, 2);
close(fd_stdout);
}
}
/* exec "/install" */
{
char *iv[2];
iv[0] = "/install";
iv[1] = NULL;
if(fstdout)
fprintf(fstdout, "INSTALL: exec(\"/install\")\n");
execve(iv[0], iv, envp);
if(fstdout)
fprintf(fstdout, "INSTALL: exec(\"/install\") failed\n");
sleep(10);
}
}
if (mount("/dev", "/rootfs/dev", NULL, MS_MOVE, NULL) < 0) {
if(fstdout)
fprintf(fstdout, "INIT: failed to mount moving /dev to /rootfs/dev\n");
sleep(1);
}
if (mount("/proc", "/rootfs/proc", NULL, MS_MOVE, NULL) < 0) {
if(fstdout)
fprintf(fstdout, "INIT: failed to mount moving /proc to /rootfs/proc\n");
sleep(1);
}
/*
* mkdir /sbin
* copy /rootfs/sbin/init to /sbin/init
* mount --bind /rootfs/sbin/init /sbin/init
*/
if(mkdir("/sbin", 0755)) {
if(fstdout)
fprintf(fstdout, "INIT: mkdir(\"/sbin\") failed: %s\n", strerror(errno));
sleep(1);
} else {
int fd, ofd;
ssize_t siz;
struct stat statb;
if(stat("/rootfs/sbin/init", &statb)) {
if(fstdout) fprintf(fstdout, "INIT: stat(\"/rootfs/sbin/init\") failed: %s\n", strerror(errno));
sleep(1);
goto noinitcopy;
}
siz = statb.st_size;
if(mount("tmpfs", "/sbin","tmpfs", 0,"")) {
if(fstdout) fprintf(fstdout, "INIT: mount(\"tmpfs\", \"/sbin\") failed: %s\n", strerror(errno));
}
if( (fd = open("/rootfs/sbin/init", O_RDONLY)) == -1) {
if(fstdout) fprintf(fstdout, "INIT: open(\"/rootfs/sbin/init\", O_RDONLY) failed: %s\n", strerror(errno));
sleep(1);
goto noinitcopy;
}
if( (ofd = open("/sbin/init", O_WRONLY|O_CREAT|O_TRUNC, 0755)) == -1) {
if(fstdout) fprintf(fstdout, "INIT: open(\"/sbin/init\", O_WRONLY|O_CREAT|O_TRUNC) failed: %s\n", strerror(errno));
sleep(1);
close(fd);
goto noinitcopy;
}
if(data(fd, siz, ofd)) {
if(fstdout) fprintf(fstdout, "INIT: datacopy of /sbin/init failed: %s\n", strerror(errno));
sleep(1);
close(fd);
close(ofd);
goto noinitcopy;
}
close(fd);
if(close(ofd)) {
if(fstdout) fprintf(fstdout, "INIT: close(\"/sbin/init\") failed: %s\n", strerror(errno));
sleep(1);
goto noinitcopy;
}
if (mount("rootfs", "/", NULL, MS_REMOUNT|MS_NOATIME|MS_RDONLY, NULL) < 0) {
if(fstdout)
fprintf(fstdout, "INIT: failed to remount initramfs as read-only\n");
sleep(1);
}
if (mount("tmpfs", "/sbin", NULL, MS_REMOUNT|MS_NOATIME|MS_RDONLY, NULL) < 0) {
if(fstdout)
fprintf(fstdout, "INIT: failed to remount \"/sbin\" as read-only\n");
sleep(1);
}
if(mount("/sbin/init", "/rootfs/sbin/init", "tmpfs", MS_BIND|MS_RDONLY, NULL)) {
if(mount("/sbin/init", "/rootfs/sbin/init", "tmpfs", MS_BIND, NULL)) {
if(fstdout)
fprintf(fstdout, "INIT: bind mount(\"/sbin/init\", \"/rootfs/sbin/init\") failed: %s\n", strerror(errno));
sleep(1);
}
}
}
noinitcopy:
if(chdir("/rootfs")) {
if(fstdout)
fprintf(fstdout, "INIT: chdir(\"/rootfs\") failed: %s\n", strerror(errno));
goto forever;
}
if (mount("/rootfs", "/", NULL, MS_MOVE, NULL) < 0) {
if(fstdout)
fprintf(fstdout, "INIT: failed to mount moving /rootfs to /\n");
goto forever;
}
/*
Now, the init process may still access the old root via its
executable, shared libraries, standard input/output/error, and its
current root directory. All these references are dropped by the
following command:
# exec chroot . /sbin/init <dev/console >dev/console 2>&1
*/
if(chroot(".")) {
if(fstdout) {
fprintf(fstdout, "INIT: chroot(\".\") failed: %s\n", strerror(errno));
sleep(5);
sleep(5);
}
}
/* check if we need to copy default versions of some config files */
{
int remounted=0;
chk_cfg_file(&remounted, "ssh/ssh_config");
chk_cfg_file(&remounted, "ssh/sshd_config");
chk_cfg_file(&remounted, "inetd.conf");
chk_cfg_file(&remounted, "inittab");
chk_cfg_file(&remounted, "login.defs");
chk_cfg_file(&remounted, "limits");
chk_cfg_file(&remounted, "login.access");
if(remounted)
if (mount("rootfs", "/", NULL, MS_REMOUNT|MS_NOATIME|MS_RDONLY|conf.mountflags, NULL) < 0) {
if(fstdout)
fprintf(fstdout, "INIT: failed to remount rootfs as read-only\n");
sleep(1);
}
}
fd_stdin = open("/dev/console", O_RDONLY|O_NOCTTY);
if(fd_stdin == -1) {
if(fstdout)
fprintf(fstdout, "INIT: open(\"/dev/console\", O_RDONLY) failed: %s\n", strerror(errno));
} else {
if(fd_stdin != 0) {
dup2(fd_stdin, 0);
close(fd_stdin);
}
}
fd_stdout = open("/dev/console", O_WRONLY|O_NOCTTY);
if(fd_stdout == -1) {
if(fstdout)
fprintf(fstdout, "INIT: open(\"/dev/console\", O_WRONLY) failed: %s\n", strerror(errno));
} else {
if(fd_stdout != 1) {
dup2(fd_stdout, 1);
dup2(fd_stdout, 2);
close(fd_stdout);
}
}
if(fstdout)
fprintf(fstdout, "INIT: now execing \"%s\"\n", initprg);
sleep(1);
if(fstdout) {
fclose(fstdout);
fstdout = NULL;
}
argv[0] = initprg;
execve(initprg, argv, envp);
open_console();
if(fstdout) {
fprintf(fstdout, "INIT: execve(\"%s\") failed: %s\n", initprg, strerror(errno));
}
forever:
if(fstdout) {
fprintf(fstdout, "INIT: pid is %u\n", getpid());
fprintf(fstdout, "INIT: boot cannot proceed from here.\n");
fprintf(fstdout, "INIT: turn off the computer.\n");
}
while(1) sleep(1000);
return 2;
}
static BOOT_CODE bool_t
try_boot_sys(
unsigned long multiboot_magic,
multiboot_info_t* mbi
)
{
/* ==== following code corresponds to the "select" in abstract specification ==== */
acpi_rsdt_t* acpi_rsdt; /* physical address of ACPI root */
paddr_t mods_end_paddr; /* physical address where boot modules end */
paddr_t load_paddr;
word_t i;
p_region_t ui_p_regs;
multiboot_module_t *modules = (multiboot_module_t*)(word_t)mbi->mod_list;
if (multiboot_magic != MULTIBOOT_MAGIC) {
printf("Boot loader not multiboot compliant\n");
return false;
}
cmdline_parse((const char *)(word_t)mbi->cmdline, &cmdline_opt);
if ((mbi->flags & MULTIBOOT_INFO_MEM_FLAG) == 0) {
printf("Boot loader did not provide information about physical memory size\n");
return false;
}
if (!x86_cpuid_initialize()) {
printf("Warning: Your x86 CPU has an unsupported vendor, '%s'.\n"
"\tYour setup may not be able to competently run seL4 as "
"intended.\n"
"\tCurrently supported x86 vendors are AMD and Intel.\n",
x86_cpuid_get_identity()->vendor_string);
}
if (!is_compiled_for_microarchitecture()) {
printf("Warning: Your kernel was not compiled for the current microarchitecture.\n");
}
#if CONFIG_MAX_NUM_NODES > 1
/* copy boot code for APs to lower memory to run in real mode */
if (!copy_boot_code_aps(mbi->mem_lower)) {
return false;
}
/* Initialize any kernel TLS */
mode_init_tls(0);
#endif
/* initialize the memory. We track two kinds of memory regions. Physical memory
* that we will use for the kernel, and physical memory regions that we must
* not give to the user. Memory regions that must not be given to the user
* include all the physical memory in the kernel window, but also includes any
* important or kernel devices. */
boot_state.mem_p_regs.count = 0;
init_allocated_p_regions();
if (mbi->flags & MULTIBOOT_INFO_MMAP_FLAG) {
if (!parse_mem_map(mbi->mmap_length, mbi->mmap_addr)) {
return false;
}
} else {
/* calculate memory the old way */
p_region_t avail;
avail.start = HIGHMEM_PADDR;
avail.end = ROUND_DOWN(avail.start + (mbi->mem_upper << 10), PAGE_BITS);
if (!add_mem_p_regs(avail)) {
return false;
}
}
boot_state.ki_p_reg.start = PADDR_LOAD;
boot_state.ki_p_reg.end = kpptr_to_paddr(ki_end);
/* copy VESA information from multiboot header */
if ((mbi->flags & MULTIBOOT_INFO_GRAPHICS_FLAG) == 0) {
boot_state.vbe_info.vbeMode = -1;
printf("Multiboot gave us no video information\n");
} else {
boot_state.vbe_info.vbeInfoBlock = *(seL4_VBEInfoBlock_t*)(seL4_Word)mbi->vbe_control_info;
boot_state.vbe_info.vbeModeInfoBlock = *(seL4_VBEModeInfoBlock_t*)(seL4_Word)mbi->vbe_mode_info;
boot_state.vbe_info.vbeMode = mbi->vbe_mode;
printf("Got VBE info in multiboot. Current video mode is %d\n", mbi->vbe_mode);
boot_state.vbe_info.vbeInterfaceSeg = mbi->vbe_interface_seg;
boot_state.vbe_info.vbeInterfaceOff = mbi->vbe_interface_off;
boot_state.vbe_info.vbeInterfaceLen = mbi->vbe_interface_len;
}
printf("Kernel loaded to: start=0x%lx end=0x%lx size=0x%lx entry=0x%lx\n",
boot_state.ki_p_reg.start,
boot_state.ki_p_reg.end,
boot_state.ki_p_reg.end - boot_state.ki_p_reg.start,
(paddr_t)_start
);
/* remapping legacy IRQs to their correct vectors */
pic_remap_irqs(IRQ_INT_OFFSET);
if (config_set(CONFIG_IRQ_IOAPIC)) {
/* Disable the PIC so that it does not generate any interrupts. We need to
* do this *before* we initialize the apic */
pic_disable();
}
/* get ACPI root table */
acpi_rsdt = acpi_init();
if (!acpi_rsdt) {
return false;
}
/* check if kernel configuration matches platform requirments */
if (!acpi_fadt_scan(acpi_rsdt)) {
return false;
}
if (!config_set(CONFIG_IOMMU) || cmdline_opt.disable_iommu) {
boot_state.num_drhu = 0;
} else {
/* query available IOMMUs from ACPI */
acpi_dmar_scan(
acpi_rsdt,
boot_state.drhu_list,
&boot_state.num_drhu,
MAX_NUM_DRHU,
&boot_state.rmrr_list
);
}
/* query available CPUs from ACPI */
boot_state.num_cpus = acpi_madt_scan(acpi_rsdt, boot_state.cpus, &boot_state.num_ioapic, boot_state.ioapic_paddr);
if (boot_state.num_cpus == 0) {
printf("No CPUs detected\n");
return false;
}
if (config_set(CONFIG_IRQ_IOAPIC)) {
if (boot_state.num_ioapic == 0) {
printf("No IOAPICs detected\n");
return false;
}
} else {
if (boot_state.num_ioapic > 0) {
printf("Detected %d IOAPICs, but configured to use PIC instead\n", boot_state.num_ioapic);
}
}
if (!(mbi->flags & MULTIBOOT_INFO_MODS_FLAG)) {
printf("Boot loader did not provide information about boot modules\n");
return false;
}
printf("Detected %d boot module(s):\n", mbi->mod_count);
if (mbi->mod_count < 1) {
printf("Expect at least one boot module (containing a userland image)\n");
return false;
}
mods_end_paddr = 0;
for (i = 0; i < mbi->mod_count; i++) {
printf(
" module #%ld: start=0x%x end=0x%x size=0x%x name='%s'\n",
i,
modules[i].start,
modules[i].end,
modules[i].end - modules[i].start,
(char *) (long)modules[i].name
);
if ((sword_t)(modules[i].end - modules[i].start) <= 0) {
printf("Invalid boot module size! Possible cause: boot module file not found by QEMU\n");
return false;
}
if (mods_end_paddr < modules[i].end) {
mods_end_paddr = modules[i].end;
}
}
mods_end_paddr = ROUND_UP(mods_end_paddr, PAGE_BITS);
assert(mods_end_paddr > boot_state.ki_p_reg.end);
printf("ELF-loading userland images from boot modules:\n");
load_paddr = mods_end_paddr;
load_paddr = load_boot_module(modules, load_paddr);
if (!load_paddr) {
return false;
}
/* calculate final location of userland images */
ui_p_regs.start = boot_state.ki_p_reg.end;
ui_p_regs.end = ui_p_regs.start + load_paddr - mods_end_paddr;
printf(
"Moving loaded userland images to final location: from=0x%lx to=0x%lx size=0x%lx\n",
mods_end_paddr,
ui_p_regs.start,
ui_p_regs.end - ui_p_regs.start
);
memcpy((void*)ui_p_regs.start, (void*)mods_end_paddr, ui_p_regs.end - ui_p_regs.start);
/* adjust p_reg and pv_offset to final load address */
boot_state.ui_info.p_reg.start -= mods_end_paddr - ui_p_regs.start;
boot_state.ui_info.p_reg.end -= mods_end_paddr - ui_p_regs.start;
boot_state.ui_info.pv_offset -= mods_end_paddr - ui_p_regs.start;
/* ==== following code corresponds to abstract specification after "select" ==== */
if (!platAddDevices()) {
return false;
}
/* Total number of cores we intend to boot */
ksNumCPUs = boot_state.num_cpus;
printf("Starting node #0 with APIC ID %lu\n", boot_state.cpus[0]);
if (!try_boot_sys_node(boot_state.cpus[0])) {
return false;
}
if (config_set(CONFIG_IRQ_IOAPIC)) {
ioapic_init(1, boot_state.cpus, boot_state.num_ioapic);
}
/* initialize BKL before booting up APs */
SMP_COND_STATEMENT(clh_lock_init());
SMP_COND_STATEMENT(start_boot_aps());
/* grab BKL before leaving the kernel */
NODE_LOCK_SYS;
printf("Booting all finished, dropped to user space\n");
return true;
}
static void __init __start_xen(void)
{
memcpy(0, exception_vectors, exception_vectors_end - exception_vectors);
synchronize_caches(0, exception_vectors_end - exception_vectors);
ticks_per_usec = timebase_freq / 1000000ULL;
/* Parse the command-line options. */
cmdline_parse(xen_cmdline);
/* we need to be able to identify this CPU early on */
init_boot_cpu();
/* We initialise the serial devices very early so we can get debugging. */
ns16550.io_base = 0x3f8;
ns16550_init(0, &ns16550);
ns16550.io_base = 0x2f8;
ns16550_init(1, &ns16550);
serial_init_preirq();
init_console();
console_start_sync(); /* Stay synchronous for early debugging. */
rtas_init((void *)oftree);
memory_init();
printk("xen_cmdline: %016lx\n", (ulong)xen_cmdline);
printk("dom0_cmdline: %016lx\n", (ulong)dom0_cmdline);
printk("dom0_addr: %016lx\n", (ulong)dom0_addr);
printk("dom0_len: %016lx\n", (ulong)dom0_len);
printk("initrd_start: %016lx\n", (ulong)initrd_start);
printk("initrd_len: %016lx\n", (ulong)initrd_len);
printk("dom0: %016llx\n", *(unsigned long long *)dom0_addr);
#ifdef OF_DEBUG
key_ofdump(0);
#endif
percpu_init_areas();
init_parea(0);
cpu_initialize(0);
#ifdef CONFIG_GDB
initialise_gdb();
if (opt_earlygdb)
debugger_trap_immediate();
#endif
start_of_day();
acm_init(NULL, 0);
mpic_setup_this_cpu();
/* Deal with secondary processors. */
if (opt_nosmp || ofd_boot_cpu == -1) {
printk("nosmp: leaving secondary processors spinning forever\n");
} else {
printk("spinning up at most %d total processors ...\n", max_cpus);
kick_secondary_cpus(max_cpus);
}
/* This cannot be called before secondary cpus are marked online. */
percpu_free_unused_areas();
/* Create initial domain 0. */
dom0 = domain_create(0, 0, DOM0_SSIDREF);
if (dom0 == NULL)
panic("Error creating domain 0\n");
/* The Interrupt Controller will route everything to CPU 0 so we
* need to make sure Dom0's vVCPU 0 is pinned to the CPU */
dom0->vcpu[0]->cpu_affinity = cpumask_of_cpu(0);
dom0->is_privileged = 1;
/* scrub_heap_pages() requires IRQs enabled, and we're post IRQ setup... */
local_irq_enable();
/* Scrub RAM that is still free and so may go to an unprivileged domain. */
scrub_heap_pages();
if ((dom0_addr == 0) || (dom0_len == 0))
panic("No domain 0 found.\n");
if (construct_dom0(dom0, dom0_addr, dom0_len,
initrd_start, initrd_len,
dom0_cmdline) != 0) {
panic("Could not set up DOM0 guest OS\n");
}
init_xenheap_pages(ALIGN_UP(dom0_addr, PAGE_SIZE),
ALIGN_DOWN(dom0_addr + dom0_len, PAGE_SIZE));
if (initrd_start)
init_xenheap_pages(ALIGN_UP(initrd_start, PAGE_SIZE),
ALIGN_DOWN(initrd_start + initrd_len, PAGE_SIZE));
init_trace_bufs();
console_endboot();
/* Hide UART from DOM0 if we're using it */
serial_endboot();
console_end_sync();
domain_unpause_by_systemcontroller(dom0);
#ifdef DEBUG_IPI
ipi_torture_test();
#endif
startup_cpu_idle_loop();
}
int main(int argc, char *argv[])
{
transfer * st_sender =NULL;
int chk_interval = 0, attach = 0, cap_num = 0;
char *dst_ip = NULL;
unsigned short dst_port = 0;
int opt_idx = 0, opt_id = 0, arg_num = 0;
void *arglist = NULL;
pkt_cap_ctx_p p_cap_ctx = NULL;
st_ctx_p p_st_ctx = NULL;
cpu_set_t set;
if (argc < 2) return 1;
if (0 != cmdline_init()) {
fprintf(stderr, "cmdline_init failed!\n");
return 1;
}
if (0 != cmdline_parse(argc-1, &argv[1], opt_prof)) {
fprintf(stderr, "cmdline_parse failed!\n");
return 1;
}
while (-1 != cmdline_result_loop(&opt_idx, &opt_id, &arglist, &arg_num)) {
switch (opt_id) {
case OPT_HELP:
return usage();
break;
case OPT_DEST:
dst_ip = strdup(cmdline_get_arg(arglist, 0));
dst_port = atoi(cmdline_get_arg(arglist, 1));
break;
case OPT_INTERVAL:
chk_interval = atoi(cmdline_get_arg(arglist, 0));
break;
case OPT_CAP_NUM:
cap_num = atoi(cmdline_get_arg(arglist, 0));
break;
case OPT_ATTACH:
attach = atoi(cmdline_get_arg(arglist, 0));
break;
default:
break;
}
}
cmdline_show();
cmdline_destroy();
st_sender = new transfer(IS_CLIENT, SOCK_DGRAM, dst_ip, dst_port);
if (!st_sender || true != st_sender->is_ok()) {
return -1;
}
p_cap_ctx = pkt_cap_ctx_new(cap_num);
MEM_ALLOC(p_st_ctx, st_ctx_p, sizeof(st_ctx_t), 1);
int cpu_num = sysconf(_SC_NPROCESSORS_CONF);
fprintf(stdout, "cpu num = %d\n", cpu_num);
p_st_ctx->num = cap_num;
p_st_ctx->chk_interval = chk_interval;
p_st_ctx->p_cap_ctx = p_cap_ctx;
p_st_ctx->sender = st_sender;
if (attach) p_st_ctx->id = cap_num > cpu_num ? (cpu_num-1) : cap_num;
else p_st_ctx->id = -1;
pthread_t st_thd;
if (0 != pthread_create(&st_thd, NULL, st_cb, (void*)p_st_ctx)) {
fprintf(stderr, "create st_cb failed!\n");
return 1;
}
pthread_t cap_thd;
for (int i = 0; i < cap_num; i++) {
if (attach) p_cap_ctx[i].id = cap_num > cpu_num ? (i%(cpu_num-1)) : i;
else p_cap_ctx[i].id = -1;
if (0 != pthread_create(&cap_thd, NULL, pkt_cap_cb, &p_cap_ctx[i])) {
fprintf(stderr, "create pkt_cap_cb failed!\n");
return 1;
}
}
void *ret = NULL;
pthread_join(st_thd, &ret);
return 0;
}
static int config_init(int argc, char * * argv)
{
char const * levels;
char * temp;
char const * tok;
if (cmdline_parse(argc, argv)<0) {
return -1;
}
if (cmdline_get_version()) {
cmdline_show_version();
return -1;
}
if (cmdline_get_help()) {
cmdline_show_help();
return -1;
}
if (!cmdline_get_foreground()) {
if (setup_daemon()<0) {
return -1;
}
}
if (prefs_load(cmdline_get_prefs_file())<0) {
log_error("error loading configuration file %s",cmdline_get_prefs_file());
return -1;
}
eventlog_clear_level();
if ((levels = prefs_get_loglevels()))
{
if (!(temp = strdup(levels)))
{
eventlog(eventlog_level_fatal,"main","could not allocate memory for temp (exiting)");
return -1;
}
tok = strtok(temp,","); /* strtok modifies the string it is passed */
while (tok)
{
if (eventlog_add_level(tok)<0)
eventlog(eventlog_level_error,"main","could not add log level \"%s\"",tok);
tok = strtok(NULL,",");
}
free(temp);
}
if (cmdline_get_logstderr()) {
eventlog_set(stderr);
} else if (cmdline_get_logfile()) {
if (eventlog_open(cmdline_get_logfile())<0) {
log_error("error open eventlog file %s",cmdline_get_logfile());
return -1;
}
} else {
if (eventlog_open(prefs_get_logfile())<0) {
log_error("error open eventlog file %s",prefs_get_logfile());
return -1;
}
}
#ifdef USE_CHECK_ALLOC
memlog_fp=fopen(cmdline_get_memlog_file(),"a");
if (!memlog_fp) {
log_warn("error open file %s for memory debug logging",cmdline_get_memlog_file());
} else {
check_set_file(memlog_fp);
}
#endif
return 0;
}
/* C entry point for boot CPU */
void __init start_xen(unsigned long boot_phys_offset,
unsigned long fdt_paddr,
unsigned long cpuid)
{
size_t fdt_size;
int cpus, i;
const char *cmdline;
setup_cache();
percpu_init_areas();
set_processor_id(0); /* needed early, for smp_processor_id() */
smp_clear_cpu_maps();
/* This is mapped by head.S */
device_tree_flattened = (void *)BOOT_FDT_VIRT_START
+ (fdt_paddr & ((1 << SECOND_SHIFT) - 1));
fdt_size = device_tree_early_init(device_tree_flattened, fdt_paddr);
cmdline = device_tree_bootargs(device_tree_flattened);
early_printk("Command line: %s\n", cmdline);
cmdline_parse(cmdline);
setup_pagetables(boot_phys_offset, get_xen_paddr());
setup_mm(fdt_paddr, fdt_size);
vm_init();
dt_unflatten_host_device_tree();
dt_irq_xlate = gic_irq_xlate;
dt_uart_init();
console_init_preirq();
system_state = SYS_STATE_boot;
processor_id();
platform_init();
smp_init_cpus();
cpus = smp_get_max_cpus();
init_xen_time();
gic_init();
set_current((struct vcpu *)0xfffff000); /* debug sanity */
idle_vcpu[0] = current;
init_traps();
setup_virt_paging();
p2m_vmid_allocator_init();
softirq_init();
tasklet_subsys_init();
init_IRQ();
gic_route_ppis();
gic_route_spis();
init_maintenance_interrupt();
init_timer_interrupt();
timer_init();
init_idle_domain();
rcu_init();
arch_init_memory();
local_irq_enable();
local_abort_enable();
smp_prepare_cpus(cpus);
initialize_keytable();
console_init_postirq();
do_presmp_initcalls();
for_each_present_cpu ( i )
{
if ( (num_online_cpus() < cpus) && !cpu_online(i) )
{
int ret = cpu_up(i);
if ( ret != 0 )
printk("Failed to bring up CPU %u (error %d)\n", i, ret);
}
}
printk("Brought up %ld CPUs\n", (long)num_online_cpus());
/* TODO: smp_cpus_done(); */
do_initcalls();
/* Create initial domain 0. */
dom0 = domain_create(0, 0, 0);
if ( IS_ERR(dom0) || (alloc_dom0_vcpu0() == NULL) )
panic("Error creating domain 0");
dom0->is_privileged = 1;
dom0->target = NULL;
if ( construct_dom0(dom0) != 0)
panic("Could not set up DOM0 guest OS");
/* Scrub RAM that is still free and so may go to an unprivileged domain. */
scrub_heap_pages();
init_constructors();
console_endboot();
/* Hide UART from DOM0 if we're using it */
serial_endboot();
system_state = SYS_STATE_active;
domain_unpause_by_systemcontroller(dom0);
/* Switch on to the dynamically allocated stack for the idle vcpu
* since the static one we're running on is about to be freed. */
memcpy(idle_vcpu[0]->arch.cpu_info, get_cpu_info(),
sizeof(struct cpu_info));
switch_stack_and_jump(idle_vcpu[0]->arch.cpu_info, init_done);
}
/* C entry point for boot CPU */
void __init start_xen(unsigned long boot_phys_offset,
unsigned long fdt_paddr,
unsigned long cpuid)
{
size_t fdt_size;
int cpus, i;
paddr_t xen_paddr;
const char *cmdline;
struct bootmodule *xen_bootmodule;
struct domain *dom0;
struct xen_arch_domainconfig config;
setup_cache();
percpu_init_areas();
set_processor_id(0); /* needed early, for smp_processor_id() */
set_current((struct vcpu *)0xfffff000); /* debug sanity */
idle_vcpu[0] = current;
setup_virtual_regions(NULL, NULL);
/* Initialize traps early allow us to get backtrace when an error occurred */
init_traps();
smp_clear_cpu_maps();
/* This is mapped by head.S */
device_tree_flattened = (void *)BOOT_FDT_VIRT_START
+ (fdt_paddr & ((1 << SECOND_SHIFT) - 1));
fdt_size = boot_fdt_info(device_tree_flattened, fdt_paddr);
cmdline = boot_fdt_cmdline(device_tree_flattened);
printk("Command line: %s\n", cmdline);
cmdline_parse(cmdline);
/* Register Xen's load address as a boot module. */
xen_bootmodule = add_boot_module(BOOTMOD_XEN,
(paddr_t)(uintptr_t)(_start + boot_phys_offset),
(paddr_t)(uintptr_t)(_end - _start + 1), NULL);
BUG_ON(!xen_bootmodule);
xen_paddr = get_xen_paddr();
setup_pagetables(boot_phys_offset, xen_paddr);
/* Update Xen's address now that we have relocated. */
printk("Update BOOTMOD_XEN from %"PRIpaddr"-%"PRIpaddr" => %"PRIpaddr"-%"PRIpaddr"\n",
xen_bootmodule->start, xen_bootmodule->start + xen_bootmodule->size,
xen_paddr, xen_paddr + xen_bootmodule->size);
xen_bootmodule->start = xen_paddr;
setup_mm(fdt_paddr, fdt_size);
/* Parse the ACPI tables for possible boot-time configuration */
acpi_boot_table_init();
end_boot_allocator();
vm_init();
dt_unflatten_host_device_tree();
init_IRQ();
platform_init();
preinit_xen_time();
gic_preinit();
arm_uart_init();
console_init_preirq();
console_init_ring();
system_state = SYS_STATE_boot;
processor_id();
smp_init_cpus();
cpus = smp_get_max_cpus();
init_xen_time();
gic_init();
p2m_vmid_allocator_init();
softirq_init();
tasklet_subsys_init();
xsm_dt_init();
init_maintenance_interrupt();
init_timer_interrupt();
timer_init();
init_idle_domain();
rcu_init();
arch_init_memory();
local_irq_enable();
local_abort_enable();
smp_prepare_cpus(cpus);
initialize_keytable();
console_init_postirq();
do_presmp_initcalls();
for_each_present_cpu ( i )
{
if ( (num_online_cpus() < cpus) && !cpu_online(i) )
{
int ret = cpu_up(i);
if ( ret != 0 )
printk("Failed to bring up CPU %u (error %d)\n", i, ret);
}
}
printk("Brought up %ld CPUs\n", (long)num_online_cpus());
/* TODO: smp_cpus_done(); */
setup_virt_paging();
iommu_setup();
do_initcalls();
/*
* It needs to be called after do_initcalls to be able to use
* stop_machine (tasklets initialized via an initcall).
*/
apply_alternatives_all();
/* Create initial domain 0. */
/* The vGIC for DOM0 is exactly emulating the hardware GIC */
config.gic_version = XEN_DOMCTL_CONFIG_GIC_NATIVE;
config.nr_spis = gic_number_lines() - 32;
dom0 = domain_create(0, 0, 0, &config);
if ( IS_ERR(dom0) || (alloc_dom0_vcpu0(dom0) == NULL) )
panic("Error creating domain 0");
dom0->is_privileged = 1;
dom0->target = NULL;
if ( construct_dom0(dom0) != 0)
panic("Could not set up DOM0 guest OS");
/* Scrub RAM that is still free and so may go to an unprivileged domain. */
scrub_heap_pages();
init_constructors();
console_endboot();
/* Hide UART from DOM0 if we're using it */
serial_endboot();
system_state = SYS_STATE_active;
/* Must be done past setting system_state. */
unregister_init_virtual_region();
domain_unpause_by_systemcontroller(dom0);
/* Switch on to the dynamically allocated stack for the idle vcpu
* since the static one we're running on is about to be freed. */
memcpy(idle_vcpu[0]->arch.cpu_info, get_cpu_info(),
sizeof(struct cpu_info));
switch_stack_and_jump(idle_vcpu[0]->arch.cpu_info, init_done);
}
main (int32 argc, char *argv[])
{
char *str;
#if 0
ckd_debug(100000);
#endif
E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
/* Digest command line argument definitions */
cmd_ln_define (defn);
if ((argc == 2) && (strcmp (argv[1], "help") == 0)) {
cmd_ln_print_definitions();
exit(1);
}
/* Look for default or specified arguments file */
str = NULL;
if ((argc == 2) && (argv[1][0] != '-'))
str = argv[1];
else if (argc == 1) {
str = "s3align.arg";
E_INFO("Looking for default argument file: %s\n", str);
}
if (str) {
/* Build command line argument list from file */
if ((argc = load_argfile (str, argv[0], &argv)) < 0) {
fprintf (stderr, "Usage:\n");
fprintf (stderr, "\t%s argument-list, or\n", argv[0]);
fprintf (stderr, "\t%s [argument-file] (default file: s3align.arg)\n\n",
argv[0]);
cmd_ln_print_definitions();
exit(1);
}
}
cmdline_parse (argc, argv);
if ((cmd_ln_access("-mdeffn") == NULL) ||
(cmd_ln_access("-meanfn") == NULL) ||
(cmd_ln_access("-varfn") == NULL) ||
(cmd_ln_access("-mixwfn") == NULL) ||
(cmd_ln_access("-tmatfn") == NULL) ||
(cmd_ln_access("-dictfn") == NULL))
E_FATAL("Missing -mdeffn, -meanfn, -varfn, -mixwfn, -tmatfn, or -dictfn argument\n");
if ((cmd_ln_access("-ctlfn") == NULL) || (cmd_ln_access("-insentfn") == NULL))
E_FATAL("Missing -ctlfn or -insentfn argument\n");
if ((cmd_ln_access ("-s2stsegdir") == NULL) &&
(cmd_ln_access ("-stsegdir") == NULL) &&
(cmd_ln_access ("-phsegdir") == NULL) &&
(cmd_ln_access ("-wdsegdir") == NULL) &&
(cmd_ln_access ("-outsentfn") == NULL))
E_FATAL("Missing output file/directory argument(s)\n");
tm_utt = timing_new ();
/*
* Initialize log(S3-base). All scores (probs...) computed in log domain to avoid
* underflow. At the same time, log base = 1.0001 (1+epsilon) to allow log values
* to be maintained in int32 variables without significant loss of precision.
*/
if (cmd_ln_access("-logbase") == NULL)
logs3_init (1.0001);
else {
float32 logbase;
logbase = *((float32 *) cmd_ln_access("-logbase"));
if (logbase <= 1.0)
E_FATAL("Illegal log-base: %e; must be > 1.0\n", logbase);
if (logbase > 1.1)
E_WARN("Logbase %e perhaps too large??\n", logbase);
logs3_init ((float64) logbase);
}
/* Initialize feature stream type */
feat_init ((char *) cmd_ln_access ("-feat"));
/* BHIKSHA: PASS CEPSIZE TO FEAT_CEPSIZE, 6 Jan 98 */
cepsize = *((int32 *) cmd_ln_access("-ceplen"));
cepsize = feat_cepsize (cepsize);
/* END CHANGES BY BHIKSHA */
/* Read in input databases */
models_init ();
senscale = (int32 *) ckd_calloc (S3_MAX_FRAMES, sizeof(int32));
tmr_utt = cyctimer_new ("U");
tmr_gauden = cyctimer_new ("G");
tmr_senone = cyctimer_new ("S");
tmr_align = cyctimer_new ("A");
/* Initialize align module */
align_init ();
printf ("\n");
tot_nfr = 0;
process_ctlfile ();
if (tot_nfr > 0) {
printf ("\n");
printf("TOTAL FRAMES: %8d\n", tot_nfr);
printf("TOTAL CPU TIME: %11.2f sec, %7.2f xRT\n",
tm_utt->t_tot_cpu, tm_utt->t_tot_cpu/(tot_nfr*0.01));
printf("TOTAL ELAPSED TIME: %11.2f sec, %7.2f xRT\n",
tm_utt->t_tot_elapsed, tm_utt->t_tot_elapsed/(tot_nfr*0.01));
}
#if (! WIN32)
system ("ps aguxwww | grep s3align");
#endif
/* Hack!! To avoid hanging problem under Linux */
if (logfp) {
fclose (logfp);
*stdout = orig_stdout;
*stderr = orig_stderr;
}
exit(0);
}
main (int32 argc, char *argv[])
{
char *str;
#if 0
ckd_debug(100000);
#endif
/* Digest command line argument definitions */
cmd_ln_define (defn);
if ((argc == 2) && (strcmp (argv[1], "help") == 0)) {
cmd_ln_print_definitions();
exit(1);
}
/* Look for default or specified arguments file */
str = NULL;
if ((argc == 2) && (argv[1][0] != '-'))
str = argv[1];
else if (argc == 1) {
str = "s3decode.arg";
E_INFO("Looking for default argument file: %s\n", str);
}
if (str) {
/* Build command line argument list from file */
if ((argc = load_argfile (str, argv[0], &argv)) < 0) {
fprintf (stderr, "Usage:\n");
fprintf (stderr, "\t%s argument-list, or\n", argv[0]);
fprintf (stderr, "\t%s [argument-file] (default file: s3decode.arg)\n\n",
argv[0]);
cmd_ln_print_definitions();
exit(1);
}
}
cmdline_parse (argc, argv);
/* Remove memory allocation restrictions */
unlimit ();
#if (! WIN32)
{
char buf[1024];
gethostname (buf, 1024);
buf[1023] = '\0';
E_INFO ("Executing on: %s\n", buf);
}
#endif
E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);
if ((cmd_ln_access("-mdeffn") == NULL) ||
(cmd_ln_access("-dictfn") == NULL) ||
(cmd_ln_access("-lmfn") == NULL))
E_FATAL("Missing -mdeffn, -dictfn, or -lmfn argument\n");
/*
* Initialize log(S3-base). All scores (probs...) computed in log domain to avoid
* underflow. At the same time, log base = 1.0001 (1+epsilon) to allow log values
* to be maintained in int32 variables without significant loss of precision.
*/
if (cmd_ln_access("-logbase") == NULL)
logs3_init (1.0001);
else {
float32 logbase;
logbase = *((float32 *) cmd_ln_access("-logbase"));
if (logbase <= 1.0)
E_FATAL("Illegal log-base: %e; must be > 1.0\n", logbase);
if (logbase > 1.1)
E_WARN("Logbase %e perhaps too large??\n", logbase);
logs3_init ((float64) logbase);
}
/* Read in input databases */
models_init ();
/* Allocate timing object */
tm_utt = timing_new ();
tot_nfr = 0;
/* Initialize forward Viterbi search module */
dag_init ();
printf ("\n");
process_ctlfile ();
printf ("\n");
printf("TOTAL FRAMES: %8d\n", tot_nfr);
if (tot_nfr > 0) {
printf("TOTAL CPU TIME: %11.2f sec, %7.2f xRT\n",
tm_utt->t_tot_cpu, tm_utt->t_tot_cpu/(tot_nfr*0.01));
printf("TOTAL ELAPSED TIME: %11.2f sec, %7.2f xRT\n",
tm_utt->t_tot_elapsed, tm_utt->t_tot_elapsed/(tot_nfr*0.01));
}
fflush (stdout);
#if (! WIN32)
system ("ps auxwww | grep s3dag");
#endif
/* Hack!! To avoid hanging problem under Linux */
if (logfp) {
fclose (logfp);
*stdout = orig_stdout;
*stderr = orig_stderr;
}
exit(0);
}
int menu(const menuItem Menu)
{
signed char line_screen = 1;
signed char line_menu = 0;
displayMenu(Menu, line_menu);
ssd1306InvertArea(0, MARGIN, HIGHLIGHT_LENGHT, HIGHLIGHT_HEIGHT);
ssd1306Refresh();
while (true)
{
int joystick = expanderJoyFiltered();
// Exit Button JOYSTICK_LEFT
switch (joystick)
{
case JOY_LEFT:
return SUCCESS;
break;
// Joystick down
case JOY_DOWN:
//beeper
if (Menu.line[line_menu + 1].name != null)
{
line_menu++;
line_screen++;
if (line_screen > MAX_LINE_SCREEN)
{
line_screen--;
displayMenu(Menu, line_menu - (line_screen - 1));
ssd1306InvertArea(0, line_screen * MARGIN,
HIGHLIGHT_LENGHT, HIGHLIGHT_HEIGHT);
ssd1306Refresh();
}
else
{
menuHighlightedMove((line_screen - 1) * ROW_HEIGHT + 1,
(line_screen) * ROW_HEIGHT);
}
}
break;
case JOY_UP:
//beeper
if (line_screen == 1)
{
if (line_menu > 0)
{
line_menu--;
displayMenu(Menu, line_menu);
ssd1306InvertArea(0, MARGIN, HIGHLIGHT_LENGHT,
HIGHLIGHT_HEIGHT);
ssd1306Refresh();
}
}
else
{
line_menu--;
line_screen--;
menuHighlightedMove((line_screen + 1) * ROW_HEIGHT - 1,
(line_screen) * ROW_HEIGHT);
}
break;
case JOY_RIGHT: // Validate button joystick right
//hal_beeper_beep(app_context.beeper, 4000, 10);
switch (Menu.line[line_menu].type)
{
case 'b':
modifyBoolParam(Menu.line[line_menu].name,
(unsigned char*) Menu.line[line_menu].param);
break;
case 'i':
modifyLongParam(Menu.line[line_menu].name,
(long*) (int*) Menu.line[line_menu].param);
break;
case 'l':
modifyLongParam(Menu.line[line_menu].name,
(long*) Menu.line[line_menu].param);
break;
case 'm':
menu(*(const menuItem*) Menu.line[line_menu].param);
break;
case 'f':
if (Menu.line[line_menu].param != null)
{
ssd1306ClearScreen();
ssd1306Refresh();
Menu.line[line_menu].param();
}
break;
case 'g':
graphMotorSettings(
(float*) Menu.line[line_menu - 3].param,
(float*) Menu.line[line_menu - 2].param,
(float*) Menu.line[line_menu - 1].param);
break;
default:
break;
}
displayMenu(Menu, line_menu - (line_screen - 1));
ssd1306InvertArea(0, MARGIN * line_screen, HIGHLIGHT_LENGHT,
HIGHLIGHT_HEIGHT);
ssd1306Refresh();
break;
default:
break;
}
cmdline_parse();
}
return -1;
}
;
cpu_init();
platform_init(arg);
/*
* Switch away from the bootstrap stack (in boot.S) as early as possible.
*/
_newstack(platform_mem_size(), _start2, 0);
}
static void _start2(void *arg __attribute__((unused)))
{
static struct solo5_start_info si;
si.cmdline = cmdline_parse(platform_cmdline());
log(INFO, " | ___|\n");
log(INFO, " __| _ \\ | _ \\ __ \\\n");
log(INFO, "\\__ \\ ( | | ( | ) |\n");
log(INFO, "____/\\___/ _|\\___/____/\n");
mem_init();
time_init();
pci_enumerate();
cpu_intr_enable();
mem_lock_heap(&si.heap_start, &si.heap_size);
solo5_exit(solo5_app_main(&si));
}
// Real entry point of the OS :
void init() {
unsigned int freq;
interrupt_init();
earlyterm_init();
earlyterm_clear();
kbd_init();
rtc_init();
time_init();
earlyterm_write("Kernel initialization...\n");
set_kernel_print(&earlyterm_write);
printk(LOG_INFO, "cmd args: '%s'\n", &cmdargs_begin);
cmdline_parse(&cmdargs_begin, 1024);
mmu_init();
pm_init_pages();
stimer_init();
hwkbd_start_periodic_update();
DBG_WAIT;
interrupt_inhibit_all(0);
// console initialisation as soon as possible
dev_init();
// add TTY device (on major 4)
ttydev_device.init();
dev_register_device(&ttydev_device, 4);
// add virtual terminal TTYs
vt_init();
// USB initialisation
usb_init();
// add usb-acm TTY
acm_usb_init();
DBG_WAIT;
// will be the last message displayed on early console
printk(LOG_INFO, "Switching screen to tty1...\n The display will be cleared.\n");
console_make_active();
// in all cases, Virtual Terminals should be made active (tty1)
DBG_WAIT;
vt_set_active(0);
// need to be changed for "overclocking" :
//freq_change(FREQ_STC_4, FREQ_DIV_1, FREQ_DIV_4);
freq_time_calibrate();
freq = freq_get_internal_hz();
printk(LOG_INFO, "CPU freq : %d.%dMHz\n", freq/1000000, (freq/100000)%10);
freq = freq_get_peripheral_hz();
printk(LOG_INFO, "Peripheral freq : %d.%dMHz\n", freq/1000000, (freq/100000)%10);
// initialize sysctl tables
ctl_init();
//test_keyboard_int();
//test_virtual_mem();
//asm volatile ("trapa #50");
//DBG_WAIT;
// Initializing VFS and device sub-sytems, mount platform filesystems,
// register platform devices...
vfs_init();
vfs_file_init();
vfs_register_fs(&smemfs_file_system, VFS_REGISTER_STATIC);
vfs_register_fs(&protofs_file_system, VFS_REGISTER_STATIC);
vfs_mount("protofs", NULL, VFS_MOUNT_ROOT);
vfs_create("/", "dev", INODE_TYPE_PARENT, INODE_FLAG_READ | INODE_FLAG_EXEC, 0);
vfs_create("/dev", "tty1", INODE_TYPE_DEV, INODE_FLAG_WRITE, 0x00040000);
vfs_create("/dev", "tty2", INODE_TYPE_DEV, INODE_FLAG_WRITE, 0x00040001);
vfs_create("/dev", "serial", INODE_TYPE_DEV, INODE_FLAG_WRITE, 0x00030000);
vfs_create("/dev", "console", INODE_TYPE_DEV, INODE_FLAG_WRITE,
console_get_device());
DBG_WAIT;
// keyboard input for virtual terminals
kbd_set_kstroke_handler(&vt_key_stroke);
// mount additional filesystems
vfs_create("/", "mnt", INODE_TYPE_PARENT, INODE_FLAG_WRITE, 0);
vfs_create("/mnt", "smem", INODE_TYPE_PARENT, INODE_FLAG_WRITE, 0);
vfs_mount("smemfs", "/mnt/smem", VFS_MOUNT_NORMAL);
DBG_WAIT;
// set /dev/display device
_display_device.init();
dev_register_device(&_display_device, 0x20);
vfs_create("/dev", "display", INODE_TYPE_DEV, INODE_FLAG_WRITE, 0x00200001);
// direct keyboard device on major 0x21
fxkeyboard_device.init();
dev_register_device(&fxkeyboard_device, 0x21);
vfs_create("/dev", "keyboard", INODE_TYPE_DEV, INODE_FLAG_WRITE, 0x00210000);
DBG_WAIT;
//test_keymatrix();
// test_keyboard();
/*while(1) {
char c;
if(vfs_read(console, &c, 1) == 1) {
vfs_write(console, &c, 1);
}
}*/
DBG_WAIT;
//test_vfs();
//test_sdcard();
//test_sleep_funcs();
// EEPROM-related code commented to avoid useless write cycles ;)
//test_eeprom();
/*char mybuf[128];
int len;
len = usb_receive(USB_EP_ADDR_EP1OUT, mybuf, 10, 0);
printk(LOG_DEBUG, "usb_receive ret=%d\n", len);
if(len > 0) {
mybuf[len] = '\0';
printk(LOG_DEBUG, "content = '%s'\n", mybuf);
}
while(!_magic_lock);
set_kernel_print(&print_usb_ep2);
test_vfs();
*/
// memory area subsystem
mem_area_init();
process_init();
sched_init();
test_process();
printk(LOG_WARNING, "End of init job, sleeping...\n");
while(1)
printk(LOG_WARNING, "IER: 0x%x 0x%x\n", USB.IFR0.BYTE, USB.IFR1.BYTE);
}
static Token* cmdline_parse(Cmdline *cmdline, Token *word, UT_array *parent)
{
char ch;
bool seek;
Cmdstr cmd = {.ed = 0};
if (word)
cmd.st = word->start;
QUEUE *stack = &cmd.stack;
QUEUE_INIT(stack);
cmd.args = list_new(cmdline);
stack_push(stack, cmd.args);
Token *headref = stack_head(stack);
utarray_new(cmd.chlds, &chld_icd);
check_flags(cmdline, &cmd);
int idx = 0;
while ((word = (Token*)utarray_next(cmdline->tokens, word))) {
char *str = token_val(word, VAR_STRING);
if (word->quoted) {
push(*word, stack, word->start);
pop(stack, cmdline, &idx);
continue;
}
switch(ch = str[0]) {
case '(':
cmdline->lvl++;
word = cmdline_parse(cmdline, word, cmd.chlds);
((Cmdstr*)utarray_back(cmd.chlds))->idx = idx - 1;
if (!word)
goto breakout;
break;
case ')':
if (cmdline->lvl < 1)
break;
cmdline->lvl--;
cmd.ed = word->start;
goto breakout;
case '[':
push(list_new(cmdline), stack, word->start);
stack_head(stack)->start = word->start;
break;
case ']':
if (!valid_arry(cmdline, stack, headref))
break;
stack_head(stack)->end = word->end;
push_arry_container(cmdline, headref, word);
pop(stack, cmdline, &idx);
break;
case '|':
if (cmdline->lvl < 1) {
cmd.bar = true;
cmd.ed = word->start;
goto breakout;
}
/*FALLTHROUGH*/
case '.':
case ':':
case ',':
break;
case '%':
case '$':
word = valid_var(cmdline, word, ch);
case '!':
if (valid_exec(cmdline, &cmd, word))
break;
/*FALLTHROUGH*/
default:
seek = seek_ahead(cmdline, stack, word);
push(*word, stack, word->start);
if (!seek)
pop(stack, cmdline, &idx);
}
}
breakout:
while (!QUEUE_EMPTY(stack))
stack_pop(stack);
utarray_push_back(parent, &cmd);
return word;
}
void cmdline_build_tokens(Cmdline *cmdline, char *line)
{
log_msg("CMDSTR", "cmdline_build_tokens");
SWAP_ALLOC_PTR(cmdline->line, strdup(line));
Token *word = NULL;
while ((word = (Token*)utarray_next(cmdline->tokens, word)))
free(word->var.vval.v_string);
utarray_clear(cmdline->tokens);
cmdline_tokenize(cmdline);
}
