Function _sys_lwcond_queue_wait

kernel/cellos/src/sys_lwcond.cpp:383–565

}

error_code _sys_lwcond_queue_wait(ppu_thread &ppu, u32 lwcond_id,
                                  u32 lwmutex_id, u64 timeout) {
  ppu.state += cpu_flag::wait;

  sys_lwcond.trace(
      "_sys_lwcond_queue_wait(lwcond_id=0x%x, lwmutex_id=0x%x, timeout=0x%llx)",
      lwcond_id, lwmutex_id, timeout);

  ppu.gpr[3] = CELL_OK;

  shared_ptr<lv2_lwmutex> mutex;

  auto &sstate = *ppu.optional_savestate_state;

  const auto cond = idm::get<lv2_obj, lv2_lwcond>(
      lwcond_id, [&, notify = lv2_obj::notify_all_t()](lv2_lwcond &cond) {
        mutex = idm::get_unlocked<lv2_obj, lv2_lwmutex>(lwmutex_id);

        if (!mutex) {
          return;
        }

        // Increment lwmutex's lwcond's waiters count
        mutex->lwcond_waiters++;

        lv2_obj::prepare_for_sleep(ppu);

        std::lock_guard lock(cond.mutex);

        cond.lwmutex_waiters++;

        const bool mutex_sleep = sstate.try_read<bool>().second;
        sstate.clear();

        if (mutex_sleep) {
          // Special: loading state from the point of waiting on lwmutex sleep
          // queue
          mutex->try_own(&ppu, true);
        } else {
          // Add a waiter
          lv2_obj::emplace(cond.sq, &ppu);
        }

        if (!ppu.loaded_from_savestate && !mutex->try_unlock(false)) {
          std::lock_guard lock2(mutex->mutex);

          // Process lwmutex sleep queue
          if (const auto cpu = mutex->reown<ppu_thread>()) {
            if (static_cast<ppu_thread *>(cpu)->state & cpu_flag::again) {
              ensure(cond.unqueue(cond.sq, &ppu));
              ppu.state += cpu_flag::again;
              return;
            }

            // Put the current thread to sleep and schedule lwmutex waiter
            // atomically
            cond.append(cpu);
            cond.sleep(ppu, timeout);