jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 1 | // Copyright 2014 The Chromium Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 5 | #include "mojo/edk/embedder/entrypoints.h" |
| 6 | |
Avi Drissman | 2e88ac37 | 2015-12-21 18:14:57 | [diff] [blame] | 7 | #include <stdint.h> |
| 8 | |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 9 | #include "mojo/edk/embedder/embedder_internal.h" |
| 10 | #include "mojo/edk/system/core.h" |
rockot | 85dce086 | 2015-11-13 01:33:59 | [diff] [blame] | 11 | #include "mojo/public/c/system/buffer.h" |
| 12 | #include "mojo/public/c/system/data_pipe.h" |
| 13 | #include "mojo/public/c/system/functions.h" |
| 14 | #include "mojo/public/c/system/message_pipe.h" |
rockot | 28a287e | 2016-05-24 02:51:37 | [diff] [blame] | 15 | #include "mojo/public/c/system/platform_handle.h" |
rockot | c637caf9b | 2016-02-10 09:57:08 | [diff] [blame] | 16 | #include "mojo/public/c/system/wait_set.h" |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 17 | |
| 18 | using mojo::edk::internal::g_core; |
| 19 | |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 20 | // Definitions of the system functions. |
| 21 | extern "C" { |
rockot | c637caf9b | 2016-02-10 09:57:08 | [diff] [blame] | 22 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 23 | MojoTimeTicks MojoGetTimeTicksNowImpl() { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 24 | return g_core->GetTimeTicksNow(); |
| 25 | } |
| 26 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 27 | MojoResult MojoCloseImpl(MojoHandle handle) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 28 | return g_core->Close(handle); |
| 29 | } |
| 30 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 31 | MojoResult MojoWaitImpl(MojoHandle handle, |
| 32 | MojoHandleSignals signals, |
| 33 | MojoDeadline deadline, |
| 34 | MojoHandleSignalsState* signals_state) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 35 | return g_core->Wait(handle, signals, deadline, signals_state); |
| 36 | } |
| 37 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 38 | MojoResult MojoWaitManyImpl(const MojoHandle* handles, |
| 39 | const MojoHandleSignals* signals, |
| 40 | uint32_t num_handles, |
| 41 | MojoDeadline deadline, |
| 42 | uint32_t* result_index, |
| 43 | MojoHandleSignalsState* signals_states) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 44 | return g_core->WaitMany(handles, signals, num_handles, deadline, result_index, |
| 45 | signals_states); |
| 46 | } |
| 47 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 48 | MojoResult MojoWatchImpl(MojoHandle handle, |
| 49 | MojoHandleSignals signals, |
| 50 | MojoWatchCallback callback, |
| 51 | uintptr_t context) { |
rockot | 49b69e6b27 | 2016-03-02 03:46:37 | [diff] [blame] | 52 | return g_core->Watch(handle, signals, callback, context); |
| 53 | } |
| 54 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 55 | MojoResult MojoCancelWatchImpl(MojoHandle handle, uintptr_t context) { |
rockot | 49b69e6b27 | 2016-03-02 03:46:37 | [diff] [blame] | 56 | return g_core->CancelWatch(handle, context); |
| 57 | } |
| 58 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 59 | MojoResult MojoAllocMessageImpl(uint32_t num_bytes, |
| 60 | const MojoHandle* handles, |
| 61 | uint32_t num_handles, |
| 62 | MojoAllocMessageFlags flags, |
| 63 | MojoMessageHandle* message) { |
rockot | 72d05a46 | 2016-04-26 19:56:50 | [diff] [blame] | 64 | return g_core->AllocMessage(num_bytes, handles, num_handles, flags, message); |
| 65 | } |
| 66 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 67 | MojoResult MojoFreeMessageImpl(MojoMessageHandle message) { |
rockot | 72d05a46 | 2016-04-26 19:56:50 | [diff] [blame] | 68 | return g_core->FreeMessage(message); |
| 69 | } |
| 70 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 71 | MojoResult MojoGetMessageBufferImpl(MojoMessageHandle message, void** buffer) { |
rockot | 72d05a46 | 2016-04-26 19:56:50 | [diff] [blame] | 72 | return g_core->GetMessageBuffer(message, buffer); |
| 73 | } |
| 74 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 75 | MojoResult MojoCreateWaitSetImpl(MojoHandle* wait_set_handle) { |
rockot | c637caf9b | 2016-02-10 09:57:08 | [diff] [blame] | 76 | return g_core->CreateWaitSet(wait_set_handle); |
| 77 | } |
| 78 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 79 | MojoResult MojoAddHandleImpl(MojoHandle wait_set_handle, |
| 80 | MojoHandle handle, |
| 81 | MojoHandleSignals signals) { |
rockot | c637caf9b | 2016-02-10 09:57:08 | [diff] [blame] | 82 | return g_core->AddHandle(wait_set_handle, handle, signals); |
| 83 | } |
| 84 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 85 | MojoResult MojoRemoveHandleImpl(MojoHandle wait_set_handle, MojoHandle handle) { |
rockot | c637caf9b | 2016-02-10 09:57:08 | [diff] [blame] | 86 | return g_core->RemoveHandle(wait_set_handle, handle); |
| 87 | } |
| 88 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 89 | MojoResult MojoGetReadyHandlesImpl( |
| 90 | MojoHandle wait_set_handle, |
| 91 | uint32_t* count, |
| 92 | MojoHandle* handles, |
| 93 | MojoResult* results, |
| 94 | struct MojoHandleSignalsState* signals_states) { |
rockot | c637caf9b | 2016-02-10 09:57:08 | [diff] [blame] | 95 | return g_core->GetReadyHandles(wait_set_handle, count, handles, results, |
| 96 | signals_states); |
| 97 | } |
| 98 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 99 | MojoResult MojoCreateMessagePipeImpl( |
| 100 | const MojoCreateMessagePipeOptions* options, |
| 101 | MojoHandle* message_pipe_handle0, |
| 102 | MojoHandle* message_pipe_handle1) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 103 | return g_core->CreateMessagePipe(options, message_pipe_handle0, |
| 104 | message_pipe_handle1); |
| 105 | } |
| 106 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 107 | MojoResult MojoWriteMessageImpl(MojoHandle message_pipe_handle, |
| 108 | const void* bytes, |
| 109 | uint32_t num_bytes, |
| 110 | const MojoHandle* handles, |
| 111 | uint32_t num_handles, |
| 112 | MojoWriteMessageFlags flags) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 113 | return g_core->WriteMessage(message_pipe_handle, bytes, num_bytes, handles, |
| 114 | num_handles, flags); |
| 115 | } |
| 116 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 117 | MojoResult MojoWriteMessageNewImpl(MojoHandle message_pipe_handle, |
| 118 | MojoMessageHandle message, |
| 119 | MojoWriteMessageFlags flags) { |
rockot | 72d05a46 | 2016-04-26 19:56:50 | [diff] [blame] | 120 | return g_core->WriteMessageNew(message_pipe_handle, message, flags); |
| 121 | } |
| 122 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 123 | MojoResult MojoReadMessageImpl(MojoHandle message_pipe_handle, |
| 124 | void* bytes, |
| 125 | uint32_t* num_bytes, |
| 126 | MojoHandle* handles, |
| 127 | uint32_t* num_handles, |
| 128 | MojoReadMessageFlags flags) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 129 | return g_core->ReadMessage( |
| 130 | message_pipe_handle, bytes, num_bytes, handles, num_handles, flags); |
| 131 | } |
| 132 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 133 | MojoResult MojoReadMessageNewImpl(MojoHandle message_pipe_handle, |
| 134 | MojoMessageHandle* message, |
| 135 | uint32_t* num_bytes, |
| 136 | MojoHandle* handles, |
| 137 | uint32_t* num_handles, |
| 138 | MojoReadMessageFlags flags) { |
rockot | 72d05a46 | 2016-04-26 19:56:50 | [diff] [blame] | 139 | return g_core->ReadMessageNew( |
| 140 | message_pipe_handle, message, num_bytes, handles, num_handles, flags); |
| 141 | } |
| 142 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 143 | MojoResult MojoFuseMessagePipesImpl(MojoHandle handle0, MojoHandle handle1) { |
rockot | b1e74df | 2016-03-14 13:18:30 | [diff] [blame] | 144 | return g_core->FuseMessagePipes(handle0, handle1); |
| 145 | } |
| 146 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 147 | MojoResult MojoCreateDataPipeImpl(const MojoCreateDataPipeOptions* options, |
| 148 | MojoHandle* data_pipe_producer_handle, |
| 149 | MojoHandle* data_pipe_consumer_handle) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 150 | return g_core->CreateDataPipe(options, data_pipe_producer_handle, |
| 151 | data_pipe_consumer_handle); |
| 152 | } |
| 153 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 154 | MojoResult MojoWriteDataImpl(MojoHandle data_pipe_producer_handle, |
| 155 | const void* elements, |
| 156 | uint32_t* num_elements, |
| 157 | MojoWriteDataFlags flags) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 158 | return g_core->WriteData(data_pipe_producer_handle, elements, num_elements, |
| 159 | flags); |
| 160 | } |
| 161 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 162 | MojoResult MojoBeginWriteDataImpl(MojoHandle data_pipe_producer_handle, |
| 163 | void** buffer, |
| 164 | uint32_t* buffer_num_elements, |
| 165 | MojoWriteDataFlags flags) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 166 | return g_core->BeginWriteData(data_pipe_producer_handle, buffer, |
| 167 | buffer_num_elements, flags); |
| 168 | } |
| 169 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 170 | MojoResult MojoEndWriteDataImpl(MojoHandle data_pipe_producer_handle, |
| 171 | uint32_t num_elements_written) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 172 | return g_core->EndWriteData(data_pipe_producer_handle, num_elements_written); |
| 173 | } |
| 174 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 175 | MojoResult MojoReadDataImpl(MojoHandle data_pipe_consumer_handle, |
| 176 | void* elements, |
| 177 | uint32_t* num_elements, |
| 178 | MojoReadDataFlags flags) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 179 | return g_core->ReadData(data_pipe_consumer_handle, elements, num_elements, |
| 180 | flags); |
| 181 | } |
| 182 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 183 | MojoResult MojoBeginReadDataImpl(MojoHandle data_pipe_consumer_handle, |
| 184 | const void** buffer, |
| 185 | uint32_t* buffer_num_elements, |
| 186 | MojoReadDataFlags flags) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 187 | return g_core->BeginReadData(data_pipe_consumer_handle, buffer, |
| 188 | buffer_num_elements, flags); |
| 189 | } |
| 190 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 191 | MojoResult MojoEndReadDataImpl(MojoHandle data_pipe_consumer_handle, |
| 192 | uint32_t num_elements_read) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 193 | return g_core->EndReadData(data_pipe_consumer_handle, num_elements_read); |
| 194 | } |
| 195 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 196 | MojoResult MojoCreateSharedBufferImpl( |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 197 | const struct MojoCreateSharedBufferOptions* options, |
| 198 | uint64_t num_bytes, |
| 199 | MojoHandle* shared_buffer_handle) { |
| 200 | return g_core->CreateSharedBuffer(options, num_bytes, shared_buffer_handle); |
| 201 | } |
| 202 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 203 | MojoResult MojoDuplicateBufferHandleImpl( |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 204 | MojoHandle buffer_handle, |
| 205 | const struct MojoDuplicateBufferHandleOptions* options, |
| 206 | MojoHandle* new_buffer_handle) { |
| 207 | return g_core->DuplicateBufferHandle(buffer_handle, options, |
| 208 | new_buffer_handle); |
| 209 | } |
| 210 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 211 | MojoResult MojoMapBufferImpl(MojoHandle buffer_handle, |
| 212 | uint64_t offset, |
| 213 | uint64_t num_bytes, |
| 214 | void** buffer, |
| 215 | MojoMapBufferFlags flags) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 216 | return g_core->MapBuffer(buffer_handle, offset, num_bytes, buffer, flags); |
| 217 | } |
| 218 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 219 | MojoResult MojoUnmapBufferImpl(void* buffer) { |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 220 | return g_core->UnmapBuffer(buffer); |
| 221 | } |
| 222 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 223 | MojoResult MojoWrapPlatformHandleImpl(const MojoPlatformHandle* platform_handle, |
| 224 | MojoHandle* mojo_handle) { |
rockot | 28a287e | 2016-05-24 02:51:37 | [diff] [blame] | 225 | return g_core->WrapPlatformHandle(platform_handle, mojo_handle); |
| 226 | } |
| 227 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 228 | MojoResult MojoUnwrapPlatformHandleImpl(MojoHandle mojo_handle, |
| 229 | MojoPlatformHandle* platform_handle) { |
rockot | 28a287e | 2016-05-24 02:51:37 | [diff] [blame] | 230 | return g_core->UnwrapPlatformHandle(mojo_handle, platform_handle); |
| 231 | } |
| 232 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 233 | MojoResult MojoWrapPlatformSharedBufferHandleImpl( |
rockot | 28a287e | 2016-05-24 02:51:37 | [diff] [blame] | 234 | const MojoPlatformHandle* platform_handle, |
| 235 | size_t num_bytes, |
| 236 | MojoPlatformSharedBufferHandleFlags flags, |
| 237 | MojoHandle* mojo_handle) { |
| 238 | return g_core->WrapPlatformSharedBufferHandle(platform_handle, num_bytes, |
| 239 | flags, mojo_handle); |
| 240 | } |
| 241 | |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 242 | MojoResult MojoUnwrapPlatformSharedBufferHandleImpl( |
rockot | 28a287e | 2016-05-24 02:51:37 | [diff] [blame] | 243 | MojoHandle mojo_handle, |
| 244 | MojoPlatformHandle* platform_handle, |
| 245 | size_t* num_bytes, |
| 246 | MojoPlatformSharedBufferHandleFlags* flags) { |
| 247 | return g_core->UnwrapPlatformSharedBufferHandle(mojo_handle, platform_handle, |
| 248 | num_bytes, flags); |
| 249 | } |
| 250 | |
jam | 76bcf0c | 2015-10-02 21:01:28 | [diff] [blame] | 251 | } // extern "C" |
rockot | b04b89b5 | 2016-06-09 03:58:56 | [diff] [blame^] | 252 | |
| 253 | namespace mojo { |
| 254 | namespace edk { |
| 255 | |
| 256 | MojoSystemThunks MakeSystemThunks() { |
| 257 | MojoSystemThunks system_thunks = {sizeof(MojoSystemThunks), |
| 258 | MojoGetTimeTicksNowImpl, |
| 259 | MojoCloseImpl, |
| 260 | MojoWaitImpl, |
| 261 | MojoWaitManyImpl, |
| 262 | MojoCreateMessagePipeImpl, |
| 263 | MojoWriteMessageImpl, |
| 264 | MojoReadMessageImpl, |
| 265 | MojoCreateDataPipeImpl, |
| 266 | MojoWriteDataImpl, |
| 267 | MojoBeginWriteDataImpl, |
| 268 | MojoEndWriteDataImpl, |
| 269 | MojoReadDataImpl, |
| 270 | MojoBeginReadDataImpl, |
| 271 | MojoEndReadDataImpl, |
| 272 | MojoCreateSharedBufferImpl, |
| 273 | MojoDuplicateBufferHandleImpl, |
| 274 | MojoMapBufferImpl, |
| 275 | MojoUnmapBufferImpl, |
| 276 | MojoCreateWaitSetImpl, |
| 277 | MojoAddHandleImpl, |
| 278 | MojoRemoveHandleImpl, |
| 279 | MojoGetReadyHandlesImpl, |
| 280 | MojoWatchImpl, |
| 281 | MojoCancelWatchImpl, |
| 282 | MojoFuseMessagePipesImpl, |
| 283 | MojoWriteMessageNewImpl, |
| 284 | MojoReadMessageNewImpl, |
| 285 | MojoAllocMessageImpl, |
| 286 | MojoFreeMessageImpl, |
| 287 | MojoGetMessageBufferImpl, |
| 288 | MojoWrapPlatformHandleImpl, |
| 289 | MojoUnwrapPlatformHandleImpl, |
| 290 | MojoWrapPlatformSharedBufferHandleImpl, |
| 291 | MojoUnwrapPlatformSharedBufferHandleImpl}; |
| 292 | return system_thunks; |
| 293 | } |
| 294 | |
| 295 | } // namespace edk |
| 296 | } // namespace mojo |