From kevin at tyndur.org Fri Oct 1 22:32:15 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Fri, 1 Oct 2010 22:32:15 +0200 Subject: [tyndur-devel] [PATCH] shell: Unbenutzte Funktion entfernt Message-ID: <1285965135-17238-1-git-send-email-kevin@tyndur.org> - shell: shell_check_command ist kaputt und unbenutzt. Weg damit. Signed-off-by: Kevin Wolf --- src/modules/c/shell/shell.c | 15 --------------- 1 files changed, 0 insertions(+), 15 deletions(-) diff --git a/src/modules/c/shell/shell.c b/src/modules/c/shell/shell.c index 8306800..1e13146 100644 --- a/src/modules/c/shell/shell.c +++ b/src/modules/c/shell/shell.c @@ -64,7 +64,6 @@ char shell_command_buffer[COMMAND_BUFFER_SIZE]; char keyboard_read_char(void); void shell_read_command(void); -bool shell_check_command(const char* cmd); int shell_do_cmd(void); @@ -179,20 +178,6 @@ void shell_read_command(void) free(cwd); } - -bool shell_check_command(const char* cmd) -{ - if(strncmp(shell_command_buffer, cmd, strlen(cmd)) == 0) - { - return true; - } - else - { - return false; - } -} - - /** * Testet ob der Befehl am Anfang der uebergebenen Kommandozeile steht. * -- 1.6.0.2 From kevin at tyndur.org Sat Oct 16 15:46:19 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Sat, 16 Oct 2010 15:46:19 +0200 Subject: [tyndur-devel] =?utf-8?q?=5BPATCH=5D_shell=3A_PF_in_Dateinamenver?= =?utf-8?q?vollst=C3=A4ndigung_gefixt?= Message-ID: <1287236779-20007-1-git-send-email-kevin@tyndur.org> ! shell: Wenn irgendein Phantasiepfad vervollständigt werden soll, der mit einem nicht existierenden Verzeichnis anfängt, darf nicht directory_close(NULL) aufgerufen werden, sonst gibt es rot. Signed-off-by: Kevin Wolf --- src/modules/c/shell/completion.c | 4 +++- 1 files changed, 3 insertions(+), 1 deletions(-) diff --git a/src/modules/c/shell/completion.c b/src/modules/c/shell/completion.c index 116d7c9..b23cd75 100644 --- a/src/modules/c/shell/completion.c +++ b/src/modules/c/shell/completion.c @@ -316,7 +316,9 @@ static char** shell_file_matches(const char* word) list_destroy(matches_list); out: - directory_close(dir); + if (dir) { + directory_close(dir); + } free(dirname); free(filename); return matches; -- 1.6.0.2 From kevin at tyndur.org Sun Oct 17 13:02:10 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 17 Oct 2010 13:02:10 +0200 Subject: [tyndur-devel] [PATCH 0/2] kernel2: mmc_map_user und mmc_find_free_pages Message-ID: <1287313332-30638-1-git-send-email-kevin@tyndur.org> Zwei zusätzliche exportierte Funktionen aus der Speicherverwaltung. Kevin Wolf (2): kernel2: mmc_find_free_pages exportieren kernel2: mmc_map_user src/kernel2/include/mm.h | 24 ++++++++++++ src/kernel2/src/arch/i386/mm/mm_context.c | 57 ++++++++++++++++++++--------- 2 files changed, 64 insertions(+), 17 deletions(-) From kevin at tyndur.org Sun Oct 17 13:02:11 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 17 Oct 2010 13:02:11 +0200 Subject: [tyndur-devel] [PATCH 1/2] kernel2: mmc_find_free_pages exportieren In-Reply-To: <1287313332-30638-1-git-send-email-kevin@tyndur.org> References: <1287313332-30638-1-git-send-email-kevin@tyndur.org> Message-ID: <1287313332-30638-2-git-send-email-kevin@tyndur.org> * kernel2: find_contiguous_pages in mmc_find_free_pages umbenannt und global zugänglich gemacht Signed-off-by: Kevin Wolf --- src/kernel2/include/mm.h | 8 ++++++++ src/kernel2/src/arch/i386/mm/mm_context.c | 9 ++++----- 2 files changed, 12 insertions(+), 5 deletions(-) diff --git a/src/kernel2/include/mm.h b/src/kernel2/include/mm.h index ffb68b1..9330863 100644 --- a/src/kernel2/include/mm.h +++ b/src/kernel2/include/mm.h @@ -93,6 +93,14 @@ bool mmc_map(mmc_context_t* context, vaddr_t vaddr, paddr_t paddr, bool mmc_unmap(mmc_context_t* context, vaddr_t vaddr, size_t count); paddr_t mmc_resolve(mmc_context_t* context, vaddr_t vaddr); +/** + * Findet einen freien Bereich mit num freien Seiten + * + * @return Die Anfangsadresse der ersten Seite dieses Bereiches + */ +vaddr_t mmc_find_free_pages(mmc_context_t* context, size_t num, + uintptr_t lower_limit, uintptr_t upper_limit); + vaddr_t mmc_automap(mmc_context_t* context, paddr_t start, size_t count, uintptr_t lower_limit, uintptr_t upper_limit, int flags); vaddr_t mmc_automap_user(mmc_context_t* target_ctx, mmc_context_t* source_ctx, diff --git a/src/kernel2/src/arch/i386/mm/mm_context.c b/src/kernel2/src/arch/i386/mm/mm_context.c index 3fdce23..55ab12b 100644 --- a/src/kernel2/src/arch/i386/mm/mm_context.c +++ b/src/kernel2/src/arch/i386/mm/mm_context.c @@ -500,8 +500,7 @@ paddr_t mmc_resolve(mmc_context_t* context, vaddr_t vaddr) * * @return Die Anfangsadresse der ersten Seite dieses Bereiches */ -static vaddr_t find_contiguous_pages - (mmc_context_t* context, size_t num, +vaddr_t mmc_find_free_pages(mmc_context_t* context, size_t num, uintptr_t lower_limit, uintptr_t upper_limit) { uint32_t free_pages = 0; @@ -583,7 +582,7 @@ vaddr_t mmc_automap(mmc_context_t* context, paddr_t start, size_t count, uintptr_t lower_limit, uintptr_t upper_limit, int flags) { vaddr_t free_page = - find_contiguous_pages(context, count, lower_limit, upper_limit); + mmc_find_free_pages(context, count, lower_limit, upper_limit); if (free_page == NULL) { return NULL; @@ -617,7 +616,7 @@ vaddr_t mmc_automap_user(mmc_context_t* target_ctx, mmc_context_t* source_ctx, paddr_t paddr; vaddr_t vaddr; vaddr_t free_page = - find_contiguous_pages(target_ctx, count, lower_limit, upper_limit); + mmc_find_free_pages(target_ctx, count, lower_limit, upper_limit); if (free_page == NULL) { return NULL; @@ -657,7 +656,7 @@ inline vaddr_t mmc_valloc_limits(mmc_context_t* context, size_t num_pages, size_t i; paddr_t paddr; vaddr_t vaddr; - vaddr_t free_page = find_contiguous_pages(context, num_pages, + vaddr_t free_page = mmc_find_free_pages(context, num_pages, virt_lower_limit, virt_upper_limit); if (free_page == NULL) { -- 1.6.0.2 From kevin at tyndur.org Sun Oct 17 13:02:12 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 17 Oct 2010 13:02:12 +0200 Subject: [tyndur-devel] [PATCH 2/2] kernel2: mmc_map_user In-Reply-To: <1287313332-30638-1-git-send-email-kevin@tyndur.org> References: <1287313332-30638-1-git-send-email-kevin@tyndur.org> Message-ID: <1287313332-30638-3-git-send-email-kevin@tyndur.org> + kernel2: Neue Funktion, um virtuell zusammenhängenden Speicher zusätzlich woanders hinzumappen (mit vorgegebener Adresse statt irgendwohin wie bei mmc_automap_user) Signed-off-by: Kevin Wolf --- src/kernel2/include/mm.h | 16 +++++++++ src/kernel2/src/arch/i386/mm/mm_context.c | 48 +++++++++++++++++++++------- 2 files changed, 52 insertions(+), 12 deletions(-) diff --git a/src/kernel2/include/mm.h b/src/kernel2/include/mm.h index 9330863..559733c 100644 --- a/src/kernel2/include/mm.h +++ b/src/kernel2/include/mm.h @@ -101,6 +101,22 @@ paddr_t mmc_resolve(mmc_context_t* context, vaddr_t vaddr); vaddr_t mmc_find_free_pages(mmc_context_t* context, size_t num, uintptr_t lower_limit, uintptr_t upper_limit); +/** + * Mappt einen Speicherbereich eines anderen Tasks in einen MM-Kontext an eine + * gegebene virtuelle Adresse im Zielkontext + * + * @param target_ctx Kontext, in den gemappt werden soll + * @param source_ctx Kontext, aus dem Speicher gemappt werden soll + * @param start Virtuelle Startadresse des zu mappenden Speicherbereichs + * bezueglich source_ctx + * @param count Anzahl der zu mappenden Seiten + * @param target_vaddr Virtuelle Startadresse im Zielkontext + * @param flags Flags fuer die Pagetable + */ +bool mmc_map_user(mmc_context_t* target_ctx, mmc_context_t* source_ctx, + vaddr_t source_vaddr, size_t count, vaddr_t target_vaddr, + int flags); + vaddr_t mmc_automap(mmc_context_t* context, paddr_t start, size_t count, uintptr_t lower_limit, uintptr_t upper_limit, int flags); vaddr_t mmc_automap_user(mmc_context_t* target_ctx, mmc_context_t* source_ctx, diff --git a/src/kernel2/src/arch/i386/mm/mm_context.c b/src/kernel2/src/arch/i386/mm/mm_context.c index 55ab12b..22a58e5 100644 --- a/src/kernel2/src/arch/i386/mm/mm_context.c +++ b/src/kernel2/src/arch/i386/mm/mm_context.c @@ -597,6 +597,40 @@ vaddr_t mmc_automap(mmc_context_t* context, paddr_t start, size_t count, /** * Mappt einen Speicherbereich eines anderen Tasks in einen MM-Kontext an eine + * gegebene virtuelle Adresse im Zielkontext + * + * @param target_ctx Kontext, in den gemappt werden soll + * @param source_ctx Kontext, aus dem Speicher gemappt werden soll + * @param start Virtuelle Startadresse des zu mappenden Speicherbereichs + * bezueglich source_ctx + * @param count Anzahl der zu mappenden Seiten + * @param target_vaddr Virtuelle Startadresse im Zielkontext + * @param flags Flags fuer die Pagetable + */ +bool mmc_map_user(mmc_context_t* target_ctx, mmc_context_t* source_ctx, + vaddr_t source_vaddr, size_t count, vaddr_t target_vaddr, + int flags) +{ + size_t i; + paddr_t paddr; + vaddr_t vaddr; + + // FIXME Hier wird unter Umstaenden ziemlich oft dieselbe Pagetable gemappt + // und wieder ungemappt (in mmc_resolve) + for (i = 0; i < count; i++) { + paddr = mmc_resolve(source_ctx, source_vaddr + (i * PAGE_SIZE)); + vaddr = target_vaddr + (i * PAGE_SIZE); + if (!mmc_map(target_ctx, vaddr, paddr, flags, 1)) { + mmc_unmap(target_ctx, target_vaddr, i); + return false; + } + } + + return true; +} + +/** + * Mappt einen Speicherbereich eines anderen Tasks in einen MM-Kontext an eine * freie Adresse in einem vorgegebenen Adressberech. * * @param target_ctx Kontext, in den gemappt werden soll @@ -612,9 +646,6 @@ vaddr_t mmc_automap_user(mmc_context_t* target_ctx, mmc_context_t* source_ctx, vaddr_t start, size_t count, uintptr_t lower_limit, uintptr_t upper_limit, int flags) { - size_t i; - paddr_t paddr; - vaddr_t vaddr; vaddr_t free_page = mmc_find_free_pages(target_ctx, count, lower_limit, upper_limit); @@ -622,15 +653,8 @@ vaddr_t mmc_automap_user(mmc_context_t* target_ctx, mmc_context_t* source_ctx, return NULL; } - // FIXME Hier wird unter Umstaenden ziemlich oft dieselbe Pagetable gemappt - // und wieder ungemappt (in mmc_resolve) - for (i = 0; i < count; i++) { - paddr = mmc_resolve(source_ctx, start + (i * PAGE_SIZE)); - vaddr = free_page + (i * PAGE_SIZE); - if (!mmc_map(target_ctx, vaddr, paddr, flags, 1)) { - mmc_unmap(target_ctx, free_page, i); - return NULL; - } + if (!mmc_map_user(target_ctx, source_ctx, start, count, free_page, flags)) { + return NULL; } return free_page; -- 1.6.0.2 From kevin at tyndur.org Fri Oct 22 21:20:11 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Fri, 22 Oct 2010 21:20:11 +0200 Subject: [PATCH 0/2] Fixes für Stacktraces Message-ID: <1287775213-24588-1-git-send-email-kevin@tyndur.org> Kevin Wolf (2): kernel2: Bei Stacktraces nicht ins Leere greifen kernel2: Stacktraces umformatiert src/kernel2/src/arch/i386/debug.c | 9 +++++++-- 1 files changed, 7 insertions(+), 2 deletions(-) From kevin at tyndur.org Fri Oct 22 21:20:12 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Fri, 22 Oct 2010 21:20:12 +0200 Subject: [tyndur-devel] [PATCH 1/2] kernel2: Bei Stacktraces nicht ins Leere greifen In-Reply-To: <1287775213-24588-1-git-send-email-kevin@tyndur.org> References: <1287775213-24588-1-git-send-email-kevin@tyndur.org> Message-ID: <1287775213-24588-2-git-send-email-kevin@tyndur.org> ! kernel2: Bei einem kaputten Stack passiert es leicht, dass ein Page Fault nach dem anderen auftritt, weil wir nicht aufpassen. Eine Prüfung, ob die Adresse auch wirklich gemappt ist, sollte dem Abhilfe schaffen. Signed-off-by: Kevin Wolf --- src/kernel2/src/arch/i386/debug.c | 5 +++++ 1 files changed, 5 insertions(+), 0 deletions(-) diff --git a/src/kernel2/src/arch/i386/debug.c b/src/kernel2/src/arch/i386/debug.c index 34d3d5a..4b29c93 100644 --- a/src/kernel2/src/arch/i386/debug.c +++ b/src/kernel2/src/arch/i386/debug.c @@ -175,6 +175,11 @@ void stack_backtrace(uint32_t start_ebp, uint32_t start_eip) } #endif + if (!mmc_resolve(&mmc_current_context(), stack_frame->ebp)) { + kprintf(" (nicht gemappt)\n"); + break; + } + kprintf("\n"); } } -- 1.6.0.2 From kevin at tyndur.org Fri Oct 22 21:20:13 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Fri, 22 Oct 2010 21:20:13 +0200 Subject: [tyndur-devel] [PATCH 2/2] kernel2: Stacktraces umformatiert In-Reply-To: <1287775213-24588-1-git-send-email-kevin@tyndur.org> References: <1287775213-24588-1-git-send-email-kevin@tyndur.org> Message-ID: <1287775213-24588-3-git-send-email-kevin@tyndur.org> * kernel2: Alle Adressen in Stacktraces auf 8 Zeichen ausgerichtet und Leerzeichen statt Nullen als Padding, damit man in der objdump-Ausgabe suchen kann ohne manuell Nullen zu entfernen. Signed-off-by: Kevin Wolf --- src/kernel2/src/arch/i386/debug.c | 4 ++-- 1 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/kernel2/src/arch/i386/debug.c b/src/kernel2/src/arch/i386/debug.c index 4b29c93..6d4ef54 100644 --- a/src/kernel2/src/arch/i386/debug.c +++ b/src/kernel2/src/arch/i386/debug.c @@ -148,7 +148,7 @@ void stack_backtrace(uint32_t start_ebp, uint32_t start_eip) if (start_ebp != 0) { - kprintf("ebp %08x eip %08x", start_ebp, start_eip); + kprintf("ebp %8x eip %8x", start_ebp, start_eip); #ifdef USE_ELF_SYM if((sym = elf_find_sym(start_eip))) { @@ -166,7 +166,7 @@ void stack_backtrace(uint32_t start_ebp, uint32_t start_eip) for( ; stack_frame != 0 && stack_frame->ebp != 0; stack_frame = stack_frame->ebp) { - kprintf("ebp %08x eip %08x", stack_frame->ebp, stack_frame->eip); + kprintf("ebp %8p eip %8x", stack_frame->ebp, stack_frame->eip); #ifdef USE_ELF_SYM if((sym = elf_find_sym(stack_frame->eip))) -- 1.6.0.2 From kevin at tyndur.org Fri Oct 22 21:20:31 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Fri, 22 Oct 2010 21:20:31 +0200 Subject: [tyndur-devel] [PATCH] kernel2: Aktiven Thread in pm_thread_destroy wechseln Message-ID: <1287775231-24873-1-git-send-email-kevin@tyndur.org> ! kernel2: Wir brauchen immer einen gültigen aktiven Thread, ansonsten fliegen selbst Dinge wie die Exceptionhandler auf die Schnauze. Anstatt erst nach dem Beenden eines Prozesses zum nächsten zu wechseln, wird jetzt beim Löschen des aktiven Threads geschedult. Signed-off-by: Kevin Wolf --- src/kernel2/src/syscalls/pm.c | 3 --- src/kernel2/src/tasks/thread.c | 7 +++++++ 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/kernel2/src/syscalls/pm.c b/src/kernel2/src/syscalls/pm.c index f65018f..bb31d40 100644 --- a/src/kernel2/src/syscalls/pm.c +++ b/src/kernel2/src/syscalls/pm.c @@ -87,9 +87,6 @@ void syscall_pm_exit_process(void) // Genau jetzt muss der Prozess geloescht werden: Der Thread ist nicht mehr // aktiv, und er darf auch nicht wieder aktiviert werden. pm_destroy(old_task); - - // Einen neuen Task holen. - current_thread = pm_scheduler_pop(); } /** diff --git a/src/kernel2/src/tasks/thread.c b/src/kernel2/src/tasks/thread.c index ba6e569..618d369 100644 --- a/src/kernel2/src/tasks/thread.c +++ b/src/kernel2/src/tasks/thread.c @@ -142,6 +142,13 @@ void pm_thread_destroy(pm_thread_t* thread) // Beim Scheduler abmelden pm_scheduler_delete(thread); + // Wir brauchen immer einen gueltigen aktiven Thread, sonst kommt der + // Interrupthandler durcheinander und kann bei Exceptions im Kernel keine + // ordentliche Meldung mehr anzeigen. + if (current_thread == thread) { + current_thread = pm_scheduler_pop(); + } + // TODO: Den Userspacestack auch freigeben // Kernelstack freigeben -- 1.6.0.2 From kevin at tyndur.org Sun Oct 31 20:09:52 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 31 Oct 2010 20:09:52 +0100 Subject: [tyndur-devel] [PATCH 1/2] kernel2: cpu_prepare_current_task In-Reply-To: <1288552193-936-1-git-send-email-kevin@tyndur.org> References: <1288552193-936-1-git-send-email-kevin@tyndur.org> Message-ID: <1288552193-936-2-git-send-email-kevin@tyndur.org> * kernel2: Architekturspezifischen Teil des Taskwechsels (TSS-Manipulationen) in eine eigene Funktion ausgelagert Signed-off-by: Kevin Wolf --- src/kernel2/include/arch/i386/cpu.h | 5 +++++ src/kernel2/src/arch/i386/cpu.c | 19 +++++++++++++++++++ src/kernel2/src/interrupts/im.c | 12 +----------- 3 files changed, 25 insertions(+), 11 deletions(-) diff --git a/src/kernel2/include/arch/i386/cpu.h b/src/kernel2/include/arch/i386/cpu.h index bbc01b9..23c673b 100644 --- a/src/kernel2/include/arch/i386/cpu.h +++ b/src/kernel2/include/arch/i386/cpu.h @@ -137,5 +137,10 @@ uint64_t cpu_read_msr(uint32_t reg); cpu_t* cpu_get_current(void); void cpu_dump(machine_state_t* machine_state); +/** + * Wird aufgerufen, nachdem zu einem neuen Task gewechselt wurde + */ +void cpu_prepare_current_task(void); + #endif //ifndef _CPU_H_ diff --git a/src/kernel2/src/arch/i386/cpu.c b/src/kernel2/src/arch/i386/cpu.c index 194b13a..c170755 100644 --- a/src/kernel2/src/arch/i386/cpu.c +++ b/src/kernel2/src/arch/i386/cpu.c @@ -153,3 +153,22 @@ void cpu_dump(machine_state_t* machine_state) machine_state->fs, machine_state->gs, machine_state->ss); } +/** + * Wird aufgerufen, nachdem zu einem neuen Task gewechselt wurde + */ +void cpu_prepare_current_task(void) +{ + pm_thread_t* thread = current_thread; + interrupt_stack_frame_t* isf = thread->kernel_stack; + + cpu_get_current()->tss.ss0 = 2 << 3; + if (isf->eflags & 0x20000) { + cpu_get_current()->tss.esp0 = + (uintptr_t) thread->user_isf + + sizeof(struct vm86_isf); + } else { + cpu_get_current()->tss.esp0 = + (uintptr_t) thread->user_isf + + sizeof(interrupt_stack_frame_t); + } +} diff --git a/src/kernel2/src/interrupts/im.c b/src/kernel2/src/interrupts/im.c index 425d7bc..4472947 100644 --- a/src/kernel2/src/interrupts/im.c +++ b/src/kernel2/src/interrupts/im.c @@ -216,18 +216,8 @@ interrupt_stack_frame_t* im_prepare_current_thread(void) pm_thread_t* thread = current_thread; interrupt_stack_frame_t* isf = thread->kernel_stack; - cpu_get_current()->tss.ss0 = 2 << 3; - if (isf->eflags & 0x20000) { - cpu_get_current()->tss.esp0 = - (uintptr_t) thread->user_isf - + sizeof(struct vm86_isf); - } else { - cpu_get_current()->tss.esp0 = - (uintptr_t) thread->user_isf - + sizeof(interrupt_stack_frame_t); - } - mmc_activate(&thread->process->context); + cpu_prepare_current_task(); return isf; } -- 1.6.0.2 From kevin at tyndur.org Sun Oct 31 20:09:51 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 31 Oct 2010 20:09:51 +0100 Subject: [tyndur-devel] [PATCH 0/2] kernel2: I/O-Bitmap Message-ID: <1288552193-936-1-git-send-email-kevin@tyndur.org> Diese Patchserie implementiert die I/O-Bitmap für i386. Kevin Wolf (2): kernel2: cpu_prepare_current_task kernel2: I/O-Bitmap benutzen src/kernel2/include/arch/i386/cpu.h | 47 ++++++++ src/kernel2/include/syscall.h | 2 +- src/kernel2/include/tasks.h | 5 + src/kernel2/src/arch/i386/cpu.c | 21 ++++ src/kernel2/src/arch/i386/io.c | 214 +++++++++++++++++++++++++++++++++++ src/kernel2/src/interrupts/im.c | 23 ++-- src/kernel2/src/syscalls/io.c | 11 ++- src/kernel2/src/tasks/pm.c | 3 + 8 files changed, 312 insertions(+), 14 deletions(-) create mode 100644 src/kernel2/src/arch/i386/io.c From kevin at tyndur.org Sun Oct 31 20:09:53 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 31 Oct 2010 20:09:53 +0100 Subject: [tyndur-devel] [PATCH 2/2] kernel2: I/O-Bitmap benutzen In-Reply-To: <1288552193-936-1-git-send-email-kevin@tyndur.org> References: <1288552193-936-1-git-send-email-kevin@tyndur.org> Message-ID: <1288552193-936-3-git-send-email-kevin@tyndur.org> ! kernel2: Echte Verwaltung der I/O-Bitmap anstatt zufaellig Ports freizugeben, weil der groesste Teil des TSS aus Nullen besteht Signed-off-by: Kevin Wolf --- src/kernel2/include/arch/i386/cpu.h | 42 +++++++ src/kernel2/include/syscall.h | 2 +- src/kernel2/include/tasks.h | 5 + src/kernel2/src/arch/i386/cpu.c | 2 + src/kernel2/src/arch/i386/io.c | 214 +++++++++++++++++++++++++++++++++++ src/kernel2/src/interrupts/im.c | 11 ++ src/kernel2/src/syscalls/io.c | 11 ++- src/kernel2/src/tasks/pm.c | 3 + 8 files changed, 287 insertions(+), 3 deletions(-) create mode 100644 src/kernel2/src/arch/i386/io.c diff --git a/src/kernel2/include/arch/i386/cpu.h b/src/kernel2/include/arch/i386/cpu.h index 23c673b..9b9acbd 100644 --- a/src/kernel2/include/arch/i386/cpu.h +++ b/src/kernel2/include/arch/i386/cpu.h @@ -81,6 +81,11 @@ struct vm86_isf { #define CPU_IO_BITMAP_LENGTH 0xffff +// Dieser Wert muss ausserhalb des in der GDT definierten Limits +// fuer das TSS liegen +#define TSS_IO_BITMAP_NOT_LOADED (sizeof(cpu_tss_t) + 0x100) +#define TSS_IO_BITMAP_OFFSET offsetof(cpu_tss_t, io_bit_map) + /// Task state segment typedef struct { uint32_t backlink; @@ -138,9 +143,46 @@ cpu_t* cpu_get_current(void); void cpu_dump(machine_state_t* machine_state); /** + * Reserviert einen Bereich von IO-Ports für einen Task. + * Es werden entweder alle angeforderten oder im Fehlerfall gar keine Ports + * reserviert. Eine teilweise Reservierung tritt nicht auf. + * + * @param task Task, für den die Ports reserviert werden sollen + * @param port Nummer des niedrigsten zu reservierenden Ports + * @param length Anzahl der Ports, die zu reservieren sind + */ +bool io_ports_request(pm_process_t* task, uint32_t port, uint32_t length); + +/** + * Gibt einen Bereich von Ports frei. + * + * @param task Task, der die Freigabe anfordert + * @param port Niedrigster freizugebender Port + * @param length Anzahl der freizugebenden Ports + * + * @return true, wenn alle Ports freigegeben werden konnten. Wenn ein Port + * nicht freigegeben werden konnte (war nicht für den Task reserviert), + * wird false zurückgegeben, die Bearbeitung allerdings nicht abgebrochen, + * sondern die weiteren Ports versucht freizugeben. + */ +bool io_ports_release(pm_process_t* task, uint32_t port, uint32_t length); + +/** + * Gibt alle von einem Task reservierten Ports frei + * + * @param task Task, dessen Ports freigegeben werden sollen + */ +void io_ports_release_all(pm_process_t* task); + +/** * Wird aufgerufen, nachdem zu einem neuen Task gewechselt wurde */ void cpu_prepare_current_task(void); +/* + * Aktiviert die I/O-Bitmap fuer den Prozess + */ +void io_activate_bitmap(pm_process_t* task); + #endif //ifndef _CPU_H_ diff --git a/src/kernel2/include/syscall.h b/src/kernel2/include/syscall.h index 72bbb26..11e4bb7 100644 --- a/src/kernel2/include/syscall.h +++ b/src/kernel2/include/syscall.h @@ -130,7 +130,7 @@ void syscall_init_child_page(pid_t pid, vaddr_t src, vaddr_t dest, size_t size); /// IO-Ports anfordern -void syscall_io_request_port(uint32_t port, uint32_t length); +int syscall_io_request_port(uint32_t port, uint32_t length); /// Aktuelle Zeit abfragen (Mikrosekunden seit Systemstart) uint64_t syscall_get_tick_count(void); diff --git a/src/kernel2/include/tasks.h b/src/kernel2/include/tasks.h index 744cfc3..9266fa6 100644 --- a/src/kernel2/include/tasks.h +++ b/src/kernel2/include/tasks.h @@ -90,6 +90,11 @@ typedef struct pm_process { /// Eine Liste von geoeffneten SHM-Bereichen list_t* shm; +#ifdef ARCH_I386 + /// IO-Bitmap + void* io_bitmap; +#endif + /** * Eine Liste von Eventhandlern, die beim Loeschen des Prozesses * aufgerufen werden diff --git a/src/kernel2/src/arch/i386/cpu.c b/src/kernel2/src/arch/i386/cpu.c index c170755..43432f2 100644 --- a/src/kernel2/src/arch/i386/cpu.c +++ b/src/kernel2/src/arch/i386/cpu.c @@ -171,4 +171,6 @@ void cpu_prepare_current_task(void) (uintptr_t) thread->user_isf + sizeof(interrupt_stack_frame_t); } + + cpu_get_current()->tss.io_bit_map_offset = TSS_IO_BITMAP_NOT_LOADED; } diff --git a/src/kernel2/src/arch/i386/io.c b/src/kernel2/src/arch/i386/io.c new file mode 100644 index 0000000..0dc6ca7 --- /dev/null +++ b/src/kernel2/src/arch/i386/io.c @@ -0,0 +1,214 @@ +/* + * Copyright (c) 2007-2010 The tyndur Project. All rights reserved. + * + * This code is derived from software contributed to the tyndur Project + * by Kevin Wolf. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the tyndur Project + * and its contributors. + * 4. Neither the name of the tyndur Project nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; + * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR + * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include + +#include "tasks.h" +#include "kernel.h" + +/* Gesetztes Bit: Port wird benutzt */ +uint8_t global_port_bitmap[CPU_IO_BITMAP_LENGTH / 8] = { 0 }; + +/** + * Reserviert einen einzelnen IO-Port für einen Task + * + * @param task Task, dem der Port zugeordnet werden soll + * @param port Nummer des zuzuordnenden IO-Ports + * + * @return Gibt true zurück, wenn der Task auf den Port zugreifen kann + * (erfolgreiche oder bereits vorhandene Reservierung für denselben Task), + * ansonsten false. + */ +static bool io_port_request(pm_process_t* task, uint32_t port) +{ + uint32_t index = port / 8; + uint8_t bit = 1 << (port % 8); + uint8_t* io_bitmap = task->io_bitmap; + + // Prüfen, ob der Port überhaupt von der Bitmap abgedeckt wird + if (port >= CPU_IO_BITMAP_LENGTH) { + return false; + } + + // Ist der Port noch frei? + // Wenn der Port für denselben Task schon einmal reserviert wurde, + // abbrechen, aber true zurückgeben + if (global_port_bitmap[index] & bit) { + return (io_bitmap && ((io_bitmap[index] & bit) == 0)); + } + + // Falls der Task noch keine zugeordnete Bitmap hat, wird es jetzt + // Zeit, eine anzulegen + if (io_bitmap == NULL) { + io_bitmap = task->io_bitmap = malloc(CPU_IO_BITMAP_LENGTH / 8); + memset(io_bitmap, 0xFF, CPU_IO_BITMAP_LENGTH / 8); + } + + // Die eigentliche Reservierung + global_port_bitmap[index] |= bit; + io_bitmap[index] &= ~bit; + + return true; +} + +/** + * Gibt einen einzelnen IO-Port frei. + * + * @param task Task, der die Freigabe anfordert + * @param port Freizugebender Port + * + * @return true, wenn der Port freigegeben werden konnte, false wenn der + * Port nicht für den Task reserviert war. + */ +static bool io_port_release(pm_process_t* task, uint32_t port) +{ + uint32_t index = port / 8; + uint8_t bit = 1 << (port % 8); + uint8_t* io_bitmap = task->io_bitmap; + + // Wenn der Port gar nicht für den Task reserviert ist, false zurückgeben + if ((!io_bitmap) || (io_bitmap[index] & bit)) { + return false; + } + + // Wenn der Port zwar für den Task reserviert ist, aber in der globalen + // Tabelle als frei markiert, haben wir einen Kernel-Bug. + if ((global_port_bitmap[index] & bit) == 0) { + panic("IO-Port-Bitmaps sind beschaedigt (Port %d, PID %d)", + port, task->pid); + } + + // Die eigentliche Freigabe + global_port_bitmap[index] &= ~bit; + io_bitmap[index] |= bit; + + return true; +} + +/** + * Reserviert einen Bereich von IO-Ports für einen Task. + * Es werden entweder alle angeforderten oder im Fehlerfall gar keine Ports + * reserviert. Eine teilweise Reservierung tritt nicht auf. + * + * @param task Task, für den die Ports reserviert werden sollen + * @param port Nummer des niedrigsten zu reservierenden Ports + * @param length Anzahl der Ports, die zu reservieren sind + */ +bool io_ports_request(pm_process_t* task, uint32_t port, uint32_t length) +{ + uint32_t n = length; + while (n--) + { + if (!io_port_request(task, port++)) + { + // Bereits reservierte Ports wieder freigeben + while (++n != length) { + io_port_release(task, --port); + } + return false; + } + } + + return true; +} + +/** + * Gibt einen Bereich von Ports frei. + * + * @param task Task, der die Freigabe anfordert + * @param port Niedrigster freizugebender Port + * @param length Anzahl der freizugebenden Ports + * + * @return true, wenn alle Ports freigegeben werden konnten. Wenn ein Port + * nicht freigegeben werden konnte (war nicht für den Task reserviert), + * wird false zurückgegeben, die Bearbeitung allerdings nicht abgebrochen, + * sondern die weiteren Ports versucht freizugeben. + */ +bool io_ports_release(pm_process_t* task, uint32_t port, uint32_t length) +{ + bool success = true; + + while (length--) + { + if (!io_port_release(task, port++)) { + success = false; + } + } + + return success; +} + +/** + * Gibt alle von einem Task reservierten Ports frei + * + * @param task Task, dessen Ports freigegeben werden sollen + */ +void io_ports_release_all(pm_process_t* task) +{ + uint32_t i; + uint8_t* io_bitmap = task->io_bitmap; + + if (io_bitmap == NULL) { + return; + } + + for (i = 0; i < CPU_IO_BITMAP_LENGTH / 8; i++) + { + if (io_bitmap[i] != (uint8_t) -1) { + io_ports_release(task, 8*i, 8); + } + } +} + +/* + * Aktiviert die I/O-Bitmap fuer den Prozess + */ +void io_activate_bitmap(pm_process_t* task) +{ + cpu_tss_t* tss = &cpu_get_current()->tss; + + tss->io_bit_map_offset = TSS_IO_BITMAP_OFFSET; + + /* TODO Mit geschicktem Einsatz von Paging koennte man sich die Kopiererei + * sparen */ + if (task->io_bitmap) { + memcpy(tss->io_bit_map, task->io_bitmap, CPU_IO_BITMAP_LENGTH / 8); + } else { + memset(tss->io_bit_map, 0xff, CPU_IO_BITMAP_LENGTH / 8); + } +} diff --git a/src/kernel2/src/interrupts/im.c b/src/kernel2/src/interrupts/im.c index 4472947..9fae56b 100644 --- a/src/kernel2/src/interrupts/im.c +++ b/src/kernel2/src/interrupts/im.c @@ -80,6 +80,17 @@ static void handle_exception(interrupt_stack_frame_t* isf, uint8_t int_num) } } + if (int_num == 0x0d) { + // Pruefen, ob der #GP moeglicherweise durch eine nicht geladene + // I/O-Bitmap verurscht worden ist + if (cpu_get_current()->tss.io_bit_map_offset == + TSS_IO_BITMAP_NOT_LOADED) + { + io_activate_bitmap(current_process); + return; + } + } + if (int_num == 0x0e) { // Ueberprüfen ob der Pagefault durch einen Stackoverflow // hervorgerufen wurde. Falls ja: Stack vergroessern und weitermachen diff --git a/src/kernel2/src/syscalls/io.c b/src/kernel2/src/syscalls/io.c index de840be..efe344b 100644 --- a/src/kernel2/src/syscalls/io.c +++ b/src/kernel2/src/syscalls/io.c @@ -35,7 +35,14 @@ #include -void syscall_io_request_port(uint32_t port, uint32_t length) +#include "cpu.h" + +int syscall_io_request_port(uint32_t port, uint32_t length) { - // TODO syscall_io_request_port + int ret; + + ret = io_ports_request(current_process, port, length); + io_activate_bitmap(current_process); + + return ret; } diff --git a/src/kernel2/src/tasks/pm.c b/src/kernel2/src/tasks/pm.c index a077621..78cd50f 100644 --- a/src/kernel2/src/tasks/pm.c +++ b/src/kernel2/src/tasks/pm.c @@ -197,6 +197,9 @@ void pm_destroy(pm_process_t* process) } list_destroy(process->on_destroy); + // IO-Ports freigeben + io_ports_release_all(process); + // Timer freigeben timer_cancel_all(process); -- 1.6.0.2 From kevin at tyndur.org Sun Oct 31 20:29:47 2010 From: kevin at tyndur.org (Kevin Wolf) Date: Sun, 31 Oct 2010 20:29:47 +0100 Subject: [tyndur-devel] [PATCH] kernel2: Bei einer Exception nur den Prozess beenden Message-ID: <1288553387-16611-1-git-send-email-kevin@tyndur.org> * kernel2: Bei einer Exception im Usermodus wird nur der aktuelle Prozess beendet. Bei einer Exception im Kernelmodus wird weiterhin das System angehalten. Signed-off-by: Kevin Wolf --- src/kernel2/src/interrupts/im.c | 18 ++++++++++++------ 1 files changed, 12 insertions(+), 6 deletions(-) diff --git a/src/kernel2/src/interrupts/im.c b/src/kernel2/src/interrupts/im.c index 9fae56b..bd774be 100644 --- a/src/kernel2/src/interrupts/im.c +++ b/src/kernel2/src/interrupts/im.c @@ -124,14 +124,20 @@ static void handle_exception(interrupt_stack_frame_t* isf, uint8_t int_num) } } - // Hier werden alle Prozessoren zum halten gebracht - if (cpu_count > 1) { - apic_ipi_broadcast(0xF0, true); + // Wenn die Exception im Kernel passiert ist, geben wir auf + if ((isf->cs & 0x03) == 0) { + // Hier werden alle Prozessoren zum halten gebracht + if (cpu_count > 1) { + apic_ipi_broadcast(0xF0, true); + } + + // Aber da das ohne APIC nicht so funktioniert, wird das noch + // abgefangen. + asm("cli; hlt"); } - // Aber da das ohne APIC nicht so funktioniert, wird das noch - // abgefangen. - asm("cli; hlt"); + // Ansonsten wird nur der aktuelle Task beendet + syscall_pm_exit_process(); } /** -- 1.6.0.2