void finish_SRTN(int id)
{
if (queue_peek(q) == NULL || q->head->task.id != id) {
printf("Queue either empty, or the process with the given id is not the current head of the Queue!\n");
return;
}
Element *el = queue_poll(q);
free(el);
if (queue_size(q)){
switch_task(q->head->task.id);
}else{
switch_task(IDLE);
free_SRTN();
}
}
/* Called by svc_handler */
void sched_svc_end_task(void) {
struct task_ctrl *task = get_task_ctrl(curr_task);
if (task->stack_limit > task->stack_top) {
panic_print("Task (0x%x, fptr: 0x%x) has overflowed its stack. stack_top: 0x%x stack_limit: 0x%x", task, task->fptr, task->stack_top, task->stack_limit);
}
list_remove(&task->runnable_task_list);
/* Periodic (but only if aborted) */
if (task->period && task->abort) {
list_remove(&task->periodic_task_list);
}
/* Periodic (but only if not aborted) */
if (!task->abort && task->period) {
task->running = 0;
/* Reset stack */
task->stack_top = task->stack_base;
}
else {
/* Add to queue for freeing */
list_add(&task->free_task_list, &free_task_list);
total_tasks -= 1;
}
switch_task(NULL);
}
void kexit(int status) {
current_task->exit_status = status;
current_task->STATUS = TASK_ZOMBIE;
current_task->end_time = timer_tick;
//current_task->parent = 0; //A zombie has no parent
if (DEBUG) printf("Exiting with status %d\n", status);
switch_task();
printf("Warning: Should never come here at the end of kexit.c");
return;
}
void timer_handler(struct regs *r)
{
timer_ticks++;
switch_task();
if (timer_ticks % 18 == 0)
{
uptime++;
}
}
static void xtest_a(void * data, char * name) {
fs_node_t * tty = data;
fprintf(tty, "[%s] Hello world.\n", name);
while (1) {
fprintf(tty, "[%s] Ping.\n", name);
unsigned long s, ss;
relative_time(1, 0, &s, &ss);
sleep_until((process_t *)current_process, s, ss);
switch_task(0);
}
}
uint32_t read_serial(fs_node_t *node, uint32_t offset, uint32_t size, uint8_t *buffer) {
if (size < 1) {
return 0;
}
memset(buffer, 0x00, 1);
uint32_t collected = 0;
while (collected < size) {
while (!serial_rcvd((int)node->device)) {
switch_task(1);
}
debug_print(NOTICE, "Data received from TTY");
buffer[collected] = serial_recv((int)node->device);
collected++;
}
return collected;
}
void consumer() {
while (1) {
uint32_t times = rand()%7;
while (times--) {
sem_wait(n);
sem_wait(s);
buffer--;
printf("%d", buffer);
// printf("Buffer length = %d\n", buffer);
sem_signal(s);
sem_signal(e);
// printf("Consume a product !\n");
}
switch_task();
}
}
void producer() {
while (1) {
uint32_t times = rand()%7;
while (times--) {
// printf("Produced a product !\n");
sem_wait(e);
sem_wait(s);
buffer++;
printf("%d", buffer);
// printf("Buffer length = %d\n", buffer);
sem_signal(s);
sem_signal(n);
}
switch_task();
}
}
void next_task()
{
uint8_t is_enabled = readeflags() & 0x200;
cli();
if (task_count <= 1)
{
return;
}
task_t *previous_task = current_task;
current_task = current_task->next;
switch_task(&(previous_task->regs), current_task->regs);
if(is_enabled)
{
sti();
}
}
/*
* multiboot i386 (pc) kernel entry point
*/
int kmain(struct multiboot *mboot, uint32_t mboot_mag, uintptr_t esp) {
initial_esp = esp;
extern char * cmdline;
uint32_t mboot_mods_count = 0;
mboot_mod_t * mboot_mods = NULL;
mboot_ptr = mboot;
ENABLE_EARLY_BOOT_LOG(0);
assert(mboot_mag == MULTIBOOT_EAX_MAGIC && "Didn't boot with multiboot, not sure how we got here.");
debug_print(NOTICE, "Processing Multiboot information.");
/* Initialize core modules */
gdt_install(); /* Global descriptor table */
idt_install(); /* IDT */
isrs_install(); /* Interrupt service requests */
irq_install(); /* Hardware interrupt requests */
if (mboot_ptr->flags & (1 << 3)) {
debug_print(NOTICE, "There %s %d module%s starting at 0x%x.", mboot_ptr->mods_count == 1 ? "is" : "are", mboot_ptr->mods_count, mboot_ptr->mods_count == 1 ? "" : "s", mboot_ptr->mods_addr);
debug_print(NOTICE, "Current kernel heap start point would be 0x%x.", &end);
if (mboot_ptr->mods_count > 0) {
uintptr_t last_mod = (uintptr_t)&end;
uint32_t i;
mboot_mods = (mboot_mod_t *)mboot_ptr->mods_addr;
mboot_mods_count = mboot_ptr->mods_count;
for (i = 0; i < mboot_ptr->mods_count; ++i ) {
mboot_mod_t * mod = &mboot_mods[i];
uint32_t module_start = mod->mod_start;
uint32_t module_end = mod->mod_end;
if ((uintptr_t)mod + sizeof(mboot_mod_t) > last_mod) {
/* Just in case some silly person put this *behind* the modules... */
last_mod = (uintptr_t)mod + sizeof(mboot_mod_t);
}
debug_print(NOTICE, "Module %d is at 0x%x:0x%x", i, module_start, module_end);
if (last_mod < module_end) {
last_mod = module_end;
}
}
debug_print(NOTICE, "Moving kernel heap start to 0x%x", last_mod);
kmalloc_startat(last_mod);
}
}
paging_install(mboot_ptr->mem_upper + mboot_ptr->mem_lower);
if (mboot_ptr->flags & (1 << 6)) {
debug_print(NOTICE, "Parsing memory map.");
mboot_memmap_t * mmap = (void *)mboot_ptr->mmap_addr;
while ((uintptr_t)mmap < mboot_ptr->mmap_addr + mboot_ptr->mmap_length) {
if (mmap->type == 2) {
for (unsigned long long int i = 0; i < mmap->length; i += 0x1000) {
if (mmap->base_addr + i > 0xFFFFFFFF) break; /* xxx */
debug_print(INFO, "Marking 0x%x", (uint32_t)(mmap->base_addr + i));
paging_mark_system((mmap->base_addr + i) & 0xFFFFF000);
}
}
mmap = (mboot_memmap_t *) ((uintptr_t)mmap + mmap->size + sizeof(uintptr_t));
}
}
paging_finalize();
{
char cmdline_[1024];
size_t len = strlen((char *)mboot_ptr->cmdline);
memmove(cmdline_, (char *)mboot_ptr->cmdline, len + 1);
/* Relocate the command line */
cmdline = (char *)kmalloc(len + 1);
memcpy(cmdline, cmdline_, len + 1);
}
/* Memory management */
heap_install(); /* Kernel heap */
if (cmdline) {
args_parse(cmdline);
}
vfs_install();
tasking_install(); /* Multi-tasking */
timer_install(); /* PIC driver */
fpu_install(); /* FPU/SSE magic */
syscalls_install(); /* Install the system calls */
shm_install(); /* Install shared memory */
modules_install(); /* Modules! */
DISABLE_EARLY_BOOT_LOG();
/* Load modules from bootloader */
debug_print(NOTICE, "%d modules to load", mboot_mods_count);
for (unsigned int i = 0; i < mboot_ptr->mods_count; ++i ) {
mboot_mod_t * mod = &mboot_mods[i];
uint32_t module_start = mod->mod_start;
uint32_t module_end = mod->mod_end;
size_t module_size = module_end - module_start;
if (!module_quickcheck((void *)module_start)) {
debug_print(NOTICE, "Loading ramdisk: 0x%x:0x%x", module_start, module_end);
ramdisk_mount(module_start, module_size);
} else {
debug_print(NOTICE, "Loading a module: 0x%x:0x%x", module_start, module_end);
module_data_t * mod_info = (module_data_t *)module_load_direct((void *)(module_start), module_size);
if (mod_info) {
debug_print(NOTICE, "Loaded: %s", mod_info->mod_info->name);
}
}
}
/* Map /dev to a device mapper */
map_vfs_directory("/dev");
if (args_present("root")) {
vfs_mount_type("ext2", args_value("root"), "/");
}
if (args_present("start")) {
char * c = args_value("start");
if (!c) {
debug_print(WARNING, "Expected an argument to kernel option `start`. Ignoring.");
} else {
debug_print(NOTICE, "Got start argument: %s", c);
boot_arg = strdup(c);
}
}
if (!fs_root) {
debug_print(CRITICAL, "No root filesystem is mounted. Skipping init.");
map_vfs_directory("/");
switch_task(0);
}
/* Prepare to run /bin/init */
char * argv[] = {
"/bin/init",
boot_arg,
NULL
};
int argc = 0;
while (argv[argc]) {
argc++;
}
system(argv[0], argc, argv); /* Run init */
return 0;
}
static void timer_callback(registers_t regs)
{
tick++;
switch_task();
}
void spin_lock(uint8_t volatile * lock) {
while(__sync_lock_test_and_set(lock, 0x01)) {
switch_task(1);
}
}
static void timer_callback(struct s_regs *regs)
{
tick++;
switch_task(regs);
}
