mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2025-05-25 12:14:24 -04:00
meso: skeleton libmesosphere in prep for kernelldr dev
This commit is contained in:
Michael Scire
SciresM
parent
0b0fdc5c58
commit
36c47a0014
22 changed files with 732 additions and 13 deletions
|
|
@ -0,0 +1,28 @@
|
|||
/*
|
||||
* Copyright (c) 2018-2019 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <vapours.hpp>
|
||||
|
||||
namespace ams::kern {
|
||||
|
||||
class KSystemControl {
|
||||
public:
|
||||
|
||||
/* Panic. */
|
||||
static NORETURN void StopSystem();
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,240 @@
|
|||
/*
|
||||
* Copyright (c) 2018-2019 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <vapours.hpp>
|
||||
|
||||
namespace ams::kern {
|
||||
|
||||
#ifndef MESOSPHERE_DISABLE_TYPED_ADDRESSES
|
||||
|
||||
template<bool Virtual, typename T>
|
||||
class KTypedAddress {
|
||||
private:
|
||||
uintptr_t address;
|
||||
public:
|
||||
/* Constructors. */
|
||||
constexpr ALWAYS_INLINE KTypedAddress() : address(0) { /* ... */ }
|
||||
constexpr ALWAYS_INLINE KTypedAddress(uintptr_t a) : address(a) { /* ... */ }
|
||||
template<typename U>
|
||||
constexpr ALWAYS_INLINE explicit KTypedAddress(U *ptr) : address(reinterpret_cast<uintptr_t>(ptr)) { /* ... */ }
|
||||
|
||||
/* Assignment operator. */
|
||||
constexpr ALWAYS_INLINE KTypedAddress operator=(KTypedAddress rhs) {
|
||||
this->address = rhs.address;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/* Arithmetic operators. */
|
||||
template<typename I>
|
||||
constexpr ALWAYS_INLINE KTypedAddress operator+(I rhs) const {
|
||||
static_assert(std::is_integral<I>::value);
|
||||
return this->address + rhs;
|
||||
}
|
||||
|
||||
template<typename I>
|
||||
constexpr ALWAYS_INLINE KTypedAddress operator-(I rhs) const {
|
||||
static_assert(std::is_integral<I>::value);
|
||||
return this->address - rhs;
|
||||
}
|
||||
|
||||
template<typename I>
|
||||
constexpr ALWAYS_INLINE KTypedAddress operator+=(I rhs) {
|
||||
static_assert(std::is_integral<I>::value);
|
||||
this->address += rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename I>
|
||||
constexpr ALWAYS_INLINE KTypedAddress operator-=(I rhs) {
|
||||
static_assert(std::is_integral<I>::value);
|
||||
this->address -= rhs;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/* Logical operators. */
|
||||
constexpr ALWAYS_INLINE uintptr_t operator&(uintptr_t mask) const {
|
||||
return this->address & mask;
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE uintptr_t operator|(uintptr_t mask) const {
|
||||
return this->address | mask;
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE uintptr_t operator<<(int shift) const {
|
||||
return this->address << shift;
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE uintptr_t operator>>(int shift) const {
|
||||
return this->address >> shift;
|
||||
}
|
||||
|
||||
/* Comparison operators. */
|
||||
constexpr ALWAYS_INLINE bool operator==(KTypedAddress rhs) const {
|
||||
return this->address == rhs.address;
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE bool operator!=(KTypedAddress rhs) const {
|
||||
return this->address != rhs.address;
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE bool operator<(KTypedAddress rhs) const {
|
||||
return this->address < rhs.address;
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE bool operator<=(KTypedAddress rhs) const {
|
||||
return this->address <= rhs.address;
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE bool operator>(KTypedAddress rhs) const {
|
||||
return this->address > rhs.address;
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE bool operator>=(KTypedAddress rhs) const {
|
||||
return this->address >= rhs.address;
|
||||
}
|
||||
|
||||
/* For convenience, also define comparison operators versus uintptr_t. */
|
||||
constexpr ALWAYS_INLINE bool operator==(uintptr_t rhs) const {
|
||||
return this->address == rhs;
|
||||
}
|
||||
|
||||
constexpr ALWAYS_INLINE bool operator!=(uintptr_t rhs) const {
|
||||
return this->address != rhs;
|
||||
}
|
||||
|
||||
/* TODO: <, <=, >, >= against uintptr_t? would need to be declared outside of class. Maybe worth it. */
|
||||
|
||||
/* Allow getting the address explicitly, for use in accessors. */
|
||||
constexpr ALWAYS_INLINE uintptr_t GetValue() const {
|
||||
return this->address;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
struct KPhysicalAddressTag{};
|
||||
struct KVirtualAddressTag{};
|
||||
struct KProcessAddressTag{};
|
||||
|
||||
using KPhysicalAddress = KTypedAddress<false, KPhysicalAddressTag>;
|
||||
using KVirtualAddress = KTypedAddress<true, KVirtualAddressTag>;
|
||||
using KProcessAddress = KTypedAddress<true, KProcessAddressTag>;
|
||||
|
||||
/* Define accessors. */
|
||||
template<bool Virtual, typename T>
|
||||
constexpr ALWAYS_INLINE uintptr_t GetInteger(KTypedAddress<Virtual, T> address) {
|
||||
return address.GetValue();
|
||||
}
|
||||
|
||||
template<typename T, typename U>
|
||||
constexpr ALWAYS_INLINE T *GetPointer(KTypedAddress<true, U> address) {
|
||||
return CONST_FOLD(reinterpret_cast<T *>(address.GetValue()));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr ALWAYS_INLINE void *GetVoidPointer(KTypedAddress<true, T> address) {
|
||||
return CONST_FOLD(reinterpret_cast<void *>(address.GetValue()));
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* Plausibly, we may not want compiler overhead from using strongly typed addresses. */
|
||||
/* In this case, we should just use uintptr_t. */
|
||||
using KPhysicalAddress = uintptr_t;
|
||||
using KVirtualAddress = uintptr_t;
|
||||
using KProcessAddress = uintptr_t;
|
||||
|
||||
/* Define accessors. */
|
||||
constexpr ALWAYS_INLINE uintptr_t GetInteger(uintptr_t address) {
|
||||
return address;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr ALWAYS_INLINE T *GetPointer(uintptr_t address) {
|
||||
return CONST_FOLD(reinterpret_cast<T *>(address));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr ALWAYS_INLINE void *GetVoidPointer(uintptr_t address) {
|
||||
return CONST_FOLD(reinterpret_cast<void *>(address));
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
template<typename T>
|
||||
constexpr inline T Null = [] {
|
||||
if constexpr (std::is_same<T, uintptr_t>::value) {
|
||||
return 0;
|
||||
} else {
|
||||
static_assert(std::is_same<T, KPhysicalAddress>::value ||
|
||||
std::is_same<T, KVirtualAddress>::value ||
|
||||
std::is_same<T, KProcessAddress>::value);
|
||||
return T(0);
|
||||
}
|
||||
}();
|
||||
|
||||
/* Basic type validations. */
|
||||
static_assert(sizeof(KPhysicalAddress) == sizeof(uintptr_t));
|
||||
static_assert(sizeof(KVirtualAddress) == sizeof(uintptr_t));
|
||||
static_assert(sizeof(KProcessAddress) == sizeof(uintptr_t));
|
||||
|
||||
static_assert(std::is_trivially_destructible<KPhysicalAddress>::value);
|
||||
static_assert(std::is_trivially_destructible<KVirtualAddress>::value);
|
||||
static_assert(std::is_trivially_destructible<KProcessAddress>::value);
|
||||
|
||||
static_assert(Null<uintptr_t> == 0);
|
||||
static_assert(Null<KPhysicalAddress> == Null<uintptr_t>);
|
||||
static_assert(Null<KVirtualAddress> == Null<uintptr_t>);
|
||||
static_assert(Null<KProcessAddress> == Null<uintptr_t>);
|
||||
|
||||
/* Arithmetic validations. */
|
||||
static_assert(KPhysicalAddress(10) + 5 == KPhysicalAddress(15));
|
||||
static_assert(KPhysicalAddress(10) - 5 == KPhysicalAddress(5));
|
||||
static_assert([]{ KPhysicalAddress v(10); v += 5; return v; }() == KPhysicalAddress(15));
|
||||
static_assert([]{ KPhysicalAddress v(10); v -= 5; return v; }() == KPhysicalAddress(5));
|
||||
|
||||
/* Logical validations. */
|
||||
static_assert((KPhysicalAddress(0b11111111) >> 1) == 0b01111111);
|
||||
static_assert((KPhysicalAddress(0b10101010) >> 1) == 0b01010101);
|
||||
static_assert((KPhysicalAddress(0b11111111) << 1) == 0b111111110);
|
||||
static_assert((KPhysicalAddress(0b01010101) << 1) == 0b10101010);
|
||||
static_assert((KPhysicalAddress(0b11111111) & 0b01010101) == 0b01010101);
|
||||
static_assert((KPhysicalAddress(0b11111111) & 0b10101010) == 0b10101010);
|
||||
static_assert((KPhysicalAddress(0b01010101) & 0b10101010) == 0b00000000);
|
||||
static_assert((KPhysicalAddress(0b00000000) | 0b01010101) == 0b01010101);
|
||||
static_assert((KPhysicalAddress(0b11111111) | 0b01010101) == 0b11111111);
|
||||
static_assert((KPhysicalAddress(0b10101010) | 0b01010101) == 0b11111111);
|
||||
|
||||
/* Comparisons. */
|
||||
static_assert(KPhysicalAddress(0) == KPhysicalAddress(0));
|
||||
static_assert(KPhysicalAddress(0) != KPhysicalAddress(1));
|
||||
static_assert(KPhysicalAddress(0) < KPhysicalAddress(1));
|
||||
static_assert(KPhysicalAddress(0) <= KPhysicalAddress(1));
|
||||
static_assert(KPhysicalAddress(1) > KPhysicalAddress(0));
|
||||
static_assert(KPhysicalAddress(1) >= KPhysicalAddress(0));
|
||||
|
||||
static_assert(!(KPhysicalAddress(0) == KPhysicalAddress(1)));
|
||||
static_assert(!(KPhysicalAddress(0) != KPhysicalAddress(0)));
|
||||
static_assert(!(KPhysicalAddress(1) < KPhysicalAddress(0)));
|
||||
static_assert(!(KPhysicalAddress(1) <= KPhysicalAddress(0)));
|
||||
static_assert(!(KPhysicalAddress(0) > KPhysicalAddress(1)));
|
||||
static_assert(!(KPhysicalAddress(0) >= KPhysicalAddress(1)));
|
||||
|
||||
/* Accessors. */
|
||||
static_assert(15 == GetInteger(KPhysicalAddress(15)));
|
||||
static_assert(0 == GetInteger(Null<KPhysicalAddress>));
|
||||
/* TODO: reinterpret_cast<> not valid in a constant expression, can't test get pointers. */
|
||||
|
||||
}
|
||||
53
libraries/libmesosphere/include/mesosphere/kern_panic.hpp
Normal file
53
libraries/libmesosphere/include/mesosphere/kern_panic.hpp
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
/*
|
||||
* Copyright (c) 2018-2019 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
#pragma once
|
||||
#include <vapours.hpp>
|
||||
|
||||
namespace ams::kern {
|
||||
|
||||
NORETURN void Panic(const char *file, int line, const char *format, ...);
|
||||
NORETURN void Panic();
|
||||
|
||||
}
|
||||
|
||||
#ifdef MESOSPHERE_ENABLE_DEBUG_PRINT
|
||||
#define MESOSPHERE_PANIC(...) ams::kern::Panic(__FILE__, __LINE__, __VA_ARGS__)
|
||||
#else
|
||||
#define MESOSPHERE_PANIC(...) ams::kern::Panic()
|
||||
#endif
|
||||
|
||||
#ifdef MESOSPHERE_ENABLE_ASSERTIONS
|
||||
#define MESOSPHERE_ASSERT_IMPL(expr, ...) \
|
||||
({ \
|
||||
if (AMS_UNLIKELY(!expr)) { \
|
||||
MESOSPHERE_PANIC(__VA_ARGS__); \
|
||||
} \
|
||||
})
|
||||
#else
|
||||
#define MESOSPHERE_ASSERT_IMPL(expr, ...) do { } while (0)
|
||||
#endif
|
||||
|
||||
#define MESOSPHERE_ASSERT(expr) MESOSPHERE_ASSERT_IMPL(expr, "Assertion failed: %s", #expr)
|
||||
#define MESOSPHERE_R_ASSERT(expr) MESOSPHERE_ASSERT_IMPL(R_SUCCEEDED(expr), "Result assertion failed: %s", #expr)
|
||||
|
||||
#define MESOSPHERE_ABORT() MESOSPHERE_PANIC("Abort()");
|
||||
|
||||
#define MESOSPHERE_ABORT_UNLESS(expr) \
|
||||
({ \
|
||||
if (AMS_UNLIKELY(!expr)) { \
|
||||
MESOSPHERE_PANIC("Abort(): %s", #expr); \
|
||||
} \
|
||||
})
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
/*
|
||||
* Copyright (c) 2018-2019 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
#pragma once
|
||||
|
||||
#ifdef ATMOSPHERE_BOARD_NINTENDO_SWITCH
|
||||
#include "board/nintendo/switch/kern_k_system_control.hpp"
|
||||
#else
|
||||
#error "Unknown board for KSystemControl"
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue