MemoryManager.cpp 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683
  1. /*
  2. * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
  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 are met:
  7. *
  8. * 1. Redistributions of source code must retain the above copyright notice, this
  9. * list of conditions and the following disclaimer.
  10. *
  11. * 2. Redistributions in binary form must reproduce the above copyright notice,
  12. * this list of conditions and the following disclaimer in the documentation
  13. * and/or other materials provided with the distribution.
  14. *
  15. * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  16. * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  18. * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  19. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  21. * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  22. * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  23. * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  24. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25. */
  26. #include "CMOS.h"
  27. #include "Process.h"
  28. #include <AK/Assertions.h>
  29. #include <Kernel/Arch/i386/CPU.h>
  30. #include <Kernel/FileSystem/Inode.h>
  31. #include <Kernel/Multiboot.h>
  32. #include <Kernel/VM/AnonymousVMObject.h>
  33. #include <Kernel/VM/InodeVMObject.h>
  34. #include <Kernel/VM/MemoryManager.h>
  35. #include <Kernel/VM/PurgeableVMObject.h>
  36. #include <LibBareMetal/StdLib.h>
  37. //#define MM_DEBUG
  38. //#define PAGE_FAULT_DEBUG
  39. static MemoryManager* s_the;
  40. MemoryManager& MM
  41. {
  42. return *s_the;
  43. }
  44. MemoryManager::MemoryManager()
  45. {
  46. m_kernel_page_directory = PageDirectory::create_kernel_page_directory();
  47. parse_memory_map();
  48. write_cr3(kernel_page_directory().cr3());
  49. setup_low_identity_mapping();
  50. protect_kernel_image();
  51. m_shared_zero_page = allocate_user_physical_page();
  52. }
  53. MemoryManager::~MemoryManager()
  54. {
  55. }
  56. void MemoryManager::protect_kernel_image()
  57. {
  58. // Disable writing to the kernel text and rodata segments.
  59. extern uintptr_t start_of_kernel_text;
  60. extern uintptr_t start_of_kernel_data;
  61. for (size_t i = (uintptr_t)&start_of_kernel_text; i < (uintptr_t)&start_of_kernel_data; i += PAGE_SIZE) {
  62. auto& pte = ensure_pte(kernel_page_directory(), VirtualAddress(i));
  63. pte.set_writable(false);
  64. }
  65. if (g_cpu_supports_nx) {
  66. // Disable execution of the kernel data and bss segments.
  67. extern uintptr_t end_of_kernel_bss;
  68. for (size_t i = (uintptr_t)&start_of_kernel_data; i < (uintptr_t)&end_of_kernel_bss; i += PAGE_SIZE) {
  69. auto& pte = ensure_pte(kernel_page_directory(), VirtualAddress(i));
  70. pte.set_execute_disabled(true);
  71. }
  72. }
  73. }
  74. void MemoryManager::setup_low_identity_mapping()
  75. {
  76. m_low_page_table = allocate_user_physical_page(ShouldZeroFill::Yes);
  77. auto* pd_zero = quickmap_pd(kernel_page_directory(), 0);
  78. pd_zero[1].set_present(false);
  79. pd_zero[2].set_present(false);
  80. pd_zero[3].set_present(false);
  81. auto& pde_zero = pd_zero[0];
  82. pde_zero.set_page_table_base(m_low_page_table->paddr().get());
  83. pde_zero.set_present(true);
  84. pde_zero.set_huge(false);
  85. pde_zero.set_writable(true);
  86. pde_zero.set_user_allowed(false);
  87. if (g_cpu_supports_nx)
  88. pde_zero.set_execute_disabled(true);
  89. for (uintptr_t offset = (1 * MB); offset < (2 * MB); offset += PAGE_SIZE) {
  90. auto& page_table_page = m_low_page_table;
  91. auto& pte = quickmap_pt(page_table_page->paddr())[offset / PAGE_SIZE];
  92. pte.set_physical_page_base(offset);
  93. pte.set_user_allowed(false);
  94. pte.set_present(offset != 0);
  95. pte.set_writable(offset < (1 * MB));
  96. }
  97. }
  98. void MemoryManager::parse_memory_map()
  99. {
  100. RefPtr<PhysicalRegion> region;
  101. bool region_is_super = false;
  102. auto* mmap = (multiboot_memory_map_t*)(low_physical_to_virtual(multiboot_info_ptr->mmap_addr));
  103. for (; (unsigned long)mmap < (low_physical_to_virtual(multiboot_info_ptr->mmap_addr)) + (multiboot_info_ptr->mmap_length); mmap = (multiboot_memory_map_t*)((unsigned long)mmap + mmap->size + sizeof(mmap->size))) {
  104. kprintf("MM: Multiboot mmap: base_addr = 0x%x%08x, length = 0x%x%08x, type = 0x%x\n",
  105. (uintptr_t)(mmap->addr >> 32),
  106. (uintptr_t)(mmap->addr & 0xffffffff),
  107. (uintptr_t)(mmap->len >> 32),
  108. (uintptr_t)(mmap->len & 0xffffffff),
  109. (uintptr_t)mmap->type);
  110. if (mmap->type != MULTIBOOT_MEMORY_AVAILABLE)
  111. continue;
  112. // FIXME: Maybe make use of stuff below the 1MB mark?
  113. if (mmap->addr < (1 * MB))
  114. continue;
  115. if ((mmap->addr + mmap->len) > 0xffffffff)
  116. continue;
  117. auto diff = (uintptr_t)mmap->addr % PAGE_SIZE;
  118. if (diff != 0) {
  119. kprintf("MM: got an unaligned region base from the bootloader; correcting %p by %d bytes\n", mmap->addr, diff);
  120. diff = PAGE_SIZE - diff;
  121. mmap->addr += diff;
  122. mmap->len -= diff;
  123. }
  124. if ((mmap->len % PAGE_SIZE) != 0) {
  125. kprintf("MM: got an unaligned region length from the bootloader; correcting %d by %d bytes\n", mmap->len, mmap->len % PAGE_SIZE);
  126. mmap->len -= mmap->len % PAGE_SIZE;
  127. }
  128. if (mmap->len < PAGE_SIZE) {
  129. kprintf("MM: memory region from bootloader is too small; we want >= %d bytes, but got %d bytes\n", PAGE_SIZE, mmap->len);
  130. continue;
  131. }
  132. #ifdef MM_DEBUG
  133. kprintf("MM: considering memory at %p - %p\n",
  134. (uintptr_t)mmap->addr, (uintptr_t)(mmap->addr + mmap->len));
  135. #endif
  136. for (size_t page_base = mmap->addr; page_base < (mmap->addr + mmap->len); page_base += PAGE_SIZE) {
  137. auto addr = PhysicalAddress(page_base);
  138. if (page_base < 7 * MB) {
  139. // nothing
  140. } else if (page_base >= 7 * MB && page_base < 8 * MB) {
  141. if (region.is_null() || !region_is_super || region->upper().offset(PAGE_SIZE) != addr) {
  142. m_super_physical_regions.append(PhysicalRegion::create(addr, addr));
  143. region = m_super_physical_regions.last();
  144. region_is_super = true;
  145. } else {
  146. region->expand(region->lower(), addr);
  147. }
  148. } else {
  149. if (region.is_null() || region_is_super || region->upper().offset(PAGE_SIZE) != addr) {
  150. m_user_physical_regions.append(PhysicalRegion::create(addr, addr));
  151. region = m_user_physical_regions.last();
  152. region_is_super = false;
  153. } else {
  154. region->expand(region->lower(), addr);
  155. }
  156. }
  157. }
  158. }
  159. for (auto& region : m_super_physical_regions)
  160. m_super_physical_pages += region.finalize_capacity();
  161. for (auto& region : m_user_physical_regions)
  162. m_user_physical_pages += region.finalize_capacity();
  163. }
  164. PageTableEntry& MemoryManager::ensure_pte(PageDirectory& page_directory, VirtualAddress vaddr)
  165. {
  166. ASSERT_INTERRUPTS_DISABLED();
  167. u32 page_directory_table_index = (vaddr.get() >> 30) & 0x3;
  168. u32 page_directory_index = (vaddr.get() >> 21) & 0x1ff;
  169. u32 page_table_index = (vaddr.get() >> 12) & 0x1ff;
  170. auto* pd = quickmap_pd(page_directory, page_directory_table_index);
  171. PageDirectoryEntry& pde = pd[page_directory_index];
  172. if (!pde.is_present()) {
  173. #ifdef MM_DEBUG
  174. dbgprintf("MM: PDE %u not present (requested for V%p), allocating\n", page_directory_index, vaddr.get());
  175. #endif
  176. auto page_table = allocate_user_physical_page(ShouldZeroFill::Yes);
  177. #ifdef MM_DEBUG
  178. dbgprintf("MM: PD K%p (%s) at P%p allocated page table #%u (for V%p) at P%p\n",
  179. &page_directory,
  180. &page_directory == m_kernel_page_directory ? "Kernel" : "User",
  181. page_directory.cr3(),
  182. page_directory_index,
  183. vaddr.get(),
  184. page_table->paddr().get());
  185. #endif
  186. pde.set_page_table_base(page_table->paddr().get());
  187. pde.set_user_allowed(true);
  188. pde.set_present(true);
  189. pde.set_writable(true);
  190. pde.set_global(&page_directory == m_kernel_page_directory.ptr());
  191. page_directory.m_physical_pages.set(page_directory_index, move(page_table));
  192. }
  193. return quickmap_pt(PhysicalAddress((uintptr_t)pde.page_table_base()))[page_table_index];
  194. }
  195. void MemoryManager::initialize()
  196. {
  197. s_the = new MemoryManager;
  198. }
  199. Region* MemoryManager::kernel_region_from_vaddr(VirtualAddress vaddr)
  200. {
  201. if (vaddr.get() < 0xc0000000)
  202. return nullptr;
  203. for (auto& region : MM.m_kernel_regions) {
  204. if (region.contains(vaddr))
  205. return &region;
  206. }
  207. return nullptr;
  208. }
  209. Region* MemoryManager::user_region_from_vaddr(Process& process, VirtualAddress vaddr)
  210. {
  211. // FIXME: Use a binary search tree (maybe red/black?) or some other more appropriate data structure!
  212. for (auto& region : process.m_regions) {
  213. if (region.contains(vaddr))
  214. return &region;
  215. }
  216. dbg() << process << " Couldn't find user region for " << vaddr;
  217. return nullptr;
  218. }
  219. Region* MemoryManager::region_from_vaddr(Process& process, VirtualAddress vaddr)
  220. {
  221. if (auto* region = kernel_region_from_vaddr(vaddr))
  222. return region;
  223. return user_region_from_vaddr(process, vaddr);
  224. }
  225. const Region* MemoryManager::region_from_vaddr(const Process& process, VirtualAddress vaddr)
  226. {
  227. if (auto* region = kernel_region_from_vaddr(vaddr))
  228. return region;
  229. return user_region_from_vaddr(const_cast<Process&>(process), vaddr);
  230. }
  231. Region* MemoryManager::region_from_vaddr(VirtualAddress vaddr)
  232. {
  233. if (auto* region = kernel_region_from_vaddr(vaddr))
  234. return region;
  235. auto page_directory = PageDirectory::find_by_cr3(read_cr3());
  236. if (!page_directory)
  237. return nullptr;
  238. ASSERT(page_directory->process());
  239. return user_region_from_vaddr(*page_directory->process(), vaddr);
  240. }
  241. PageFaultResponse MemoryManager::handle_page_fault(const PageFault& fault)
  242. {
  243. ASSERT_INTERRUPTS_DISABLED();
  244. ASSERT(current);
  245. #ifdef PAGE_FAULT_DEBUG
  246. dbgprintf("MM: handle_page_fault(%w) at V%p\n", fault.code(), fault.vaddr().get());
  247. #endif
  248. auto* region = region_from_vaddr(fault.vaddr());
  249. if (!region) {
  250. kprintf("NP(error) fault at invalid address V%p\n", fault.vaddr().get());
  251. return PageFaultResponse::ShouldCrash;
  252. }
  253. return region->handle_fault(fault);
  254. }
  255. OwnPtr<Region> MemoryManager::allocate_kernel_region(size_t size, const StringView& name, u8 access, bool user_accessible, bool should_commit, bool cacheable)
  256. {
  257. InterruptDisabler disabler;
  258. ASSERT(!(size % PAGE_SIZE));
  259. auto range = kernel_page_directory().range_allocator().allocate_anywhere(size);
  260. ASSERT(range.is_valid());
  261. OwnPtr<Region> region;
  262. if (user_accessible)
  263. region = Region::create_user_accessible(range, name, access, cacheable);
  264. else
  265. region = Region::create_kernel_only(range, name, access, cacheable);
  266. region->map(kernel_page_directory());
  267. if (should_commit)
  268. region->commit();
  269. return region;
  270. }
  271. OwnPtr<Region> MemoryManager::allocate_kernel_region(PhysicalAddress paddr, size_t size, const StringView& name, u8 access, bool user_accessible, bool cacheable)
  272. {
  273. InterruptDisabler disabler;
  274. ASSERT(!(size % PAGE_SIZE));
  275. auto range = kernel_page_directory().range_allocator().allocate_anywhere(size);
  276. ASSERT(range.is_valid());
  277. auto vmobject = AnonymousVMObject::create_for_physical_range(paddr, size);
  278. if (!vmobject)
  279. return nullptr;
  280. OwnPtr<Region> region;
  281. if (user_accessible)
  282. region = Region::create_user_accessible(range, vmobject.release_nonnull(), 0, name, access, cacheable);
  283. else
  284. region = Region::create_kernel_only(range, vmobject.release_nonnull(), 0, name, access, cacheable);
  285. region->map(kernel_page_directory());
  286. return region;
  287. }
  288. OwnPtr<Region> MemoryManager::allocate_user_accessible_kernel_region(size_t size, const StringView& name, u8 access, bool cacheable)
  289. {
  290. return allocate_kernel_region(size, name, access, true, true, cacheable);
  291. }
  292. OwnPtr<Region> MemoryManager::allocate_kernel_region_with_vmobject(VMObject& vmobject, size_t size, const StringView& name, u8 access, bool user_accessible, bool cacheable)
  293. {
  294. InterruptDisabler disabler;
  295. ASSERT(!(size % PAGE_SIZE));
  296. auto range = kernel_page_directory().range_allocator().allocate_anywhere(size);
  297. ASSERT(range.is_valid());
  298. OwnPtr<Region> region;
  299. if (user_accessible)
  300. region = Region::create_user_accessible(range, vmobject, 0, name, access, cacheable);
  301. else
  302. region = Region::create_kernel_only(range, vmobject, 0, name, access, cacheable);
  303. region->map(kernel_page_directory());
  304. return region;
  305. }
  306. void MemoryManager::deallocate_user_physical_page(PhysicalPage&& page)
  307. {
  308. for (auto& region : m_user_physical_regions) {
  309. if (!region.contains(page)) {
  310. kprintf(
  311. "MM: deallocate_user_physical_page: %p not in %p -> %p\n",
  312. page.paddr().get(), region.lower().get(), region.upper().get());
  313. continue;
  314. }
  315. region.return_page(move(page));
  316. --m_user_physical_pages_used;
  317. return;
  318. }
  319. kprintf("MM: deallocate_user_physical_page couldn't figure out region for user page @ %p\n", page.paddr().get());
  320. ASSERT_NOT_REACHED();
  321. }
  322. RefPtr<PhysicalPage> MemoryManager::find_free_user_physical_page()
  323. {
  324. RefPtr<PhysicalPage> page;
  325. for (auto& region : m_user_physical_regions) {
  326. page = region.take_free_page(false);
  327. if (!page.is_null())
  328. break;
  329. }
  330. return page;
  331. }
  332. RefPtr<PhysicalPage> MemoryManager::allocate_user_physical_page(ShouldZeroFill should_zero_fill)
  333. {
  334. InterruptDisabler disabler;
  335. RefPtr<PhysicalPage> page = find_free_user_physical_page();
  336. if (!page) {
  337. if (m_user_physical_regions.is_empty()) {
  338. kprintf("MM: no user physical regions available (?)\n");
  339. }
  340. for_each_vmobject([&](auto& vmobject) {
  341. if (vmobject.is_purgeable()) {
  342. auto& purgeable_vmobject = static_cast<PurgeableVMObject&>(vmobject);
  343. int purged_page_count = purgeable_vmobject.purge_with_interrupts_disabled({});
  344. if (purged_page_count) {
  345. kprintf("MM: Purge saved the day! Purged %d pages from PurgeableVMObject{%p}\n", purged_page_count, &purgeable_vmobject);
  346. page = find_free_user_physical_page();
  347. ASSERT(page);
  348. return IterationDecision::Break;
  349. }
  350. }
  351. return IterationDecision::Continue;
  352. });
  353. if (!page) {
  354. kprintf("MM: no user physical pages available\n");
  355. ASSERT_NOT_REACHED();
  356. return {};
  357. }
  358. }
  359. #ifdef MM_DEBUG
  360. dbgprintf("MM: allocate_user_physical_page vending P%p\n", page->paddr().get());
  361. #endif
  362. if (should_zero_fill == ShouldZeroFill::Yes) {
  363. auto* ptr = quickmap_page(*page);
  364. memset(ptr, 0, PAGE_SIZE);
  365. unquickmap_page();
  366. }
  367. ++m_user_physical_pages_used;
  368. return page;
  369. }
  370. void MemoryManager::deallocate_supervisor_physical_page(PhysicalPage&& page)
  371. {
  372. for (auto& region : m_super_physical_regions) {
  373. if (!region.contains(page)) {
  374. kprintf(
  375. "MM: deallocate_supervisor_physical_page: %p not in %p -> %p\n",
  376. page.paddr().get(), region.lower().get(), region.upper().get());
  377. continue;
  378. }
  379. region.return_page(move(page));
  380. --m_super_physical_pages_used;
  381. return;
  382. }
  383. kprintf("MM: deallocate_supervisor_physical_page couldn't figure out region for super page @ %p\n", page.paddr().get());
  384. ASSERT_NOT_REACHED();
  385. }
  386. RefPtr<PhysicalPage> MemoryManager::allocate_supervisor_physical_page()
  387. {
  388. InterruptDisabler disabler;
  389. RefPtr<PhysicalPage> page;
  390. for (auto& region : m_super_physical_regions) {
  391. page = region.take_free_page(true);
  392. if (page.is_null())
  393. continue;
  394. }
  395. if (!page) {
  396. if (m_super_physical_regions.is_empty()) {
  397. kprintf("MM: no super physical regions available (?)\n");
  398. }
  399. kprintf("MM: no super physical pages available\n");
  400. ASSERT_NOT_REACHED();
  401. return {};
  402. }
  403. #ifdef MM_DEBUG
  404. dbgprintf("MM: allocate_supervisor_physical_page vending P%p\n", page->paddr().get());
  405. #endif
  406. fast_u32_fill((u32*)page->paddr().offset(0xc0000000).as_ptr(), 0, PAGE_SIZE / sizeof(u32));
  407. ++m_super_physical_pages_used;
  408. return page;
  409. }
  410. void MemoryManager::enter_process_paging_scope(Process& process)
  411. {
  412. ASSERT(current);
  413. InterruptDisabler disabler;
  414. current->tss().cr3 = process.page_directory().cr3();
  415. write_cr3(process.page_directory().cr3());
  416. }
  417. void MemoryManager::flush_entire_tlb()
  418. {
  419. write_cr3(read_cr3());
  420. }
  421. void MemoryManager::flush_tlb(VirtualAddress vaddr)
  422. {
  423. #ifdef MM_DEBUG
  424. dbgprintf("MM: Flush page V%p\n", vaddr.get());
  425. #endif
  426. asm volatile("invlpg %0"
  427. :
  428. : "m"(*(char*)vaddr.get())
  429. : "memory");
  430. }
  431. extern "C" PageTableEntry boot_pd3_pde1023_pt[1024];
  432. PageDirectoryEntry* MemoryManager::quickmap_pd(PageDirectory& directory, size_t pdpt_index)
  433. {
  434. auto& pte = boot_pd3_pde1023_pt[4];
  435. auto pd_paddr = directory.m_directory_pages[pdpt_index]->paddr();
  436. if (pte.physical_page_base() != pd_paddr.as_ptr()) {
  437. #ifdef MM_DEBUG
  438. dbgprintf("quickmap_pd: Mapping P%p at 0xffe04000 in pte @ %p\n", directory.m_directory_pages[pdpt_index]->paddr().as_ptr(), &pte);
  439. #endif
  440. pte.set_physical_page_base(pd_paddr.get());
  441. pte.set_present(true);
  442. pte.set_writable(true);
  443. pte.set_user_allowed(false);
  444. flush_tlb(VirtualAddress(0xffe04000));
  445. }
  446. return (PageDirectoryEntry*)0xffe04000;
  447. }
  448. PageTableEntry* MemoryManager::quickmap_pt(PhysicalAddress pt_paddr)
  449. {
  450. auto& pte = boot_pd3_pde1023_pt[8];
  451. if (pte.physical_page_base() != pt_paddr.as_ptr()) {
  452. #ifdef MM_DEBUG
  453. dbgprintf("quickmap_pt: Mapping P%p at 0xffe08000 in pte @ %p\n", pt_paddr.as_ptr(), &pte);
  454. #endif
  455. pte.set_physical_page_base(pt_paddr.get());
  456. pte.set_present(true);
  457. pte.set_writable(true);
  458. pte.set_user_allowed(false);
  459. flush_tlb(VirtualAddress(0xffe08000));
  460. }
  461. return (PageTableEntry*)0xffe08000;
  462. }
  463. u8* MemoryManager::quickmap_page(PhysicalPage& physical_page)
  464. {
  465. ASSERT_INTERRUPTS_DISABLED();
  466. ASSERT(!m_quickmap_in_use);
  467. m_quickmap_in_use = true;
  468. auto& pte = boot_pd3_pde1023_pt[0];
  469. if (pte.physical_page_base() != physical_page.paddr().as_ptr()) {
  470. #ifdef MM_DEBUG
  471. dbgprintf("quickmap_page: Mapping P%p at 0xffe00000 in pte @ %p\n", physical_page.paddr().as_ptr(), &pte);
  472. #endif
  473. pte.set_physical_page_base(physical_page.paddr().get());
  474. pte.set_present(true);
  475. pte.set_writable(true);
  476. pte.set_user_allowed(false);
  477. flush_tlb(VirtualAddress(0xffe00000));
  478. }
  479. return (u8*)0xffe00000;
  480. }
  481. void MemoryManager::unquickmap_page()
  482. {
  483. ASSERT_INTERRUPTS_DISABLED();
  484. ASSERT(m_quickmap_in_use);
  485. auto& pte = boot_pd3_pde1023_pt[0];
  486. pte.clear();
  487. flush_tlb(VirtualAddress(0xffe00000));
  488. m_quickmap_in_use = false;
  489. }
  490. template<MemoryManager::AccessSpace space, MemoryManager::AccessType access_type>
  491. bool MemoryManager::validate_range(const Process& process, VirtualAddress base_vaddr, size_t size) const
  492. {
  493. ASSERT(size);
  494. if (base_vaddr > base_vaddr.offset(size)) {
  495. dbg() << "Shenanigans! Asked to validate wrappy " << base_vaddr << " size=" << size;
  496. return false;
  497. }
  498. VirtualAddress vaddr = base_vaddr.page_base();
  499. VirtualAddress end_vaddr = base_vaddr.offset(size - 1).page_base();
  500. if (end_vaddr < vaddr) {
  501. dbg() << "Shenanigans! Asked to validate " << base_vaddr << " size=" << size;
  502. return false;
  503. }
  504. const Region* region = nullptr;
  505. while (vaddr <= end_vaddr) {
  506. if (!region || !region->contains(vaddr)) {
  507. if (space == AccessSpace::Kernel)
  508. region = kernel_region_from_vaddr(vaddr);
  509. if (!region || !region->contains(vaddr))
  510. region = user_region_from_vaddr(const_cast<Process&>(process), vaddr);
  511. if (!region
  512. || (space == AccessSpace::User && !region->is_user_accessible())
  513. || (access_type == AccessType::Read && !region->is_readable())
  514. || (access_type == AccessType::Write && !region->is_writable())) {
  515. return false;
  516. }
  517. }
  518. vaddr = vaddr.offset(PAGE_SIZE);
  519. }
  520. return true;
  521. }
  522. bool MemoryManager::validate_user_stack(const Process& process, VirtualAddress vaddr) const
  523. {
  524. if (!is_user_address(vaddr))
  525. return false;
  526. auto* region = user_region_from_vaddr(const_cast<Process&>(process), vaddr);
  527. return region && region->is_user_accessible() && region->is_stack();
  528. }
  529. bool MemoryManager::validate_kernel_read(const Process& process, VirtualAddress vaddr, size_t size) const
  530. {
  531. return validate_range<AccessSpace::Kernel, AccessType::Read>(process, vaddr, size);
  532. }
  533. bool MemoryManager::validate_user_read(const Process& process, VirtualAddress vaddr, size_t size) const
  534. {
  535. if (!is_user_address(vaddr))
  536. return false;
  537. return validate_range<AccessSpace::User, AccessType::Read>(process, vaddr, size);
  538. }
  539. bool MemoryManager::validate_user_write(const Process& process, VirtualAddress vaddr, size_t size) const
  540. {
  541. if (!is_user_address(vaddr))
  542. return false;
  543. return validate_range<AccessSpace::User, AccessType::Write>(process, vaddr, size);
  544. }
  545. void MemoryManager::register_vmobject(VMObject& vmobject)
  546. {
  547. InterruptDisabler disabler;
  548. m_vmobjects.append(&vmobject);
  549. }
  550. void MemoryManager::unregister_vmobject(VMObject& vmobject)
  551. {
  552. InterruptDisabler disabler;
  553. m_vmobjects.remove(&vmobject);
  554. }
  555. void MemoryManager::register_region(Region& region)
  556. {
  557. InterruptDisabler disabler;
  558. if (region.vaddr().get() >= 0xc0000000)
  559. m_kernel_regions.append(&region);
  560. else
  561. m_user_regions.append(&region);
  562. }
  563. void MemoryManager::unregister_region(Region& region)
  564. {
  565. InterruptDisabler disabler;
  566. if (region.vaddr().get() >= 0xc0000000)
  567. m_kernel_regions.remove(&region);
  568. else
  569. m_user_regions.remove(&region);
  570. }
  571. void MemoryManager::dump_kernel_regions()
  572. {
  573. kprintf("Kernel regions:\n");
  574. kprintf("BEGIN END SIZE ACCESS NAME\n");
  575. for (auto& region : MM.m_kernel_regions) {
  576. kprintf("%08x -- %08x %08x %c%c%c%c%c%c %s\n",
  577. region.vaddr().get(),
  578. region.vaddr().offset(region.size() - 1).get(),
  579. region.size(),
  580. region.is_readable() ? 'R' : ' ',
  581. region.is_writable() ? 'W' : ' ',
  582. region.is_executable() ? 'X' : ' ',
  583. region.is_shared() ? 'S' : ' ',
  584. region.is_stack() ? 'T' : ' ',
  585. region.vmobject().is_purgeable() ? 'P' : ' ',
  586. region.name().characters());
  587. }
  588. }
  589. ProcessPagingScope::ProcessPagingScope(Process& process)
  590. {
  591. ASSERT(current);
  592. m_previous_cr3 = read_cr3();
  593. MM.enter_process_paging_scope(process);
  594. }
  595. ProcessPagingScope::~ProcessPagingScope()
  596. {
  597. InterruptDisabler disabler;
  598. current->tss().cr3 = m_previous_cr3;
  599. write_cr3(m_previous_cr3);
  600. }