1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// Copyright 2014 Citra Emulator Project
// Licensed under GPLv2
// Refer to the license.txt file included.
#include <map>
#include <vector>
#include "common/common.h"
#include "core/hle/kernel/kernel.h"
#include "core/hle/kernel/mutex.h"
#include "core/hle/kernel/thread.h"
namespace Kernel {
class Mutex : public Object {
public:
std::string GetTypeName() const override { return "Mutex"; }
std::string GetName() const override { return name; }
static Kernel::HandleType GetStaticHandleType() { return Kernel::HandleType::Mutex; }
Kernel::HandleType GetHandleType() const override { return Kernel::HandleType::Mutex; }
bool initial_locked; ///< Initial lock state when mutex was created
bool locked; ///< Current locked state
Handle lock_thread; ///< Handle to thread that currently has mutex
std::vector<Handle> waiting_threads; ///< Threads that are waiting for the mutex
std::string name; ///< Name of mutex (optional)
ResultVal<bool> WaitSynchronization() override {
bool wait = locked;
if (locked) {
Kernel::WaitCurrentThread(WAITTYPE_MUTEX, GetHandle());
} else {
// Lock the mutex when the first thread accesses it
locked = true;
}
return MakeResult<bool>(wait);
}
};
////////////////////////////////////////////////////////////////////////////////////////////////////
typedef std::multimap<Handle, Handle> MutexMap;
static MutexMap g_mutex_held_locks;
void MutexAcquireLock(Mutex* mutex, Handle thread) {
g_mutex_held_locks.insert(std::make_pair(thread, mutex->GetHandle()));
mutex->lock_thread = thread;
}
void MutexAcquireLock(Mutex* mutex) {
Handle thread = GetCurrentThreadHandle();
MutexAcquireLock(mutex, thread);
}
void MutexEraseLock(Mutex* mutex) {
Handle handle = mutex->GetHandle();
auto locked = g_mutex_held_locks.equal_range(mutex->lock_thread);
for (MutexMap::iterator iter = locked.first; iter != locked.second; ++iter) {
if ((*iter).second == handle) {
g_mutex_held_locks.erase(iter);
break;
}
}
mutex->lock_thread = -1;
}
bool LockMutex(Mutex* mutex) {
// Mutex alread locked?
if (mutex->locked) {
return false;
}
MutexAcquireLock(mutex);
return true;
}
bool ReleaseMutexForThread(Mutex* mutex, Handle thread) {
MutexAcquireLock(mutex, thread);
Kernel::ResumeThreadFromWait(thread);
return true;
}
bool ReleaseMutex(Mutex* mutex) {
MutexEraseLock(mutex);
// Find the next waiting thread for the mutex...
if (mutex->waiting_threads.empty()) {
// Reset mutex lock thread handle, nothing is waiting
mutex->locked = false;
mutex->lock_thread = -1;
} else {
// Resume the next waiting thread and re-lock the mutex
std::vector<Handle>::iterator iter = mutex->waiting_threads.begin();
ReleaseMutexForThread(mutex, *iter);
mutex->waiting_threads.erase(iter);
}
return true;
}
/**
* Releases a mutex
* @param handle Handle to mutex to release
*/
ResultCode ReleaseMutex(Handle handle) {
Mutex* mutex = Kernel::g_object_pool.Get<Mutex>(handle);
if (mutex == nullptr) return InvalidHandle(ErrorModule::Kernel);
if (!ReleaseMutex(mutex)) {
// TODO(yuriks): Verify error code, this one was pulled out of thin air. I'm not even sure
// what error condition this is supposed to be signaling.
return ResultCode(ErrorDescription::AlreadyDone, ErrorModule::Kernel,
ErrorSummary::NothingHappened, ErrorLevel::Temporary);
}
return RESULT_SUCCESS;
}
/**
* Creates a mutex
* @param handle Reference to handle for the newly created mutex
* @param initial_locked Specifies if the mutex should be locked initially
* @param name Optional name of mutex
* @return Pointer to new Mutex object
*/
Mutex* CreateMutex(Handle& handle, bool initial_locked, const std::string& name) {
Mutex* mutex = new Mutex;
handle = Kernel::g_object_pool.Create(mutex);
mutex->locked = mutex->initial_locked = initial_locked;
mutex->name = name;
// Acquire mutex with current thread if initialized as locked...
if (mutex->locked) {
MutexAcquireLock(mutex);
// Otherwise, reset lock thread handle
} else {
mutex->lock_thread = -1;
}
return mutex;
}
/**
* Creates a mutex
* @param initial_locked Specifies if the mutex should be locked initially
* @param name Optional name of mutex
* @return Handle to newly created object
*/
Handle CreateMutex(bool initial_locked, const std::string& name) {
Handle handle;
Mutex* mutex = CreateMutex(handle, initial_locked, name);
return handle;
}
} // namespace
|
