[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