1 /*---------------------------------------------------------------------------*
2 Project: Horizon
3 File: os_Synchronization.h
4
5 Copyright (C)2009 Nintendo Co., Ltd. All rights reserved.
6
7 These coded instructions, statements, and computer programs contain
8 proprietary information of Nintendo of America Inc. and/or Nintendo
9 Company Ltd., and are protected by Federal copyright law. They may
10 not be disclosed to third parties or copied or duplicated in any form,
11 in whole or in part, without the prior written consent of Nintendo.
12
13 $Rev: 38846 $
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/os/os_ErrorHandlerSelect.h>
29 #include <nn/fnd/fnd_TimeSpan.h>
30
31 #include <nn/util/util_Result.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_OS_ERROR_IF_FAILED(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_OS_ERROR_IF_FAILED(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_OS_ERROR_IF_FAILED(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_OS_ERROR_IF_FAILED(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_OS_ERROR_IF_FAILED(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_OS_ERROR_IF_FAILED(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