yuzu-emu
/
yuzu-mainline
Archived
1
0
Fork 0
Code

IPC Cleanup: Remove 3DS-specific code and translate copy, move and domain objects in IPC requests. 

Popping objects from the buffer is still not implemented.
This commit is contained in:
Subv 2018-01-07 01:50:55 -05:00 committed by bunnei
parent b0ceb4df70
commit 0368324f79
8 changed files with 116 additions and 403 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
src/core/hle/ipc.h
View File

@ -143,120 +143,25 @@ struct DataPayloadHeader {
}; };
static_assert(sizeof(DataPayloadHeader) == 8, "DataPayloadRequest size is incorrect"); static_assert(sizeof(DataPayloadHeader) == 8, "DataPayloadRequest size is incorrect");
struct DomainRequestMessageHeader { struct DomainMessageHeader {
union { union {
BitField<0, 8, u32_le> command; // Used when responding to an IPC request, Server -> Client.
BitField<16, 16, u32_le> size; struct {
u32_le num_objects;
INSERT_PADDING_WORDS(3);
};
// Used when performing an IPC request, Client -> Server.
struct {
union {
BitField<0, 8, u32_le> command;
BitField<16, 16, u32_le> size;
};
u32_le object_id;
INSERT_PADDING_WORDS(2);
};
}; };
u32_le object_id;
INSERT_PADDING_WORDS(2);
}; };
static_assert(sizeof(DomainRequestMessageHeader) == 16, "DomainRequestMessageHeader size is incorrect"); static_assert(sizeof(DomainMessageHeader) == 16, "DomainMessageHeader size is incorrect");
struct DomainResponseMessageHeader {
u32_le num_objects;
INSERT_PADDING_WORDS(3);
};
static_assert(sizeof(DomainResponseMessageHeader) == 16, "DomainResponseMessageHeader size is incorrect");
enum DescriptorType : u32 {
// Buffer related desciptors types (mask : 0x0F)
StaticBuffer = 0x02,
PXIBuffer = 0x04,
MappedBuffer = 0x08,
// Handle related descriptors types (mask : 0x30, but need to check for buffer related
// descriptors first )
CopyHandle = 0x00,
MoveHandle = 0x10,
CallingPid = 0x20,
};
constexpr u32 MoveHandleDesc(u32 num_handles = 1) {
return MoveHandle | ((num_handles - 1) << 26);
}
constexpr u32 CopyHandleDesc(u32 num_handles = 1) {
return CopyHandle | ((num_handles - 1) << 26);
}
constexpr u32 CallingPidDesc() {
return CallingPid;
}
constexpr bool IsHandleDescriptor(u32 descriptor) {
return (descriptor & 0xF) == 0x0;
}
constexpr u32 HandleNumberFromDesc(u32 handle_descriptor) {
return (handle_descriptor >> 26) + 1;
}
union StaticBufferDescInfo {
u32 raw;
BitField<0, 4, u32> descriptor_type;
BitField<10, 4, u32> buffer_id;
BitField<14, 18, u32> size;
};
inline u32 StaticBufferDesc(size_t size, u8 buffer_id) {
StaticBufferDescInfo info{};
info.descriptor_type.Assign(StaticBuffer);
info.buffer_id.Assign(buffer_id);
info.size.Assign(static_cast<u32>(size));
return info.raw;
}
/**
* @brief Creates a header describing a buffer to be sent over PXI.
* @param size Size of the buffer. Max 0x00FFFFFF.
* @param buffer_id The Id of the buffer. Max 0xF.
* @param is_read_only true if the buffer is read-only. If false, the buffer is considered to have
* read-write access.
* @return The created PXI buffer header.
*
* The next value is a phys-address of a table located in the BASE memregion.
*/
inline u32 PXIBufferDesc(u32 size, unsigned buffer_id, bool is_read_only) {
u32 type = PXIBuffer;
if (is_read_only)
type |= 0x2;
return type | (size << 8) | ((buffer_id & 0xF) << 4);
}
enum MappedBufferPermissions : u32 {
R = 1,
W = 2,
RW = R | W,
};
union MappedBufferDescInfo {
u32 raw;
BitField<0, 4, u32> flags;
BitField<1, 2, MappedBufferPermissions> perms;
BitField<4, 28, u32> size;
};
inline u32 MappedBufferDesc(size_t size, MappedBufferPermissions perms) {
MappedBufferDescInfo info{};
info.flags.Assign(MappedBuffer);
info.perms.Assign(perms);
info.size.Assign(static_cast<u32>(size));
return info.raw;
}
inline DescriptorType GetDescriptorType(u32 descriptor) {
// Note: Those checks must be done in this order
if (IsHandleDescriptor(descriptor))
return (DescriptorType)(descriptor & 0x30);
// handle the fact that the following descriptors can have rights
if (descriptor & MappedBuffer)
return MappedBuffer;
if (descriptor & PXIBuffer)
return PXIBuffer;
return StaticBuffer;
}
} // namespace IPC } // namespace IPC

240
src/core/hle/ipc_helpers.h
View File

@ -58,18 +58,18 @@ public:
RequestBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {} RequestBuilder(u32* command_buffer) : RequestHelperBase(command_buffer) {}
RequestBuilder(Kernel::HLERequestContext& context, unsigned normal_params_size, RequestBuilder(Kernel::HLERequestContext& context, unsigned normal_params_size,
u32 num_handles_to_copy = 0, u32 num_handles_to_move = 0, u32 num_domain_objects = 0) u32 num_handles_to_copy = 0, u32 num_handles_to_move = 0,
u32 num_domain_objects = 0)
: RequestHelperBase(context) { : RequestHelperBase(context) {
memset(cmdbuf, 0, 64); memset(cmdbuf, 0, sizeof(u32) * IPC::COMMAND_BUFFER_LENGTH);
context.ClearIncomingObjects();
IPC::CommandHeader header{}; IPC::CommandHeader header{};
// The entire size of the raw data section in u32 units, including the 16 bytes of mandatory padding. // The entire size of the raw data section in u32 units, including the 16 bytes of mandatory
// padding.
u32 raw_data_size = sizeof(IPC::DataPayloadHeader) / 4 + 4 + normal_params_size; u32 raw_data_size = sizeof(IPC::DataPayloadHeader) / 4 + 4 + normal_params_size;
if (context.IsDomain()) if (context.IsDomain())
raw_data_size += sizeof(DomainResponseMessageHeader) / 4 + num_domain_objects; raw_data_size += sizeof(DomainMessageHeader) / 4 + num_domain_objects;
header.data_size.Assign(raw_data_size); header.data_size.Assign(raw_data_size);
if (num_handles_to_copy || num_handles_to_move) { if (num_handles_to_copy || num_handles_to_move) {
@ -88,7 +88,7 @@ public:
AlignWithPadding(); AlignWithPadding();
if (context.IsDomain()) { if (context.IsDomain()) {
IPC::DomainResponseMessageHeader domain_header{}; IPC::DomainMessageHeader domain_header{};
domain_header.num_objects = num_domain_objects; domain_header.num_objects = num_domain_objects;
PushRaw(domain_header); PushRaw(domain_header);
} }
@ -100,12 +100,7 @@ public:
template <class T> template <class T>
void PushIpcInterface() { void PushIpcInterface() {
auto& request_handlers = context->Domain()->request_handlers; context->AddDomainObject(std::make_shared<T>());
request_handlers.emplace_back(std::make_shared<T>());
Push(RESULT_SUCCESS);
Push<u32>(0); // The error code is the lower word of an u64, so we fill the rest with 0.
// Now push the id of the newly-added object.
Push<u32>(static_cast<u32>(request_handlers.size()));
} }
// Validate on destruction, as there shouldn't be any case where we don't want it // Validate on destruction, as there shouldn't be any case where we don't want it
@ -127,21 +122,11 @@ public:
template <typename T> template <typename T>
void PushRaw(const T& value); void PushRaw(const T& value);
// TODO : ensure that translate params are added after all regular params template <typename... O>
template <typename... H> void PushMoveObjects(Kernel::SharedPtr<O>... pointers);
void PushCopyHandles(H... handles);
template <typename... H>
void PushMoveHandles(H... handles);
template <typename... O> template <typename... O>
void PushObjects(Kernel::SharedPtr<O>... pointers); void PushCopyObjects(Kernel::SharedPtr<O>... pointers);
void PushCurrentPIDHandle();
void PushStaticBuffer(VAddr buffer_vaddr, size_t size, u8 buffer_id);
void PushMappedBuffer(VAddr buffer_vaddr, size_t size, MappedBufferPermissions perms);
}; };
/// Push /// /// Push ///
@ -189,37 +174,20 @@ void RequestBuilder::Push(const First& first_value, const Other&... other_values
Push(other_values...); Push(other_values...);
} }
template <typename... H> template <typename... O>
inline void RequestBuilder::PushCopyHandles(H... handles) { inline void RequestBuilder::PushCopyObjects(Kernel::SharedPtr<O>... pointers) {
Push(CopyHandleDesc(sizeof...(H))); auto objects = {pointers...};
Push(static_cast<Kernel::Handle>(handles)...); for (auto& object : objects) {
} context->AddCopyObject(std::move(object));
}
template <typename... H>
inline void RequestBuilder::PushMoveHandles(H... handles) {
Push(MoveHandleDesc(sizeof...(H)));
Push(static_cast<Kernel::Handle>(handles)...);
} }
template <typename... O> template <typename... O>
inline void RequestBuilder::PushObjects(Kernel::SharedPtr<O>... pointers) { inline void RequestBuilder::PushMoveObjects(Kernel::SharedPtr<O>... pointers) {
PushMoveHandles(context->AddOutgoingHandle(std::move(pointers))...); auto objects = {pointers...};
} for (auto& object : objects) {
context->AddMoveObject(std::move(object));
inline void RequestBuilder::PushCurrentPIDHandle() { }
Push(CallingPidDesc());
Push(u32(0));
}
inline void RequestBuilder::PushStaticBuffer(VAddr buffer_vaddr, size_t size, u8 buffer_id) {
Push(StaticBufferDesc(size, buffer_id));
Push(buffer_vaddr);
}
inline void RequestBuilder::PushMappedBuffer(VAddr buffer_vaddr, size_t size,
MappedBufferPermissions perms) {
Push(MappedBufferDesc(size, perms));
Push(buffer_vaddr);
} }
class RequestParser : public RequestHelperBase { class RequestParser : public RequestHelperBase {
@ -229,6 +197,9 @@ public:
RequestParser(Kernel::HLERequestContext& context) : RequestHelperBase(context) { RequestParser(Kernel::HLERequestContext& context) : RequestHelperBase(context) {
ASSERT_MSG(context.GetDataPayloadOffset(), "context is incomplete"); ASSERT_MSG(context.GetDataPayloadOffset(), "context is incomplete");
Skip(context.GetDataPayloadOffset(), false); Skip(context.GetDataPayloadOffset(), false);
// Skip the u64 command id, it's already stored in the context
static constexpr u32 CommandIdSize = 2;
Skip(CommandIdSize, false);
} }
RequestBuilder MakeBuilder(u32 normal_params_size, u32 num_handles_to_copy, RequestBuilder MakeBuilder(u32 normal_params_size, u32 num_handles_to_copy,
@ -249,80 +220,6 @@ public:
template <typename First, typename... Other> template <typename First, typename... Other>
void Pop(First& first_value, Other&... other_values); void Pop(First& first_value, Other&... other_values);
/// Equivalent to calling `PopHandles<1>()[0]`.
Kernel::Handle PopHandle();
/**
* Pops a descriptor containing `N` handles. The handles are returned as an array. The
* descriptor must contain exactly `N` handles, it is not permitted to, for example, call
* PopHandles<1>() twice to read a multi-handle descriptor with 2 handles, or to make a single
* PopHandles<2>() call to read 2 single-handle descriptors.
*/
template <unsigned int N>
std::array<Kernel::Handle, N> PopHandles();
/// Convenience wrapper around PopHandles() which assigns the handles to the passed references.
template <typename... H>
void PopHandles(H&... handles) {
std::tie(handles...) = PopHandles<sizeof...(H)>();
}
/// 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 same caveats from
* PopHandles() apply regarding `N` matching the number of handles in the descriptor.
*/
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...>();
}
/**
* @brief Pops the static buffer vaddr
* @return The virtual address of the buffer
* @param[out] data_size If non-null, the pointed value will be set to the size of the data
* @param[out] useStaticBuffersToGetVaddr Indicates if we should read the vaddr from the static
* buffers (which is the correct thing to do, but no service presently implement it) instead of
* using the same value as the process who sent the request
* given by the source process
*
* 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
* Please note that the setup uses virtual addresses.
*/
VAddr PopStaticBuffer(size_t* data_size = nullptr, bool useStaticBuffersToGetVaddr = false);
/**
* @brief Pops the mapped buffer vaddr
* @return The virtual address of the buffer
* @param[out] data_size If non-null, the pointed value will be set to the size of the data
* given by the source process
* @param[out] buffer_perms If non-null, the pointed value will be set to the permissions of the
* buffer
*/
VAddr PopMappedBuffer(size_t* data_size = nullptr,
MappedBufferPermissions* buffer_perms = nullptr);
/** /**
* @brief Reads the next normal parameters as a struct, by copying it * @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. * @note: The output class must be correctly packed/padded to fit hardware layout.
@ -396,91 +293,4 @@ void RequestParser::Pop(First& first_value, Other&... other_values) {
Pop(other_values...); Pop(other_values...);
} }
inline Kernel::Handle RequestParser::PopHandle() {
const u32 handle_descriptor = Pop<u32>();
DEBUG_ASSERT_MSG(IsHandleDescriptor(handle_descriptor),
"Tried to pop handle(s) but the descriptor is not a handle descriptor");
DEBUG_ASSERT_MSG(HandleNumberFromDesc(handle_descriptor) == 1,
"Descriptor indicates that there isn't exactly one handle");
return Pop<Kernel::Handle>();
}
template <unsigned int N>
std::array<Kernel::Handle, N> RequestParser::PopHandles() {
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<Kernel::Handle, N> handles{};
for (Kernel::Handle& handle : handles) {
handle = Pop<Kernel::Handle>();
}
return handles;
}
inline Kernel::SharedPtr<Kernel::Object> RequestParser::PopGenericObject() {
Kernel::Handle handle = PopHandle();
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<Kernel::Handle, N> handles = PopHandles<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...>{});
}
inline VAddr RequestParser::PopStaticBuffer(size_t* data_size, bool useStaticBuffersToGetVaddr) {
const u32 sbuffer_descriptor = Pop<u32>();
StaticBufferDescInfo bufferInfo{sbuffer_descriptor};
if (data_size != nullptr)
*data_size = bufferInfo.size;
if (!useStaticBuffersToGetVaddr)
return Pop<VAddr>();
else {
ASSERT_MSG(0, "remove the assert if multiprocess/IPC translation are implemented.");
// The buffer has already been copied to the static buffer by the kernel during
// translation
Pop<VAddr>(); // Pop the calling process buffer address
// and get the vaddr from the static buffers
return cmdbuf[(0x100 >> 2) + bufferInfo.buffer_id * 2 + 1];
}
}
inline VAddr RequestParser::PopMappedBuffer(size_t* data_size,
MappedBufferPermissions* buffer_perms) {
const u32 sbuffer_descriptor = Pop<u32>();
MappedBufferDescInfo bufferInfo{sbuffer_descriptor};
if (data_size != nullptr)
*data_size = bufferInfo.size;
if (buffer_perms != nullptr)
*buffer_perms = bufferInfo.perms;
return Pop<VAddr>();
}
} // namespace IPC } // namespace IPC

103
src/core/hle/kernel/hle_ipc.cpp
View File

@ -37,20 +37,6 @@ HLERequestContext::HLERequestContext(SharedPtr<Kernel::ServerSession> server_ses
HLERequestContext::~HLERequestContext() = default; HLERequestContext::~HLERequestContext() = default;
SharedPtr<Object> HLERequestContext::GetIncomingHandle(u32 id_from_cmdbuf) const {
ASSERT(id_from_cmdbuf < request_handles.size());
return request_handles[id_from_cmdbuf];
}
u32 HLERequestContext::AddOutgoingHandle(SharedPtr<Object> object) {
request_handles.push_back(std::move(object));
return static_cast<u32>(request_handles.size() - 1);
}
void HLERequestContext::ClearIncomingObjects() {
request_handles.clear();
}
void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) { void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
IPC::RequestParser rp(src_cmdbuf); IPC::RequestParser rp(src_cmdbuf);
command_header = std::make_unique<IPC::CommandHeader>(rp.PopRaw<IPC::CommandHeader>()); command_header = std::make_unique<IPC::CommandHeader>(rp.PopRaw<IPC::CommandHeader>());
@ -95,7 +81,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
// If this is an incoming message, only CommandType "Request" has a domain header // If this is an incoming message, only CommandType "Request" has a domain header
// All outgoing domain messages have the domain header // All outgoing domain messages have the domain header
domain_message_header = domain_message_header =
std::make_unique<IPC::DomainRequestMessageHeader>(rp.PopRaw<IPC::DomainRequestMessageHeader>()); std::make_unique<IPC::DomainMessageHeader>(rp.PopRaw<IPC::DomainMessageHeader>());
} }
data_payload_header = data_payload_header =
@ -107,61 +93,78 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
ASSERT(data_payload_header->magic == Common::MakeMagic('S', 'F', 'C', 'O')); ASSERT(data_payload_header->magic == Common::MakeMagic('S', 'F', 'C', 'O'));
} }
data_payload_offset = rp.GetCurrentOffset();
command = rp.Pop<u32_le>(); command = rp.Pop<u32_le>();
rp.Skip(1, false); // The command is actually an u64, but we don't use the high part. rp.Skip(1, false); // The command is actually an u64, but we don't use the high part.
data_payload_offset = rp.GetCurrentOffset();
} }
ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(u32_le* src_cmdbuf, ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(u32_le* src_cmdbuf,
Process& src_process, Process& src_process,
HandleTable& src_table) { HandleTable& src_table) {
ParseCommandBuffer(src_cmdbuf, true); ParseCommandBuffer(src_cmdbuf, true);
size_t untranslated_size = data_payload_offset + command_header->data_size; // The data_size already includes the payload header, the padding and the domain header.
std::copy_n(src_cmdbuf, untranslated_size, cmd_buf.begin()); size_t size = data_payload_offset + command_header->data_size -
sizeof(IPC::DataPayloadHeader) / sizeof(u32) - 4;
if (domain_message_header)
size -= sizeof(IPC::DomainMessageHeader) / sizeof(u32);
std::copy_n(src_cmdbuf, size, cmd_buf.begin());
return RESULT_SUCCESS; return RESULT_SUCCESS;
} }
ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf, Process& dst_process, ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(u32_le* dst_cmdbuf, Process& dst_process,
HandleTable& dst_table) { HandleTable& dst_table) {
ParseCommandBuffer(&cmd_buf[0], false); // The header was already built in the internal command buffer. Attempt to parse it to verify
size_t untranslated_size = data_payload_offset + command_header->data_size; // the integrity and then copy it over to the target command buffer.
std::copy_n(cmd_buf.begin(), untranslated_size, dst_cmdbuf); ParseCommandBuffer(cmd_buf.data(), false);
// The data_size already includes the payload header, the padding and the domain header.
size_t size = data_payload_offset + command_header->data_size -
sizeof(IPC::DataPayloadHeader) / sizeof(u32) - 4;
if (domain_message_header)
size -= sizeof(IPC::DomainMessageHeader) / sizeof(u32);
std::copy_n(cmd_buf.begin(), size, dst_cmdbuf);
if (command_header->enable_handle_descriptor) { if (command_header->enable_handle_descriptor) {
size_t command_size = untranslated_size + handle_descriptor_header->num_handles_to_copy + ASSERT_MSG(!move_objects.empty() || !copy_objects.empty(),
handle_descriptor_header->num_handles_to_move; "Handle descriptor bit set but no handles to translate");
ASSERT(command_size <= IPC::COMMAND_BUFFER_LENGTH); // We write the translated handles at a specific offset in the command buffer, this space
// was already reserved when writing the header.
size_t current_offset =
(sizeof(IPC::CommandHeader) + sizeof(IPC::HandleDescriptorHeader)) / sizeof(u32);
ASSERT_MSG(!handle_descriptor_header->send_current_pid, "Sending PID is not implemented");
size_t untranslated_index = untranslated_size; ASSERT_MSG(copy_objects.size() == handle_descriptor_header->num_handles_to_copy);
size_t handle_write_offset = 3; ASSERT_MSG(move_objects.size() == handle_descriptor_header->num_handles_to_move);
while (untranslated_index < command_size) {
u32 descriptor = cmd_buf[untranslated_index];
untranslated_index += 1;
switch (IPC::GetDescriptorType(descriptor)) { // We don't make a distinction between copy and move handles when translating since HLE
case IPC::DescriptorType::CopyHandle: // services don't deal with handles directly. However, the guest applications might check
case IPC::DescriptorType::MoveHandle: { // for specific values in each of these descriptors.
// HLE services don't use handles, so we treat both CopyHandle and MoveHandle for (auto& object : copy_objects) {
// equally ASSERT(object != nullptr);
u32 num_handles = IPC::HandleNumberFromDesc(descriptor); dst_cmdbuf[current_offset++] = Kernel::g_handle_table.Create(object).Unwrap();
for (u32 j = 0; j < num_handles; ++j) { }
SharedPtr<Object> object = GetIncomingHandle(cmd_buf[untranslated_index]);
Handle handle = 0; for (auto& object : move_objects) {
if (object != nullptr) { ASSERT(object != nullptr);
// TODO(yuriks): Figure out the proper error handling for if this fails dst_cmdbuf[current_offset++] = Kernel::g_handle_table.Create(object).Unwrap();
handle = dst_table.Create(object).Unwrap();
}
dst_cmdbuf[handle_write_offset++] = handle;
untranslated_index++;
}
break;
}
default:
UNIMPLEMENTED_MSG("Unsupported handle translation: 0x%08X", descriptor);
}
} }
} }
// TODO(Subv): Translate the X/A/B/W buffers.
if (IsDomain()) {
ASSERT(domain_message_header->num_objects == domain_objects.size());
// Write the domain objects to the command buffer, these go after the raw untranslated data.
// TODO(Subv): This completely ignores C buffers.
size_t domain_offset = size - domain_message_header->num_objects;
auto& request_handlers = domain->request_handlers;
for (auto& object : domain_objects) {
request_handlers.emplace_back(object);
dst_cmdbuf[domain_offset++] = request_handlers.size();
}
}
return RESULT_SUCCESS; return RESULT_SUCCESS;
} }

39
src/core/hle/kernel/hle_ipc.h
View File

@ -110,25 +110,6 @@ public:
return server_session; return server_session;
} }
/**
* Resolves a object id from the request command buffer into a pointer to an object. See the
* "HLE handle protocol" section in the class documentation for more details.
*/
SharedPtr<Object> GetIncomingHandle(u32 id_from_cmdbuf) const;
/**
* Adds an outgoing object to the response, returning the id which should be used to reference
* it. See the "HLE handle protocol" section in the class documentation for more details.
*/
u32 AddOutgoingHandle(SharedPtr<Object> object);
/**
* Discards all Objects from the context, invalidating all ids. This may be called after reading
* out all incoming objects, so that the buffer memory can be re-used for outgoing handles, but
* this is not required.
*/
void ClearIncomingObjects();
void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming); void ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming);
/// Populates this context with data from the requesting process/thread. /// Populates this context with data from the requesting process/thread.
@ -158,7 +139,7 @@ public:
return buffer_a_desciptors; return buffer_a_desciptors;
} }
const std::unique_ptr<IPC::DomainRequestMessageHeader>& GetDomainMessageHeader() const { const std::unique_ptr<IPC::DomainMessageHeader>& GetDomainMessageHeader() const {
return domain_message_header; return domain_message_header;
} }
@ -166,17 +147,31 @@ public:
return domain != nullptr; return domain != nullptr;
} }
void AddMoveObject(SharedPtr<Object> object) {
move_objects.emplace_back(std::move(object));
}
void AddCopyObject(SharedPtr<Object> object) {
copy_objects.emplace_back(std::move(object));
}
void AddDomainObject(std::shared_ptr<SessionRequestHandler> object) {
domain_objects.emplace_back(std::move(object));
}
private: private:
std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf; std::array<u32, IPC::COMMAND_BUFFER_LENGTH> cmd_buf;
SharedPtr<Kernel::Domain> domain; SharedPtr<Kernel::Domain> domain;
SharedPtr<Kernel::ServerSession> server_session; SharedPtr<Kernel::ServerSession> server_session;
// TODO(yuriks): Check common usage of this and optimize size accordingly // TODO(yuriks): Check common usage of this and optimize size accordingly
boost::container::small_vector<SharedPtr<Object>, 8> request_handles; boost::container::small_vector<SharedPtr<Object>, 8> move_objects;
boost::container::small_vector<SharedPtr<Object>, 8> copy_objects;
boost::container::small_vector<std::shared_ptr<SessionRequestHandler>, 8> domain_objects;
std::unique_ptr<IPC::CommandHeader> command_header; std::unique_ptr<IPC::CommandHeader> command_header;
std::unique_ptr<IPC::HandleDescriptorHeader> handle_descriptor_header; std::unique_ptr<IPC::HandleDescriptorHeader> handle_descriptor_header;
std::unique_ptr<IPC::DataPayloadHeader> data_payload_header; std::unique_ptr<IPC::DataPayloadHeader> data_payload_header;
std::unique_ptr<IPC::DomainRequestMessageHeader> domain_message_header; std::unique_ptr<IPC::DomainMessageHeader> domain_message_header;
std::vector<IPC::BufferDescriptorX> buffer_x_desciptors; std::vector<IPC::BufferDescriptorX> buffer_x_desciptors;
std::vector<IPC::BufferDescriptorABW> buffer_a_desciptors; std::vector<IPC::BufferDescriptorABW> buffer_a_desciptors;
std::vector<IPC::BufferDescriptorABW> buffer_b_desciptors; std::vector<IPC::BufferDescriptorABW> buffer_b_desciptors;

2
src/core/hle/service/am/applet_oe.cpp
View File

@ -73,7 +73,7 @@ private:
IPC::RequestBuilder rb{ctx, 2, 1}; IPC::RequestBuilder rb{ctx, 2, 1};
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
rb.PushObjects(event); rb.PushCopyObjects(event);
LOG_WARNING(Service, "(STUBBED) called"); LOG_WARNING(Service, "(STUBBED) called");
} }

2
src/core/hle/service/lm/lm.cpp
View File

@ -150,7 +150,7 @@ void LM::Initialize(Kernel::HLERequestContext& ctx) {
(*session)->GetObjectId()); (*session)->GetObjectId());
IPC::RequestBuilder rb{ctx, 1, 0, 1}; IPC::RequestBuilder rb{ctx, 1, 0, 1};
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
rb.PushObjects(std::move(session).Unwrap()); rb.PushMoveObjects(std::move(session).Unwrap());
registered_loggers.emplace_back(std::move(client_port)); registered_loggers.emplace_back(std::move(client_port));
} else { } else {
UNIMPLEMENTED(); UNIMPLEMENTED();

2
src/core/hle/service/sm/controller.cpp
View File

@ -24,7 +24,7 @@ void Controller::ConvertSessionToDomain(Kernel::HLERequestContext& ctx) {
void Controller::DuplicateSession(Kernel::HLERequestContext& ctx) { void Controller::DuplicateSession(Kernel::HLERequestContext& ctx) {
IPC::RequestBuilder rb{ctx, 1, 0, 1}; IPC::RequestBuilder rb{ctx, 1, 0, 1};
rb.Push(RESULT_SUCCESS); rb.Push(RESULT_SUCCESS);
rb.PushObjects(ctx.ServerSession()); rb.PushMoveObjects(ctx.ServerSession());
LOG_DEBUG(Service, "called"); LOG_DEBUG(Service, "called");
} }

2
src/core/hle/service/sm/sm.cpp
View File

@ -121,7 +121,7 @@ void SM::GetService(Kernel::HLERequestContext& ctx) {
(*session)->GetObjectId()); (*session)->GetObjectId());
IPC::RequestBuilder rb = rp.MakeBuilder(2, 0, 1); IPC::RequestBuilder rb = rp.MakeBuilder(2, 0, 1);
rb.Push<u64>(0); rb.Push<u64>(0);
rb.PushObjects(std::move(session).Unwrap()); rb.PushMoveObjects(std::move(session).Unwrap());
} }
} }