beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 23:50:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Kernel/PhysicalAddress.h

69 lines
2.8 KiB
C
Raw Normal View History

LibBareMetal: Add Memory definitions Add classes of VirtualAddress & PhysicalAddress.
2020-02-09 16:00:00 +00:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 08:24:48 +00:00
* SPDX-License-Identifier: BSD-2-Clause
LibBareMetal: Add Memory definitions Add classes of VirtualAddress & PhysicalAddress.
2020-02-09 16:00:00 +00:00
*/
#pragma once
Kernel: Fix restrictions in is_allowed_to_mmap_to_userspace function This small change simplifies the function a bit but also fixes a problem with it. Let's take an example to see this: Let's say we have a reserved range between 0xe0000 to 0xfffff (EBDA), then we want to map from the memory device (/dev/mem) the entire EBDA to a program. If a program tries to map more than 131072 bytes, the current logic will work - the start address is 0xe0000, and ofcourse it's below the limit, hence it passes the first two restrictions. Then, the third if statement will fail if we try to mmap more than the said allowed bytes. However, let's take another scenario, where we try to mmap from 0xf0000 - but we try to mmap less than 131072 - but more than 65536. In such case, we again pass the first two if statements, but the third one is passed two, because it doesn't take into account the offseted address from the start of the reserved range (0xe0000). In such case, a user can easily mmap 65535 bytes above 0x100000. This might seem negligible. However, it's still a severe bug that can theoretically be exploited into a info leak or tampering with important kernel structures.
2021-10-22 08:59:31 +00:00
#include <AK/Checked.h>
Everywhere: Remove klog(), dbg() and purge all LogStream usage :^) Good-bye LogStream. Long live AK::Format!
2021-03-12 16:29:37 +00:00
#include <AK/Format.h>
LibBareMetal: Add Memory definitions Add classes of VirtualAddress & PhysicalAddress.
2020-02-09 16:00:00 +00:00
#include <AK/Types.h>
Kernel: Use PAE to allow accessing all physical memory beyond 4GB We already use PAE for the NX bit, but this changes the PhysicalAddress structure to be able to hold 64 bit physical addresses. This allows us to use all the available physical memory.
2021-07-07 03:35:15 +00:00
typedef u64 PhysicalPtr;
typedef u64 PhysicalSize;
LibBareMetal: Add Memory definitions Add classes of VirtualAddress & PhysicalAddress.
2020-02-09 16:00:00 +00:00
class PhysicalAddress {
public:
Kernel: Use PAE to allow accessing all physical memory beyond 4GB We already use PAE for the NX bit, but this changes the PhysicalAddress structure to be able to hold 64 bit physical addresses. This allows us to use all the available physical memory.
2021-07-07 03:35:15 +00:00
ALWAYS_INLINE static PhysicalPtr physical_page_base(PhysicalPtr page_address) { return page_address & ~(PhysicalPtr)0xfff; }
Kernel: Move PhysicalPage classes out of the heap into an array By moving the PhysicalPage classes out of the kernel heap into a static array, one for each physical page, we can avoid the added overhead and easily find them by indexing into an array. This also wraps the PhysicalPage into a PhysicalPageEntry, which allows us to re-use each slot with information where to find the next free page.
2021-07-08 01:50:05 +00:00
ALWAYS_INLINE static size_t physical_page_index(PhysicalPtr page_address)
{
auto page_index = page_address >> 12;
if constexpr (sizeof(size_t) < sizeof(PhysicalPtr))
VERIFY(!(page_index & ~(PhysicalPtr)((size_t)-1)));
return (size_t)(page_index);
}
Kernel: Use PAE to allow accessing all physical memory beyond 4GB We already use PAE for the NX bit, but this changes the PhysicalAddress structure to be able to hold 64 bit physical addresses. This allows us to use all the available physical memory.
2021-07-07 03:35:15 +00:00
Kernel: Use default con/de-structors This may seem like a no-op change, however it shrinks down the Kernel by a bit: .text -432 .unmap_after_init -60 .data -480 .debug_info -673 .debug_aranges 8 .debug_ranges -232 .debug_line -558 .debug_str -308 .debug_frame -40 With '= default', the compiler can do more inlining, hence the savings. I intentionally omitted some opportunities for '= default', because they would increase the Kernel size.
2021-02-28 13:42:08 +00:00
PhysicalAddress() = default;
Kernel: Use PAE to allow accessing all physical memory beyond 4GB We already use PAE for the NX bit, but this changes the PhysicalAddress structure to be able to hold 64 bit physical addresses. This allows us to use all the available physical memory.
2021-07-07 03:35:15 +00:00
explicit PhysicalAddress(PhysicalPtr address)
LibBareMetal: Add Memory definitions Add classes of VirtualAddress & PhysicalAddress.
2020-02-09 16:00:00 +00:00
: m_address(address)
{
}
Kernel: Use PAE to allow accessing all physical memory beyond 4GB We already use PAE for the NX bit, but this changes the PhysicalAddress structure to be able to hold 64 bit physical addresses. This allows us to use all the available physical memory.
2021-07-07 03:35:15 +00:00
[[nodiscard]] PhysicalAddress offset(PhysicalPtr o) const { return PhysicalAddress(m_address + o); }
Kernel: Fix restrictions in is_allowed_to_mmap_to_userspace function This small change simplifies the function a bit but also fixes a problem with it. Let's take an example to see this: Let's say we have a reserved range between 0xe0000 to 0xfffff (EBDA), then we want to map from the memory device (/dev/mem) the entire EBDA to a program. If a program tries to map more than 131072 bytes, the current logic will work - the start address is 0xe0000, and ofcourse it's below the limit, hence it passes the first two restrictions. Then, the third if statement will fail if we try to mmap more than the said allowed bytes. However, let's take another scenario, where we try to mmap from 0xf0000 - but we try to mmap less than 131072 - but more than 65536. In such case, we again pass the first two if statements, but the third one is passed two, because it doesn't take into account the offseted address from the start of the reserved range (0xe0000). In such case, a user can easily mmap 65535 bytes above 0x100000. This might seem negligible. However, it's still a severe bug that can theoretically be exploited into a info leak or tampering with important kernel structures.
2021-10-22 08:59:31 +00:00
[[nodiscard]] bool offset_addition_would_overflow(PhysicalPtr o) const { return Checked<PhysicalPtr>::addition_would_overflow(m_address, o); }
Kernel: Use PAE to allow accessing all physical memory beyond 4GB We already use PAE for the NX bit, but this changes the PhysicalAddress structure to be able to hold 64 bit physical addresses. This allows us to use all the available physical memory.
2021-07-07 03:35:15 +00:00
[[nodiscard]] PhysicalPtr get() const { return m_address; }
void set(PhysicalPtr address) { m_address = address; }
void mask(PhysicalPtr m) { m_address &= m; }
LibBareMetal: Add Memory definitions Add classes of VirtualAddress & PhysicalAddress.
2020-02-09 16:00:00 +00:00
Kernel: Mark PhysicalAddress/VirtualAddress getters as [[nodiscard]] There is no reason to call a getter without observing the result, doing so indicates an error in the code. Mark these methods as [[nodiscard]] to find these cases.
2021-02-14 23:18:35 +00:00
[[nodiscard]] bool is_null() const { return m_address == 0; }
LibBareMetal: Add Memory definitions Add classes of VirtualAddress & PhysicalAddress.
2020-02-09 16:00:00 +00:00
Kernel: Resolve clang-tidy readability-make-member-function-const ... In files included from Kernel/Thread.cpp or Kernel/Process.cpp Some places the warning is suppressed, because we do not want a const object do have non-const access to the returned sub-object.
2021-10-31 21:54:39 +00:00
// NOLINTNEXTLINE(readability-make-member-function-const) const PhysicalAddress shouldn't be allowed to modify the underlying memory
Kernel: Mark PhysicalAddress/VirtualAddress getters as [[nodiscard]] There is no reason to call a getter without observing the result, doing so indicates an error in the code. Mark these methods as [[nodiscard]] to find these cases.
2021-02-14 23:18:35 +00:00
[[nodiscard]] u8* as_ptr() { return reinterpret_cast<u8*>(m_address); }
Kernel: Resolve clang-tidy readability-make-member-function-const ... In files included from Kernel/Thread.cpp or Kernel/Process.cpp Some places the warning is suppressed, because we do not want a const object do have non-const access to the returned sub-object.
2021-10-31 21:54:39 +00:00
[[nodiscard]] const u8* as_ptr() const { return reinterpret_cast<u8 const*>(m_address); }
LibBareMetal: Add Memory definitions Add classes of VirtualAddress & PhysicalAddress.
2020-02-09 16:00:00 +00:00
Kernel: Use PAE to allow accessing all physical memory beyond 4GB We already use PAE for the NX bit, but this changes the PhysicalAddress structure to be able to hold 64 bit physical addresses. This allows us to use all the available physical memory.
2021-07-07 03:35:15 +00:00
[[nodiscard]] PhysicalAddress page_base() const { return PhysicalAddress(physical_page_base(m_address)); }
[[nodiscard]] PhysicalPtr offset_in_page() const { return PhysicalAddress(m_address & 0xfff).get(); }
LibBareMetal: Add Memory definitions Add classes of VirtualAddress & PhysicalAddress.
2020-02-09 16:00:00 +00:00
bool operator==(const PhysicalAddress& other) const { return m_address == other.m_address; }
bool operator!=(const PhysicalAddress& other) const { return m_address != other.m_address; }
bool operator>(const PhysicalAddress& other) const { return m_address > other.m_address; }
bool operator>=(const PhysicalAddress& other) const { return m_address >= other.m_address; }
bool operator<(const PhysicalAddress& other) const { return m_address < other.m_address; }
bool operator<=(const PhysicalAddress& other) const { return m_address <= other.m_address; }
private:
Kernel: Use PAE to allow accessing all physical memory beyond 4GB We already use PAE for the NX bit, but this changes the PhysicalAddress structure to be able to hold 64 bit physical addresses. This allows us to use all the available physical memory.
2021-07-07 03:35:15 +00:00
PhysicalPtr m_address { 0 };
LibBareMetal: Add Memory definitions Add classes of VirtualAddress & PhysicalAddress.
2020-02-09 16:00:00 +00:00
};
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-08 23:42:44 +00:00
template<>
struct AK::Formatter<PhysicalAddress> : AK::Formatter<FormatString> {
AK: Convert AK::Format formatting helpers to returning ErrorOr<void> This isn't a complete conversion to ErrorOr<void>, but a good chunk. The end goal here is to propagate buffer allocation failures to the caller, and allow the use of TRY() with formatting functions.
2021-11-16 00:15:21 +00:00
ErrorOr<void> format(FormatBuilder& builder, PhysicalAddress value)
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-08 23:42:44 +00:00
{
Kernel: Use PAE to allow accessing all physical memory beyond 4GB We already use PAE for the NX bit, but this changes the PhysicalAddress structure to be able to hold 64 bit physical addresses. This allows us to use all the available physical memory.
2021-07-07 03:35:15 +00:00
if constexpr (sizeof(PhysicalPtr) == sizeof(u64))
return AK::Formatter<FormatString>::format(builder, "P{:016x}", value.get());
else
return AK::Formatter<FormatString>::format(builder, "P{}", value.as_ptr());
Everywhere: Replace a bundle of dbg with dbgln. These changes are arbitrarily divided into multiple commits to make it easier to find potentially introduced bugs with git bisect.
2021-01-08 23:42:44 +00:00
}
};
Reference in a new issue Copy permalink