1// Copyright 2013 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#ifndef MOJO_EDK_SYSTEM_CORE_H_
6#define MOJO_EDK_SYSTEM_CORE_H_
7
8#include <memory>
9#include <vector>
10
11#include "base/callback.h"
12#include "base/macros.h"
13#include "base/memory/ref_counted.h"
14#include "base/memory/shared_memory_handle.h"
15#include "base/synchronization/lock.h"
16#include "base/task_runner.h"
17#include "mojo/edk/embedder/scoped_platform_handle.h"
18#include "mojo/edk/system/dispatcher.h"
19#include "mojo/edk/system/handle_signals_state.h"
20#include "mojo/edk/system/handle_table.h"
21#include "mojo/edk/system/mapping_table.h"
22#include "mojo/edk/system/node_controller.h"
23#include "mojo/edk/system/system_impl_export.h"
24#include "mojo/public/c/system/buffer.h"
25#include "mojo/public/c/system/data_pipe.h"
26#include "mojo/public/c/system/message_pipe.h"
27#include "mojo/public/c/system/platform_handle.h"
28#include "mojo/public/c/system/types.h"
29#include "mojo/public/cpp/system/message_pipe.h"
30
31namespace base {
32class PortProvider;
33}
34
35namespace mojo {
36namespace edk {
37
38// |Core| is an object that implements the Mojo system calls. All public methods
39// are thread-safe.
40class MOJO_SYSTEM_IMPL_EXPORT Core {
41 public:
42  explicit Core();
43  virtual ~Core();
44
45  // Called exactly once, shortly after construction, and before any other
46  // methods are called on this object.
47  void SetIOTaskRunner(scoped_refptr<base::TaskRunner> io_task_runner);
48
49  // Retrieves the NodeController for the current process.
50  NodeController* GetNodeController();
51
52  scoped_refptr<Dispatcher> GetDispatcher(MojoHandle handle);
53
54  // Called in the parent process any time a new child is launched.
55  void AddChild(base::ProcessHandle process_handle,
56                ScopedPlatformHandle platform_handle,
57                const std::string& child_token,
58                const ProcessErrorCallback& process_error_callback);
59
60  // Called in the parent process when a child process fails to launch.
61  void ChildLaunchFailed(const std::string& child_token);
62
63  // Called in a child process exactly once during early initialization.
64  void InitChild(ScopedPlatformHandle platform_handle);
65
66  // Creates a message pipe endpoint associated with |token|, which a child
67  // holding the token can later locate and connect to.
68  ScopedMessagePipeHandle CreateParentMessagePipe(
69      const std::string& token, const std::string& child_token);
70
71  // Creates a message pipe endpoint and connects it to a pipe the parent has
72  // associated with |token|.
73  ScopedMessagePipeHandle CreateChildMessagePipe(const std::string& token);
74
75  // Sets the mach port provider for this process.
76  void SetMachPortProvider(base::PortProvider* port_provider);
77
78  MojoHandle AddDispatcher(scoped_refptr<Dispatcher> dispatcher);
79
80  // Adds new dispatchers for non-message-pipe handles received in a message.
81  // |dispatchers| and |handles| should be the same size.
82  bool AddDispatchersFromTransit(
83      const std::vector<Dispatcher::DispatcherInTransit>& dispatchers,
84      MojoHandle* handles);
85
86  // See "mojo/edk/embedder/embedder.h" for more information on these functions.
87  MojoResult CreatePlatformHandleWrapper(ScopedPlatformHandle platform_handle,
88                                         MojoHandle* wrapper_handle);
89
90  MojoResult PassWrappedPlatformHandle(MojoHandle wrapper_handle,
91                                       ScopedPlatformHandle* platform_handle);
92
93  MojoResult CreateSharedBufferWrapper(
94      base::SharedMemoryHandle shared_memory_handle,
95      size_t num_bytes,
96      bool read_only,
97      MojoHandle* mojo_wrapper_handle);
98
99  MojoResult PassSharedMemoryHandle(
100      MojoHandle mojo_handle,
101      base::SharedMemoryHandle* shared_memory_handle,
102      size_t* num_bytes,
103      bool* read_only);
104
105  // Requests that the EDK tear itself down. |callback| will be called once
106  // the shutdown process is complete. Note that |callback| is always called
107  // asynchronously on the calling thread if said thread is running a message
108  // loop, and the calling thread must continue running a MessageLoop at least
109  // until the callback is called. If there is no running loop, the |callback|
110  // may be called from any thread. Beware!
111  void RequestShutdown(const base::Closure& callback);
112
113  MojoResult SetProperty(MojoPropertyType type, const void* value);
114
115  // ---------------------------------------------------------------------------
116
117  // The following methods are essentially implementations of the Mojo Core
118  // functions of the Mojo API, with the C interface translated to C++ by
119  // "mojo/edk/embedder/entrypoints.cc". The best way to understand the contract
120  // of these methods is to look at the header files defining the corresponding
121  // API functions, referenced below.
122
123  // These methods correspond to the API functions defined in
124  // "mojo/public/c/system/functions.h":
125  MojoTimeTicks GetTimeTicksNow();
126  MojoResult Close(MojoHandle handle);
127  MojoResult Wait(MojoHandle handle,
128                  MojoHandleSignals signals,
129                  MojoDeadline deadline,
130                  MojoHandleSignalsState* signals_state);
131  MojoResult WaitMany(const MojoHandle* handles,
132                      const MojoHandleSignals* signals,
133                      uint32_t num_handles,
134                      MojoDeadline deadline,
135                      uint32_t* result_index,
136                      MojoHandleSignalsState* signals_states);
137  MojoResult Watch(MojoHandle handle,
138                   MojoHandleSignals signals,
139                   MojoWatchCallback callback,
140                   uintptr_t context);
141  MojoResult CancelWatch(MojoHandle handle, uintptr_t context);
142  MojoResult AllocMessage(uint32_t num_bytes,
143                          const MojoHandle* handles,
144                          uint32_t num_handles,
145                          MojoAllocMessageFlags flags,
146                          MojoMessageHandle* message);
147  MojoResult FreeMessage(MojoMessageHandle message);
148  MojoResult GetMessageBuffer(MojoMessageHandle message, void** buffer);
149  MojoResult GetProperty(MojoPropertyType type, void* value);
150
151  // These methods correspond to the API functions defined in
152  // "mojo/public/c/system/wait_set.h":
153  MojoResult CreateWaitSet(MojoHandle* wait_set_handle);
154  MojoResult AddHandle(MojoHandle wait_set_handle,
155                       MojoHandle handle,
156                       MojoHandleSignals signals);
157  MojoResult RemoveHandle(MojoHandle wait_set_handle,
158                          MojoHandle handle);
159  MojoResult GetReadyHandles(MojoHandle wait_set_handle,
160                             uint32_t* count,
161                             MojoHandle* handles,
162                             MojoResult* results,
163                             MojoHandleSignalsState* signals_states);
164
165  // These methods correspond to the API functions defined in
166  // "mojo/public/c/system/message_pipe.h":
167  MojoResult CreateMessagePipe(
168      const MojoCreateMessagePipeOptions* options,
169      MojoHandle* message_pipe_handle0,
170      MojoHandle* message_pipe_handle1);
171  MojoResult WriteMessage(MojoHandle message_pipe_handle,
172                          const void* bytes,
173                          uint32_t num_bytes,
174                          const MojoHandle* handles,
175                          uint32_t num_handles,
176                          MojoWriteMessageFlags flags);
177  MojoResult WriteMessageNew(MojoHandle message_pipe_handle,
178                             MojoMessageHandle message,
179                             MojoWriteMessageFlags flags);
180  MojoResult ReadMessage(MojoHandle message_pipe_handle,
181                         void* bytes,
182                         uint32_t* num_bytes,
183                         MojoHandle* handles,
184                         uint32_t* num_handles,
185                         MojoReadMessageFlags flags);
186  MojoResult ReadMessageNew(MojoHandle message_pipe_handle,
187                            MojoMessageHandle* message,
188                            uint32_t* num_bytes,
189                            MojoHandle* handles,
190                            uint32_t* num_handles,
191                            MojoReadMessageFlags flags);
192  MojoResult FuseMessagePipes(MojoHandle handle0, MojoHandle handle1);
193  MojoResult NotifyBadMessage(MojoMessageHandle message,
194                              const char* error,
195                              size_t error_num_bytes);
196
197  // These methods correspond to the API functions defined in
198  // "mojo/public/c/system/data_pipe.h":
199  MojoResult CreateDataPipe(
200      const MojoCreateDataPipeOptions* options,
201      MojoHandle* data_pipe_producer_handle,
202      MojoHandle* data_pipe_consumer_handle);
203  MojoResult WriteData(MojoHandle data_pipe_producer_handle,
204                       const void* elements,
205                       uint32_t* num_bytes,
206                       MojoWriteDataFlags flags);
207  MojoResult BeginWriteData(MojoHandle data_pipe_producer_handle,
208                            void** buffer,
209                            uint32_t* buffer_num_bytes,
210                            MojoWriteDataFlags flags);
211  MojoResult EndWriteData(MojoHandle data_pipe_producer_handle,
212                          uint32_t num_bytes_written);
213  MojoResult ReadData(MojoHandle data_pipe_consumer_handle,
214                      void* elements,
215                      uint32_t* num_bytes,
216                      MojoReadDataFlags flags);
217  MojoResult BeginReadData(MojoHandle data_pipe_consumer_handle,
218                           const void** buffer,
219                           uint32_t* buffer_num_bytes,
220                           MojoReadDataFlags flags);
221  MojoResult EndReadData(MojoHandle data_pipe_consumer_handle,
222                         uint32_t num_bytes_read);
223
224  // These methods correspond to the API functions defined in
225  // "mojo/public/c/system/buffer.h":
226  MojoResult CreateSharedBuffer(
227      const MojoCreateSharedBufferOptions* options,
228      uint64_t num_bytes,
229      MojoHandle* shared_buffer_handle);
230  MojoResult DuplicateBufferHandle(
231      MojoHandle buffer_handle,
232      const MojoDuplicateBufferHandleOptions* options,
233      MojoHandle* new_buffer_handle);
234  MojoResult MapBuffer(MojoHandle buffer_handle,
235                       uint64_t offset,
236                       uint64_t num_bytes,
237                       void** buffer,
238                       MojoMapBufferFlags flags);
239  MojoResult UnmapBuffer(void* buffer);
240
241  // These methods correspond to the API functions defined in
242  // "mojo/public/c/system/platform_handle.h".
243  MojoResult WrapPlatformHandle(const MojoPlatformHandle* platform_handle,
244                                MojoHandle* mojo_handle);
245  MojoResult UnwrapPlatformHandle(MojoHandle mojo_handle,
246                                  MojoPlatformHandle* platform_handle);
247  MojoResult WrapPlatformSharedBufferHandle(
248      const MojoPlatformHandle* platform_handle,
249      size_t size,
250      MojoPlatformSharedBufferHandleFlags flags,
251      MojoHandle* mojo_handle);
252  MojoResult UnwrapPlatformSharedBufferHandle(
253      MojoHandle mojo_handle,
254      MojoPlatformHandle* platform_handle,
255      size_t* size,
256      MojoPlatformSharedBufferHandleFlags* flags);
257
258  void GetActiveHandlesForTest(std::vector<MojoHandle>* handles);
259
260 private:
261  MojoResult WaitManyInternal(const MojoHandle* handles,
262                              const MojoHandleSignals* signals,
263                              uint32_t num_handles,
264                              MojoDeadline deadline,
265                              uint32_t *result_index,
266                              HandleSignalsState* signals_states);
267
268  // Used to pass ownership of our NodeController over to the IO thread in the
269  // event that we're torn down before said thread.
270  static void PassNodeControllerToIOThread(
271      std::unique_ptr<NodeController> node_controller);
272
273  // Guards node_controller_.
274  //
275  // TODO(rockot): Consider removing this. It's only needed because we
276  // initialize node_controller_ lazily and that may happen on any thread.
277  // Otherwise it's effectively const and shouldn't need to be guarded.
278  //
279  // We can get rid of lazy initialization if we defer Mojo initialization far
280  // enough that zygotes don't do it. The zygote can't create a NodeController.
281  base::Lock node_controller_lock_;
282
283  // This is lazily initialized on first access. Always use GetNodeController()
284  // to access it.
285  std::unique_ptr<NodeController> node_controller_;
286
287  base::Lock handles_lock_;
288  HandleTable handles_;
289
290  base::Lock mapping_table_lock_;  // Protects |mapping_table_|.
291  MappingTable mapping_table_;
292
293  base::Lock property_lock_;
294  // Properties that can be read using the MojoGetProperty() API.
295  bool property_sync_call_allowed_ = true;
296
297  DISALLOW_COPY_AND_ASSIGN(Core);
298};
299
300}  // namespace edk
301}  // namespace mojo
302
303#endif  // MOJO_EDK_SYSTEM_CORE_H_
304