nold/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere synced 2024-11-10 07:06:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

htc: Implement HtcmiscImpl::ClientThread

Browse source
This commit is contained in:
Michael Scire 2021-02-10 01:29:40 -08:00 committed by SciresM
parent 1867c31f63
commit d60b1abed0
5 changed files with 203 additions and 2 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
libraries/libstratosphere/source/htc/server/htc_htcmisc_impl.cpp
View file

@ -77,11 +77,83 @@ namespace ams::htc::server {
}
void HtcmiscImpl::ClientThread() {
AMS_ABORT("HtcmiscImpl::ClientThread");
/* Loop so long as we're not cancelled. */
while (!m_cancelled) {
/* Open the rpc client. */
m_rpc_client.Open();
/* Ensure we close, if something goes wrong. */
auto client_guard = SCOPE_GUARD { m_rpc_client.Close(); };
/* Wait for the rpc client. */
if (m_rpc_client.WaitAny(htclow::ChannelState_Connectable, m_cancel_event.GetBase()) != 0) {
break;
}
/* Start the rpc client. */
if (R_FAILED(m_rpc_client.Start())) {
break;
}
/* We're connected! */
this->SetClientConnectionEvent(true);
client_guard.Cancel();
/* We're connected, so we want to cleanup when we're done. */
ON_SCOPE_EXIT {
m_rpc_client.Close();
m_rpc_client.Cancel();
m_rpc_client.Wait();
};
/* Wait to become disconnected. */
if (m_rpc_client.WaitAny(htclow::ChannelState_Disconnected, m_cancel_event.GetBase()) != 0) {
break;
}
/* Set ourselves as disconnected. */
this->SetClientConnectionEvent(false);
}
/* Set ourselves as disconnected. */
this->SetClientConnectionEvent(false);
}
void HtcmiscImpl::ServerThread() {
AMS_ABORT("HtcmiscImpl::ServerThread");
}
void HtcmiscImpl::SetClientConnectionEvent(bool en) {
/* Lock ourselves. */
std::scoped_lock lk(m_connection_mutex);
/* Update our state. */
if (m_client_connected != en) {
m_client_connected = en;
this->UpdateConnectionEvent();
}
}
void HtcmiscImpl::SetServerConnectionEvent(bool en) {
/* Lock ourselves. */
std::scoped_lock lk(m_connection_mutex);
/* Update our state. */
if (m_server_connected != en) {
m_server_connected = en;
this->UpdateConnectionEvent();
}
}
void HtcmiscImpl::UpdateConnectionEvent() {
/* Determine if we're connected. */
const bool connected = m_client_connected && m_server_connected;
/* Update our state. */
if (m_connected != connected) {
m_connected = connected;
m_connection_event.Signal();
}
}
}

5
libraries/libstratosphere/source/htc/server/htc_htcmisc_impl.hpp
View file

@ -47,6 +47,11 @@ namespace ams::htc::server {
public:
HtcmiscImpl(htclow::HtclowManager *htclow_manager);
~HtcmiscImpl();
private:
void SetClientConnectionEvent(bool en);
void SetServerConnectionEvent(bool en);
void UpdateConnectionEvent();
public:
void Cancel();
/* TODO */

109
libraries/libstratosphere/source/htc/server/rpc/htc_rpc_client.cpp
View file

@ -53,4 +53,113 @@ namespace ams::htc::server::rpc {
}
}
void RpcClient::Open() {
R_ABORT_UNLESS(m_driver->Open(m_channel_id));
}
void RpcClient::Close() {
m_driver->Close(m_channel_id);
}
Result RpcClient::Start() {
/* Connect. */
R_TRY(m_driver->Connect(m_channel_id));
/* Initialize our task queue. */
m_task_queue.Initialize();
/* Create our threads. */
R_ABORT_UNLESS(os::CreateThread(std::addressof(m_receive_thread), ReceiveThreadEntry, this, m_receive_thread_stack, ThreadStackSize, AMS_GET_SYSTEM_THREAD_PRIORITY(htc, HtcmiscReceive)));
R_ABORT_UNLESS(os::CreateThread(std::addressof(m_send_thread), SendThreadEntry, this, m_send_thread_stack, ThreadStackSize, AMS_GET_SYSTEM_THREAD_PRIORITY(htc, HtcmiscSend)));
/* Set thread name pointers. */
os::SetThreadNamePointer(std::addressof(m_receive_thread), AMS_GET_SYSTEM_THREAD_NAME(htc, HtcmiscReceive));
os::SetThreadNamePointer(std::addressof(m_send_thread), AMS_GET_SYSTEM_THREAD_NAME(htc, HtcmiscSend));
/* Start threads. */
os::StartThread(std::addressof(m_receive_thread));
os::StartThread(std::addressof(m_send_thread));
/* Set initial state. */
m_cancelled = false;
m_thread_running = true;
/* Clear events. */
for (size_t i = 0; i < MaxRpcCount; ++i) {
os::ClearEvent(std::addressof(m_receive_buffer_available_events[i]));
os::ClearEvent(std::addressof(m_send_buffer_available_events[i]));
}
return ResultSuccess();
}
void RpcClient::Cancel() {
/* Set cancelled. */
m_cancelled = true;
/* Signal all events. */
for (size_t i = 0; i < MaxRpcCount; ++i) {
os::SignalEvent(std::addressof(m_receive_buffer_available_events[i]));
os::SignalEvent(std::addressof(m_send_buffer_available_events[i]));
}
/* Cancel our queue. */
m_task_queue.Cancel();
}
void RpcClient::Wait() {
/* Wait for thread to not be running. */
if (m_thread_running) {
os::WaitThread(std::addressof(m_receive_thread));
os::WaitThread(std::addressof(m_send_thread));
os::DestroyThread(std::addressof(m_receive_thread));
os::DestroyThread(std::addressof(m_send_thread));
}
m_thread_running = false;
/* Lock ourselves. */
std::scoped_lock lk(m_mutex);
/* Finalize the task queue. */
m_task_queue.Finalize();
/* Cancel all tasks. */
for (size_t i = 0; i < MaxRpcCount; ++i) {
if (m_task_active[i]) {
/* TODO: enum member */
m_task_table.Get<Task>(i)->Cancel(static_cast<RpcTaskCancelReason>(2));
}
}
}
int RpcClient::WaitAny(htclow::ChannelState state, os::EventType *event) {
/* Check if we're already signaled. */
if (os::TryWaitEvent(event)) {
return 1;
}
if (m_driver->GetChannelState(m_channel_id) == state) {
return 0;
}
/* Wait. */
while (true) {
const auto idx = os::WaitAny(m_driver->GetChannelStateEvent(m_channel_id), event);
if (idx == 0) {
if (m_driver->GetChannelState(m_channel_id) == state) {
return 0;
}
} else {
return idx;
}
}
}
void RpcClient::ReceiveThread() {
AMS_ABORT("RpcClient::ReceiveThread");
}
void RpcClient::SendThread() {
AMS_ABORT("RpcClient::SendThread");
}
}

15
libraries/libstratosphere/source/htc/server/rpc/htc_rpc_client.hpp
View file

@ -45,8 +45,23 @@ namespace ams::htc::server::rpc {
os::EventType m_send_buffer_available_events[MaxRpcCount];
u8 m_receive_buffer[BufferSize];
u8 m_send_buffer[BufferSize];
private:
static void ReceiveThreadEntry(void *arg) { static_cast<RpcClient *>(arg)->ReceiveThread(); }
static void SendThreadEntry(void *arg) { static_cast<RpcClient *>(arg)->SendThread(); }
void ReceiveThread();
void SendThread();
public:
RpcClient(driver::IDriver *driver, htclow::ChannelId channel);
public:
void Open();
void Close();
Result Start();
void Cancel();
void Wait();
int WaitAny(htclow::ChannelState state, os::EventType *event);
};
}

2
libraries/libstratosphere/source/htc/server/rpc/htc_rpc_task_id_free_list.hpp
View file

@ -38,7 +38,7 @@ namespace ams::htc::server::rpc {
/* Get index. */
const auto index = m_offset;
m_free_count = (m_free_count + 1) % MaxRpcCount;
m_offset = (m_offset + 1) % MaxRpcCount;
--m_free_count;
/* Get the task id. */