[rpcsx-os/orbis-kernel] random fixes

fix pipe
fix socketpair
fix bridge
fix evf_wait with timeout
fix umtx_op(0x17)
implement ipmi evf
stub sched_get_priority_max/min
stub sys_rtprio_thread
implement sys_yield
emit event on signal
stub ajm register/unregister ioctls
stub av_control ioctl
hack removal

orbis-kernel/include/orbis/evf.hpp

@@ -24,9 +24,9 @@ struct EventFlag final {
   char name[32];
 
   bool isDeleted = false;
-  std::uint8_t attrs;
+  std::uint8_t attrs = kEvfAttrMulti | kEvfAttrThFifo;
   std::atomic<unsigned> references{0};
-  std::atomic<std::uint64_t> value;
+  std::atomic<std::uint64_t> value{0};
 
   struct WaitingThread {
     Thread *thread;
@@ -61,7 +61,8 @@ struct EventFlag final {
 
   enum class NotifyType { Set, Cancel, Destroy };
 
-  explicit EventFlag(std::int32_t attrs, std::uint64_t initPattern)
+  EventFlag() = default;
+  EventFlag(std::int32_t attrs, std::uint64_t initPattern)
       : attrs(attrs), value(initPattern) {}
 
   ErrorCode wait(Thread *thread, std::uint8_t waitMode,

orbis-kernel/include/orbis/ipmi.hpp

@@ -59,6 +59,7 @@ struct IpmiClient : RcBase {
   shared_cv sessionCv;
   sint pid;
   kdeque<kvector<std::byte>> messages;
+  kdeque<EventFlag> eventFlags;
   shared_cv messageCv;
 
   explicit IpmiClient(kstring name) : name(std::move(name)) {}
@@ -77,7 +78,6 @@ struct IpmiSession : RcBase {
   shared_mutex mutex;
   shared_cv responseCv;
   kdeque<MessageResponse> messageResponses;
-  EventFlag evf{0, 0};
   shared_cv connectCv;
   bool expectedOutput = false; // TODO: verify
   sint connectionStatus{0};
@@ -98,12 +98,19 @@ struct IpmiCreateServerConfig {
 
 static_assert(sizeof(IpmiCreateServerConfig) == 0x38);
 
+struct IpmiCreateClientConfig {
+  orbis::uint64_t size;
+  orbis::uint32_t unk[80];
+  orbis::ptr<void> userData;
+};
+
+static_assert(sizeof(IpmiCreateClientConfig) == 0x150);
+
 struct IpmiBufferInfo {
   ptr<void> data;
   uint64_t size;
 };
 
-static_assert(sizeof(IpmiBufferInfo) == 0x10);
 
 struct IpmiDataInfo {
   ptr<void> data;
@@ -111,6 +118,7 @@ struct IpmiDataInfo {
   uint64_t capacity; //?
 };
 
+static_assert(sizeof(IpmiBufferInfo) == 0x10);
 static_assert(sizeof(IpmiDataInfo) == 0x18);
 
 struct IpmiSyncMessageHeader {
@@ -124,7 +132,7 @@ struct IpmiSyncMessageHeader {
 static_assert(sizeof(IpmiSyncMessageHeader) == 0x18);
 
 ErrorCode ipmiCreateClient(Process *proc, void *clientImpl, const char *name,
-                           void *config, Ref<IpmiClient> &result);
+                           const IpmiCreateClientConfig &config, Ref<IpmiClient> &result);
 ErrorCode ipmiCreateServer(Process *proc, void *serverImpl, const char *name,
                            const IpmiCreateServerConfig &config,
                            Ref<IpmiServer> &result);
@@ -151,16 +159,21 @@ SysResult sysIpmiSendConnectResult(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 sysIpmiClientInvokeAsyncMethod(Thread *thread, ptr<uint> result,
+                                         uint kid, ptr<void> params,
+                                         uint64_t paramsSz);
+SysResult sysIpmiClientTryGetResult(Thread *thread, ptr<uint> result,
+                                          uint kid, ptr<void> params,
+                                          uint64_t paramsSz);
 SysResult sysIpmiClientGetMessage(Thread *thread, ptr<uint> result, uint kid,
                                   ptr<void> params, uint64_t paramsSz);
 SysResult sysIpmiClientTryGetMessage(Thread *thread, ptr<uint> result, uint kid,
                                      ptr<void> params, uint64_t paramsSz);
 SysResult sysIpmiSessionTrySendMessage(Thread *thread, ptr<uint> result,
-                                      uint kid, ptr<void> params,
-                                      uint64_t paramsSz);
-SysResult sysIpmiClientDisconnect(Thread *thread, ptr<uint> result,
-                                        uint kid, ptr<void> params,
-                                        uint64_t paramsSz);
+                                       uint kid, ptr<void> params,
+                                       uint64_t paramsSz);
+SysResult sysIpmiClientDisconnect(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,
@@ -172,11 +185,10 @@ SysResult sysIpmiSessionGetUserData(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);
+SysResult sysIpmiClientWaitEventFlag(Thread *thread, ptr<uint> result, uint kid,
+                                     ptr<void> params, uint64_t paramsSz);
 SysResult sysIpmiClientPollEventFlag(Thread *thread, ptr<uint> result, uint kid,
                                      ptr<void> params, uint64_t paramsSz);
-SysResult sysIpmiSessionWaitEventFlag(Thread *thread, ptr<uint> result,
-                                      uint kid, ptr<void> params,
-                                      uint64_t paramsSz);
 SysResult sysIpmiSessionSetEventFlag(Thread *thread, ptr<uint> result, uint kid,
                                      ptr<void> params, uint64_t paramsSz);
 

orbis-kernel/include/orbis/pipe.hpp

@@ -5,12 +5,14 @@
 #include "utils/Rc.hpp"
 #include "utils/SharedCV.hpp"
 #include "utils/SharedMutex.hpp"
+#include <utility>
 
 namespace orbis {
 struct Pipe final : File {
   shared_cv cv;
   kvector<std::byte> data;
+  Ref<Pipe> other;
 };
 
-Ref<Pipe> createPipe();
+std::pair<Ref<Pipe>, Ref<Pipe>> createPipe();
 } // namespace orbis

orbis-kernel/include/orbis/sys/sysproto.hpp

@@ -21,6 +21,7 @@ struct Stat;
 struct stack_t;
 struct IoVec;
 struct BatchMapEntry;
+struct UContext;
 
 SysResult nosys(Thread *thread);
 
@@ -743,10 +744,10 @@ SysResult sys_mmap_dmem(Thread *thread, caddr_t addr, size_t len,
 SysResult sys_physhm_open(Thread *thread /* TODO */);
 SysResult sys_physhm_unlink(Thread *thread /* TODO */);
 SysResult sys_resume_internal_hdd(Thread *thread /* TODO */);
-SysResult sys_thr_suspend_ucontext(Thread *thread /* TODO */);
-SysResult sys_thr_resume_ucontext(Thread *thread /* TODO */);
-SysResult sys_thr_get_ucontext(Thread *thread /* TODO */);
-SysResult sys_thr_set_ucontext(Thread *thread /* TODO */);
+SysResult sys_thr_suspend_ucontext(Thread *thread, lwpid_t tid);
+SysResult sys_thr_resume_ucontext(Thread *thread, lwpid_t tid);
+SysResult sys_thr_get_ucontext(Thread *thread, lwpid_t tid, ptr<UContext> context);
+SysResult sys_thr_set_ucontext(Thread *thread, lwpid_t tid, ptr<UContext> context);
 SysResult sys_set_timezone_info(Thread *thread /* TODO */);
 SysResult sys_set_phys_fmem_limit(Thread *thread /* TODO */);
 SysResult sys_utc_to_localtime(Thread *thread, int64_t time, int64_t *localtime,

orbis-kernel/include/orbis/thread/types.hpp

@@ -27,5 +27,7 @@ struct thr_param {
                    // following flags:
   ptr<rtprio> rtp; // Real-time scheduling priority for the new thread. May be
                    // NULL to inherit the priority from the creating	thread
+  ptr<char> name;
+  ptr<void> spare[2];
 };
 } // namespace orbis

orbis-kernel/include/orbis/ucontext.hpp

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "orbis-config.hpp"
+namespace orbis {
+
+struct MContext {
+  ulong onstack;
+  ulong rdi;
+  ulong rsi;
+  ulong rdx;
+  ulong rcx;
+  ulong r8;
+  ulong r9;
+  ulong rax;
+  ulong rbx;
+  ulong rbp;
+  ulong r10;
+  ulong r11;
+  ulong r12;
+  ulong r13;
+  ulong r14;
+  ulong r15;
+  uint trapno;
+  ushort fs;
+  ushort gs;
+  ulong addr;
+  uint flags;
+  ushort es;
+  ushort ds;
+  ulong err;
+  ulong rip;
+  ulong cs;
+  ulong rflags;
+  ulong rsp;
+  ulong ss;
+  ulong len;
+  ulong fpformat;
+  ulong ownedfp;
+  ulong lbrfrom;
+  ulong lbrto;
+  ulong aux1;
+  ulong aux2;
+  ulong fpstate[104];
+  ulong fsbase;
+  ulong gsbase;
+  ulong spare[6];
+};
+
+struct Stack {
+  ptr<void> sp;
+  size_t size;
+  sint flags;
+  sint align;
+};
+
+struct SigSet {
+  ulong bits[2];
+};
+
+struct UContext {
+  SigSet sigmask;
+  sint unk0[12];
+  MContext mcontext;
+  ptr<UContext> link;
+  Stack stack;
+  sint uc_flags;
+  sint spare[4];
+  sint unk1[3];
+};
+} // namespace orbis

orbis-kernel/include/orbis/umtx.hpp

@@ -85,7 +85,7 @@ ErrorCode umtx_rw_wrlock(Thread *thread, ptr<urwlock> rwlock, ulong ut);
 ErrorCode umtx_rw_unlock(Thread *thread, ptr<urwlock> rwlock);
 ErrorCode umtx_wake_private(Thread *thread, ptr<void> uaddr, sint n_wake);
 ErrorCode umtx_wait_umutex(Thread *thread, ptr<umutex> m, std::uint64_t ut);
-ErrorCode umtx_wake_umutex(Thread *thread, ptr<umutex> m);
+ErrorCode umtx_wake_umutex(Thread *thread, ptr<umutex> m, sint wakeFlags);
 ErrorCode umtx_sem_wait(Thread *thread, ptr<usem> sem, std::uint64_t ut);
 ErrorCode umtx_sem_wake(Thread *thread, ptr<usem> sem);
 ErrorCode umtx_nwake_private(Thread *thread, ptr<void *> uaddrs,