[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[tyndur-devel] [PATCH 1/3] kernel2: UTF-8 und Trailing Whitespace
! kernel2: Codeformatierung in arch/i386/mm/mm_context.c gefixt
Signed-off-by: Kevin Wolf <kevin@xxxxxxxxxx>
---
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�igen 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� 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�n 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�in tempor�s Mapping einer Page Table durch, falls sie nicht zum
- * aktuellen Page Directory geh� Ansonsten wird ein Pointer auf die
- * Page Table in den oberen 4 MB des Kernelspeichers zur�eben
+ * 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�
+ * 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�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�ich 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�+ // Wenn genau dasselbe Mapping doppelt gemacht wird, wird darüber
// hinweggesehen.
//
- // Und wenn das Mapping aufgehoben werden soll, sollte man sich auch nicht
- // dar�eschweren, 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� 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�ende 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�gig 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� 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�die einzelnen Eintr�
+ // 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�d unseren
- // gefundenen Bereich um eine Page vergr�rt. 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�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�ige virtuelle Adresse
- * @param upper_limit H�te zul�ige virtuelle Adresse
- * @param flags Flags f� 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