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
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This file contains types and constants/macros common to different Mojo system
// APIs.
//
// Note: This header should be compilable as C.
#ifndef MOJO_PUBLIC_C_SYSTEM_TYPES_H_
#define MOJO_PUBLIC_C_SYSTEM_TYPES_H_
#include <stdint.h>
#include "mojo/public/c/system/macros.h"
// |MojoTimeTicks|: A time delta, in microseconds, the meaning of which is
// source-dependent.
typedef int64_t MojoTimeTicks;
// |MojoHandle|: Handles to Mojo objects.
// |MOJO_HANDLE_INVALID| - A value that is never a valid handle.
typedef uint32_t MojoHandle;
#ifdef __cplusplus
const MojoHandle MOJO_HANDLE_INVALID = 0;
#else
#define MOJO_HANDLE_INVALID ((MojoHandle)0)
#endif
// |MojoResult|: Result codes for Mojo operations. The only success code is zero
// (|MOJO_RESULT_OK|); all non-zero values should be considered as error/failure
// codes (even if the value is not recognized).
// |MOJO_RESULT_OK| - Not an error; returned on success.
// |MOJO_RESULT_CANCELLED| - Operation was cancelled, typically by the caller.
// |MOJO_RESULT_UNKNOWN| - Unknown error (e.g., if not enough information is
// available for a more specific error).
// |MOJO_RESULT_INVALID_ARGUMENT| - Caller specified an invalid argument. This
// differs from |MOJO_RESULT_FAILED_PRECONDITION| in that the former
// indicates arguments that are invalid regardless of the state of the
// system.
// |MOJO_RESULT_DEADLINE_EXCEEDED| - Deadline expired before the operation
// could complete.
// |MOJO_RESULT_NOT_FOUND| - Some requested entity was not found (i.e., does
// not exist).
// |MOJO_RESULT_ALREADY_EXISTS| - Some entity or condition that we attempted
// to create already exists.
// |MOJO_RESULT_PERMISSION_DENIED| - The caller does not have permission to
// for the operation (use |MOJO_RESULT_RESOURCE_EXHAUSTED| for rejections
// caused by exhausting some resource instead).
// |MOJO_RESULT_RESOURCE_EXHAUSTED| - Some resource required for the call
// (possibly some quota) has been exhausted.
// |MOJO_RESULT_FAILED_PRECONDITION| - The system is not in a state required
// for the operation (use this if the caller must do something to rectify
// the state before retrying).
// |MOJO_RESULT_ABORTED| - The operation was aborted by the system, possibly
// due to a concurrency issue (use this if the caller may retry at a
// higher level).
// |MOJO_RESULT_OUT_OF_RANGE| - The operation was attempted past the valid
// range. Unlike |MOJO_RESULT_INVALID_ARGUMENT|, this indicates that the
// operation may be/become valid depending on the system state. (This
// error is similar to |MOJO_RESULT_FAILED_PRECONDITION|, but is more
// specific.)
// |MOJO_RESULT_UNIMPLEMENTED| - The operation is not implemented, supported,
// or enabled.
// |MOJO_RESULT_INTERNAL| - Internal error: this should never happen and
// indicates that some invariant expected by the system has been broken.
// |MOJO_RESULT_UNAVAILABLE| - The operation is (temporarily) currently
// unavailable. The caller may simply retry the operation (possibly with a
// backoff).
// |MOJO_RESULT_DATA_LOSS| - Unrecoverable data loss or corruption.
// |MOJO_RESULT_BUSY| - One of the resources involved is currently being used
// (possibly on another thread) in a way that prevents the current
// operation from proceeding, e.g., if the other operation may result in
// the resource being invalidated.
// |MOJO_RESULT_SHOULD_WAIT| - The request cannot currently be completed
// (e.g., if the data requested is not yet available). The caller should
// wait for it to be feasible using a watcher.
//
// The codes from |MOJO_RESULT_OK| to |MOJO_RESULT_DATA_LOSS| come from
// Google3's canonical error codes.
typedef uint32_t MojoResult;
#ifdef __cplusplus
const MojoResult MOJO_RESULT_OK = 0;
const MojoResult MOJO_RESULT_CANCELLED = 1;
const MojoResult MOJO_RESULT_UNKNOWN = 2;
const MojoResult MOJO_RESULT_INVALID_ARGUMENT = 3;
const MojoResult MOJO_RESULT_DEADLINE_EXCEEDED = 4;
const MojoResult MOJO_RESULT_NOT_FOUND = 5;
const MojoResult MOJO_RESULT_ALREADY_EXISTS = 6;
const MojoResult MOJO_RESULT_PERMISSION_DENIED = 7;
const MojoResult MOJO_RESULT_RESOURCE_EXHAUSTED = 8;
const MojoResult MOJO_RESULT_FAILED_PRECONDITION = 9;
const MojoResult MOJO_RESULT_ABORTED = 10;
const MojoResult MOJO_RESULT_OUT_OF_RANGE = 11;
const MojoResult MOJO_RESULT_UNIMPLEMENTED = 12;
const MojoResult MOJO_RESULT_INTERNAL = 13;
const MojoResult MOJO_RESULT_UNAVAILABLE = 14;
const MojoResult MOJO_RESULT_DATA_LOSS = 15;
const MojoResult MOJO_RESULT_BUSY = 16;
const MojoResult MOJO_RESULT_SHOULD_WAIT = 17;
#else
#define MOJO_RESULT_OK ((MojoResult)0)
#define MOJO_RESULT_CANCELLED ((MojoResult)1)
#define MOJO_RESULT_UNKNOWN ((MojoResult)2)
#define MOJO_RESULT_INVALID_ARGUMENT ((MojoResult)3)
#define MOJO_RESULT_DEADLINE_EXCEEDED ((MojoResult)4)
#define MOJO_RESULT_NOT_FOUND ((MojoResult)5)
#define MOJO_RESULT_ALREADY_EXISTS ((MojoResult)6)
#define MOJO_RESULT_PERMISSION_DENIED ((MojoResult)7)
#define MOJO_RESULT_RESOURCE_EXHAUSTED ((MojoResult)8)
#define MOJO_RESULT_FAILED_PRECONDITION ((MojoResult)9)
#define MOJO_RESULT_ABORTED ((MojoResult)10)
#define MOJO_RESULT_OUT_OF_RANGE ((MojoResult)11)
#define MOJO_RESULT_UNIMPLEMENTED ((MojoResult)12)
#define MOJO_RESULT_INTERNAL ((MojoResult)13)
#define MOJO_RESULT_UNAVAILABLE ((MojoResult)14)
#define MOJO_RESULT_DATA_LOSS ((MojoResult)15)
#define MOJO_RESULT_BUSY ((MojoResult)16)
#define MOJO_RESULT_SHOULD_WAIT ((MojoResult)17)
#endif
// |MojoDeadline|: Used to specify deadlines (timeouts), in microseconds (except
// for |MOJO_DEADLINE_INDEFINITE|).
// |MOJO_DEADLINE_INDEFINITE| - Used to indicate "forever".
typedef uint64_t MojoDeadline;
#ifdef __cplusplus
const MojoDeadline MOJO_DEADLINE_INDEFINITE = static_cast<MojoDeadline>(-1);
#else
#define MOJO_DEADLINE_INDEFINITE ((MojoDeadline) - 1)
#endif
// |MojoHandleSignals|: Used to specify signals that can be watched for on a
// handle (and which can be triggered), e.g., the ability to read or write to
// the handle.
// |MOJO_HANDLE_SIGNAL_NONE| - No flags. A registered watch will always fail
// to arm with |MOJO_RESULT_FAILED_PRECONDITION| when watching for this.
// |MOJO_HANDLE_SIGNAL_READABLE| - Can read (e.g., a message) from the handle.
// |MOJO_HANDLE_SIGNAL_WRITABLE| - Can write (e.g., a message) to the handle.
// |MOJO_HANDLE_SIGNAL_PEER_CLOSED| - The peer handle is closed.
// |MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE| - Can read data from a data pipe
// consumer handle (implying MOJO_HANDLE_SIGNAL_READABLE is also set),
// AND there is some nonzero quantity of new data available on the pipe
// since the last |MojoReadData()| or |MojoBeginReadData()| call on the
// handle.
typedef uint32_t MojoHandleSignals;
#ifdef __cplusplus
const MojoHandleSignals MOJO_HANDLE_SIGNAL_NONE = 0;
const MojoHandleSignals MOJO_HANDLE_SIGNAL_READABLE = 1 << 0;
const MojoHandleSignals MOJO_HANDLE_SIGNAL_WRITABLE = 1 << 1;
const MojoHandleSignals MOJO_HANDLE_SIGNAL_PEER_CLOSED = 1 << 2;
const MojoHandleSignals MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE = 1 << 3;
#else
#define MOJO_HANDLE_SIGNAL_NONE ((MojoHandleSignals)0)
#define MOJO_HANDLE_SIGNAL_READABLE ((MojoHandleSignals)1 << 0)
#define MOJO_HANDLE_SIGNAL_WRITABLE ((MojoHandleSignals)1 << 1)
#define MOJO_HANDLE_SIGNAL_PEER_CLOSED ((MojoHandleSignals)1 << 2)
#define MOJO_HANDLE_SIGNAL_NEW_DATA_READABLE ((MojoHandleSignals)1 << 3);
#endif
// |MojoHandleSignalsState|: Returned by watch notification callbacks and
// |MojoQueryHandleSignalsState| functions to indicate the signaling state of
// handles. Members are as follows:
// - |satisfied signals|: Bitmask of signals that were satisfied at some time
// before the call returned.
// - |satisfiable signals|: These are the signals that are possible to
// satisfy. For example, if the return value was
// |MOJO_RESULT_FAILED_PRECONDITION|, you can use this field to
// determine which, if any, of the signals can still be satisfied.
// Note: This struct is not extensible (and only has 32-bit quantities), so it's
// 32-bit-aligned.
MOJO_STATIC_ASSERT(MOJO_ALIGNOF(int32_t) == 4, "int32_t has weird alignment");
struct MOJO_ALIGNAS(4) MojoHandleSignalsState {
MojoHandleSignals satisfied_signals;
MojoHandleSignals satisfiable_signals;
};
MOJO_STATIC_ASSERT(sizeof(MojoHandleSignalsState) == 8,
"MojoHandleSignalsState has wrong size");
// |MojoWatcherNotificationFlags|: Passed to a callback invoked by a watcher
// when some observed signals are raised or a watched handle is closed. May take
// on any combination of the following values:
//
// |MOJO_WATCHER_NOTIFICATION_FLAG_FROM_SYSTEM| - The callback is being
// invoked as a result of a system-level event rather than a direct API
// call from user code. This may be used as an indication that user code
// is safe to call without fear of reentry.
typedef uint32_t MojoWatcherNotificationFlags;
#ifdef __cplusplus
const MojoWatcherNotificationFlags MOJO_WATCHER_NOTIFICATION_FLAG_NONE = 0;
const MojoWatcherNotificationFlags MOJO_WATCHER_NOTIFICATION_FLAG_FROM_SYSTEM =
1 << 0;
#else
#define MOJO_WATCHER_NOTIFICATION_FLAG_NONE ((MojoWatcherNotificationFlags)0)
#define MOJO_WATCHER_NOTIFICATION_FLAG_FROM_SYSTEM \
((MojoWatcherNotificationFlags)1 << 0);
#endif
// |MojoPropertyType|: Property types that can be passed to |MojoGetProperty()|
// to retrieve system properties. May take the following values:
// |MOJO_PROPERTY_TYPE_SYNC_CALL_ALLOWED| - Whether making synchronous calls
// (i.e., blocking to wait for a response to an outbound message) is
// allowed. The property value is of boolean type. If the value is true,
// users should refrain from making sync calls.
typedef uint32_t MojoPropertyType;
#ifdef __cplusplus
const MojoPropertyType MOJO_PROPERTY_TYPE_SYNC_CALL_ALLOWED = 0;
#else
#define MOJO_PROPERTY_TYPE_SYNC_CALL_ALLOWED ((MojoPropertyType)0)
#endif
#endif // MOJO_PUBLIC_C_SYSTEM_TYPES_H_
|
