kernel/context.cpp

   1 /*
   2 lightOS kernel
   3 Copyright (C) 2006-2009 Jörg Pfähler
   4
   5 This program is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18 */
  19 #include <kernel/context.hpp>
  20 #include <kernel/process.hpp>
  21 #include <kernel/page_allocator.hpp>
  22 #include <kernel/virtual_memory.hpp>
  23 using kernel::context;
  24 using kernel::kernel_context;
  25 using kernel::virtual_memory;
  26
  27
  28 SINGLETON_INSTANCE(kernel::kernel_context);
  29
  30
  31 context::context(context& c)
  32   : m_handle(), m_heap()
  33 {
  34   SCOPED_LOCK(c.m_lock, scope);
  35   m_heap = c.m_heap;
  36   m_handle = c.m_handle;
  37   c.m_heap = 0;
  38   c.m_handle = 0;
  39 }
  40
  41 context::context(kernel::context_handle_t handle,
  42                  void* heap)
  43   : m_handle(handle), m_heap(heap)
  44 {
  45 }
  46
  47 // TODO: Locking
  48
  49 void *context::heap_map(void *paddress,
  50                         size_t pages,
  51                         size_t flags)
  52 {
  53   for (size_t i = 0;i < pages;i++)
  54   {
  55     map(adjust_pointer(paddress, i * virtual_memory::page_size),
  56         adjust_pointer(m_heap, i * virtual_memory::page_size),
  57         flags);
  58   }
  59
  60   // Set new heap address
  61   void *tmp = m_heap;
  62   m_heap = adjust_pointer(m_heap, pages * virtual_memory::page_size);
  63   return tmp;
  64 }
  65
  66 void *context::heap_map(size_t pages,
  67                         size_t flags,
  68                         process *Process)
  69 {
  70   page_allocator &PageAllocator = page_allocator::instance();
  71   for (size_t i = 0;i < pages;i++)
  72   {
  73     void *page = PageAllocator.allocate();
  74     if (Process != 0)Process->mPages.push_back(page);
  75     map(page,
  76         adjust_pointer(m_heap, i * virtual_memory::page_size),
  77         flags);
  78   }
  79
  80   // Set new heap address
  81   void *tmp = m_heap;
  82   m_heap = adjust_pointer(m_heap, pages * virtual_memory::page_size);
  83   return tmp;
  84 }
  85
  86 void *kernel_context::map_memory_region(void *paddress, size_t flags)
  87 {
  88   mLastKernelMemoryRegion = adjust_pointer(mLastKernelMemoryRegion, - virtual_memory::page_size);
  89   map(paddress,
  90       mLastKernelMemoryRegion,
  91       flags);
  92   return mLastKernelMemoryRegion;
  93 }
  94
  95 void *kernel_context::allocate_memory_region(size_t pages, size_t flags)
  96 {
  97   page_allocator &PageAllocator = page_allocator::instance();
  98   mLastKernelMemoryRegion = adjust_pointer(mLastKernelMemoryRegion, - pages * virtual_memory::page_size);
  99   for (size_t i = 0;i < pages;i++)
 100   {
 101     void *page = PageAllocator.allocate();
 102     map(page,
 103       adjust_pointer(mLastKernelMemoryRegion, i * virtual_memory::page_size),
 104       flags);
 105   }
 106   return mLastKernelMemoryRegion;
 107 }
 108
 109 void kernel_context::free_memory_region(void *address, size_t pages)
 110 {
 111   page_allocator &PageAllocator = page_allocator::instance();
 112   for (size_t i = 0;i < pages;i++)
 113   {
 114     void *page = physical_address(adjust_pointer(address, i * virtual_memory::page_size));
 115     PageAllocator.free(page);
 116   }
 117
 118   if (mLastKernelMemoryRegion == address)
 119     mLastKernelMemoryRegion = adjust_pointer(address, pages * virtual_memory::page_size);
 120 }
 121
 122 kernel_context::kernel_context()
 123   : context(virtual_memory::kernel_context_handle(), virtual_memory::kernel_binary_end<void>()),
 124     mLastKernelMemoryRegion(virtual_memory::kernel_memory_region_begin<void>())
 125 {
 126 }
 127
 128 kernel_context::~kernel_context()
 129 {
 130   m_handle = 0;
 131 }