mirrors/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2025-06-03 08:08:39 -04:00
Code Issues Projects Releases Packages Wiki Activity

strat: use m_ for member variables

Browse source
This commit is contained in:
Michael Scire 2021-10-10 00:14:06 -07:00
parent ce28591ab2
commit a595c232b9
425 changed files with 8531 additions and 8484 deletions
Download patch file Download diff file Expand all files Collapse all files

70
libraries/libstratosphere/source/sf/cmif/sf_cmif_domain_manager.cpp
View file

@ -18,87 +18,87 @@
namespace ams::sf::cmif {
ServerDomainManager::Domain::~Domain() {
while (!this->entries.empty()) {
Entry *entry = std::addressof(this->entries.front());
while (!m_entries.empty()) {
Entry *entry = std::addressof(m_entries.front());
{
std::scoped_lock lk(this->manager->entry_owner_lock);
std::scoped_lock lk(m_manager->m_entry_owner_lock);
AMS_ABORT_UNLESS(entry->owner == this);
entry->owner = nullptr;
}
entry->object.Reset();
this->entries.pop_front();
this->manager->entry_manager.FreeEntry(entry);
m_entries.pop_front();
m_manager->m_entry_manager.FreeEntry(entry);
}
}
void ServerDomainManager::Domain::DisposeImpl() {
ServerDomainManager *manager = this->manager;
ServerDomainManager *manager = m_manager;
std::destroy_at(this);
manager->FreeDomain(this);
}
Result ServerDomainManager::Domain::ReserveIds(DomainObjectId *out_ids, size_t count) {
for (size_t i = 0; i < count; i++) {
Entry *entry = this->manager->entry_manager.AllocateEntry();
Entry *entry = m_manager->m_entry_manager.AllocateEntry();
R_UNLESS(entry != nullptr, sf::cmif::ResultOutOfDomainEntries());
AMS_ABORT_UNLESS(entry->owner == nullptr);
out_ids[i] = this->manager->entry_manager.GetId(entry);
out_ids[i] = m_manager->m_entry_manager.GetId(entry);
}
return ResultSuccess();
}
void ServerDomainManager::Domain::ReserveSpecificIds(const DomainObjectId *ids, size_t count) {
this->manager->entry_manager.AllocateSpecificEntries(ids, count);
m_manager->m_entry_manager.AllocateSpecificEntries(ids, count);
}
void ServerDomainManager::Domain::UnreserveIds(const DomainObjectId *ids, size_t count) {
for (size_t i = 0; i < count; i++) {
Entry *entry = this->manager->entry_manager.GetEntry(ids[i]);
Entry *entry = m_manager->m_entry_manager.GetEntry(ids[i]);
AMS_ABORT_UNLESS(entry != nullptr);
AMS_ABORT_UNLESS(entry->owner == nullptr);
this->manager->entry_manager.FreeEntry(entry);
m_manager->m_entry_manager.FreeEntry(entry);
}
}
void ServerDomainManager::Domain::RegisterObject(DomainObjectId id, ServiceObjectHolder &&obj) {
Entry *entry = this->manager->entry_manager.GetEntry(id);
Entry *entry = m_manager->m_entry_manager.GetEntry(id);
AMS_ABORT_UNLESS(entry != nullptr);
{
std::scoped_lock lk(this->manager->entry_owner_lock);
std::scoped_lock lk(m_manager->m_entry_owner_lock);
AMS_ABORT_UNLESS(entry->owner == nullptr);
entry->owner = this;
this->entries.push_back(*entry);
m_entries.push_back(*entry);
}
entry->object = std::move(obj);
}
ServiceObjectHolder ServerDomainManager::Domain::UnregisterObject(DomainObjectId id) {
ServiceObjectHolder obj;
Entry *entry = this->manager->entry_manager.GetEntry(id);
Entry *entry = m_manager->m_entry_manager.GetEntry(id);
if (entry == nullptr) {
return ServiceObjectHolder();
}
{
std::scoped_lock lk(this->manager->entry_owner_lock);
std::scoped_lock lk(m_manager->m_entry_owner_lock);
if (entry->owner != this) {
return ServiceObjectHolder();
}
entry->owner = nullptr;
obj = std::move(entry->object);
this->entries.erase(this->entries.iterator_to(*entry));
m_entries.erase(m_entries.iterator_to(*entry));
}
this->manager->entry_manager.FreeEntry(entry);
m_manager->m_entry_manager.FreeEntry(entry);
return obj;
}
ServiceObjectHolder ServerDomainManager::Domain::GetObject(DomainObjectId id) {
Entry *entry = this->manager->entry_manager.GetEntry(id);
Entry *entry = m_manager->m_entry_manager.GetEntry(id);
if (entry == nullptr) {
return ServiceObjectHolder();
}
{
std::scoped_lock lk(this->manager->entry_owner_lock);
std::scoped_lock lk(m_manager->m_entry_owner_lock);
if (entry->owner != this) {
return ServiceObjectHolder();
}
@ -106,41 +106,41 @@ namespace ams::sf::cmif {
return entry->object.Clone();
}
ServerDomainManager::EntryManager::EntryManager(DomainEntryStorage *entry_storage, size_t entry_count) : lock() {
this->entries = reinterpret_cast<Entry *>(entry_storage);
this->num_entries = entry_count;
for (size_t i = 0; i < this->num_entries; i++) {
this->free_list.push_back(*std::construct_at(this->entries + i));
ServerDomainManager::EntryManager::EntryManager(DomainEntryStorage *entry_storage, size_t entry_count) : m_lock() {
m_entries = reinterpret_cast<Entry *>(entry_storage);
m_num_entries = entry_count;
for (size_t i = 0; i < m_num_entries; i++) {
m_free_list.push_back(*std::construct_at(m_entries + i));
}
}
ServerDomainManager::EntryManager::~EntryManager() {
for (size_t i = 0; i < this->num_entries; i++) {
std::destroy_at(this->entries + i);
for (size_t i = 0; i < m_num_entries; i++) {
std::destroy_at(m_entries + i);
}
}
ServerDomainManager::Entry *ServerDomainManager::EntryManager::AllocateEntry() {
std::scoped_lock lk(this->lock);
std::scoped_lock lk(m_lock);
if (this->free_list.empty()) {
if (m_free_list.empty()) {
return nullptr;
}
Entry *e = std::addressof(this->free_list.front());
this->free_list.pop_front();
Entry *e = std::addressof(m_free_list.front());
m_free_list.pop_front();
return e;
}
void ServerDomainManager::EntryManager::FreeEntry(Entry *entry) {
std::scoped_lock lk(this->lock);
std::scoped_lock lk(m_lock);
AMS_ABORT_UNLESS(entry->owner == nullptr);
AMS_ABORT_UNLESS(!entry->object);
this->free_list.push_front(*entry);
m_free_list.push_front(*entry);
}
void ServerDomainManager::EntryManager::AllocateSpecificEntries(const DomainObjectId *ids, size_t count) {
std::scoped_lock lk(this->lock);
std::scoped_lock lk(m_lock);
/* Allocate new IDs. */
for (size_t i = 0; i < count; i++) {
@ -149,7 +149,7 @@ namespace ams::sf::cmif {
if (id != InvalidDomainObjectId) {
AMS_ABORT_UNLESS(entry != nullptr);
AMS_ABORT_UNLESS(entry->owner == nullptr);
this->free_list.erase(this->free_list.iterator_to(*entry));
m_free_list.erase(m_free_list.iterator_to(*entry));
}
}
}

22
libraries/libstratosphere/source/sf/cmif/sf_cmif_domain_service_object.cpp
View file

@ -109,17 +109,17 @@ namespace ams::sf::cmif {
Result DomainServiceObjectProcessor::PrepareForProcess(const ServiceDispatchContext &ctx, const ServerMessageRuntimeMetadata runtime_metadata) const {
/* Validate in object count. */
R_UNLESS(this->impl_metadata.GetInObjectCount() == this->GetInObjectCount(), sf::cmif::ResultInvalidNumInObjects());
R_UNLESS(m_impl_metadata.GetInObjectCount() == this->GetInObjectCount(), sf::cmif::ResultInvalidNumInObjects());
/* Nintendo reserves domain object IDs here. We do this later, to support mitm semantics. */
/* Pass onwards. */
return this->impl_processor->PrepareForProcess(ctx, runtime_metadata);
return m_impl_processor->PrepareForProcess(ctx, runtime_metadata);
}
Result DomainServiceObjectProcessor::GetInObjects(ServiceObjectHolder *in_objects) const {
for (size_t i = 0; i < this->GetInObjectCount(); i++) {
in_objects[i] = this->domain->GetObject(this->in_object_ids[i]);
in_objects[i] = m_domain->GetObject(m_in_object_ids[i]);
}
return ResultSuccess();
}
@ -127,7 +127,7 @@ namespace ams::sf::cmif {
HipcRequest DomainServiceObjectProcessor::PrepareForReply(const cmif::ServiceDispatchContext &ctx, PointerAndSize &out_raw_data, const ServerMessageRuntimeMetadata runtime_metadata) {
/* Call into impl processor, get request. */
PointerAndSize raw_data;
HipcRequest request = this->impl_processor->PrepareForReply(ctx, raw_data, runtime_metadata);
HipcRequest request = m_impl_processor->PrepareForReply(ctx, raw_data, runtime_metadata);
/* Write out header. */
constexpr size_t out_header_size = sizeof(CmifDomainOutHeader);
@ -137,7 +137,7 @@ namespace ams::sf::cmif {
/* Set output raw data. */
out_raw_data = cmif::PointerAndSize(raw_data.GetAddress() + out_header_size, raw_data.GetSize() - out_header_size);
this->out_object_ids = reinterpret_cast<DomainObjectId *>(out_raw_data.GetAddress() + impl_out_data_total_size);
m_out_object_ids = reinterpret_cast<DomainObjectId *>(out_raw_data.GetAddress() + impl_out_data_total_size);
return request;
}
@ -145,7 +145,7 @@ namespace ams::sf::cmif {
void DomainServiceObjectProcessor::PrepareForErrorReply(const cmif::ServiceDispatchContext &ctx, PointerAndSize &out_raw_data, const ServerMessageRuntimeMetadata runtime_metadata) {
/* Call into impl processor, get request. */
PointerAndSize raw_data;
this->impl_processor->PrepareForErrorReply(ctx, raw_data, runtime_metadata);
m_impl_processor->PrepareForErrorReply(ctx, raw_data, runtime_metadata);
/* Write out header. */
constexpr size_t out_header_size = sizeof(CmifDomainOutHeader);
@ -188,8 +188,8 @@ namespace ams::sf::cmif {
}
}
/* TODO: Can we make this error non-fatal? It isn't for N, since they can reserve IDs earlier due to not having to worry about mitm. */
R_ABORT_UNLESS(this->domain->ReserveIds(reservations, num_unreserved_ids));
this->domain->ReserveSpecificIds(specific_ids, num_specific_ids);
R_ABORT_UNLESS(m_domain->ReserveIds(reservations, num_unreserved_ids));
m_domain->ReserveSpecificIds(specific_ids, num_specific_ids);
}
size_t reservation_index = 0;
@ -205,17 +205,17 @@ namespace ams::sf::cmif {
for (size_t i = 0; i < num_out_objects; i++) {
if (!out_objects[i]) {
if (is_reserved[i]) {
this->domain->UnreserveIds(object_ids + i, 1);
m_domain->UnreserveIds(object_ids + i, 1);
}
object_ids[i] = InvalidDomainObjectId;
continue;
}
this->domain->RegisterObject(object_ids[i], std::move(out_objects[i]));
m_domain->RegisterObject(object_ids[i], std::move(out_objects[i]));
}
/* Set out object IDs in message. */
for (size_t i = 0; i < num_out_objects; i++) {
this->out_object_ids[i] = object_ids[i];
m_out_object_ids[i] = object_ids[i];
}
}

4
libraries/libstratosphere/source/sf/cmif/sf_cmif_service_object_holder.cpp
View file

@ -18,8 +18,8 @@
namespace ams::sf::cmif {
Result ServiceObjectHolder::ProcessMessage(ServiceDispatchContext &ctx, const cmif::PointerAndSize &in_raw_data) const {
const auto ProcessHandler = this->dispatch_meta->ProcessHandler;
const auto *DispatchTable = this->dispatch_meta->DispatchTable;
const auto ProcessHandler = m_dispatch_meta->ProcessHandler;
const auto *DispatchTable = m_dispatch_meta->DispatchTable;
return (DispatchTable->*ProcessHandler)(ctx, in_raw_data);
}

6
libraries/libstratosphere/source/sf/hipc/sf_hipc_mitm_query_api.cpp
View file

@ -27,12 +27,12 @@ namespace ams::sf::hipc::impl {
class MitmQueryService {
private:
ServerManagerBase::MitmQueryFunction query_function;
ServerManagerBase::MitmQueryFunction m_query_function;
public:
MitmQueryService(ServerManagerBase::MitmQueryFunction qf) : query_function(qf) { /* ... */ }
MitmQueryService(ServerManagerBase::MitmQueryFunction qf) : m_query_function(qf) { /* ... */ }
void ShouldMitm(sf::Out<bool> out, const sm::MitmProcessInfo &client_info) {
*out = this->query_function(client_info);
*out = m_query_function(client_info);
}
};
static_assert(IsIMitmQueryService<MitmQueryService>);

52
libraries/libstratosphere/source/sf/hipc/sf_hipc_server_domain_session_manager.cpp
View file

@ -30,13 +30,13 @@ namespace ams::sf::hipc {
class HipcManagerImpl {
private:
ServerDomainSessionManager *manager;
ServerSession *session;
bool is_mitm_session;
ServerDomainSessionManager *m_manager;
ServerSession *m_session;
bool m_is_mitm_session;
private:
Result CloneCurrentObjectImpl(sf::OutMoveHandle &out_client_handle, ServerSessionManager *tagged_manager) {
/* Clone the object. */
cmif::ServiceObjectHolder &&clone = this->session->srv_obj_holder.Clone();
cmif::ServiceObjectHolder &&clone = m_session->m_srv_obj_holder.Clone();
R_UNLESS(clone, sf::hipc::ResultDomainObjectNotFound());
/* Create new session handles. */
@ -44,12 +44,12 @@ namespace ams::sf::hipc {
R_ABORT_UNLESS(hipc::CreateSession(std::addressof(server_handle), std::addressof(client_handle)));
/* Register with manager. */
if (!is_mitm_session) {
if (!m_is_mitm_session) {
R_ABORT_UNLESS(tagged_manager->RegisterSession(server_handle, std::move(clone)));
} else {
/* Clone the forward service. */
std::shared_ptr<::Service> new_forward_service = std::move(ServerSession::CreateForwardService());
R_ABORT_UNLESS(serviceClone(this->session->forward_service.get(), new_forward_service.get()));
R_ABORT_UNLESS(serviceClone(m_session->m_forward_service.get(), new_forward_service.get()));
R_ABORT_UNLESS(tagged_manager->RegisterMitmSession(server_handle, std::move(clone), std::move(new_forward_service)));
}
@ -58,34 +58,34 @@ namespace ams::sf::hipc {
return ResultSuccess();
}
public:
explicit HipcManagerImpl(ServerDomainSessionManager *m, ServerSession *s) : manager(m), session(s), is_mitm_session(s->forward_service != nullptr) {
explicit HipcManagerImpl(ServerDomainSessionManager *m, ServerSession *s) : m_manager(m), m_session(s), m_is_mitm_session(s->m_forward_service != nullptr) {
/* ... */
}
Result ConvertCurrentObjectToDomain(sf::Out<cmif::DomainObjectId> out) {
/* Allocate a domain. */
auto domain = this->manager->AllocateDomainServiceObject();
auto domain = m_manager->AllocateDomainServiceObject();
R_UNLESS(domain, sf::hipc::ResultOutOfDomains());
/* Set up the new domain object. */
cmif::DomainObjectId object_id = cmif::InvalidDomainObjectId;
if (this->is_mitm_session) {
if (m_is_mitm_session) {
/* Make a new shared pointer to manage the allocated domain. */
SharedPointer<cmif::MitmDomainServiceObject> cmif_domain(static_cast<cmif::MitmDomainServiceObject *>(domain), false);
/* Convert the remote session to domain. */
AMS_ABORT_UNLESS(session->forward_service->own_handle);
R_TRY(serviceConvertToDomain(session->forward_service.get()));
AMS_ABORT_UNLESS(m_session->m_forward_service->own_handle);
R_TRY(serviceConvertToDomain(m_session->m_forward_service.get()));
/* The object ID reservation cannot fail here, as that would cause desynchronization from target domain. */
object_id = cmif::DomainObjectId{session->forward_service->object_id};
object_id = cmif::DomainObjectId{m_session->m_forward_service->object_id};
domain->ReserveSpecificIds(std::addressof(object_id), 1);
/* Register the object. */
domain->RegisterObject(object_id, std::move(session->srv_obj_holder));
domain->RegisterObject(object_id, std::move(m_session->m_srv_obj_holder));
/* Set the new object holder. */
session->srv_obj_holder = cmif::ServiceObjectHolder(std::move(cmif_domain));
m_session->m_srv_obj_holder = cmif::ServiceObjectHolder(std::move(cmif_domain));
} else {
/* Make a new shared pointer to manage the allocated domain. */
SharedPointer<cmif::DomainServiceObject> cmif_domain(domain, false);
@ -94,10 +94,10 @@ namespace ams::sf::hipc {
R_TRY(domain->ReserveIds(std::addressof(object_id), 1));
/* Register the object. */
domain->RegisterObject(object_id, std::move(session->srv_obj_holder));
domain->RegisterObject(object_id, std::move(m_session->m_srv_obj_holder));
/* Set the new object holder. */
session->srv_obj_holder = cmif::ServiceObjectHolder(std::move(cmif_domain));
m_session->m_srv_obj_holder = cmif::ServiceObjectHolder(std::move(cmif_domain));
}
/* Return the allocated id. */
@ -108,35 +108,35 @@ namespace ams::sf::hipc {
Result CopyFromCurrentDomain(sf::OutMoveHandle out, cmif::DomainObjectId object_id) {
/* Get domain. */
auto domain = this->session->srv_obj_holder.GetServiceObject<cmif::DomainServiceObject>();
auto domain = m_session->m_srv_obj_holder.GetServiceObject<cmif::DomainServiceObject>();
R_UNLESS(domain != nullptr, sf::hipc::ResultTargetNotDomain());
/* Get domain object. */
auto &&object = domain->GetObject(object_id);
if (!object) {
R_UNLESS(this->is_mitm_session, sf::hipc::ResultDomainObjectNotFound());
R_UNLESS(m_is_mitm_session, sf::hipc::ResultDomainObjectNotFound());
os::NativeHandle handle;
R_TRY(cmifCopyFromCurrentDomain(this->session->forward_service->session, object_id.value, std::addressof(handle)));
R_TRY(cmifCopyFromCurrentDomain(m_session->m_forward_service->session, object_id.value, std::addressof(handle)));
out.SetValue(handle, false);
return ResultSuccess();
}
if (!this->is_mitm_session || object_id.value != serviceGetObjectId(this->session->forward_service.get())) {
if (!m_is_mitm_session || object_id.value != serviceGetObjectId(m_session->m_forward_service.get())) {
/* Create new session handles. */
os::NativeHandle server_handle, client_handle;
R_ABORT_UNLESS(hipc::CreateSession(std::addressof(server_handle), std::addressof(client_handle)));
/* Register. */
R_ABORT_UNLESS(this->manager->RegisterSession(server_handle, std::move(object)));
R_ABORT_UNLESS(m_manager->RegisterSession(server_handle, std::move(object)));
/* Set output client handle. */
out.SetValue(client_handle, false);
} else {
/* Copy from the target domain. */
os::NativeHandle new_forward_target;
R_TRY(cmifCopyFromCurrentDomain(this->session->forward_service->session, object_id.value, std::addressof(new_forward_target)));
R_TRY(cmifCopyFromCurrentDomain(m_session->m_forward_service->session, object_id.value, std::addressof(new_forward_target)));
/* Create new session handles. */
os::NativeHandle server_handle, client_handle;
@ -145,7 +145,7 @@ namespace ams::sf::hipc {
/* Register. */
std::shared_ptr<::Service> new_forward_service = std::move(ServerSession::CreateForwardService());
serviceCreate(new_forward_service.get(), new_forward_target);
R_ABORT_UNLESS(this->manager->RegisterMitmSession(server_handle, std::move(object), std::move(new_forward_service)));
R_ABORT_UNLESS(m_manager->RegisterMitmSession(server_handle, std::move(object), std::move(new_forward_service)));
/* Set output client handle. */
out.SetValue(client_handle, false);
@ -155,15 +155,15 @@ namespace ams::sf::hipc {
}
Result CloneCurrentObject(sf::OutMoveHandle out) {
return this->CloneCurrentObjectImpl(out, this->manager);
return this->CloneCurrentObjectImpl(out, m_manager);
}
void QueryPointerBufferSize(sf::Out<u16> out) {
out.SetValue(this->session->pointer_buffer.GetSize());
out.SetValue(m_session->m_pointer_buffer.GetSize());
}
Result CloneCurrentObjectEx(sf::OutMoveHandle out, u32 tag) {
return this->CloneCurrentObjectImpl(out, this->manager->GetSessionManagerByTag(tag));
return this->CloneCurrentObjectImpl(out, m_manager->GetSessionManagerByTag(tag));
}
};
static_assert(IsIHipcManager<HipcManagerImpl>);

40
libraries/libstratosphere/source/sf/hipc/sf_hipc_server_manager.cpp
View file

@ -33,7 +33,7 @@ namespace ams::sf::hipc {
}
void ServerManagerBase::RegisterServerSessionToWait(ServerSession *session) {
session->has_received = false;
session->m_has_received = false;
/* Set user data tag. */
os::SetMultiWaitHolderUserData(session, static_cast<uintptr_t>(UserDataTag::Session));
@ -42,25 +42,25 @@ namespace ams::sf::hipc {
}
void ServerManagerBase::LinkToDeferredList(os::MultiWaitHolderType *holder) {
std::scoped_lock lk(this->deferred_list_mutex);
os::LinkMultiWaitHolder(std::addressof(this->deferred_list), holder);
this->notify_event.Signal();
std::scoped_lock lk(m_deferred_list_mutex);
os::LinkMultiWaitHolder(std::addressof(m_deferred_list), holder);
m_notify_event.Signal();
}
void ServerManagerBase::LinkDeferred() {
std::scoped_lock lk(this->deferred_list_mutex);
os::MoveAllMultiWaitHolder(std::addressof(this->multi_wait), std::addressof(this->deferred_list));
std::scoped_lock lk(m_deferred_list_mutex);
os::MoveAllMultiWaitHolder(std::addressof(m_multi_wait), std::addressof(m_deferred_list));
}
os::MultiWaitHolderType *ServerManagerBase::WaitSignaled() {
std::scoped_lock lk(this->selection_mutex);
std::scoped_lock lk(m_selection_mutex);
while (true) {
this->LinkDeferred();
auto selected = os::WaitAny(std::addressof(this->multi_wait));
if (selected == std::addressof(this->request_stop_event_holder)) {
auto selected = os::WaitAny(std::addressof(m_multi_wait));
if (selected == std::addressof(m_request_stop_event_holder)) {
return nullptr;
} else if (selected == std::addressof(this->notify_event_holder)) {
this->notify_event.Clear();
} else if (selected == std::addressof(m_notify_event_holder)) {
m_notify_event.Clear();
} else {
os::UnlinkMultiWaitHolder(selected);
return selected;
@ -69,11 +69,11 @@ namespace ams::sf::hipc {
}
void ServerManagerBase::ResumeProcessing() {
this->request_stop_event.Clear();
m_request_stop_event.Clear();
}
void ServerManagerBase::RequestStopProcessing() {
this->request_stop_event.Signal();
m_request_stop_event.Signal();
}
void ServerManagerBase::AddUserMultiWaitHolder(os::MultiWaitHolderType *holder) {
@ -91,10 +91,10 @@ namespace ams::sf::hipc {
ON_SCOPE_EXIT { this->LinkToDeferredList(server); };
/* Create new session. */
if (server->static_object) {
return this->AcceptSession(server->port_handle, server->static_object.Clone());
if (server->m_static_object) {
return this->AcceptSession(server->m_port_handle, server->m_static_object.Clone());
} else {
return this->OnNeedsToAccept(server->index, server);
return this->OnNeedsToAccept(server->m_index, server);
}
}
@ -105,7 +105,7 @@ namespace ams::sf::hipc {
ON_SCOPE_EXIT { this->LinkToDeferredList(server); };
/* Create resources for new session. */
return this->OnNeedsToAccept(server->index, server);
return this->OnNeedsToAccept(server->m_index, server);
}
Result ServerManagerBase::ProcessForSession(os::MultiWaitHolderType *holder) {
@ -114,11 +114,11 @@ namespace ams::sf::hipc {
ServerSession *session = static_cast<ServerSession *>(holder);
cmif::PointerAndSize tls_message(svc::GetThreadLocalRegion()->message_buffer, hipc::TlsMessageBufferSize);
const cmif::PointerAndSize &saved_message = session->saved_message;
const cmif::PointerAndSize &saved_message = session->m_saved_message;
AMS_ABORT_UNLESS(tls_message.GetSize() == saved_message.GetSize());
if (!session->has_received) {
if (!session->m_has_received) {
R_TRY(this->ReceiveRequest(session, tls_message));
session->has_received = true;
session->m_has_received = true;
std::memcpy(saved_message.GetPointer(), tls_message.GetPointer(), tls_message.GetSize());
} else {
/* We were deferred and are re-receiving, so just memcpy. */

40
libraries/libstratosphere/source/sf/hipc/sf_hipc_server_session_manager.cpp
View file

@ -42,20 +42,20 @@ namespace ams::sf::hipc {
Result ServerSession::ForwardRequest(const cmif::ServiceDispatchContext &ctx) const {
AMS_ABORT_UNLESS(this->IsMitmSession());
/* TODO: Support non-TLS messages? */
AMS_ABORT_UNLESS(this->saved_message.GetPointer() != nullptr);
AMS_ABORT_UNLESS(this->saved_message.GetSize() == TlsMessageBufferSize);
AMS_ABORT_UNLESS(m_saved_message.GetPointer() != nullptr);
AMS_ABORT_UNLESS(m_saved_message.GetSize() == TlsMessageBufferSize);
/* Get TLS message buffer. */
u32 * const message_buffer = svc::GetThreadLocalRegion()->message_buffer;
/* Copy saved TLS in. */
std::memcpy(message_buffer, this->saved_message.GetPointer(), this->saved_message.GetSize());
std::memcpy(message_buffer, m_saved_message.GetPointer(), m_saved_message.GetSize());
/* Prepare buffer. */
PreProcessCommandBufferForMitm(ctx, this->pointer_buffer, reinterpret_cast<uintptr_t>(message_buffer));
PreProcessCommandBufferForMitm(ctx, m_pointer_buffer, reinterpret_cast<uintptr_t>(message_buffer));
/* Dispatch forwards. */
R_TRY(svc::SendSyncRequest(this->forward_service->session));
R_TRY(svc::SendSyncRequest(m_forward_service->session));
/* Parse, to ensure we catch any copy handles and close them. */
{
@ -80,7 +80,7 @@ namespace ams::sf::hipc {
}
void ServerSessionManager::CloseSessionImpl(ServerSession *session) {
const auto session_handle = session->session_handle;
const auto session_handle = session->m_session_handle;
os::FinalizeMultiWaitHolder(session);
this->DestroySession(session);
os::CloseNativeHandle(session_handle);
@ -91,8 +91,8 @@ namespace ams::sf::hipc {
std::construct_at(session_memory, session_handle, std::forward<cmif::ServiceObjectHolder>(obj));
/* Assign session resources. */
session_memory->pointer_buffer = this->GetSessionPointerBuffer(session_memory);
session_memory->saved_message = this->GetSessionSavedMessageBuffer(session_memory);
session_memory->m_pointer_buffer = this->GetSessionPointerBuffer(session_memory);
session_memory->m_saved_message = this->GetSessionSavedMessageBuffer(session_memory);
/* Register to wait list. */
this->RegisterServerSessionToWait(session_memory);
@ -118,12 +118,12 @@ namespace ams::sf::hipc {
std::construct_at(session_memory, mitm_session_handle, std::forward<cmif::ServiceObjectHolder>(obj), std::forward<std::shared_ptr<::Service>>(fsrv));
/* Assign session resources. */
session_memory->pointer_buffer = this->GetSessionPointerBuffer(session_memory);
session_memory->saved_message = this->GetSessionSavedMessageBuffer(session_memory);
session_memory->m_pointer_buffer = this->GetSessionPointerBuffer(session_memory);
session_memory->m_saved_message = this->GetSessionSavedMessageBuffer(session_memory);
/* Validate session pointer buffer. */
AMS_ABORT_UNLESS(session_memory->pointer_buffer.GetSize() >= session_memory->forward_service->pointer_buffer_size);
session_memory->pointer_buffer = cmif::PointerAndSize(session_memory->pointer_buffer.GetAddress(), session_memory->forward_service->pointer_buffer_size);
AMS_ABORT_UNLESS(session_memory->m_pointer_buffer.GetSize() >= session_memory->m_forward_service->pointer_buffer_size);
session_memory->m_pointer_buffer = cmif::PointerAndSize(session_memory->m_pointer_buffer.GetAddress(), session_memory->m_forward_service->pointer_buffer_size);
/* Register to wait list. */
this->RegisterServerSessionToWait(session_memory);
@ -169,7 +169,7 @@ namespace ams::sf::hipc {
}
Result ServerSessionManager::ReceiveRequestImpl(ServerSession *session, const cmif::PointerAndSize &message) {
const cmif::PointerAndSize &pointer_buffer = session->pointer_buffer;
const cmif::PointerAndSize &pointer_buffer = session->m_pointer_buffer;
/* If the receive list is odd, we may need to receive repeatedly. */
while (true) {
@ -184,13 +184,13 @@ namespace ams::sf::hipc {
);
}
hipc::ReceiveResult recv_result;
R_TRY(hipc::Receive(std::addressof(recv_result), session->session_handle, message));
R_TRY(hipc::Receive(std::addressof(recv_result), session->m_session_handle, message));
switch (recv_result) {
case hipc::ReceiveResult::Success:
session->is_closed = false;
session->m_is_closed = false;
return ResultSuccess();
case hipc::ReceiveResult::Closed:
session->is_closed = true;
session->m_is_closed = true;
return ResultSuccess();
case hipc::ReceiveResult::NeedsRetry:
continue;
@ -210,7 +210,7 @@ namespace ams::sf::hipc {
}
Result ServerSessionManager::ProcessRequest(ServerSession *session, const cmif::PointerAndSize &message) {
if (session->is_closed) {
if (session->m_is_closed) {
this->CloseSessionImpl(session);
return ResultSuccess();
}
@ -266,7 +266,7 @@ namespace ams::sf::hipc {
switch (cmif_command_type) {
case CmifCommandType_Request:
case CmifCommandType_RequestWithContext:
return this->DispatchRequest(session->srv_obj_holder.Clone(), session, in_message, out_message);
return this->DispatchRequest(session->m_srv_obj_holder.Clone(), session, in_message, out_message);
case CmifCommandType_Control:
case CmifCommandType_ControlWithContext:
return this->DispatchManagerRequest(session, in_message, out_message);
@ -290,7 +290,7 @@ namespace ams::sf::hipc {
.session = session,
.processor = nullptr, /* Filled in by template implementations. */
.handles_to_close = std::addressof(handles_to_close),
.pointer_buffer = session->pointer_buffer,
.pointer_buffer = session->m_pointer_buffer,
.in_message_buffer = in_message,
.out_message_buffer = out_message,
.request = hipcParseRequest(in_message.GetPointer()),
@ -320,7 +320,7 @@ namespace ams::sf::hipc {
os::CloseNativeHandle(handles_to_close.handles[i]);
}
};
R_TRY(hipc::Reply(session->session_handle, out_message));
R_TRY(hipc::Reply(session->m_session_handle, out_message));
}
return ResultSuccess();