citra/src/core/hle/ipc_helpers.h

437 lines
14 KiB
C
Raw Normal View History

2016-12-26 13:39:45 +01:00
// Copyright 2016 Citra Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#pragma once
#include <array>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
2016-12-26 13:39:45 +01:00
#include "core/hle/ipc.h"
#include "core/hle/kernel/hle_ipc.h"
2016-12-26 13:39:45 +01:00
#include "core/hle/kernel/kernel.h"
namespace IPC {
class RequestHelperBase {
protected:
Kernel::HLERequestContext* context;
2016-12-26 13:39:45 +01:00
u32* cmdbuf;
ptrdiff_t index = 1;
Header header;
public:
RequestHelperBase(Kernel::HLERequestContext& context, Header desired_header)
: context(&context), cmdbuf(context.CommandBuffer()), header(desired_header) {}
2016-12-26 13:39:45 +01:00
/// Returns the total size of the request in words
size_t TotalSize() const {
return 1 /* command header */ + header.normal_params_size + header.translate_params_size;
}
void ValidateHeader() {
DEBUG_ASSERT_MSG(index == TotalSize(), "Operations do not match the header (cmd {:#x})",
2016-12-26 13:39:45 +01:00
header.raw);
}
void Skip(unsigned size_in_words, bool set_to_null) {
if (set_to_null)
memset(cmdbuf + index, 0, size_in_words * sizeof(u32));
index += size_in_words;
}
2016-12-26 13:39:45 +01:00
};
class RequestBuilder : public RequestHelperBase {
public:
RequestBuilder(Kernel::HLERequestContext& context, Header command_header)
: RequestHelperBase(context, command_header) {
// From this point we will start overwriting the existing command buffer, so it's safe to
// release all previous incoming Object pointers since they won't be usable anymore.
context.ClearIncomingObjects();
cmdbuf[0] = header.raw;
}
RequestBuilder(Kernel::HLERequestContext& context, u16 command_id, unsigned normal_params_size,
unsigned translate_params_size)
: RequestBuilder(
context, Header{MakeHeader(command_id, normal_params_size, translate_params_size)}) {}
2016-12-26 13:39:45 +01:00
// Validate on destruction, as there shouldn't be any case where we don't want it
~RequestBuilder() {
ValidateHeader();
}
template <typename T>
void Push(T value);
template <typename First, typename... Other>
void Push(const First& first_value, const Other&... other_values);
2016-12-26 13:39:45 +01:00
template <typename T>
void PushEnum(T value) {
static_assert(std::is_enum<T>(), "T must be an enum type within a PushEnum call.");
static_assert(!std::is_convertible<T, int>(),
"enum type in PushEnum must be a strongly typed enum.");
static_assert(sizeof(value) < sizeof(u64), "64-bit enums may not be pushed.");
Push(static_cast<std::underlying_type_t<T>>(value));
}
2016-12-26 13:39:45 +01:00
/**
* @brief Copies the content of the given trivially copyable class to the buffer as a normal
* param
* @note: The input class must be correctly packed/padded to fit hardware layout.
*/
template <typename T>
void PushRaw(const T& value);
2016-12-26 13:39:45 +01:00
// TODO : ensure that translate params are added after all regular params
template <typename... O>
void PushCopyObjects(Kernel::SharedPtr<O>... pointers);
template <typename... O>
void PushMoveObjects(Kernel::SharedPtr<O>... pointers);
void PushStaticBuffer(const std::vector<u8>& buffer, u8 buffer_id);
2016-12-26 13:39:45 +01:00
/// Pushes an HLE MappedBuffer interface back to unmapped the buffer.
void PushMappedBuffer(const Kernel::MappedBuffer& mapped_buffer);
private:
template <typename... H>
void PushCopyHLEHandles(H... handles);
template <typename... H>
void PushMoveHLEHandles(H... handles);
2016-12-26 13:39:45 +01:00
};
2016-12-26 14:42:06 +01:00
/// Push ///
template <>
inline void RequestBuilder::Push(u32 value) {
cmdbuf[index++] = value;
}
template <>
inline void RequestBuilder::Push(s32 value) {
cmdbuf[index++] = static_cast<u32>(value);
}
template <typename T>
void RequestBuilder::PushRaw(const T& value) {
static_assert(std::is_trivially_copyable<T>(), "Raw types should be trivially copyable");
std::memcpy(cmdbuf + index, &value, sizeof(T));
index += (sizeof(T) + 3) / 4; // round up to word length
}
template <>
inline void RequestBuilder::Push(u8 value) {
PushRaw(value);
}
template <>
inline void RequestBuilder::Push(u16 value) {
PushRaw(value);
2016-12-26 14:42:06 +01:00
}
template <>
inline void RequestBuilder::Push(u64 value) {
2016-12-26 14:42:06 +01:00
Push(static_cast<u32>(value));
Push(static_cast<u32>(value >> 32));
}
template <>
inline void RequestBuilder::Push(bool value) {
2017-02-11 15:07:12 +01:00
Push(static_cast<u8>(value));
}
template <>
inline void RequestBuilder::Push(ResultCode value) {
2016-12-26 14:42:06 +01:00
Push(value.raw);
}
template <typename First, typename... Other>
void RequestBuilder::Push(const First& first_value, const Other&... other_values) {
Push(first_value);
Push(other_values...);
}
template <typename... H>
inline void RequestBuilder::PushCopyHLEHandles(H... handles) {
Push(CopyHandleDesc(sizeof...(H)));
Push(static_cast<u32>(handles)...);
}
template <typename... H>
inline void RequestBuilder::PushMoveHLEHandles(H... handles) {
Push(MoveHandleDesc(sizeof...(H)));
Push(static_cast<u32>(handles)...);
}
template <typename... O>
inline void RequestBuilder::PushCopyObjects(Kernel::SharedPtr<O>... pointers) {
PushCopyHLEHandles(context->AddOutgoingHandle(std::move(pointers))...);
}
template <typename... O>
inline void RequestBuilder::PushMoveObjects(Kernel::SharedPtr<O>... pointers) {
PushMoveHLEHandles(context->AddOutgoingHandle(std::move(pointers))...);
}
inline void RequestBuilder::PushStaticBuffer(const std::vector<u8>& buffer, u8 buffer_id) {
ASSERT_MSG(buffer_id < MAX_STATIC_BUFFERS, "Invalid static buffer id");
Push(StaticBufferDesc(buffer.size(), buffer_id));
// This address will be replaced by the correct static buffer address during IPC translation.
Push<VAddr>(0xDEADC0DE);
context->AddStaticBuffer(buffer_id, buffer);
}
inline void RequestBuilder::PushMappedBuffer(const Kernel::MappedBuffer& mapped_buffer) {
Push(mapped_buffer.GenerateDescriptor());
Push(mapped_buffer.GetId());
}
2016-12-26 13:39:45 +01:00
class RequestParser : public RequestHelperBase {
public:
RequestParser(Kernel::HLERequestContext& context, Header desired_header)
: RequestHelperBase(context, desired_header) {}
RequestParser(Kernel::HLERequestContext& context, u16 command_id, unsigned normal_params_size,
unsigned translate_params_size)
: RequestParser(context,
Header{MakeHeader(command_id, normal_params_size, translate_params_size)}) {
}
2016-12-26 13:39:45 +01:00
RequestBuilder MakeBuilder(u32 normal_params_size, u32 translate_params_size,
bool validateHeader = true) {
if (validateHeader)
ValidateHeader();
2017-09-27 01:26:09 +02:00
Header builderHeader{MakeHeader(static_cast<u16>(header.command_id), normal_params_size,
translate_params_size)};
return {*context, builderHeader};
2016-12-26 13:39:45 +01:00
}
template <typename T>
T Pop();
template <typename T>
2016-12-26 14:42:06 +01:00
void Pop(T& value);
2016-12-26 13:39:45 +01:00
template <typename First, typename... Other>
2016-12-26 14:42:06 +01:00
void Pop(First& first_value, Other&... other_values);
2016-12-26 13:39:45 +01:00
template <typename T>
T PopEnum() {
static_assert(std::is_enum<T>(), "T must be an enum type within a PopEnum call.");
static_assert(!std::is_convertible<T, int>(),
"enum type in PopEnum must be a strongly typed enum.");
static_assert(sizeof(T) < sizeof(u64), "64-bit enums cannot be popped.");
return static_cast<T>(Pop<std::underlying_type_t<T>>());
}
/// Equivalent to calling `PopGenericObjects<1>()[0]`.
Kernel::SharedPtr<Kernel::Object> PopGenericObject();
/// Equivalent to calling `std::get<0>(PopObjects<T>())`.
template <typename T>
Kernel::SharedPtr<T> PopObject();
/**
* Pop a descriptor containing `N` handles and resolves them to Kernel::Object pointers. If a
* handle is invalid, null is returned for that object instead. The descriptor must contain
* exactly `N` handles, it is not permitted to, for example, call PopGenericObjects<1>() twice
* to read a multi-handle descriptor with 2 handles, or to make a single PopGenericObjects<2>()
* call to read 2 single-handle descriptors.
*/
template <unsigned int N>
std::array<Kernel::SharedPtr<Kernel::Object>, N> PopGenericObjects();
/**
* Resolves handles to Kernel::Objects as in PopGenericsObjects(), but then also casts them to
* the passed `T` types, while verifying that the cast is valid. If the type of an object does
* not match, null is returned instead.
*/
template <typename... T>
std::tuple<Kernel::SharedPtr<T>...> PopObjects();
/// Convenience wrapper around PopObjects() which assigns the handles to the passed references.
template <typename... T>
void PopObjects(Kernel::SharedPtr<T>&... pointers) {
std::tie(pointers...) = PopObjects<T...>();
}
2016-12-26 13:39:45 +01:00
u32 PopPID();
/**
* @brief Pops a static buffer from the IPC request buffer.
* @return The buffer that was copied from the IPC request originator.
*
* In real services, static buffers must be set up before any IPC request using those is sent.
* It is the duty of the process (usually services) to allocate and set up the receiving static
* buffer information. Our HLE services do not need to set up the buffers beforehand.
*/
const std::vector<u8>& PopStaticBuffer();
2016-12-26 13:39:45 +01:00
/// Pops a mapped buffer descriptor with its vaddr and resolves it to an HLE interface
Kernel::MappedBuffer& PopMappedBuffer();
2016-12-26 13:39:45 +01:00
/**
* @brief Reads the next normal parameters as a struct, by copying it
* @note: The output class must be correctly packed/padded to fit hardware layout.
*/
template <typename T>
2016-12-26 14:42:06 +01:00
void PopRaw(T& value);
/**
* @brief Reads the next normal parameters as a struct, by copying it into a new value
* @note: The output class must be correctly packed/padded to fit hardware layout.
*/
template <typename T>
T PopRaw();
private:
template <unsigned int N>
std::array<u32, N> PopHLEHandles();
2016-12-26 13:39:45 +01:00
};
/// Pop ///
template <>
inline u32 RequestParser::Pop() {
2016-12-26 13:39:45 +01:00
return cmdbuf[index++];
}
template <typename T>
void RequestParser::PopRaw(T& value) {
static_assert(std::is_trivially_copyable<T>(), "Raw types should be trivially copyable");
std::memcpy(&value, cmdbuf + index, sizeof(T));
index += (sizeof(T) + 3) / 4; // round up to word length
}
template <typename T>
T RequestParser::PopRaw() {
T value;
PopRaw(value);
return value;
}
2016-12-26 13:39:45 +01:00
template <>
inline u8 RequestParser::Pop() {
return PopRaw<u8>();
}
template <>
inline u16 RequestParser::Pop() {
return PopRaw<u16>();
}
template <>
inline u64 RequestParser::Pop() {
2016-12-26 13:39:45 +01:00
const u64 lsw = Pop<u32>();
const u64 msw = Pop<u32>();
return msw << 32 | lsw;
}
template <>
inline s32 RequestParser::Pop() {
s32_le data = PopRaw<s32_le>();
return data;
}
2016-12-26 13:39:45 +01:00
template <>
inline bool RequestParser::Pop() {
2017-02-11 15:07:12 +01:00
return Pop<u8>() != 0;
}
template <>
inline ResultCode RequestParser::Pop() {
2016-12-26 13:39:45 +01:00
return ResultCode{Pop<u32>()};
}
2016-12-26 14:42:06 +01:00
template <typename T>
void RequestParser::Pop(T& value) {
value = Pop<T>();
}
2016-12-26 13:39:45 +01:00
template <typename First, typename... Other>
2016-12-26 14:42:06 +01:00
void RequestParser::Pop(First& first_value, Other&... other_values) {
first_value = Pop<First>();
Pop(other_values...);
2016-12-26 13:39:45 +01:00
}
template <unsigned int N>
std::array<u32, N> RequestParser::PopHLEHandles() {
u32 handle_descriptor = Pop<u32>();
ASSERT_MSG(IsHandleDescriptor(handle_descriptor),
"Tried to pop handle(s) but the descriptor is not a handle descriptor");
ASSERT_MSG(N == HandleNumberFromDesc(handle_descriptor),
"Number of handles doesn't match the descriptor");
std::array<u32, N> handles{};
for (u32& handle : handles) {
handle = Pop<u32>();
}
return handles;
}
inline Kernel::SharedPtr<Kernel::Object> RequestParser::PopGenericObject() {
auto [handle] = PopHLEHandles<1>();
return context->GetIncomingHandle(handle);
}
template <typename T>
Kernel::SharedPtr<T> RequestParser::PopObject() {
return Kernel::DynamicObjectCast<T>(PopGenericObject());
}
template <unsigned int N>
inline std::array<Kernel::SharedPtr<Kernel::Object>, N> RequestParser::PopGenericObjects() {
std::array<u32, N> handles = PopHLEHandles<N>();
std::array<Kernel::SharedPtr<Kernel::Object>, N> pointers;
for (int i = 0; i < N; ++i) {
pointers[i] = context->GetIncomingHandle(handles[i]);
}
return pointers;
}
namespace detail {
template <typename... T, size_t... I>
std::tuple<Kernel::SharedPtr<T>...> PopObjectsHelper(
std::array<Kernel::SharedPtr<Kernel::Object>, sizeof...(T)>&& pointers,
std::index_sequence<I...>) {
return std::make_tuple(Kernel::DynamicObjectCast<T>(std::move(pointers[I]))...);
}
} // namespace detail
template <typename... T>
inline std::tuple<Kernel::SharedPtr<T>...> RequestParser::PopObjects() {
return detail::PopObjectsHelper<T...>(PopGenericObjects<sizeof...(T)>(),
std::index_sequence_for<T...>{});
2016-12-26 14:42:06 +01:00
}
inline u32 RequestParser::PopPID() {
ASSERT(Pop<u32>() == static_cast<u32>(DescriptorType::CallingPid));
return Pop<u32>();
}
inline const std::vector<u8>& RequestParser::PopStaticBuffer() {
const u32 sbuffer_descriptor = Pop<u32>();
// Pop the address from the incoming request buffer
Pop<VAddr>();
StaticBufferDescInfo buffer_info{sbuffer_descriptor};
return context->GetStaticBuffer(buffer_info.buffer_id);
2016-12-26 14:42:06 +01:00
}
inline Kernel::MappedBuffer& RequestParser::PopMappedBuffer() {
u32 mapped_buffer_descriptor = Pop<u32>();
ASSERT_MSG(GetDescriptorType(mapped_buffer_descriptor) == MappedBuffer,
"Tried to pop mapped buffer but the descriptor is not a mapped buffer descriptor");
return context->GetMappedBuffer(Pop<u32>());
}
2016-12-26 13:39:45 +01:00
} // namespace IPC