| // 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_ |