Function _sys_ppu_thread_create

kernel/cellos/src/sys_ppu_thread.cpp:441–526

}

error_code _sys_ppu_thread_create(ppu_thread &ppu, vm::ptr<u64> thread_id,
                                  vm::ptr<ppu_thread_param_t> param, u64 arg,
                                  u64 unk, s32 prio, u32 _stacksz, u64 flags,
                                  vm::cptr<char> threadname) {
  ppu.state += cpu_flag::wait;

  sys_ppu_thread.warning(
      "_sys_ppu_thread_create(thread_id=*0x%x, param=*0x%x, arg=0x%llx, "
      "unk=0x%llx, prio=%d, stacksize=0x%x, flags=0x%llx, threadname=*0x%x)",
      thread_id, param, arg, unk, prio, _stacksz, flags, threadname);

  // thread_id is checked for null in stub -> CELL_ENOMEM
  // unk is set to 0 in sys_ppu_thread_create stub

  if (!param || !param->entry) {
    return CELL_EFAULT;
  }

  if (prio < (g_ps3_process_info.debug_or_root() ? -512 : 0) || prio > 3071) {
    return CELL_EINVAL;
  }

  if ((flags & 3) == 3) // Check two flags: joinable + interrupt not allowed
  {
    return CELL_EPERM;
  }

  const ppu_func_opd_t entry = param->entry.opd();
  const u32 tls = param->tls;

  // Compute actual stack size and allocate
  const u32 stack_size = rx::alignUp<u32>(std::max<u32>(_stacksz, 4096), 4096);

  auto &dct = g_fxo->get<lv2_memory_container>();

  // Try to obtain "physical memory" from the default container
  if (!dct.take(stack_size)) {
    return {CELL_ENOMEM, dct.size - dct.used};
  }

  const vm::addr_t stack_base{vm::alloc(stack_size, vm::stack, 4096)};

  if (!stack_base) {
    dct.free(stack_size);
    return CELL_ENOMEM;
  }

  std::string ppu_name;

  if (threadname) {
    constexpr u32 max_size =
        c_max_ppu_name_size - 1; // max size excluding null terminator

    if (!vm::read_string(threadname.addr(), max_size, ppu_name, true)) {
      dct.free(stack_size);
      return CELL_EFAULT;
    }
  }