RPCSX/rpcsx
1
0
Fork 0
mirror of https://github.com/RPCSX/rpcsx.git synced 2026-04-04 14:08:37 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[orbis-kernel] impi: implement create server/client/session

Browse source
This commit is contained in:
DH 2023-11-11 02:55:00 +03:00
parent 37295c16a1
commit 8e376c465e
7 changed files with 408 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

16
orbis-kernel/include/orbis/KernelContext.hpp
View file

@ -116,14 +116,22 @@ public:
return {};
}
std::pair<IpmiServer *, bool> createIpmiServer(utils::kstring name) {
std::pair<Ref<IpmiServer>, ErrorCode> createIpmiServer(utils::kstring name) {
std::lock_guard lock(m_sem_mtx);
auto [it, inserted] = mIpmiServers.try_emplace(std::move(name), nullptr);
if (inserted) {
it->second = knew<IpmiServer>(it->first);
if (!inserted) {
return {it->second, ErrorCode::EXIST};
}
return {it->second.get(), inserted};
it->second = knew<IpmiServer>(it->first);
if (it->second == nullptr) {
mIpmiServers.erase(it);
return {nullptr, ErrorCode::NOMEM};
}
return {it->second, {}};
}
Ref<IpmiServer> findIpmiServer(std::string_view name) {

116
orbis-kernel/include/orbis/ipmi.hpp
View file

@ -1,19 +1,133 @@
#pragma once
#include "KernelAllocator.hpp"
#include "evf.hpp"
#include "orbis-config.hpp"
#include "orbis/utils/SharedCV.hpp"
#include "orbis/utils/SharedMutex.hpp"
#include "utils/Rc.hpp"
#include <list>
namespace orbis {
struct IpmiSession;
struct IpmiClient;
struct Thread;
struct IpmiServer : RcBase {
struct IpmiPacketInfo {
ptr<void> userData;
uint type;
uint clientKid;
ptr<void> eventHandler;
};
static_assert(sizeof(IpmiPacketInfo) == 0x18);
struct Packet {
IpmiPacketInfo info;
kvector<std::byte> message;
};
struct ConnectionRequest {
Ref<IpmiClient> client;
slong clientTid{};
slong clientPid{};
slong serverTid{};
};
kstring name;
ptr<void> serverImpl;
ptr<void> eventHandler;
ptr<void> userData;
shared_mutex mutex;
shared_cv receiveCv;
sint pid;
kdeque<Packet> packets;
std::list<ConnectionRequest, kallocator<ConnectionRequest>>
connectionRequests;
explicit IpmiServer(kstring name) : name(std::move(name)) {}
};
struct IpmiClient : RcBase {
Ref<IpmiServer> connection;
kstring name;
ptr<void> clientImpl;
ptr<void> userData;
Ref<IpmiSession> session;
shared_mutex mutex;
sint pid;
explicit IpmiClient(kstring name) : name(std::move(name)) {}
};
struct IpmiSession : RcBase {
struct MessageResponse {
sint errorCode;
kvector<std::byte> data;
};
ptr<void> sessionImpl;
ptr<void> userData;
Ref<IpmiClient> client;
Ref<IpmiServer> server;
shared_mutex mutex;
shared_cv responseCv;
kdeque<MessageResponse> messageResponses;
EventFlag evf{0, 0};
bool connection = false; // TODO: implement more states
};
struct IpmiCreateServerConfig {
orbis::uint64_t size;
orbis::uint32_t unk1;
orbis::uint32_t unk2;
orbis::uint32_t unk3;
orbis::uint32_t unk4;
orbis::uint32_t enableMultipleServerThreads;
orbis::uint32_t unk5;
orbis::uint64_t unk6;
orbis::ptr<void> userData;
orbis::ptr<void> eventHandler;
};
static_assert(sizeof(IpmiCreateServerConfig) == 0x38);
ErrorCode ipmiCreateClient(Thread *thread, void *clientImpl, const char *name,
void *config, Ref<IpmiClient> &result);
ErrorCode ipmiCreateServer(Thread *thread, void *serverImpl, const char *name,
const IpmiCreateServerConfig &config,
Ref<IpmiServer> &result);
ErrorCode ipmiCreateSession(Thread *thread, void *sessionImpl,
ptr<void> userData, Ref<IpmiSession> &result);
SysResult sysIpmiCreateClient(Thread *thread, ptr<uint> result,
ptr<void> params, uint64_t paramsSz);
SysResult sysIpmiCreateServer(Thread *thread, ptr<uint> result,
ptr<void> params, uint64_t paramsSz);
SysResult sysIpmiCreateSession(Thread *thread, ptr<uint> result,
ptr<void> params, uint64_t paramsSz);
SysResult sysIpmiDestroyClient(Thread *thread, ptr<uint> result, uint kid,
ptr<void> params, uint64_t paramsSz);
SysResult sysIpmiDestroyServer(Thread *thread, ptr<uint> result, uint kid,
ptr<void> params, uint64_t paramsSz);
SysResult sysIpmiDestroySession(Thread *thread, ptr<uint> result, uint kid,
ptr<void> params, uint64_t paramsSz);
SysResult sysIpmiServerReceivePacket(Thread *thread, ptr<uint> result, uint kid,
ptr<void> params, uint64_t paramsSz);
SysResult sysIpmiSessionConnectResult(Thread *thread, ptr<uint> result,
uint kid, ptr<void> params,
uint64_t paramsSz);
SysResult sysIpmiSessionRespondSync(Thread *thread, ptr<uint> result, uint kid,
ptr<void> params, uint64_t paramsSz);
SysResult sysIpmiSessionGetClientPid(Thread *thread, ptr<uint> result, uint kid,
ptr<void> params, uint64_t paramsSz);
SysResult sysIpmiClientInvokeSyncMethod(Thread *thread, ptr<uint> result,
uint kid, ptr<void> params,
uint64_t paramsSz);
SysResult sysIpmiClientConnect(Thread *thread, ptr<uint> result, uint kid,
ptr<void> params, uint64_t paramsSz);
SysResult sysIpmiServerGetName(Thread *thread, ptr<uint> result, uint kid,
ptr<void> params, uint64_t paramsSz);
} // namespace orbis

2
orbis-kernel/include/orbis/sys/sysproto.hpp
View file

@ -723,7 +723,7 @@ SysResult sys_test_debug_rwmem(Thread *thread /* TODO */);
SysResult sys_free_stack(Thread *thread /* TODO */);
SysResult sys_suspend_system(Thread *thread /* TODO */);
SysResult sys_ipmimgr_call(Thread *thread, uint op, uint kid, ptr<uint> result,
ptr<void> params, uint64_t paramsz, uint64_t arg6);
ptr<void> params, uint64_t paramsz);
SysResult sys_get_gpo(Thread *thread /* TODO */);
SysResult sys_get_vm_map_timestamp(Thread *thread /* TODO */);
SysResult sys_opmc_set_hw(Thread *thread /* TODO */);

3
orbis-kernel/include/orbis/thread/Process.hpp
View file

@ -61,8 +61,7 @@ struct Process final {
utils::RcIdMap<EventFlag, sint, 4097, 1> evfMap;
utils::RcIdMap<Semaphore, sint, 4097, 1> semMap;
utils::RcIdMap<IpmiClient, sint, 4097, 1> ipmiClientMap;
utils::RcIdMap<IpmiServer, sint, 4097, 1> ipmiServerMap;
utils::RcIdMap<RcBase, sint, 4097, 1> ipmiMap;
utils::RcIdMap<Module, ModuleHandle> modulesMap;
utils::OwningIdMap<Thread, lwpid_t> threadsMap;
utils::RcIdMap<orbis::File, sint> fileDescriptors;