system/kernel/thread.cpp

239 	// when it exited, but that might still exist, if the thread was never run.
302 	// look it up and acquire a reference
311 	// lock and check, if it is still in the hash table
419 /*!	Adds the given user timer to the thread and, if user-defined, assigns it an
424 	\param timer The timer to be added. If it doesn't have an ID yet, it is
506 	// get the next team -- if there is one, get reference for it
548 		use afterwards (or until it is reinitialized).
900 	// If a thread object is given, acquire a reference to it, otherwise create
997 	// lock the team and see, if it is still alive
1011 		// If the new thread belongs to the same team as the current thread, it
1131 		// remove this thread from from the kernel team -- this makes it
1165 		if it isn't waiting on a semaphore.
1302 		// were killed, it's probably okay to do so (but also
1473 	for (ThreadHashTable::Iterator it = sThreadHash.GetIterator();
1474 			Thread* thread = it.Next();) {
1511 	for (ThreadHashTable::Iterator it = sThreadHash.GetIterator();
1512 			Thread* thread = it.Next();) {
1543 	for (ThreadHashTable::Iterator it = sThreadHash.GetIterator();
1544 			Thread* thread = it.Next();) {
1577 	for (ThreadHashTable::Iterator it = sThreadHash.GetIterator();
1578 			Thread* thread = it.Next();) {
1688 		// does it block on a semaphore or a condition variable?
1750 		// on which CPU does it run?
1898 		for (ThreadHashTable::Iterator it = sThreadHash.GetIterator();
1899 				Thread* thread = it.Next();) {
1960 	for (ThreadHashTable::Iterator it = sThreadHash.GetIterator();
1961 			Thread* thread = it.Next();) {
2021 		// Delete the thread's user thread, if it's not the main thread. If it
2022 		// is, we can save the work, since it will be deleted with the team's
2028 	// remember the user stack area -- we will delete it below
2102 		// put the thread into the kernel team until it dies
2145 			// might destroy it otherwise and we wouldn't be able to unlock it.
2182 			// for it, unless someone is already waiting for it.
2208 		// we need to delete any death entry that made it to here
2217 	// mark invisible in global hash/list, so it's no longer accessible
2258 		// there is data waiting for us, so let us eat it
2462 	state, and if it has a higher priority than the other ready threads, it
2484 	for (ThreadHashTable::Iterator it = sThreadHash.GetIterator();
2485 		Thread* thread = it.Next();) {
2529 		// we couldn't find this thread -- maybe it's already gone, and we'll
2836 		"Resumes the specified thread, if it is currently suspended.\n"
2883 	The thread is blocked until someone else unblock it. Must be called after a
2927 	The current thread is blocked until someone else unblock it or the specified
2986 	// cancel timer, if it didn't fire
3036 		// Even if the user_thread->wait_status was > 0, it may be the
3269 	// only need a read lock, it's probably acceptable.
3271 	for (ThreadHashTable::Iterator it = sThreadHash.GetIterator();
3272 			Thread* thread = it.Next();) {
3309 		// don't pass the thread structure, as it's unsafe, if it isn't ours
3800 	// Note: GCC 13 marks the following call as potentially overflowing, since it thinks `thread`