[tyndur-devel] [PATCH 1/3] kernel2: UTF-8 und Trailing Whitespace
Kevin Wolf ·
! kernel2: Codeformatierung in arch/i386/mm/mm_context.c gefixt Signed-off-by: Kevin Wolf <kevin at tyndur.org> --- src/kernel2/src/arch/i386/mm/mm_context.c | 180 ++++++++++++++-------------- 1 files changed, 90 insertions(+), 90 deletions(-) diff --git a/src/kernel2/src/arch/i386/mm/mm_context.c b/src/kernel2/src/arch/i386/mm/mm_context.c index 46fab94..7f40312 100644 --- a/src/kernel2/src/arch/i386/mm/mm_context.c +++ b/src/kernel2/src/arch/i386/mm/mm_context.c @@ -1,4 +1,4 @@ -/* +/* * Copyright (c) 2006-2007 The tyndur Project. All rights reserved. * * This code is derived from software contributed to the tyndur Project @@ -20,18 +20,18 @@ * 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 + * 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 + * 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 <string.h> #include <stdint.h> @@ -52,8 +52,8 @@ uint32_t page_directory_version = 0; page_directory_t page_directory_current; -/** - * Zur Initialisierung: Wenn gesetzt, wird mit nicht mit Paging, sondern +/** + * Zur Initialisierung: Wenn gesetzt, wird mit nicht mit Paging, sondern * physischen Adressen gearbeitet */ bool use_phys_addr = true; @@ -81,18 +81,18 @@ mmc_context_t mmc_create() context.page_directory, PAGE_SIZE); memset(context.page_directory_virt, 0, PAGE_SIZE); - + // Kernel Page Tables mappen - context.page_directory_virt[PAGETABLES_MEM_START >> PGDIR_SHIFT] = + context.page_directory_virt[PAGETABLES_MEM_START >> PGDIR_SHIFT] = (uintptr_t) context.page_directory | PTE_W | PTE_P; - + mmc_sync(&context); - + return context; } /** - * Erstellt einen komplett neuen und unabhängigen MM-Kontext + * Erstellt einen komplett neuen und unabhängigen MM-Kontext */ mmc_context_t mmc_create_empty() { @@ -111,7 +111,7 @@ mmc_context_t mmc_create_empty() } /** - * Erstellt einen neuen MM-Kontext (Page Directory) für den Kernel. + * Erstellt einen neuen MM-Kontext (Page Directory) für den Kernel. * Diese Funktion wird nur zur Initialisierung benutzt, solange Paging * noch nicht aktiviert ist. */ @@ -129,7 +129,7 @@ mmc_context_t mmc_create_kernel_context() memset(page_directory, 0, PAGE_SIZE); // Kernel Page Tables mappen - page_directory[PAGETABLES_MEM_START >> PGDIR_SHIFT] = + page_directory[PAGETABLES_MEM_START >> PGDIR_SHIFT] = (uintptr_t) page_directory | PTE_W | PTE_P; // Die Rueckgabe von mmc_current_context muss von Anfang an korrekt sein @@ -149,7 +149,7 @@ static void mmc_sync(mmc_context_t* context) context->version = page_directory_version; } - // Wenn wir hier das neu synchronisierte PD setzen, können wir Probleme + // Wenn wir hier das neu synchronisierte PD setzen, können wir Probleme // beim zerstoeren von Kontexten umgehen, falls der zu loeschende // Kontext auch der aktuellste war. page_directory_current = context->page_directory_virt; @@ -213,9 +213,9 @@ void mmc_destroy(mmc_context_t* context) } /** - * Führt ein temporäres Mapping einer Page Table durch, falls sie nicht zum - * aktuellen Page Directory gehört. Ansonsten wird ein Pointer auf die - * Page Table in den oberen 4 MB des Kernelspeichers zurückgegeben + * Führt ein temporäres Mapping einer Page Table durch, falls sie nicht zum + * aktuellen Page Directory gehört. Ansonsten wird ein Pointer auf die + * Page Table in den oberen 4 MB des Kernelspeichers zurückgegeben */ vaddr_t get_pagetable(mmc_context_t* context, size_t index) { @@ -228,7 +228,7 @@ vaddr_t get_pagetable(mmc_context_t* context, size_t index) if (context->page_directory == mmc_current_context().page_directory) { if (!use_phys_addr) { - page_table = (page_table_t) + page_table = (page_table_t) (PAGETABLES_MEM_START + (PAGE_TABLE_LENGTH * 4 * index)); } else { page_table = (vaddr_t) (pagedir[index] & PAGE_MASK); @@ -243,7 +243,7 @@ vaddr_t get_pagetable(mmc_context_t* context, size_t index) /** * Gibt eine mit get_pagetable angeforderte Page Table wieder frei, falls sie - * nicht zum aktuellen Page Directory gehört. + * nicht zum aktuellen Page Directory gehört. */ void free_pagetable(mmc_context_t* context, vaddr_t page_table) { @@ -257,27 +257,27 @@ void free_pagetable(mmc_context_t* context, vaddr_t page_table) * Mappt eine virtuelle Adresse auf eine physische. * Beide Adressen muessen dazu 4K-aligned sein. * - * @param page_directory Page Directory, auf das sich die virtuelle + * @param page_directory Page Directory, auf das sich die virtuelle * Adresse bezieht * * @param vaddr Virtuelle Speicheradresse * @param paddr Physische Speicheradresse * @param flags Flags, die in der Page Table gesetzt werden sollen - * - * @return true, wenn die virtuelle Seite erfolgreich gemappt werden konnte, + * + * @return true, wenn die virtuelle Seite erfolgreich gemappt werden konnte, * false sonst */ static bool map_page - (mmc_context_t* context, vaddr_t vaddr, paddr_t paddr, int flags) + (mmc_context_t* context, vaddr_t vaddr, paddr_t paddr, int flags) { page_table_t page_table; bool clear_page_table = false; page_directory_t page_directory = context->page_directory_virt; - + uint32_t vpage = (uint32_t) vaddr / PAGE_SIZE; - + // kprintf("map_page %x => %x PD:0x%08x (virt:0x%08x) CPU %u\n", vaddr, // paddr, context->page_directory, context->page_directory_virt, // cpu_get_current()->id); @@ -287,7 +287,7 @@ static bool map_page panic("Versuchtes Mapping nach virtuell NULL"); return false; } - + // Wenn boese Flags die Adresse manipulieren wollen, fliegt // das entsprechende Programm eben beim naechsten Zugriff // auf die Schnauze. @@ -295,10 +295,10 @@ static bool map_page return false; } - // Umgekehrt müssen die Adressen 4K-aligned sein und nicht + // Umgekehrt müssen die Adressen 4K-aligned sein und nicht // irgendwelche Flags enthalten if (((uint32_t) vaddr | (uint32_t) paddr) & 0xFFF) { - panic("Adressen sind nicht 4K-aligned (virt = %x, phys = %x)", + panic("Adressen sind nicht 4K-aligned (virt = %x, phys = %x)", vaddr, paddr); } @@ -306,7 +306,7 @@ static bool map_page // Ales andere ergibt keinen Sinn, weil diese Bereiche ohnehin zwischen // allen Kontexten synchron gehalten werden muessen. // - // TODO: Ergibt sehr wohl Sinn, wenn man nämlich IDT und GDT von einem + // TODO: Ergibt sehr wohl Sinn, wenn man nämlich IDT und GDT von einem // vm86-Task erstellen will. #if 0 if ((context != &mmc_current_context()) && @@ -324,13 +324,13 @@ static bool map_page // ansonsten nehmen wir diese. Und wenn es sich bei dem Eintrag // um eine 4M-Seite handelt, laeuft was schief. lock(&context->lock); - if ((page_directory[vpage / PAGE_TABLE_LENGTH] & PTE_P) == 0) + if ((page_directory[vpage / PAGE_TABLE_LENGTH] & PTE_P) == 0) { page_table = (page_table_t) pmm_alloc(1); // kprintf("Pagetable=0x%08x\n", page_table); page_directory[vpage / PAGE_TABLE_LENGTH] = (uint32_t) page_table | PTE_P | PTE_W | PTE_U; - + // An dieser Stelle kann die Page Table noch nicht initialisiert // werden, weil sie noch nicht gemappt ist. clear_page_table = true; @@ -341,33 +341,33 @@ static bool map_page context->version = ++page_directory_version; page_directory_current = context->page_directory_virt; } - } - else if (page_directory[vpage / PAGE_TABLE_LENGTH] & PTE_PS) + } + else if (page_directory[vpage / PAGE_TABLE_LENGTH] & PTE_PS) { // 4M-Page panic("Doppelbelegung im Page Directory. (virt = 0x%x, phys = 0x%x)", vaddr, paddr); - } + } unlock(&context->lock); // Virtuelle Adresse der Page Table holen page_table = get_pagetable(context, vpage / PAGE_TABLE_LENGTH); - + lock(&context->lock); // Jetzt ist die Page Table gemappt und kann initialisiert werden, falls es // sich um eine neu angelegte Page Table handelt. if (clear_page_table) { memset(page_table, 0, PAGE_SIZE); } - + // Wenn der Eintrag in der Pagetable noch nicht gesetzt ist, setzen. // Ansonsten stehen wir vor einer Doppelbelegung. // - // Wenn genau dasselbe Mapping doppelt gemacht wird, wird darüber + // Wenn genau dasselbe Mapping doppelt gemacht wird, wird darüber // hinweggesehen. // - // Und wenn das Mapping aufgehoben werden soll, sollte man sich auch nicht - // darüber beschweren, dass der Eintrag schon besteht. - + // Und wenn das Mapping aufgehoben werden soll, sollte man sich auch nicht + // darüber beschweren, dass der Eintrag schon besteht. + bool page_is_present = (page_table[vpage % PAGE_TABLE_LENGTH] & PTE_P); bool unmap_page = ! (flags & PTE_P); bool mapping_changed = @@ -380,15 +380,15 @@ static bool map_page panic("Doppelbelegung in einer Page Table."); unlock(&context->lock); return false; - } - else + } + else { // Setze den Page-Table-Eintrag page_table[vpage % PAGE_TABLE_LENGTH] = ((uint32_t) paddr) | flags; - // Falls es um das aktive Page Directory geht, wäre jetzt ein + // Falls es um das aktive Page Directory geht, wäre jetzt ein // guter Zeitpunkt, den TLB zu invalidieren. - // Falls wir die Page Table extra in den Kerneladressraum gemappt + // Falls wir die Page Table extra in den Kerneladressraum gemappt // haben, den Speicher wieder freigeben. if (context->page_directory == mmc_current_context().page_directory) { __asm__ __volatile__("invlpg %0" : : "m" (* (char*) vaddr)); @@ -401,22 +401,22 @@ static bool map_page } /** - * Mappt mehrere zusammenhängende virtuelle Seiten auf einen physischen + * Mappt mehrere zusammenhängende virtuelle Seiten auf einen physischen * Speicherbereich. Beide Adressen muessen dazu 4K-aligned sein. * - * @param page_directory Page Directory, auf das sich die virtuelle + * @param page_directory Page Directory, auf das sich die virtuelle * Adresse bezieht * * @param vaddr Virtuelle Speicheradresse der ersten Page * @param paddr Physische Speicheradresse der ersten Page * @param flags Flags, die in der Page Table gesetzt werden sollen * @param num Anzahl der Seiten - * - * @return true, wenn der bereich erfolgreich gemappt werden konnte, + * + * @return true, wenn der bereich erfolgreich gemappt werden konnte, * false sonst */ -bool mmc_map(mmc_context_t* context, vaddr_t vaddr, paddr_t paddr, - int flags, size_t num_pages) +bool mmc_map(mmc_context_t* context, vaddr_t vaddr, paddr_t paddr, + int flags, size_t num_pages) { // kprintf("vaddr = %x, paddr = %x\n", vaddr, paddr); size_t i; @@ -430,7 +430,7 @@ bool mmc_map(mmc_context_t* context, vaddr_t vaddr, paddr_t paddr, if(map_page(context, va, pa, flags) != true) { - // TODO: Das bereits geschehene Mapping rückgängig machen + // TODO: Das bereits geschehene Mapping rückgängig machen return false; } } @@ -441,14 +441,14 @@ bool mmc_map(mmc_context_t* context, vaddr_t vaddr, paddr_t paddr, /** * Entfernt das Mapping einer virtuellen Adresse. * - * @param page_directory Page Directory, auf das sich die virtuelle + * @param page_directory Page Directory, auf das sich die virtuelle * Adresse bezieht * @param vaddr Virtuelle Speicheradresse - * - * @return true, wenn die virtuelle Seite erfolgreich ungemappt werden konnte, + * + * @return true, wenn die virtuelle Seite erfolgreich ungemappt werden konnte, * false sonst */ -bool mmc_unmap(mmc_context_t* context, vaddr_t vaddr, size_t count) +bool mmc_unmap(mmc_context_t* context, vaddr_t vaddr, size_t count) { size_t i; @@ -473,39 +473,39 @@ paddr_t mmc_resolve(mmc_context_t* context, vaddr_t vaddr) page_directory_t page_directory = context->page_directory_virt; page_table_t page_table; paddr_t result; - + uint32_t vpage = (uint32_t) vaddr / PAGE_SIZE; //kprintf("[Resolv: %x in PD %x]", vaddr, page_directory); // Passende Page Table suchen // Bei einer 4M-Page sind wir eigentlich schon am Ziel - if ((page_directory[vpage / PAGE_TABLE_LENGTH] & PTE_P) == 0) + if ((page_directory[vpage / PAGE_TABLE_LENGTH] & PTE_P) == 0) { return (paddr_t) NULL; - } - else if (page_directory[vpage / PAGE_TABLE_LENGTH] & PTE_PS) + } + else if (page_directory[vpage / PAGE_TABLE_LENGTH] & PTE_PS) { return (paddr_t) ( (page_directory[vpage / PAGE_TABLE_LENGTH] & ~0x3FFFFF) | ((uint32_t) vaddr & 0x3FFFFF)); - - } + + } // Die Page-Table-Adresse ist eine physische Adresse. Am sichersten ist es, // die Adresse einfach noch einmal zu mappen. page_table = get_pagetable(context, vpage / PAGE_TABLE_LENGTH); - + // Adresse zusammenbasteln und fertig if (page_table[vpage % PAGE_TABLE_LENGTH] & PTE_P) { - + result = (paddr_t) ( - (page_table[vpage % PAGE_TABLE_LENGTH] & ~0xFFF) + (page_table[vpage % PAGE_TABLE_LENGTH] & ~0xFFF) | ((uint32_t) vaddr & 0xFFF)); - + } else { result = (paddr_t) NULL; } - + // Falls wir die Page Table extra in den Kerneladressraum gemappt haben, // den Speicher wieder freigeben free_pagetable(context, page_table); @@ -525,34 +525,34 @@ vaddr_t mmc_find_free_pages(mmc_context_t* context, size_t num, uint32_t cur_page; uint32_t cur_page_table; page_directory_t page_directory = context->page_directory_virt; - + // Die NULL-Page bleibt ungemappt if (lower_limit < PAGE_SIZE) { lower_limit = PAGE_SIZE; } - // cur_page ist die Schleifenvariable für die Suche. + // cur_page ist die Schleifenvariable für die Suche. // Initialisierung auf die niedrigste erlaubte Page. cur_page = (lower_limit >> PAGE_SHIFT) % PAGE_TABLE_LENGTH; cur_page_table = (lower_limit >> PGDIR_SHIFT); // Suche - while ((free_pages < num) - && ((cur_page_table << PGDIR_SHIFT) < upper_limit)) + while ((free_pages < num) + && ((cur_page_table << PGDIR_SHIFT) < upper_limit)) { - if (page_directory[cur_page_table] & PTE_P) + if (page_directory[cur_page_table] & PTE_P) { - // Die Page Table ist vorhanden. Wir müssen die einzelnen Einträge + // Die Page Table ist vorhanden. Wir müssen die einzelnen Einträge // durchsuchen, um festzustellen, ob und wieviel Platz darin frei // ist. - page_table_t page_table + page_table_t page_table = get_pagetable(context, cur_page_table); while (cur_page < PAGE_TABLE_LENGTH) { - // Wenn der Eintrag frei ist, haben wir Glück und unseren - // gefundenen Bereich um eine Page vergrößtert. Wenn nicht, war + // Wenn der Eintrag frei ist, haben wir Glück und unseren + // gefundenen Bereich um eine Page vergröÃtert. Wenn nicht, war // alles, was wir bisher gefunden haben, umsonst, unnd wir - // müssen nochmal bei Null anfangen. + // müssen nochmal bei Null anfangen. if ((page_table[cur_page++] & PTE_P) == 0) { free_pages++; if (free_pages >= num) { @@ -560,14 +560,14 @@ vaddr_t mmc_find_free_pages(mmc_context_t* context, size_t num, } } else { free_pages = 0; - lower_limit = (cur_page_table << PGDIR_SHIFT) + lower_limit = (cur_page_table << PGDIR_SHIFT) + (cur_page << PAGE_SHIFT); } } free_pagetable(context, page_table); - } - else + } + else { // Die ganze Page Table ist frei und wir haben auf einen Schlag // eine ganze Menge freie Seiten gefunden @@ -592,16 +592,16 @@ vaddr_t mmc_find_free_pages(mmc_context_t* context, size_t num, * @param context Kontext, in den gemappt werden soll * @param start Physische Startadresse des zu mappenden Speicherbereichs * @param count Anzahl der zu mappenden Seiten - * @param lower_limit Niedrigste zulässige virtuelle Adresse - * @param upper_limit Höchste zulässige virtuelle Adresse - * @param flags Flags für die Pagetable + * @param lower_limit Niedrigste zulässige virtuelle Adresse + * @param upper_limit Höchste zulässige virtuelle Adresse + * @param flags Flags für die Pagetable */ 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 = + vaddr_t free_page = mmc_find_free_pages(context, count, lower_limit, upper_limit); - + if (free_page == NULL) { return NULL; } -- 1.7.7