Fixed some problems

rpcs3/Emu/Cell/SPUThread.h

@@ -611,7 +611,7 @@ public:
 
 		case SPU_RdInMbox:
 			count = SPU.In_MBox.GetCount();
-			ConLog.Warning("GetChannelCount(%s) -> %d", wxString(spu_ch_name[ch]).wx_str(), count);
+			//ConLog.Warning("GetChannelCount(%s) -> %d", wxString(spu_ch_name[ch]).wx_str(), count);
 			return count;
 
 		case SPU_WrOutIntrMbox:

rpcs3/Emu/SysCalls/Modules/cellAudio.cpp

@@ -334,6 +334,8 @@ int cellAudioGetPortConfig(u32 portNum, mem_ptr_t<CellAudioPortConfig> portConfi
 		portConfig->portAddr = m_config.m_ports[portNum]->m_buffer; // 0x20020000
 		portConfig->readIndexAddr = m_config.m_ports[portNum]->m_index; // 0x20010010 on ps3
 
+		ConLog.Write("*** nChannel=%d, nBlock=%d, portSize=0x%x, portAddr=0x%x, readIndexAddr=0x%x",
+			(u32)portConfig->nChannel, (u32)portConfig->nBlock, (u32)portConfig->portSize, (u32)portConfig->portAddr, (u32)portConfig->readIndexAddr);
 		// portAddr - readIndexAddr ==  0xFFF0 on ps3
 	}
 
@@ -446,6 +448,7 @@ int cellAudioSetPortLevel(u32 portNum, float level)
 int cellAudioCreateNotifyEventQueue(mem32_t id, mem64_t key)
 {
 	cellAudio.Error("cellAudioCreateNotifyEventQueue(id_addr=0x%x, key_addr=0x%x)", id.GetAddr(), key.GetAddr());
+	key = 0x123456789ABCDEF0;
 	return CELL_OK;
 }
 
@@ -464,7 +467,8 @@ int cellAudioSetNotifyEventQueue(u64 key)
 	EventQueue* eq;
 	if (!Emu.GetEventManager().GetEventQueue(key, eq))
 	{
-		return CELL_AUDIO_ERROR_PARAM;
+		//return CELL_AUDIO_ERROR_PARAM;
+		return CELL_OK;
 	}
 
 	// eq->events.push(0, 0, 0, 0);

rpcs3/Emu/SysCalls/Modules/cellPamf.cpp

@@ -118,8 +118,8 @@ int cellPamfGetHeaderSize(mem_ptr_t<PamfHeader> pAddr, u64 fileSize, mem64_t pSi
 	cellPamf.Warning("cellPamfGetHeaderSize(pAddr=0x%x, fileSize=%d, pSize_addr=0x%x)",
 		pAddr.GetAddr(), fileSize, pSize.GetAddr());
 
-	//if ((u32)pAddr->magic != 0x464d4150)
+	if ((u32)pAddr->magic != 0x464d4150)
-		//return CELL_PAMF_ERROR_UNKNOWN_TYPE;
+		return CELL_PAMF_ERROR_UNKNOWN_TYPE;
 
 	const u64 offset = (u64)pAddr->data_offset << 11;
 	pSize = offset /*? offset : 2048*/; //hack

rpcs3/Emu/SysCalls/Modules/cellSync.cpp

@@ -95,15 +95,13 @@ int cellSyncMutexLock(mem_ptr_t<CellSyncMutex> mutex)
 		}
 	}
 
-	int counter = 0;
+	while (old_order != Memory.Read16(mutex.GetAddr())) 
-	while (*(u16*)&old_order != *(u16*)&mutex->m_freed) 
 	{
 		Sleep(1);
-		if (++counter >= 5000)
+		if (Emu.IsStopped())
 		{
-			counter = 0;
+			ConLog.Warning("cellSyncMutexLock(mutex=0x%x) aborted", mutex.GetAddr());
-			cellSync.Warning("cellSyncMutexLock(mutex=0x%x, old_order=%d, order=%d, freed=%d): TIMEOUT", 
+			break;
-				mutex.GetAddr(), (u16)old_order, (u16)mutex->m_order, (u16)mutex->m_freed);
 		}
 	}
 	_mm_mfence();

rpcs3/Emu/SysCalls/Modules/cellSysutil.cpp

@@ -458,12 +458,15 @@ int cellVideoOutGetResolutionAvailability(u32 videoOut, u32 resolutionId, u32 as
 int cellSysutilCheckCallback()
 {
 	cellSysutil.Log("cellSysutilCheckCallback()");
+
 	Emu.GetCallbackManager().m_exit_callback.Check();
 
 	CPUThread& thr = Emu.GetCallbackThread();
 
-	while(Emu.IsRunning() && thr.IsAlive())
+	while (Emu.IsRunning() && thr.IsAlive())
+	{
 		Sleep(1);
+	}
 
 	return CELL_OK;
 }
@@ -471,6 +474,7 @@ int cellSysutilCheckCallback()
 int cellSysutilRegisterCallback(int slot, u64 func_addr, u64 userdata)
 {
 	cellSysutil.Warning("cellSysutilRegisterCallback(slot=%d, func_addr=0x%llx, userdata=0x%llx)", slot, func_addr, userdata);
+
 	Emu.GetCallbackManager().m_exit_callback.Register(slot, func_addr, userdata);
 
 	wxGetApp().SendDbgCommand(DID_REGISTRED_CALLBACK);
@@ -481,6 +485,7 @@ int cellSysutilRegisterCallback(int slot, u64 func_addr, u64 userdata)
 int cellSysutilUnregisterCallback(int slot)
 {
 	cellSysutil.Warning("cellSysutilUnregisterCallback(slot=%d)", slot);
+
 	Emu.GetCallbackManager().m_exit_callback.Unregister(slot);
 
 	wxGetApp().SendDbgCommand(DID_UNREGISTRED_CALLBACK);
@@ -646,7 +651,7 @@ int cellAudioOutGetSoundAvailability(u32 audioOut, u32 type, u32 fs, u32 option)
 
 	option = 0;
 
-	int available = 2;
+	int available = 2; // should be at least 2
 
 	switch(fs)
 	{
@@ -687,7 +692,7 @@ int cellAudioOutGetSoundAvailability2(u32 audioOut, u32 type, u32 fs, u32 ch, u3
 
 	option = 0;
 
-	int available = 2;
+	int available = 2; // should be at least 2
 
 	switch(fs)
 	{

rpcs3/Emu/SysCalls/Modules/sys_fs.cpp

@@ -137,8 +137,13 @@ int cellFsSdataOpen(u32 path_addr, int flags, mem32_t fd, mem32_t arg, u64 size)
 	return CELL_OK;
 }
 
+SMutex aio_mutex;
+bool aio_init;
+
 void fsAioRead(u32 fd, mem_ptr_t<CellFsAio> aio, int xid, mem_func_ptr_t<void (*)(mem_ptr_t<CellFsAio> xaio, u32 error, int xid, u64 size)> func)
 {
+	//SMutexLocker lock (aio_mutex);
+
 	vfsFileBase* orig_file;
 	if(!sys_fs.CheckId(fd, orig_file)) return;
 
@@ -175,30 +180,43 @@ void fsAioRead(u32 fd, mem_ptr_t<CellFsAio> aio, int xid, mem_func_ptr_t<void (*
 		error = CELL_EFAULT;
 	}
 
+	ConLog.Warning("*** fsAioRead(fd=%d, offset=0x%llx, buf_addr=0x%x, size=0x%x, res=0x%x, xid=0x%x [%s])",
+		fd, (u64)aio->offset, buf_addr, (u64)aio->size, res, xid, path.wx_str());
+
 	//start callback thread
 	if(func)
 		func.async(aio, error, xid, res);
-
-	ConLog.Warning("*** fsAioRead(fd=%d, offset=0x%llx, buf_addr=0x%x, size=0x%x, res=0x%x, xid=0x%x [%s])",
-		fd, (u64)aio->offset, buf_addr, (u64)aio->size, res, xid, path.wx_str());
 }
 
 int cellFsAioRead(mem_ptr_t<CellFsAio> aio, mem32_t aio_id, mem_func_ptr_t<void (*)(mem_ptr_t<CellFsAio> xaio, u32 error, int xid, u64 size)> func)
 {
 	sys_fs.Warning("cellFsAioRead(aio_addr=0x%x, id_addr=0x%x, func_addr=0x%x)", aio.GetAddr(), aio_id.GetAddr(), func.GetAddr());
+
+	if (!aio.IsGood() || !aio_id.IsGood() || !func.IsGood())
+	{
+		return CELL_EFAULT;
+	}
+
+	if (!aio_init)
+	{
+		return CELL_ENXIO;
+	}
+
 	vfsFileBase* orig_file;
 	u32 fd = aio->fd;
-	if(!sys_fs.CheckId(fd, orig_file)) return CELL_ESRCH;
+	if (!sys_fs.CheckId(fd, orig_file)) return CELL_EBADF;
 
 	//get a unique id for the callback (may be used by cellFsAioCancel)
 	const u32 xid = g_FsAioReadID++;
-
-	thread t("fsAioRead", std::bind(fsAioRead, fd, aio, xid, func));
-	t.detach();
-	//fsAioRead(fd, aio, xid, func);
-
 	aio_id = xid;
 
+	{
+		//SMutexLocker lock(aio_mutex);
+		thread t("fsAioRead", std::bind(fsAioRead, fd, aio, xid, func));
+		t.detach();
+		//fsAioRead(fd, aio, xid, func);
+	}
+
 	return CELL_OK;
 }
 
@@ -206,6 +224,7 @@ int cellFsAioInit(mem8_ptr_t mount_point)
 {
 	wxString mp = Memory.ReadString(mount_point.GetAddr());
 	sys_fs.Warning("cellFsAioInit(mount_point_addr=0x%x (%s))", mount_point.GetAddr(), mp.wx_str());
+	aio_init = true;
 	return CELL_OK;
 }
 
@@ -239,4 +258,5 @@ void sys_fs_init()
 	sys_fs.AddFunc(0xc1c507e7, cellFsAioRead);
 	sys_fs.AddFunc(0xdb869f20, cellFsAioInit);
 	sys_fs.AddFunc(0x9f951810, cellFsAioFinish);
+	aio_init = false;
 }

rpcs3/Emu/SysCalls/lv2/SC_Condition.cpp

@@ -6,7 +6,7 @@ SysCallBase sys_cond("sys_cond");
 
 int sys_cond_create(mem32_t cond_id, u32 mutex_id, mem_ptr_t<sys_cond_attribute> attr)
 {
-	sys_cond.Warning("sys_cond_create(cond_id_addr=0x%x, mutex_id=%d, attr_addr=%d)",
+	sys_cond.Log("sys_cond_create(cond_id_addr=0x%x, mutex_id=%d, attr_addr=%d)",
 		cond_id.GetAddr(), mutex_id, attr.GetAddr());
 
 	if (!cond_id.IsGood() || !attr.IsGood())
@@ -30,7 +30,7 @@ int sys_cond_create(mem32_t cond_id, u32 mutex_id, mem_ptr_t<sys_cond_attribute>
 	u32 id = sys_cond.GetNewId(cond);
 	cond_id = id;
 	mutex->cond_count++;
-	sys_cond.Warning("*** condition created [%s]: id = %d", wxString(attr->name, 8).wx_str(), cond_id.GetValue());
+	sys_cond.Warning("*** condition created [%s] (mutex_id=%d): id = %d", wxString(attr->name, 8).wx_str(), mutex_id, cond_id.GetValue());
 
 	return CELL_OK;
 }
@@ -75,6 +75,7 @@ int sys_cond_wait(u32 cond_id, u64 timeout)
 
 	cond->m_queue.push(tid);
 
+	mutex->recursive = 0;
 	mutex->m_mutex.unlock(tid);
 
 	u32 counter = 0;
@@ -85,11 +86,12 @@ int sys_cond_wait(u32 cond_id, u64 timeout)
 		/* switch (mutex->m_mutex.trylock(tid))
 		{
 		case SMR_OK: mutex->m_mutex.unlock(tid); break;
-		case SMR_SIGNAL: return CELL_OK;
+		case SMR_SIGNAL: mutex->recursive = 1; return CELL_OK;
 		} */
 		if (mutex->m_mutex.GetOwner() == tid)
 		{
 			_mm_mfence();
+			mutex->recursive = 1;
 			return CELL_OK;
 		}
 
@@ -126,6 +128,7 @@ int sys_cond_signal(u32 cond_id)
 		if (mutex->m_mutex.trylock(target) != SMR_OK)
 		{
 			mutex->m_mutex.lock(tid);
+			mutex->recursive = 1;
 			mutex->m_mutex.unlock(tid, target);
 		}
 	}
@@ -156,6 +159,7 @@ int sys_cond_signal_all(u32 cond_id)
 		if (mutex->m_mutex.trylock(target) != SMR_OK)
 		{
 			mutex->m_mutex.lock(tid);
+			mutex->recursive = 1;
 			mutex->m_mutex.unlock(tid, target);
 		}
 	}
@@ -189,6 +193,7 @@ int sys_cond_signal_to(u32 cond_id, u32 thread_id)
 	if (mutex->m_mutex.trylock(thread_id) != SMR_OK)
 	{
 		mutex->m_mutex.lock(tid);
+		mutex->recursive = 1;
 		mutex->m_mutex.unlock(tid, thread_id);
 	}
 

rpcs3/Emu/SysCalls/lv2/SC_Lwcond.cpp

@@ -7,10 +7,10 @@ SysCallBase sys_lwcond("sys_lwcond");
 
 int sys_lwcond_create(mem_ptr_t<sys_lwcond_t> lwcond, mem_ptr_t<sys_lwmutex_t> lwmutex, mem_ptr_t<sys_lwcond_attribute_t> attr)
 {
-	sys_lwcond.Warning("sys_lwcond_create(lwcond_addr=0x%x, lwmutex_addr=0x%x, attr_addr=0x%x)",
+	sys_lwcond.Log("sys_lwcond_create(lwcond_addr=0x%x, lwmutex_addr=0x%x, attr_addr=0x%x)",
 		lwcond.GetAddr(), lwmutex.GetAddr(), attr.GetAddr());
 
-	if (!lwcond.IsGood() || !lwmutex.IsGood() || !attr.IsGood())
+	if (!lwcond.IsGood() /*|| !lwmutex.IsGood()*/ || !attr.IsGood())
 	{
 		return CELL_EFAULT;
 	}
@@ -18,13 +18,16 @@ int sys_lwcond_create(mem_ptr_t<sys_lwcond_t> lwcond, mem_ptr_t<sys_lwmutex_t> l
 	lwcond->lwmutex = lwmutex.GetAddr();
 	lwcond->lwcond_queue = sys_lwcond.GetNewId(new SleepQueue(attr->name_u64));
 
-	if (lwmutex->attribute.ToBE() == se32(SYS_SYNC_RETRY))
+	if (lwmutex.IsGood())
 	{
-		sys_lwcond.Warning("Unsupported SYS_SYNC_RETRY lwmutex protocol");
+		if (lwmutex->attribute.ToBE() == se32(SYS_SYNC_RETRY))
+		{
+			sys_lwcond.Warning("Unsupported SYS_SYNC_RETRY lwmutex protocol");
+		}
 	}
 
-	sys_lwcond.Warning("*** lwcond created [%s] (lwmutex.attr=0x%x): id = %d", 
+	sys_lwcond.Warning("*** lwcond created [%s] (lwmutex_addr=0x%x): id = %d", 
-		wxString(attr->name, 8).wx_str(), (u32)lwmutex->attribute, (u32)lwcond->lwcond_queue);
+		wxString(attr->name, 8).wx_str(), lwmutex.GetAddr(), (u32)lwcond->lwcond_queue);
 
 	return CELL_OK;
 }
@@ -78,6 +81,7 @@ int sys_lwcond_signal(mem_ptr_t<sys_lwcond_t> lwcond)
 		if (mutex->owner.trylock(target) != SMR_OK)
 		{
 			mutex->owner.lock(tid);
+			mutex->recursive_count = 1;
 			mutex->owner.unlock(tid, target);
 		}
 	}
@@ -113,6 +117,7 @@ int sys_lwcond_signal_all(mem_ptr_t<sys_lwcond_t> lwcond)
 		if (mutex->owner.trylock(target) != SMR_OK)
 		{
 			mutex->owner.lock(tid);
+			mutex->recursive_count = 1;
 			mutex->owner.unlock(tid, target);
 		}
 	}
@@ -153,6 +158,7 @@ int sys_lwcond_signal_to(mem_ptr_t<sys_lwcond_t> lwcond, u32 ppu_thread_id)
 	if (mutex->owner.trylock(target) != SMR_OK)
 	{
 		mutex->owner.lock(tid);
+		mutex->recursive_count = 1;
 		mutex->owner.unlock(tid, target);
 	}
 
@@ -190,6 +196,7 @@ int sys_lwcond_wait(mem_ptr_t<sys_lwcond_t> lwcond, u64 timeout)
 
 	sq->push(tid_le);
 
+	mutex->recursive_count = 0;
 	mutex->owner.unlock(tid);
 
 	u32 counter = 0;
@@ -204,6 +211,7 @@ int sys_lwcond_wait(mem_ptr_t<sys_lwcond_t> lwcond, u64 timeout)
 		if (mutex->owner.GetOwner() == tid)
 		{
 			_mm_mfence();
+			mutex->recursive_count = 1;
 			return CELL_OK;
 		}
 

rpcs3/Emu/SysCalls/lv2/SC_Lwmutex.cpp

@@ -6,7 +6,7 @@ SysCallBase sc_lwmutex("sys_lwmutex");
 
 int sys_lwmutex_create(mem_ptr_t<sys_lwmutex_t> lwmutex, mem_ptr_t<sys_lwmutex_attribute_t> attr)
 {
-	sc_lwmutex.Warning("sys_lwmutex_create(lwmutex_addr=0x%x, lwmutex_attr_addr=0x%x)", 
+	sc_lwmutex.Log("sys_lwmutex_create(lwmutex_addr=0x%x, lwmutex_attr_addr=0x%x)", 
 		lwmutex.GetAddr(), attr.GetAddr());
 
 	if (!lwmutex.IsGood() || !attr.IsGood()) return CELL_EFAULT;

rpcs3/Emu/SysCalls/lv2/SC_Mutex.cpp

@@ -7,7 +7,7 @@ SysCallBase sys_mtx("sys_mutex");
 
 int sys_mutex_create(mem32_t mutex_id, mem_ptr_t<sys_mutex_attribute> attr)
 {
-	sys_mtx.Warning("sys_mutex_create(mutex_id_addr=0x%x, attr_addr=0x%x)", mutex_id.GetAddr(), attr.GetAddr());
+	sys_mtx.Log("sys_mutex_create(mutex_id_addr=0x%x, attr_addr=0x%x)", mutex_id.GetAddr(), attr.GetAddr());
 
 	if (!mutex_id.IsGood() || !attr.IsGood())
 	{
@@ -38,8 +38,9 @@ int sys_mutex_create(mem32_t mutex_id, mem_ptr_t<sys_mutex_attribute> attr)
 	}
 
 	mutex_id = sys_mtx.GetNewId(new Mutex((u32)attr->protocol, is_recursive, attr->name_u64));
-	sys_mtx.Warning("*** mutex created [%s] (protocol=0x%x, recursive=%d): id = %d",
+	sys_mtx.Warning("*** mutex created [%s] (protocol=0x%x, recursive=%s): id = %d",
-		wxString(attr->name, 8).wx_str(), (u32)attr->protocol, is_recursive, mutex_id.GetValue());
+		wxString(attr->name, 8).wx_str(), (u32)attr->protocol,
+		wxString(is_recursive ? "true" : "false").wx_str(), mutex_id.GetValue());
 
 	return CELL_OK;
 }
@@ -93,7 +94,7 @@ int sys_mutex_lock(u32 mutex_id, u64 timeout)
 	{
 		if (mutex->is_recursive)
 		{
-			if (mutex->recursive++ == 0)
+			if (++mutex->recursive == 0)
 			{
 				return CELL_EKRESOURCE;
 			}
@@ -107,7 +108,7 @@ int sys_mutex_lock(u32 mutex_id, u64 timeout)
 
 	switch (mutex->m_mutex.trylock(tid))
 	{
-	case SMR_OK: return CELL_OK;
+	case SMR_OK: mutex->recursive = 1; return CELL_OK;
 	case SMR_FAILED: break;
 	default: goto abort;
 	}
@@ -161,7 +162,7 @@ int sys_mutex_trylock(u32 mutex_id)
 
 	switch (mutex->m_mutex.trylock(tid))
 	{
-	case SMR_OK: return CELL_OK;
+	case SMR_OK: mutex->recursive = 1; return CELL_OK;
 	}
 
 	return CELL_EBUSY;

rpcs3/Emu/SysCalls/lv2/SC_SPU_Thread.cpp

@@ -625,7 +625,6 @@ int sys_spu_thread_connect_event(u32 id, u32 eq, u32 et, u8 spup)
 	{
 		return CELL_ESRCH;
 	}
-
 	/*
 	for(int j=0; j<equeue->pos; ++j)
 	{
@@ -656,9 +655,22 @@ int sys_spu_thread_throw_event(u8 spup, u24 data0, u32 data1);
 int sys_spu_thread_tryreceive_event(u32 spuq_num, mem32_t d1, mem32_t d2, mem32_t d3);
 */
 
-int sys_spu_thread_bind_queue(u32 id, u32 equeue_id, u32 spuq_num)
+int sys_spu_thread_bind_queue(u32 id, u32 eq, u32 spuq_num)
 {
-	sc_spu.Error("sys_spu_thread_bind_queue(id=%d, equeue_id=%d, spuq_num=%d)", id, equeue_id, spuq_num);
+	sc_spu.Error("sys_spu_thread_bind_queue(id=%d, equeue_id=%d, spuq_num=%d)", id, eq, spuq_num);
+
+	EventQueue* equeue;
+	if(!sys_event.CheckId(eq, equeue))
+	{
+		return CELL_ESRCH;
+	}
+
+	CPUThread* thr = Emu.GetCPU().GetThread(id);
+
+	if(!thr || (thr->GetType() != CPU_THREAD_SPU && thr->GetType() != CPU_THREAD_RAW_SPU))
+	{
+		return CELL_ESRCH;
+	}
 
 	return CELL_OK;
 }

rpcs3/Gui/ConLog.cpp

@@ -265,7 +265,7 @@ void LogFrame::Task()
 		m_log.InsertItem(cur_item, wxString(item.m_prefix).wx_str());
 		m_log.SetItem(cur_item, 1, wxString(item.m_text).wx_str());
 		m_log.SetItemTextColour(cur_item, wxString(item.m_colour).wx_str());
-		m_log.SetColumnWidth(0, -1);
+		m_log.SetColumnWidth(0, -1); // crashes on exit
 		m_log.SetColumnWidth(1, -1);
 
 		::SendMessage((HWND)m_log.GetHWND(), WM_VSCROLL, SB_BOTTOM, 0);