Put lv2_obj::awake calls under mutex

Nekotekina · Nekotekina · commit b3f5d6d85b68 · 2019-08-29T02:44:12.000+03:00
diff --git a/rpcs3/Emu/Cell/lv2/sys_cond.cpp b/rpcs3/Emu/Cell/lv2/sys_cond.cpp
@@ -77,31 +77,24 @@ error_code sys_cond_signal(ppu_thread& ppu, u32 cond_id)
 
 	sys_cond.trace("sys_cond_signal(cond_id=0x%x)", cond_id);
 
-	const auto cond = idm::check<lv2_obj, lv2_cond>(cond_id, [](lv2_cond& cond) -> cpu_thread*
+	const auto cond = idm::check<lv2_obj, lv2_cond>(cond_id, [](lv2_cond& cond)
 	{
 		if (cond.waiters)
 		{
 			std::lock_guard lock(cond.mutex->mutex);
 
 			if (const auto cpu = cond.schedule<ppu_thread>(cond.sq, cond.mutex->protocol))
 			{
-				return cpu;
+				cond.awake(cpu);
 			}
 		}
-
-		return nullptr;
 	});
 
 	if (!cond)
 	{
 		return CELL_ESRCH;
 	}
 
-	if (cond.ret)
-	{
-		cond->awake(cond.ret);
-	}
-
 	return CELL_OK;
 }
 
@@ -124,21 +117,19 @@ error_code sys_cond_signal_all(ppu_thread& ppu, u32 cond_id)
 				lv2_obj::append(cpu);
 				count++;
 			}
-		}
 
-		return count;
+			if (count)
+			{
+				lv2_obj::awake_all();
+			}
+		}
 	});
 
 	if (!cond)
 	{
 		return CELL_ESRCH;
 	}
 
-	if (cond.ret)
-	{
-		lv2_obj::awake_all();
-	}
-
 	return CELL_OK;
 }
 
@@ -148,11 +139,11 @@ error_code sys_cond_signal_to(ppu_thread& ppu, u32 cond_id, u32 thread_id)
 
 	sys_cond.trace("sys_cond_signal_to(cond_id=0x%x, thread_id=0x%x)", cond_id, thread_id);
 
-	const auto cond = idm::check<lv2_obj, lv2_cond>(cond_id, [&](lv2_cond& cond) -> cpu_thread*
+	const auto cond = idm::check<lv2_obj, lv2_cond>(cond_id, [&](lv2_cond& cond) -> int
 	{
 		if (!idm::check_unlocked<named_thread<ppu_thread>>(thread_id))
 		{
-			return (cpu_thread*)(1);
+			return -1;
 		}
 
 		if (cond.waiters)
@@ -164,24 +155,21 @@ error_code sys_cond_signal_to(ppu_thread& ppu, u32 cond_id, u32 thread_id)
 				if (cpu->id == thread_id)
 				{
 					verify(HERE), cond.unqueue(cond.sq, cpu);
-					return cpu;
+					cond.awake(cpu);
+					return 1;
 				}
 			}
 		}
 
-		return nullptr;
+		return 0;
 	});
 
-	if (!cond || cond.ret == (cpu_thread*)(1))
+	if (!cond || cond.ret == -1)
 	{
 		return CELL_ESRCH;
 	}
 
-	if (cond.ret)
-	{
-		cond->awake(cond.ret);
-	}
-	else if (!cond.ret)
+	if (!cond.ret)
 	{
 		return not_an_error(CELL_EPERM);
 	}
diff --git a/rpcs3/Emu/Cell/lv2/sys_lwcond.cpp b/rpcs3/Emu/Cell/lv2/sys_lwcond.cpp
@@ -86,11 +86,11 @@ error_code _sys_lwcond_signal(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u3
 		fmt::throw_exception("Unknown mode (%d)" HERE, mode);
 	}
 
-	const auto cond = idm::check<lv2_obj, lv2_lwcond>(lwcond_id, [&](lv2_lwcond& cond) -> cpu_thread*
+	const auto cond = idm::check<lv2_obj, lv2_lwcond>(lwcond_id, [&](lv2_lwcond& cond) -> int
 	{
 		if (ppu_thread_id != -1 && !idm::check_unlocked<named_thread<ppu_thread>>(ppu_thread_id))
 		{
-			return (cpu_thread*)(1);
+			return -1;
 		}
 
 		lv2_lwmutex* mutex;
@@ -101,7 +101,7 @@ error_code _sys_lwcond_signal(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u3
 
 			if (!mutex)
 			{
-				return (cpu_thread*)(1);
+				return -1;
 			}
 		}
 
@@ -143,15 +143,19 @@ error_code _sys_lwcond_signal(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u3
 					std::lock_guard lock(mutex->mutex);
 					mutex->sq.emplace_back(result);
 				}
+				else
+				{
+					cond.awake(result);
+				}
 
-				return result;
+				return 1;
 			}
 		}
 
-		return nullptr;
+		return 0;
 	});
 
-	if (!cond || cond.ret == (cpu_thread*)(1))
+	if (!cond || cond.ret == -1)
 	{
 		return CELL_ESRCH;
 	}
@@ -173,11 +177,6 @@ error_code _sys_lwcond_signal(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u3
 		return not_an_error(CELL_EPERM);
 	}
 
-	if (mode != 1)
-	{
-		cond->awake(cond.ret);
-	}
-
 	return CELL_OK;
 }
 
@@ -241,6 +240,11 @@ error_code _sys_lwcond_signal_all(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id
 				result++;
 			}
 
+			if (need_awake)
+			{
+				lv2_obj::awake_all();
+			}
+
 			return result;
 		}
 
@@ -252,11 +256,6 @@ error_code _sys_lwcond_signal_all(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id
 		return CELL_ESRCH;
 	}
 
-	if (need_awake)
-	{
-		lv2_obj::awake_all();
-	}
-
 	if (mode == 1)
 	{
 		// Mode 1: return the amount of threads (TODO)
diff --git a/rpcs3/Emu/Cell/lv2/sys_lwmutex.cpp b/rpcs3/Emu/Cell/lv2/sys_lwmutex.cpp
@@ -192,29 +192,24 @@ error_code _sys_lwmutex_unlock(ppu_thread& ppu, u32 lwmutex_id)
 
 	sys_lwmutex.trace("_sys_lwmutex_unlock(lwmutex_id=0x%x)", lwmutex_id);
 
-	const auto mutex = idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex) -> cpu_thread*
+	const auto mutex = idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex)
 	{
 		std::lock_guard lock(mutex.mutex);
 
 		if (const auto cpu = mutex.schedule<ppu_thread>(mutex.sq, mutex.protocol))
 		{
-			return cpu;
+			mutex.awake(cpu);
+			return;
 		}
 
 		mutex.signaled |= 1;
-		return nullptr;
 	});
 
 	if (!mutex)
 	{
 		return CELL_ESRCH;
 	}
 
-	if (mutex.ret)
-	{
-		mutex->awake(mutex.ret);
-	}
-
 	return CELL_OK;
 }
 
@@ -224,29 +219,24 @@ error_code _sys_lwmutex_unlock2(ppu_thread& ppu, u32 lwmutex_id)
 
 	sys_lwmutex.warning("_sys_lwmutex_unlock2(lwmutex_id=0x%x)", lwmutex_id);
 
-	const auto mutex = idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex) -> cpu_thread*
+	const auto mutex = idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex)
 	{
 		std::lock_guard lock(mutex.mutex);
 
 		if (const auto cpu = mutex.schedule<ppu_thread>(mutex.sq, mutex.protocol))
 		{
 			static_cast<ppu_thread*>(cpu)->gpr[3] = CELL_EBUSY;
-			return cpu;
+			mutex.awake(cpu);
+			return;
 		}
 
 		mutex.signaled |= 1 << 31;
-		return nullptr;
 	});
 
 	if (!mutex)
 	{
 		return CELL_ESRCH;
 	}
 
-	if (mutex.ret)
-	{
-		mutex->awake(mutex.ret);
-	}
-
 	return CELL_OK;
 }

Original file line number	Diff line number	Diff line change
`@@ -77,31 +77,24 @@ error_code sys_cond_signal(ppu_thread& ppu, u32 cond_id)`
`77`	`77`
`78`	`78`	`sys_cond.trace("sys_cond_signal(cond_id=0x%x)", cond_id);`
`79`	`79`
`80`		`- const auto cond = idm::check<lv2_obj, lv2_cond>(cond_id, [](lv2_cond& cond) -> cpu_thread*`
	`80`	`+ const auto cond = idm::check<lv2_obj, lv2_cond>(cond_id, [](lv2_cond& cond)`
`81`	`81`	`{`
`82`	`82`	`if (cond.waiters)`
`83`	`83`	`{`
`84`	`84`	`std::lock_guard lock(cond.mutex->mutex);`
`85`	`85`
`86`	`86`	`if (const auto cpu = cond.schedule<ppu_thread>(cond.sq, cond.mutex->protocol))`
`87`	`87`	`{`
`88`		`- return cpu;`
	`88`	`+ cond.awake(cpu);`
`89`	`89`	`}`
`90`	`90`	`}`
`91`		`-`
`92`		`- return nullptr;`
`93`	`91`	`});`
`94`	`92`
`95`	`93`	`if (!cond)`
`96`	`94`	`{`
`97`	`95`	`return CELL_ESRCH;`
`98`	`96`	`}`
`99`	`97`
`100`		`- if (cond.ret)`
`101`		`- {`
`102`		`- cond->awake(cond.ret);`
`103`		`- }`
`104`		`-`
`105`	`98`	`return CELL_OK;`
`106`	`99`	`}`
`107`	`100`
`@@ -124,21 +117,19 @@ error_code sys_cond_signal_all(ppu_thread& ppu, u32 cond_id)`
`124`	`117`	`lv2_obj::append(cpu);`
`125`	`118`	`count++;`
`126`	`119`	`}`
`127`		`- }`
`128`	`120`
`129`		`- return count;`
	`121`	`+ if (count)`
	`122`	`+ {`
	`123`	`+ lv2_obj::awake_all();`
	`124`	`+ }`
	`125`	`+ }`
`130`	`126`	`});`
`131`	`127`
`132`	`128`	`if (!cond)`
`133`	`129`	`{`
`134`	`130`	`return CELL_ESRCH;`
`135`	`131`	`}`
`136`	`132`
`137`		`- if (cond.ret)`
`138`		`- {`
`139`		`- lv2_obj::awake_all();`
`140`		`- }`
`141`		`-`
`142`	`133`	`return CELL_OK;`
`143`	`134`	`}`
`144`	`135`
`@@ -148,11 +139,11 @@ error_code sys_cond_signal_to(ppu_thread& ppu, u32 cond_id, u32 thread_id)`
`148`	`139`
`149`	`140`	`sys_cond.trace("sys_cond_signal_to(cond_id=0x%x, thread_id=0x%x)", cond_id, thread_id);`
`150`	`141`
`151`		`- const auto cond = idm::check<lv2_obj, lv2_cond>(cond_id, [&](lv2_cond& cond) -> cpu_thread*`
	`142`	`+ const auto cond = idm::check<lv2_obj, lv2_cond>(cond_id, [&](lv2_cond& cond) -> int`
`152`	`143`	`{`
`153`	`144`	`if (!idm::check_unlocked<named_thread<ppu_thread>>(thread_id))`
`154`	`145`	`{`
`155`		`- return (cpu_thread*)(1);`
	`146`	`+ return -1;`
`156`	`147`	`}`
`157`	`148`
`158`	`149`	`if (cond.waiters)`
`@@ -164,24 +155,21 @@ error_code sys_cond_signal_to(ppu_thread& ppu, u32 cond_id, u32 thread_id)`
`164`	`155`	`if (cpu->id == thread_id)`
`165`	`156`	`{`
`166`	`157`	`verify(HERE), cond.unqueue(cond.sq, cpu);`
`167`		`- return cpu;`
	`158`	`+ cond.awake(cpu);`
	`159`	`+ return 1;`
`168`	`160`	`}`
`169`	`161`	`}`
`170`	`162`	`}`
`171`	`163`
`172`		`- return nullptr;`
	`164`	`+ return 0;`
`173`	`165`	`});`
`174`	`166`
`175`		`- if (!cond \|\| cond.ret == (cpu_thread*)(1))`
	`167`	`+ if (!cond \|\| cond.ret == -1)`
`176`	`168`	`{`
`177`	`169`	`return CELL_ESRCH;`
`178`	`170`	`}`
`179`	`171`
`180`		`- if (cond.ret)`
`181`		`- {`
`182`		`- cond->awake(cond.ret);`
`183`		`- }`
`184`		`- else if (!cond.ret)`
	`172`	`+ if (!cond.ret)`
`185`	`173`	`{`
`186`	`174`	`return not_an_error(CELL_EPERM);`
`187`	`175`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,11 +86,11 @@ error_code _sys_lwcond_signal(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u3`
`86`	`86`	`fmt::throw_exception("Unknown mode (%d)" HERE, mode);`
`87`	`87`	`}`
`88`	`88`
`89`		`- const auto cond = idm::check<lv2_obj, lv2_lwcond>(lwcond_id, [&](lv2_lwcond& cond) -> cpu_thread*`
	`89`	`+ const auto cond = idm::check<lv2_obj, lv2_lwcond>(lwcond_id, [&](lv2_lwcond& cond) -> int`
`90`	`90`	`{`
`91`	`91`	`if (ppu_thread_id != -1 && !idm::check_unlocked<named_thread<ppu_thread>>(ppu_thread_id))`
`92`	`92`	`{`
`93`		`- return (cpu_thread*)(1);`
	`93`	`+ return -1;`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`lv2_lwmutex* mutex;`
`@@ -101,7 +101,7 @@ error_code _sys_lwcond_signal(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u3`
`101`	`101`
`102`	`102`	`if (!mutex)`
`103`	`103`	`{`
`104`		`- return (cpu_thread*)(1);`
	`104`	`+ return -1;`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`@@ -143,15 +143,19 @@ error_code _sys_lwcond_signal(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u3`
`143`	`143`	`std::lock_guard lock(mutex->mutex);`
`144`	`144`	`mutex->sq.emplace_back(result);`
`145`	`145`	`}`
	`146`	`+ else`
	`147`	`+ {`
	`148`	`+ cond.awake(result);`
	`149`	`+ }`
`146`	`150`
`147`		`- return result;`
	`151`	`+ return 1;`
`148`	`152`	`}`
`149`	`153`	`}`
`150`	`154`
`151`		`- return nullptr;`
	`155`	`+ return 0;`
`152`	`156`	`});`
`153`	`157`
`154`		`- if (!cond \|\| cond.ret == (cpu_thread*)(1))`
	`158`	`+ if (!cond \|\| cond.ret == -1)`
`155`	`159`	`{`
`156`	`160`	`return CELL_ESRCH;`
`157`	`161`	`}`
`@@ -173,11 +177,6 @@ error_code _sys_lwcond_signal(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id, u3`
`173`	`177`	`return not_an_error(CELL_EPERM);`
`174`	`178`	`}`
`175`	`179`
`176`		`- if (mode != 1)`
`177`		`- {`
`178`		`- cond->awake(cond.ret);`
`179`		`- }`
`180`		`-`
`181`	`180`	`return CELL_OK;`
`182`	`181`	`}`
`183`	`182`
`@@ -241,6 +240,11 @@ error_code _sys_lwcond_signal_all(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id`
`241`	`240`	`result++;`
`242`	`241`	`}`
`243`	`242`
	`243`	`+ if (need_awake)`
	`244`	`+ {`
	`245`	`+ lv2_obj::awake_all();`
	`246`	`+ }`
	`247`	`+`
`244`	`248`	`return result;`
`245`	`249`	`}`
`246`	`250`
`@@ -252,11 +256,6 @@ error_code _sys_lwcond_signal_all(ppu_thread& ppu, u32 lwcond_id, u32 lwmutex_id`
`252`	`256`	`return CELL_ESRCH;`
`253`	`257`	`}`
`254`	`258`
`255`		`- if (need_awake)`
`256`		`- {`
`257`		`- lv2_obj::awake_all();`
`258`		`- }`
`259`		`-`
`260`	`259`	`if (mode == 1)`
`261`	`260`	`{`
`262`	`261`	`// Mode 1: return the amount of threads (TODO)`
Original file line number	Diff line number	Diff line change
`@@ -192,29 +192,24 @@ error_code _sys_lwmutex_unlock(ppu_thread& ppu, u32 lwmutex_id)`
`192`	`192`
`193`	`193`	`sys_lwmutex.trace("_sys_lwmutex_unlock(lwmutex_id=0x%x)", lwmutex_id);`
`194`	`194`
`195`		`- const auto mutex = idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex) -> cpu_thread*`
	`195`	`+ const auto mutex = idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex)`
`196`	`196`	`{`
`197`	`197`	`std::lock_guard lock(mutex.mutex);`
`198`	`198`
`199`	`199`	`if (const auto cpu = mutex.schedule<ppu_thread>(mutex.sq, mutex.protocol))`
`200`	`200`	`{`
`201`		`- return cpu;`
	`201`	`+ mutex.awake(cpu);`
	`202`	`+ return;`
`202`	`203`	`}`
`203`	`204`
`204`	`205`	`mutex.signaled \|= 1;`
`205`		`- return nullptr;`
`206`	`206`	`});`
`207`	`207`
`208`	`208`	`if (!mutex)`
`209`	`209`	`{`
`210`	`210`	`return CELL_ESRCH;`
`211`	`211`	`}`
`212`	`212`
`213`		`- if (mutex.ret)`
`214`		`- {`
`215`		`- mutex->awake(mutex.ret);`
`216`		`- }`
`217`		`-`
`218`	`213`	`return CELL_OK;`
`219`	`214`	`}`
`220`	`215`
`@@ -224,29 +219,24 @@ error_code _sys_lwmutex_unlock2(ppu_thread& ppu, u32 lwmutex_id)`
`224`	`219`
`225`	`220`	`sys_lwmutex.warning("_sys_lwmutex_unlock2(lwmutex_id=0x%x)", lwmutex_id);`
`226`	`221`
`227`		`- const auto mutex = idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex) -> cpu_thread*`
	`222`	`+ const auto mutex = idm::check<lv2_obj, lv2_lwmutex>(lwmutex_id, [&](lv2_lwmutex& mutex)`
`228`	`223`	`{`
`229`	`224`	`std::lock_guard lock(mutex.mutex);`
`230`	`225`
`231`	`226`	`if (const auto cpu = mutex.schedule<ppu_thread>(mutex.sq, mutex.protocol))`
`232`	`227`	`{`
`233`	`228`	`static_cast<ppu_thread*>(cpu)->gpr[3] = CELL_EBUSY;`
`234`		`- return cpu;`
	`229`	`+ mutex.awake(cpu);`
	`230`	`+ return;`
`235`	`231`	`}`
`236`	`232`
`237`	`233`	`mutex.signaled \|= 1 << 31;`
`238`		`- return nullptr;`
`239`	`234`	`});`
`240`	`235`
`241`	`236`	`if (!mutex)`
`242`	`237`	`{`
`243`	`238`	`return CELL_ESRCH;`
`244`	`239`	`}`
`245`	`240`
`246`		`- if (mutex.ret)`
`247`		`- {`
`248`		`- mutex->awake(mutex.ret);`
`249`		`- }`
`250`		`-`
`251`	`241`	`return CELL_OK;`
`252`	`242`	`}`