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
5 #include "mojo/system/entrypoints.h"
6
7 #include "mojo/public/c/system/buffer.h"
8 #include "mojo/public/c/system/data_pipe.h"
9 #include "mojo/public/c/system/functions.h"
10 #include "mojo/public/c/system/message_pipe.h"
11 #include "mojo/system/core.h"
12
13 static mojo::system::Core* g_core = NULL;
14
15 namespace mojo {
16 namespace system {
17 namespace entrypoints {
18
SetCore(Core * core)19 void SetCore(Core* core) {
20 g_core = core;
21 }
22
GetCore()23 Core* GetCore() {
24 return g_core;
25 }
26
27 } // namespace entrypoints
28 } // namepace system
29 } // namespace mojo
30
31 // Definitions of the system functions.
32 extern "C" {
33
MojoGetTimeTicksNow()34 MojoTimeTicks MojoGetTimeTicksNow() {
35 return g_core->GetTimeTicksNow();
36 }
37
MojoClose(MojoHandle handle)38 MojoResult MojoClose(MojoHandle handle) {
39 return g_core->Close(handle);
40 }
41
MojoWait(MojoHandle handle,MojoHandleSignals signals,MojoDeadline deadline)42 MojoResult MojoWait(MojoHandle handle,
43 MojoHandleSignals signals,
44 MojoDeadline deadline) {
45 return g_core->Wait(handle, signals, deadline);
46 }
47
MojoWaitMany(const MojoHandle * handles,const MojoHandleSignals * signals,uint32_t num_handles,MojoDeadline deadline)48 MojoResult MojoWaitMany(const MojoHandle* handles,
49 const MojoHandleSignals* signals,
50 uint32_t num_handles,
51 MojoDeadline deadline) {
52 return g_core->WaitMany(handles, signals, num_handles, deadline);
53 }
54
MojoCreateMessagePipe(const MojoCreateMessagePipeOptions * options,MojoHandle * message_pipe_handle0,MojoHandle * message_pipe_handle1)55 MojoResult MojoCreateMessagePipe(const MojoCreateMessagePipeOptions* options,
56 MojoHandle* message_pipe_handle0,
57 MojoHandle* message_pipe_handle1) {
58 return g_core->CreateMessagePipe(
59 options, message_pipe_handle0, message_pipe_handle1);
60 }
61
MojoWriteMessage(MojoHandle message_pipe_handle,const void * bytes,uint32_t num_bytes,const MojoHandle * handles,uint32_t num_handles,MojoWriteMessageFlags flags)62 MojoResult MojoWriteMessage(MojoHandle message_pipe_handle,
63 const void* bytes,
64 uint32_t num_bytes,
65 const MojoHandle* handles,
66 uint32_t num_handles,
67 MojoWriteMessageFlags flags) {
68 return g_core->WriteMessage(
69 message_pipe_handle, bytes, num_bytes, handles, num_handles, flags);
70 }
71
MojoReadMessage(MojoHandle message_pipe_handle,void * bytes,uint32_t * num_bytes,MojoHandle * handles,uint32_t * num_handles,MojoReadMessageFlags flags)72 MojoResult MojoReadMessage(MojoHandle message_pipe_handle,
73 void* bytes,
74 uint32_t* num_bytes,
75 MojoHandle* handles,
76 uint32_t* num_handles,
77 MojoReadMessageFlags flags) {
78 return g_core->ReadMessage(
79 message_pipe_handle, bytes, num_bytes, handles, num_handles, flags);
80 }
81
MojoCreateDataPipe(const MojoCreateDataPipeOptions * options,MojoHandle * data_pipe_producer_handle,MojoHandle * data_pipe_consumer_handle)82 MojoResult MojoCreateDataPipe(const MojoCreateDataPipeOptions* options,
83 MojoHandle* data_pipe_producer_handle,
84 MojoHandle* data_pipe_consumer_handle) {
85 return g_core->CreateDataPipe(
86 options, data_pipe_producer_handle, data_pipe_consumer_handle);
87 }
88
MojoWriteData(MojoHandle data_pipe_producer_handle,const void * elements,uint32_t * num_elements,MojoWriteDataFlags flags)89 MojoResult MojoWriteData(MojoHandle data_pipe_producer_handle,
90 const void* elements,
91 uint32_t* num_elements,
92 MojoWriteDataFlags flags) {
93 return g_core->WriteData(
94 data_pipe_producer_handle, elements, num_elements, flags);
95 }
96
MojoBeginWriteData(MojoHandle data_pipe_producer_handle,void ** buffer,uint32_t * buffer_num_elements,MojoWriteDataFlags flags)97 MojoResult MojoBeginWriteData(MojoHandle data_pipe_producer_handle,
98 void** buffer,
99 uint32_t* buffer_num_elements,
100 MojoWriteDataFlags flags) {
101 return g_core->BeginWriteData(
102 data_pipe_producer_handle, buffer, buffer_num_elements, flags);
103 }
104
MojoEndWriteData(MojoHandle data_pipe_producer_handle,uint32_t num_elements_written)105 MojoResult MojoEndWriteData(MojoHandle data_pipe_producer_handle,
106 uint32_t num_elements_written) {
107 return g_core->EndWriteData(data_pipe_producer_handle, num_elements_written);
108 }
109
MojoReadData(MojoHandle data_pipe_consumer_handle,void * elements,uint32_t * num_elements,MojoReadDataFlags flags)110 MojoResult MojoReadData(MojoHandle data_pipe_consumer_handle,
111 void* elements,
112 uint32_t* num_elements,
113 MojoReadDataFlags flags) {
114 return g_core->ReadData(
115 data_pipe_consumer_handle, elements, num_elements, flags);
116 }
117
MojoBeginReadData(MojoHandle data_pipe_consumer_handle,const void ** buffer,uint32_t * buffer_num_elements,MojoReadDataFlags flags)118 MojoResult MojoBeginReadData(MojoHandle data_pipe_consumer_handle,
119 const void** buffer,
120 uint32_t* buffer_num_elements,
121 MojoReadDataFlags flags) {
122 return g_core->BeginReadData(
123 data_pipe_consumer_handle, buffer, buffer_num_elements, flags);
124 }
125
MojoEndReadData(MojoHandle data_pipe_consumer_handle,uint32_t num_elements_read)126 MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle,
127 uint32_t num_elements_read) {
128 return g_core->EndReadData(data_pipe_consumer_handle, num_elements_read);
129 }
130
MojoCreateSharedBuffer(const struct MojoCreateSharedBufferOptions * options,uint64_t num_bytes,MojoHandle * shared_buffer_handle)131 MojoResult MojoCreateSharedBuffer(
132 const struct MojoCreateSharedBufferOptions* options,
133 uint64_t num_bytes,
134 MojoHandle* shared_buffer_handle) {
135 return g_core->CreateSharedBuffer(options, num_bytes, shared_buffer_handle);
136 }
137
MojoDuplicateBufferHandle(MojoHandle buffer_handle,const struct MojoDuplicateBufferHandleOptions * options,MojoHandle * new_buffer_handle)138 MojoResult MojoDuplicateBufferHandle(
139 MojoHandle buffer_handle,
140 const struct MojoDuplicateBufferHandleOptions* options,
141 MojoHandle* new_buffer_handle) {
142 return g_core->DuplicateBufferHandle(
143 buffer_handle, options, new_buffer_handle);
144 }
145
MojoMapBuffer(MojoHandle buffer_handle,uint64_t offset,uint64_t num_bytes,void ** buffer,MojoMapBufferFlags flags)146 MojoResult MojoMapBuffer(MojoHandle buffer_handle,
147 uint64_t offset,
148 uint64_t num_bytes,
149 void** buffer,
150 MojoMapBufferFlags flags) {
151 return g_core->MapBuffer(buffer_handle, offset, num_bytes, buffer, flags);
152 }
153
MojoUnmapBuffer(void * buffer)154 MojoResult MojoUnmapBuffer(void* buffer) {
155 return g_core->UnmapBuffer(buffer);
156 }
157
158 } // extern "C"
159