kernel/genarch/src/mm/as_pt.c

   1 /*
   2  * Copyright (c) 2006 Jakub Jermar
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup genarchmm
  30  * @{
  31  */
  32
  33 /**
  34  * @file
  35  * @brief       Address space functions for 4-level hierarchical pagetables.
  36  */
  37
  38 #include <genarch/mm/page_pt.h>
  39 #include <mm/page.h>
  40 #include <mm/frame.h>
  41 #include <mm/as.h>
  42 #include <synch/mutex.h>
  43 #include <arch/mm/page.h>
  44 #include <arch/mm/as.h>
  45 #include <arch/types.h>
  46 #include <memstr.h>
  47 #include <arch.h>
  48
  49 static pte_t *ptl0_create(int flags);
  50 static void ptl0_destroy(pte_t *page_table);
  51
  52 static void pt_lock(as_t *as, bool lock);
  53 static void pt_unlock(as_t *as, bool unlock);
  54
  55 as_operations_t as_pt_operations = {
  56         .page_table_create = ptl0_create,
  57         .page_table_destroy = ptl0_destroy,
  58         .page_table_lock = pt_lock,
  59         .page_table_unlock = pt_unlock
  60 };
  61
  62 /** Create PTL0.
  63  *
  64  * PTL0 of 4-level page table will be created for each address space.
  65  *
  66  * @param flags Flags can specify whether ptl0 is for the kernel address space.
  67  *
  68  * @return New PTL0.
  69  */
  70 pte_t *ptl0_create(int flags)
  71 {
  72         pte_t *src_ptl0, *dst_ptl0;
  73         ipl_t ipl;
  74
  75         dst_ptl0 = (pte_t *) frame_alloc(ONE_FRAME, FRAME_KA);
  76
  77         if (flags & FLAG_AS_KERNEL) {
  78                 memsetb((uintptr_t) dst_ptl0, PAGE_SIZE, 0);
  79         } else {
  80                 uintptr_t src, dst;
  81
  82                 /*
  83                  * Copy the kernel address space portion to new PTL0.
  84                  */
  85
  86                 ipl = interrupts_disable();
  87                 mutex_lock(&AS_KERNEL->lock);
  88                 src_ptl0 = (pte_t *) PA2KA((uintptr_t) AS_KERNEL->genarch.page_table);
  89
  90                 src = (uintptr_t) &src_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
  91                 dst = (uintptr_t) &dst_ptl0[PTL0_INDEX(KERNEL_ADDRESS_SPACE_START)];
  92
  93                 memsetb((uintptr_t) dst_ptl0, PAGE_SIZE, 0);
  94                 memcpy((void *) dst, (void *) src, PAGE_SIZE - (src - (uintptr_t) src_ptl0));
  95                 mutex_unlock(&AS_KERNEL->lock);
  96                 interrupts_restore(ipl);
  97         }
  98
  99         return (pte_t *) KA2PA((uintptr_t) dst_ptl0);
 100 }
 101
 102 /** Destroy page table.
 103  *
 104  * Destroy PTL0, other levels are expected to be already deallocated.
 105  *
 106  * @param page_table Physical address of PTL0.
 107  */
 108 void ptl0_destroy(pte_t *page_table)
 109 {
 110         frame_free((uintptr_t)page_table);
 111 }
 112
 113 /** Lock page tables.
 114  *
 115  * Lock only the address space.
 116  * Interrupts must be disabled.
 117  *
 118  * @param as Address space.
 119  * @param lock If false, do not attempt to lock the address space.
 120  */
 121 void pt_lock(as_t *as, bool lock)
 122 {
 123         if (lock)
 124                 mutex_lock(&as->lock);
 125 }
 126
 127 /** Unlock page tables.
 128  *
 129  * Unlock the address space.
 130  * Interrupts must be disabled.
 131  *
 132  * @param as Address space.
 133  * @param unlock If false, do not attempt to unlock the address space.
 134  */
 135 void pt_unlock(as_t *as, bool unlock)
 136 {
 137         if (unlock)
 138                 mutex_unlock(&as->lock);
 139 }
 140
 141 /** @}
 142  */