1 /*---------------------------------------------------------------------------*
2 Project: Horizon
3 File: os_Synchronization.h
4 Copyright (C)2009 Nintendo Co., Ltd. All rights reserved.
5 These coded instructions, statements, and computer programs contain
6 proprietary information of Nintendo of America Inc. and/or Nintendo
7 Company Ltd., and are protected by Federal copyright law. They may
8 not be disclosed to third parties or copied or duplicated in any form,
9 in whole or in part, without the prior written consent of Nintendo.
10 $Rev: 31762 $
11 *---------------------------------------------------------------------------
12
13
14 */
15
16 /* Please see man pages for details
17
18
19
20 */
21
22 #ifndef NN_OS_OS_SYNCHRONIZATION_H_
23 #define NN_OS_OS_SYNCHRONIZATION_H_
24
25 #include <nn/types.h>
26 #include <nn/Result.h>
27 #include <nn/os/os_HandleObject.h>
28 #include <nn/fnd/fnd_TimeSpan.h>
29
30 #include <nn/util/util_Result.h>
31 #include <nn/err.h>
32
33 /* Please see man pages for details
34
35
36 */
37 #define NN_OS_WAIT_INFINITE -1
38
39 #ifdef __cplusplus
40
41 namespace nn{ namespace os{
42
43 const s64 WAIT_INFINITE = NN_OS_WAIT_INFINITE;
44
45 /* Please see man pages for details
46
47
48
49
50
51
52
53
54
55
56
57
58
59 */
60 class WaitObject : public HandleObject
61 {
62 public:
63
64 /* Please see man pages for details
65
66
67
68 */
69 void WaitOne();
70
71 /* Please see man pages for details
72
73
74
75
76
77 */
78 bool WaitOne(nn::fnd::TimeSpan timeout);
79
80 /* Please see man pages for details
81
82
83
84
85
86
87 */
88 static void WaitAll(WaitObject* objs[], s32 numObjects);
89
90 /* Please see man pages for details
91
92
93
94
95
96
97
98
99 */
100 static bool WaitAll(WaitObject* objs[], s32 numObjects, nn::fnd::TimeSpan timeout);
101
102 //
103 /* Please see man pages for details
104
105
106
107
108
109
110 */
111 static s32 WaitAny(WaitObject* objs[], s32 numObjects);
112
113 /* Please see man pages for details
114
115
116
117
118
119
120
121
122 */
123 static s32 WaitAny(WaitObject* objs[], s32 numObjects, nn::fnd::TimeSpan timeout);
124
125 protected:
126
127 // Prohibit independent instantiation
WaitObject()128 WaitObject() {}
~WaitObject()129 ~WaitObject() {}
130
131 private:
132
133 nn::Result WaitOneImpl(s64 nanoSecondsTimeout);
134 static nn::Result WaitMultiple(s32* pOut, WaitObject* objs[], s32 numObjects, bool waitAll, s64 nanoSecondsTimeout);
135
136 };
137
138 /* Please see man pages for details
139
140
141
142 */
143 class InterruptEvent : public WaitObject
144 {
145 protected:
InterruptEvent()146 InterruptEvent() {}
~InterruptEvent()147 ~InterruptEvent() {}
148 };
149
150 // Inline implementation
151
WaitOneImpl(s64 nanoSecondsTimeout)152 inline nn::Result WaitObject::WaitOneImpl(s64 nanoSecondsTimeout)
153 {
154 s32 dummy;
155 Handle handle = GetHandle();
156 return nn::svc::WaitSynchronization(&dummy, &handle, 1, false, nanoSecondsTimeout);
157 }
158
WaitOne()159 inline void WaitObject::WaitOne()
160 {
161 NN_ERR_THROW_FATAL(WaitOneImpl(WAIT_INFINITE));
162 }
163
WaitOne(nn::fnd::TimeSpan timeout)164 inline bool WaitObject::WaitOne(nn::fnd::TimeSpan timeout)
165 {
166 nn::Result result = WaitOneImpl(timeout.GetNanoSeconds());
167 NN_ERR_THROW_FATAL(result);
168 return result.GetDescription() != nn::Result::DESCRIPTION_TIMEOUT;
169 }
170
WaitAll(WaitObject * objs[],s32 numObjects,nn::fnd::TimeSpan timeout)171 inline bool WaitObject::WaitAll(WaitObject* objs[], s32 numObjects, nn::fnd::TimeSpan timeout)
172 {
173 s32 dummy;
174 nn::Result result = WaitMultiple(&dummy, objs, numObjects, true, timeout.GetNanoSeconds());
175 NN_ERR_THROW_FATAL(result);
176 return result.GetDescription() != nn::Result::DESCRIPTION_TIMEOUT;
177 }
178
WaitAll(WaitObject * objs[],s32 numObjects)179 inline void WaitObject::WaitAll(WaitObject* objs[], s32 numObjects)
180 {
181 s32 dummy;
182 NN_ERR_THROW_FATAL(WaitMultiple(&dummy, objs, numObjects, true, WAIT_INFINITE));
183 }
184
WaitAny(WaitObject * objs[],s32 numObjects,nn::fnd::TimeSpan timeout)185 inline s32 WaitObject::WaitAny(WaitObject* objs[], s32 numObjects, nn::fnd::TimeSpan timeout)
186 {
187 s32 ret;
188 nn::Result result = WaitMultiple(&ret, objs, numObjects, false, timeout.GetNanoSeconds());
189 NN_ERR_THROW_FATAL(result);
190 return (result.GetDescription() == nn::Result::DESCRIPTION_TIMEOUT) ? -1 : ret;
191 }
192
WaitAny(WaitObject * objs[],s32 numObjects)193 inline s32 WaitObject::WaitAny(WaitObject* objs[], s32 numObjects)
194 {
195 s32 ret;
196 NN_ERR_THROW_FATAL(WaitMultiple(&ret, objs, numObjects, false, WAIT_INFINITE));
197 return ret;
198 }
199
200 }} // namespace nn::os
201
202 #endif // __cplusplus
203
204 // C declarations follow
205 #include <nn/util/detail/util_CLibImpl.h>
206
207 NN_UTIL_DETAIL_CLIBIMPL_DEFINE_ABSTRACT_BUFFER_CLASS(nnosWaitObject)
208
209 /* Please see man pages for details
210
211 */
212 NN_EXTERN_C bool nnosWaitObjectWaitOne(nnosWaitObject* p, s64 nanoSecondsTimeout);
213
214 /* Please see man pages for details
215
216 */
217 NN_EXTERN_C bool nnosWaitObjectWaitAll(nnosWaitObject* objs[], s32 numObjects, s64 nanoSecondsTimeout);
218
219 /* Please see man pages for details
220
221 */
222 NN_EXTERN_C s32 nnosWaitObjectWaitAny(nnosWaitObject* objs[], s32 numObjects, s64 nanoSecondsTimeout);
223
224 /* NN_OS_SYNCHRONIZATION_H_ */
225 #endif /* NN_OS_OS_SYNCHRONIZATION_H_ */
226