1 /*---------------------------------------------------------------------------*
2 Project: Horizon
3 File: os_Synchronization.h
4
5 Copyright (C)2009-2012 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: 47812 $
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
61 */
62 class WaitObject : public HandleObject
63 {
64 public:
65
66 /* Please see man pages for details
67
68
69
70 */
71 void WaitOne();
72
73 /* Please see man pages for details
74
75
76
77
78
79 */
80 bool WaitOne(nn::fnd::TimeSpan timeout);
81
82 /* Please see man pages for details
83
84
85
86
87
88
89 */
90 static void WaitAll(WaitObject* objs[], s32 numObjects);
91
92 /* Please see man pages for details
93
94
95
96
97
98
99
100
101 */
102 static bool WaitAll(WaitObject* objs[], s32 numObjects, nn::fnd::TimeSpan timeout);
103
104 //
105 /* Please see man pages for details
106
107
108
109
110
111
112 */
113 static s32 WaitAny(WaitObject* objs[], s32 numObjects);
114
115 /* Please see man pages for details
116
117
118
119
120
121
122
123
124 */
125 static s32 WaitAny(WaitObject* objs[], s32 numObjects, nn::fnd::TimeSpan timeout);
126
127 protected:
128
129 // Prohibit individual instantiation
WaitObject()130 WaitObject() {}
~WaitObject()131 ~WaitObject() {}
132
133 private:
134
135 nn::Result WaitOneImpl(s64 nanoSecondsTimeout);
136 static nn::Result WaitMultiple(s32* pOut, WaitObject* objs[], s32 numObjects, bool waitAll, s64 nanoSecondsTimeout);
137
138 };
139
140 /* Please see man pages for details
141
142
143
144
145
146 */
147 class InterruptEvent : public WaitObject
148 {
149 protected:
InterruptEvent()150 InterruptEvent() {}
~InterruptEvent()151 ~InterruptEvent() {}
152 };
153
154 // In-line implementation
155
WaitOneImpl(s64 nanoSecondsTimeout)156 inline nn::Result WaitObject::WaitOneImpl(s64 nanoSecondsTimeout)
157 {
158 s32 dummy;
159 Handle handle = GetHandle();
160 return nn::svc::WaitSynchronization(&dummy, &handle, 1, false, nanoSecondsTimeout);
161 }
162
WaitOne()163 inline void WaitObject::WaitOne()
164 {
165 NN_OS_ERROR_IF_FAILED(WaitOneImpl(WAIT_INFINITE));
166 }
167
WaitOne(nn::fnd::TimeSpan timeout)168 inline bool WaitObject::WaitOne(nn::fnd::TimeSpan timeout)
169 {
170 nn::Result result = WaitOneImpl(timeout.GetNanoSeconds());
171 NN_OS_ERROR_IF_FAILED(result);
172 return result.GetDescription() != nn::Result::DESCRIPTION_TIMEOUT;
173 }
174
WaitAll(WaitObject * objs[],s32 numObjects,nn::fnd::TimeSpan timeout)175 inline bool WaitObject::WaitAll(WaitObject* objs[], s32 numObjects, nn::fnd::TimeSpan timeout)
176 {
177 s32 dummy;
178 nn::Result result = WaitMultiple(&dummy, objs, numObjects, true, timeout.GetNanoSeconds());
179 NN_OS_ERROR_IF_FAILED(result);
180 return result.GetDescription() != nn::Result::DESCRIPTION_TIMEOUT;
181 }
182
WaitAll(WaitObject * objs[],s32 numObjects)183 inline void WaitObject::WaitAll(WaitObject* objs[], s32 numObjects)
184 {
185 s32 dummy;
186 NN_OS_ERROR_IF_FAILED(WaitMultiple(&dummy, objs, numObjects, true, WAIT_INFINITE));
187 }
188
WaitAny(WaitObject * objs[],s32 numObjects,nn::fnd::TimeSpan timeout)189 inline s32 WaitObject::WaitAny(WaitObject* objs[], s32 numObjects, nn::fnd::TimeSpan timeout)
190 {
191 s32 ret;
192 nn::Result result = WaitMultiple(&ret, objs, numObjects, false, timeout.GetNanoSeconds());
193 NN_OS_ERROR_IF_FAILED(result);
194 return (result.GetDescription() == nn::Result::DESCRIPTION_TIMEOUT) ? -1 : ret;
195 }
196
WaitAny(WaitObject * objs[],s32 numObjects)197 inline s32 WaitObject::WaitAny(WaitObject* objs[], s32 numObjects)
198 {
199 s32 ret;
200 NN_OS_ERROR_IF_FAILED(WaitMultiple(&ret, objs, numObjects, false, WAIT_INFINITE));
201 return ret;
202 }
203
204 }} // namespace nn::os
205
206 #endif // __cplusplus
207
208 // Below is the C declaration
209 #include <nn/util/detail/util_CLibImpl.h>
210
211 NN_UTIL_DETAIL_CLIBIMPL_DEFINE_ABSTRACT_BUFFER_CLASS(nnosWaitObject)
212
213 /* Please see man pages for details
214
215 */
216 NN_EXTERN_C bool nnosWaitObjectWaitOne(nnosWaitObject* p, s64 nanoSecondsTimeout);
217
218 /* Please see man pages for details
219
220 */
221 NN_EXTERN_C bool nnosWaitObjectWaitAll(nnosWaitObject* objs[], s32 numObjects, s64 nanoSecondsTimeout);
222
223 /* Please see man pages for details
224
225 */
226 NN_EXTERN_C s32 nnosWaitObjectWaitAny(nnosWaitObject* objs[], s32 numObjects, s64 nanoSecondsTimeout);
227
228 /* NN_OS_SYNCHRONIZATION_H_ */
229 #endif /* NN_OS_OS_SYNCHRONIZATION_H_ */
230