Function sys_cond_wait

kernel/cellos/src/sys_cond.cpp:343–509

}

error_code sys_cond_wait(ppu_thread &ppu, u32 cond_id, u64 timeout) {
  ppu.state += cpu_flag::wait;

  sys_cond.trace("sys_cond_wait(cond_id=0x%x, timeout=%lld)", cond_id, timeout);

  // Further function result
  ppu.gpr[3] = CELL_OK;

  auto &sstate = *ppu.optional_savestate_state;

  const auto cond = idm::get<lv2_obj, lv2_cond>(
      cond_id, [&, notify = lv2_obj::notify_all_t()](lv2_cond &cond) -> s64 {
        if (!ppu.loaded_from_savestate &&
            atomic_storage<u32>::load(cond.mutex->control.raw().owner) !=
                ppu.id) {
          return -1;
        }

        lv2_obj::prepare_for_sleep(ppu);

        std::lock_guard lock(cond.mutex->mutex);

        const u64 syscall_state = sstate.try_read<u64>().second;
        sstate.clear();

        if (ppu.loaded_from_savestate) {
          if (syscall_state & 1) {
            // Mutex sleep
            ensure(!cond.mutex->try_own(ppu));
          } else {
            lv2_obj::emplace(cond.sq, &ppu);
          }

          cond.sleep(ppu, timeout);
          return static_cast<u32>(syscall_state >> 32);
        }

        // Register waiter
        lv2_obj::emplace(cond.sq, &ppu);

        // Unlock the mutex
        const u32 count = cond.mutex->lock_count.exchange(0);

        if (const auto cpu = cond.mutex->reown<ppu_thread>()) {
          if (cpu->state & cpu_flag::again) {
            ensure(cond.unqueue(cond.sq, &ppu));
            ppu.state += cpu_flag::again;
            return 0;
          }

          cond.mutex->append(cpu);
        }

        // Sleep current thread and schedule mutex waiter
        cond.sleep(ppu, timeout);

        // Save the recursive value
        return count;