rpcsx/kernel/cellos/include/cellos/sys_lwmutex.h

#pragma once

#include "sys_sync.h"

#include "Emu/Memory/vm_ptr.h"

struct sys_lwmutex_attribute_t {
  be_t<u32> protocol;
  be_t<u32> recursive;

  union {
    nse_t<u64, 1> name_u64;
    char name[sizeof(u64)];
  };
};

enum : u32 {
  lwmutex_free = 0xffffffffu,
  lwmutex_dead = 0xfffffffeu,
  lwmutex_reserved = 0xfffffffdu,
};

struct sys_lwmutex_t {
  struct alignas(8) sync_var_t {
    be_t<u32> owner;
    be_t<u32> waiter;
  };

  union {
    atomic_t<sync_var_t> lock_var;

    struct {
      atomic_be_t<u32> owner;
      atomic_be_t<u32> waiter;
    } vars;

    atomic_be_t<u64> all_info;
  };

  be_t<u32> attribute;
  be_t<u32> recursive_count;
  be_t<u32> sleep_queue; // lwmutex pseudo-id
  be_t<u32> pad;
};

struct lv2_lwmutex final : lv2_obj {
  static const u32 id_base = 0x95000000;

  const lv2_protocol protocol;
  const vm::ptr<sys_lwmutex_t> control;
  const be_t<u64> name;

  shared_mutex mutex;
  atomic_t<s32> lwcond_waiters{0};

  struct alignas(16) control_data_t {
    s32 signaled{0};
    u32 reserved{};
    ppu_thread *sq{};
  };

  atomic_t<control_data_t> lv2_control{};

  lv2_lwmutex(u32 protocol, vm::ptr<sys_lwmutex_t> control, u64 name) noexcept
      : protocol{static_cast<u8>(protocol)}, control(control),
        name(std::bit_cast<be_t<u64>>(name)) {}

  lv2_lwmutex(utils::serial &ar);
  void save(utils::serial &ar);

  ppu_thread *load_sq() const {
    return atomic_storage<ppu_thread *>::load(lv2_control.raw().sq);
  }

  template <typename T> s32 try_own(T *cpu, bool wait_only = false) {
    const s32 signal =
        lv2_control
            .fetch_op([&](control_data_t &data) {
              if (!data.signaled) {
                cpu->prio.atomic_op(
                    [tag = ++g_priority_order_tag](
                        std::common_type_t<decltype(T::prio)> &prio) {
                      prio.order = tag;
                    });

                cpu->next_cpu = data.sq;
                data.sq = cpu;
              } else {
                ensure(!wait_only);
                data.signaled = 0;
              }
            })
            .signaled;

    if (signal) {
      cpu->next_cpu = nullptr;
    } else {
      const bool notify = lwcond_waiters
                              .fetch_op([](s32 &val) {
                                if (val + 0u <= 1u << 31) {
                                  // Value was either positive or INT32_MIN
                                  return false;
                                }

                                // lwmutex was set to be destroyed, but there
                                // are lwcond waiters
                                // Turn off the "lwcond_waiters notification"
                                // bit as we are adding an lwmutex waiter
                                val &= 0x7fff'ffff;
                                return true;
                              })
                              .second;

      if (notify) {
        // Notify lwmutex destroyer (may cause EBUSY to be returned for it)
        lwcond_waiters.notify_all();
      }
    }

    return signal;
  }

  bool try_unlock(bool unlock2) {
    if (!load_sq()) {
      control_data_t old{};
      old.signaled = atomic_storage<s32>::load(lv2_control.raw().signaled);
      control_data_t store = old;
      store.signaled |= (unlock2 ? s32{smin} : 1);

      if (lv2_control.compare_exchange(old, store)) {
        return true;
      }
    }

    return false;
  }

  template <typename T> T *reown(bool unlock2 = false) {
    T *res = nullptr;

    lv2_control.fetch_op([&](control_data_t &data) {
      res = nullptr;

      if (auto sq = static_cast<T *>(data.sq)) {
        res = schedule<T>(data.sq, protocol, false);

        if (sq == data.sq) {
          return false;
        }

        return true;
      } else {
        data.signaled |= (unlock2 ? s32{smin} : 1);
        return true;
      }
    });

    if (res && cpu_flag::again - res->state) {
      // Detach manually (fetch_op can fail, so avoid side-effects on the first
      // node in this case)
      res->next_cpu = nullptr;
    }

    return res;
  }
};

// Aux
class ppu_thread;

// Syscalls

error_code _sys_lwmutex_create(ppu_thread &ppu, vm::ptr<u32> lwmutex_id,
                               u32 protocol, vm::ptr<sys_lwmutex_t> control,
                               s32 has_name, u64 name);
error_code _sys_lwmutex_destroy(ppu_thread &ppu, u32 lwmutex_id);
error_code _sys_lwmutex_lock(ppu_thread &ppu, u32 lwmutex_id, u64 timeout);
error_code _sys_lwmutex_trylock(ppu_thread &ppu, u32 lwmutex_id);
error_code _sys_lwmutex_unlock(ppu_thread &ppu, u32 lwmutex_id);
error_code _sys_lwmutex_unlock2(ppu_thread &ppu, u32 lwmutex_id);