Rearrange mojo/nacl files. Files that were previously generated are now checked in to make SDK and Chromium integration easier. Files needed to build mojo apps have been moved to //mojo/public/platform/nacl. Files needed to integrate NaCl with Mojo (used by the NaCl content handler and Chromium) have been moved to //nacl_bindings. This directory will be copied into the Chrome tree. //nacl_bindings_generator contains the script for regenerating the checked-in files. This script will likely go away when the NaCl bindings have stabilized. //mojo/nacl is deprecated and currently contains testing and build files specific to the Mojo repo. BUG=401761 R=jamesr@chromium.org Review URL: https://codereview.chromium.org/955113002
diff --git a/mojo/nacl/BUILD.gn b/mojo/nacl/BUILD.gn index 8c17ef1..267f701 100644 --- a/mojo/nacl/BUILD.gn +++ b/mojo/nacl/BUILD.gn
@@ -2,53 +2,8 @@ # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. -# All toolchains use the same generated code. -gen_dir = "$root_build_dir/gen/mojo/nacl" - -# Only allow the generator to be run by one toolchain. -if (current_toolchain == default_toolchain) { - # Generate the code to plumb the Mojo public API into the NaCl sandbox. - action("mojo_nacl_codegen") { - script = "generator/generate_nacl_bindings.py" - args = [ - "-d", - rebase_path(gen_dir, root_build_dir), - ] - inputs = [ - script, - "generator/interface.py", - "generator/interface_dsl.py", - "generator/mojo_syscall.cc.tmpl", - "generator/libmojo.cc.tmpl", - ] - outputs = [ - "$gen_dir/mojo_irt.c", - "$gen_dir/mojo_irt.h", - "$gen_dir/mojo_syscall.cc", - "$gen_dir/libmojo.cc", - ] - } -} - # Trusted code if (!is_nacl) { - # A library for launching a NaCl sandbox connected to a Mojo embedder. - static_library("monacl_sel") { - sources = [ - "mojo_syscall_internal.h", - "$gen_dir/mojo_syscall.cc", - "monacl_sel_main.cc", - ] - deps = [ - # This target makes sure we have all the pre-processor defines needed to - # use NaCl's headers. - "//native_client/build/config/nacl:nacl_base", - "//native_client/src/trusted/desc:nrd_xfer", - "//native_client/src/trusted/service_runtime:sel_main_chrome", - ":mojo_nacl_codegen($default_toolchain)", - ] - } - # A simple shell for running untrusted binaries that talk to the Mojo # embedder. (No services.) executable("monacl_shell") { @@ -59,28 +14,15 @@ deps = [ "//base:base", "//mojo/edk/system:system", - ":monacl_sel", + "//nacl_bindings:monacl_sel", ] - data_deps = - [ ":irt_mojo(//native_client/build/toolchain/nacl:irt_${cpu_arch})" ] + data_deps = [ "//nacl_bindings:irt_mojo(//native_client/build/toolchain/nacl:irt_${cpu_arch})" ] } } # Untrusted code if (is_nacl) { - # Thunk mapping the Mojo public API onto NaCl syscalls. - static_library("mojo") { - sources = [ - "$gen_dir/libmojo.cc", - "$gen_dir/mojo_irt.h", - ] - include_dirs = [ "$root_build_dir/gen" ] - deps = [ - ":mojo_nacl_codegen($default_toolchain)", - ] - } - # Unit test for the Mojo public API. executable("monacl_test") { testonly = true @@ -91,25 +33,9 @@ deps = [ "//mojo/public/c/system/tests:tests", "//mojo/public/cpp/system:system", + "//mojo/public/platform/nacl:mojo", "//testing/gtest:gtest", "//testing/gtest:gtest_main", - ":mojo", - ] - } - - executable("irt_mojo") { - cflags_c = [ "-std=c99" ] - sources = [ - "irt_entry_mojo.c", - "$gen_dir/mojo_irt.c", - "$gen_dir/mojo_irt.h", - ] - include_dirs = [ "$root_build_dir/gen" ] - deps = [ - "//native_client/build/config/nacl:nacl_base", - "//native_client/src/untrusted/irt:irt_core_lib", - "//native_client/src/untrusted/nacl:imc_syscalls", - ":mojo_nacl_codegen($default_toolchain)", ] } }
diff --git a/mojo/nacl/monacl_shell.cc b/mojo/nacl/monacl_shell.cc index b51126d..714c04f 100644 --- a/mojo/nacl/monacl_shell.cc +++ b/mojo/nacl/monacl_shell.cc
@@ -9,7 +9,7 @@ #include "base/logging.h" #include "mojo/edk/embedder/embedder.h" #include "mojo/edk/embedder/simple_platform_support.h" -#include "mojo/nacl/monacl_sel_main.h" +#include "nacl_bindings/monacl_sel_main.h" #include "native_client/src/public/nacl_desc.h" NaClDesc* OpenFile(const char* filename) {
diff --git a/mojo/public/platform/nacl/BUILD.gn b/mojo/public/platform/nacl/BUILD.gn new file mode 100644 index 0000000..7b4fb2d --- /dev/null +++ b/mojo/public/platform/nacl/BUILD.gn
@@ -0,0 +1,17 @@ +# 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. + +import("../../mojo_sdk.gni") + +# Untrusted code +if (is_nacl) { + # Thunk mapping the Mojo public API onto NaCl syscalls. + mojo_sdk_source_set("mojo") { + sources = [ + "libmojo.cc", + "mojo_irt.h", + ] + mojo_sdk_deps = [ "mojo/public/c/system" ] + } +}
diff --git a/mojo/public/platform/nacl/libmojo.cc b/mojo/public/platform/nacl/libmojo.cc new file mode 100644 index 0000000..99eddf0 --- /dev/null +++ b/mojo/public/platform/nacl/libmojo.cc
@@ -0,0 +1,226 @@ +// 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. + +// WARNING this file was generated by generate_nacl_bindings.py +// Do not edit by hand. + +#include "mojo/public/c/system/core.h" +#include "mojo/public/platform/nacl/mojo_irt.h" +#include "native_client/src/public/chrome_main.h" +#include "native_client/src/public/imc_syscalls.h" +#include "native_client/src/public/imc_types.h" +#include "native_client/src/untrusted/irt/irt.h" + +// The value for this FD must not conflict with uses inside Chromium. However, +// mojo/nacl doesn't depend on any Chromium headers, so we can't use a #define +// from there. +#define NACL_MOJO_DESC (NACL_CHROME_DESC_BASE + 3) + +bool g_irt_mojo_valid = false; +struct nacl_irt_mojo g_irt_mojo; + +struct nacl_irt_mojo* get_irt_mojo() { + if (!g_irt_mojo_valid) { + size_t rc = nacl_interface_query(NACL_IRT_MOJO_v0_1, &g_irt_mojo, + sizeof(g_irt_mojo)); + if (rc != sizeof(g_irt_mojo)) + return NULL; + else + g_irt_mojo_valid = true; + } + return &g_irt_mojo; +} + +MojoResult MojoCreateSharedBuffer( + const struct MojoCreateSharedBufferOptions* options, + uint64_t num_bytes, + MojoHandle* shared_buffer_handle) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoCreateSharedBuffer(options, num_bytes, + shared_buffer_handle); +} + +MojoResult MojoDuplicateBufferHandle( + MojoHandle buffer_handle, + const struct MojoDuplicateBufferHandleOptions* options, + MojoHandle* new_buffer_handle) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoDuplicateBufferHandle(buffer_handle, options, + new_buffer_handle); +} + +MojoResult MojoMapBuffer(MojoHandle buffer_handle, + uint64_t offset, + uint64_t num_bytes, + void** buffer, + MojoMapBufferFlags flags) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoMapBuffer(buffer_handle, offset, num_bytes, buffer, + flags); +} + +MojoResult MojoUnmapBuffer(void* buffer) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoUnmapBuffer(buffer); +} + +MojoResult MojoCreateDataPipe(const struct MojoCreateDataPipeOptions* options, + MojoHandle* data_pipe_producer_handle, + MojoHandle* data_pipe_consumer_handle) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoCreateDataPipe(options, data_pipe_producer_handle, + data_pipe_consumer_handle); +} + +MojoResult MojoWriteData(MojoHandle data_pipe_producer_handle, + const void* elements, + uint32_t* num_bytes, + MojoWriteDataFlags flags) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoWriteData(data_pipe_producer_handle, elements, num_bytes, + flags); +} + +MojoResult MojoBeginWriteData(MojoHandle data_pipe_producer_handle, + void** buffer, + uint32_t* buffer_num_bytes, + MojoWriteDataFlags flags) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoBeginWriteData(data_pipe_producer_handle, buffer, + buffer_num_bytes, flags); +} + +MojoResult MojoEndWriteData(MojoHandle data_pipe_producer_handle, + uint32_t num_bytes_written) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoEndWriteData(data_pipe_producer_handle, + num_bytes_written); +} + +MojoResult MojoReadData(MojoHandle data_pipe_consumer_handle, + void* elements, + uint32_t* num_bytes, + MojoReadDataFlags flags) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoReadData(data_pipe_consumer_handle, elements, num_bytes, + flags); +} + +MojoResult MojoBeginReadData(MojoHandle data_pipe_consumer_handle, + const void** buffer, + uint32_t* buffer_num_bytes, + MojoReadDataFlags flags) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoBeginReadData(data_pipe_consumer_handle, buffer, + buffer_num_bytes, flags); +} + +MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle, + uint32_t num_bytes_read) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoEndReadData(data_pipe_consumer_handle, num_bytes_read); +} + +MojoTimeTicks MojoGetTimeTicksNow() { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoGetTimeTicksNow(); +} + +MojoResult MojoClose(MojoHandle handle) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoClose(handle); +} + +MojoResult MojoWait(MojoHandle handle, + MojoHandleSignals signals, + MojoDeadline deadline, + struct MojoHandleSignalsState* signals_state) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoWait(handle, signals, deadline, signals_state); +} + +MojoResult MojoWaitMany(const MojoHandle* handles, + const MojoHandleSignals* signals, + uint32_t num_handles, + MojoDeadline deadline, + uint32_t* result_index, + struct MojoHandleSignalsState* signals_states) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoWaitMany(handles, signals, num_handles, deadline, + result_index, signals_states); +} + +MojoResult MojoCreateMessagePipe( + const struct MojoCreateMessagePipeOptions* options, + MojoHandle* message_pipe_handle0, + MojoHandle* message_pipe_handle1) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoCreateMessagePipe(options, message_pipe_handle0, + message_pipe_handle1); +} + +MojoResult MojoWriteMessage(MojoHandle message_pipe_handle, + const void* bytes, + uint32_t num_bytes, + const MojoHandle* handles, + uint32_t num_handles, + MojoWriteMessageFlags flags) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoWriteMessage(message_pipe_handle, bytes, num_bytes, + handles, num_handles, flags); +} + +MojoResult MojoReadMessage(MojoHandle message_pipe_handle, + void* bytes, + uint32_t* num_bytes, + MojoHandle* handles, + uint32_t* num_handles, + MojoReadMessageFlags flags) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->MojoReadMessage(message_pipe_handle, bytes, num_bytes, + handles, num_handles, flags); +} + +MojoResult _MojoGetInitialHandle(MojoHandle* handle) { + struct nacl_irt_mojo* irt_mojo = get_irt_mojo(); + if (irt_mojo == NULL) + return MOJO_RESULT_INTERNAL; + return irt_mojo->_MojoGetInitialHandle(handle); +}
diff --git a/mojo/public/platform/nacl/mojo_irt.h b/mojo/public/platform/nacl/mojo_irt.h new file mode 100644 index 0000000..db3a180 --- /dev/null +++ b/mojo/public/platform/nacl/mojo_irt.h
@@ -0,0 +1,100 @@ +// Copyright 2015 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. + +// WARNING this file was generated by generate_nacl_bindings.py +// Do not edit by hand. + +#ifndef MOJO_PUBLIC_PLATFORM_NACL_MOJO_IRT_H_ +#define MOJO_PUBLIC_PLATFORM_NACL_MOJO_IRT_H_ + +#include "mojo/public/c/system/buffer.h" +#include "mojo/public/c/system/data_pipe.h" +#include "mojo/public/c/system/message_pipe.h" +#include "mojo/public/c/system/types.h" + +#define NACL_IRT_MOJO_v0_1 "nacl-irt-mojo-0.1" + +struct nacl_irt_mojo { + MojoResult (*MojoCreateSharedBuffer)( + const struct MojoCreateSharedBufferOptions* options, + uint64_t num_bytes, + MojoHandle* shared_buffer_handle); + MojoResult (*MojoDuplicateBufferHandle)( + MojoHandle buffer_handle, + const struct MojoDuplicateBufferHandleOptions* options, + MojoHandle* new_buffer_handle); + MojoResult (*MojoMapBuffer)(MojoHandle buffer_handle, + uint64_t offset, + uint64_t num_bytes, + void** buffer, + MojoMapBufferFlags flags); + MojoResult (*MojoUnmapBuffer)(void* buffer); + MojoResult (*MojoCreateDataPipe)( + const struct MojoCreateDataPipeOptions* options, + MojoHandle* data_pipe_producer_handle, + MojoHandle* data_pipe_consumer_handle); + MojoResult (*MojoWriteData)(MojoHandle data_pipe_producer_handle, + const void* elements, + uint32_t* num_bytes, + MojoWriteDataFlags flags); + MojoResult (*MojoBeginWriteData)(MojoHandle data_pipe_producer_handle, + void** buffer, + uint32_t* buffer_num_bytes, + MojoWriteDataFlags flags); + MojoResult (*MojoEndWriteData)(MojoHandle data_pipe_producer_handle, + uint32_t num_bytes_written); + MojoResult (*MojoReadData)(MojoHandle data_pipe_consumer_handle, + void* elements, + uint32_t* num_bytes, + MojoReadDataFlags flags); + MojoResult (*MojoBeginReadData)(MojoHandle data_pipe_consumer_handle, + const void** buffer, + uint32_t* buffer_num_bytes, + MojoReadDataFlags flags); + MojoResult (*MojoEndReadData)(MojoHandle data_pipe_consumer_handle, + uint32_t num_bytes_read); + MojoTimeTicks (*MojoGetTimeTicksNow)(); + MojoResult (*MojoClose)(MojoHandle handle); + MojoResult (*MojoWait)(MojoHandle handle, + MojoHandleSignals signals, + MojoDeadline deadline, + struct MojoHandleSignalsState* signals_state); + MojoResult (*MojoWaitMany)(const MojoHandle* handles, + const MojoHandleSignals* signals, + uint32_t num_handles, + MojoDeadline deadline, + uint32_t* result_index, + struct MojoHandleSignalsState* signals_states); + MojoResult (*MojoCreateMessagePipe)( + const struct MojoCreateMessagePipeOptions* options, + MojoHandle* message_pipe_handle0, + MojoHandle* message_pipe_handle1); + MojoResult (*MojoWriteMessage)(MojoHandle message_pipe_handle, + const void* bytes, + uint32_t num_bytes, + const MojoHandle* handles, + uint32_t num_handles, + MojoWriteMessageFlags flags); + MojoResult (*MojoReadMessage)(MojoHandle message_pipe_handle, + void* bytes, + uint32_t* num_bytes, + MojoHandle* handles, + uint32_t* num_handles, + MojoReadMessageFlags flags); + MojoResult (*_MojoGetInitialHandle)(MojoHandle* handle); +}; + +#ifdef __cplusplus +extern "C" { +#endif + +size_t mojo_irt_query(const char* interface_ident, + void* table, + size_t tablesize); + +#ifdef __cplusplus +} +#endif + +#endif // MOJO_PUBLIC_PLATFORM_NACL_MOJO_IRT_H_
diff --git a/mojo/tools/roll/rev_sdk.py b/mojo/tools/roll/rev_sdk.py index 870a89b..e3dfdea 100755 --- a/mojo/tools/roll/rev_sdk.py +++ b/mojo/tools/roll/rev_sdk.py
@@ -13,6 +13,7 @@ sdk_dirs_to_clone = [ "mojo/edk", "mojo/public", + "nacl_bindings", ]
diff --git a/nacl_bindings/BUILD.gn b/nacl_bindings/BUILD.gn new file mode 100644 index 0000000..84920ee --- /dev/null +++ b/nacl_bindings/BUILD.gn
@@ -0,0 +1,42 @@ +# Copyright 2015 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. + +# Trusted code +if (!is_nacl) { + # A library for launching a NaCl sandbox connected to a Mojo embedder. + source_set("monacl_sel") { + sources = [ + "mojo_syscall_internal.h", + "mojo_syscall.cc", + "monacl_sel_main.cc", + ] + deps = [ + "../mojo/public/c/system", + + # This target makes sure we have all the pre-processor defines needed to + # use NaCl's headers. + "//native_client/build/config/nacl:nacl_base", + "//native_client/src/trusted/desc:nrd_xfer", + "//native_client/src/trusted/service_runtime:sel_main_chrome", + ] + } +} + +# Untrusted code +if (is_nacl) { + executable("irt_mojo") { + cflags_c = [ "-std=c99" ] + sources = [ + "../mojo/public/platform/nacl/mojo_irt.h", + "irt_entry_mojo.c", + "mojo_irt.c", + ] + deps = [ + "../mojo/public/c/system", + "//native_client/build/config/nacl:nacl_base", + "//native_client/src/untrusted/irt:irt_core_lib", + "//native_client/src/untrusted/nacl:imc_syscalls", + ] + } +}
diff --git a/mojo/nacl/irt_entry_mojo.c b/nacl_bindings/irt_entry_mojo.c similarity index 92% rename from mojo/nacl/irt_entry_mojo.c rename to nacl_bindings/irt_entry_mojo.c index 186da0e..5c413dd 100644 --- a/mojo/nacl/irt_entry_mojo.c +++ b/nacl_bindings/irt_entry_mojo.c
@@ -2,7 +2,7 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "mojo/nacl/mojo_irt.h" +#include "mojo/public/platform/nacl/mojo_irt.h" #include "native_client/src/public/irt_core.h" static size_t irt_query(const char* interface_ident,
diff --git a/nacl_bindings/mojo_irt.c b/nacl_bindings/mojo_irt.c new file mode 100644 index 0000000..3595f0b --- /dev/null +++ b/nacl_bindings/mojo_irt.c
@@ -0,0 +1,357 @@ +// Copyright 2015 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. + +// WARNING this file was generated by generate_nacl_bindings.py +// Do not edit by hand. + +#include <stdio.h> +#include <string.h> + +#include "mojo/public/c/system/core.h" +#include "mojo/public/platform/nacl/mojo_irt.h" +#include "native_client/src/public/chrome_main.h" +#include "native_client/src/public/imc_syscalls.h" +#include "native_client/src/public/imc_types.h" +#include "native_client/src/public/irt_core.h" + +#define NACL_MOJO_DESC (NACL_CHROME_DESC_BASE + 3) + +static void DoMojoCall(uint32_t params[], nacl_abi_size_t num_params) { + struct NaClAbiNaClImcMsgIoVec iov[1] = { + {params, num_params} + }; + struct NaClAbiNaClImcMsgHdr msgh = {iov, 1, NULL, 0}; + // Note: return value unchecked. We're relying on the result parameter being + // unmodified - if the syscall fails, the Mojo function will return whatever + // the result parameter was initialized to before this function was called. + imc_sendmsg(NACL_MOJO_DESC, &msgh, 0); +} + +static MojoResult irt_MojoCreateSharedBuffer( + const struct MojoCreateSharedBufferOptions* options, + uint64_t num_bytes, + MojoHandle* shared_buffer_handle) { + uint32_t params[5]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 0; + params[1] = (uint32_t)(options); + params[2] = (uint32_t)(&num_bytes); + params[3] = (uint32_t)(shared_buffer_handle); + params[4] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoDuplicateBufferHandle( + MojoHandle buffer_handle, + const struct MojoDuplicateBufferHandleOptions* options, + MojoHandle* new_buffer_handle) { + uint32_t params[5]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 1; + params[1] = (uint32_t)(&buffer_handle); + params[2] = (uint32_t)(options); + params[3] = (uint32_t)(new_buffer_handle); + params[4] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoMapBuffer( + MojoHandle buffer_handle, + uint64_t offset, + uint64_t num_bytes, + void** buffer, + MojoMapBufferFlags flags) { + uint32_t params[7]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 2; + params[1] = (uint32_t)(&buffer_handle); + params[2] = (uint32_t)(&offset); + params[3] = (uint32_t)(&num_bytes); + params[4] = (uint32_t)(buffer); + params[5] = (uint32_t)(&flags); + params[6] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoUnmapBuffer(void* buffer) { + uint32_t params[3]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 3; + params[1] = (uint32_t)(&buffer); + params[2] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoCreateDataPipe( + const struct MojoCreateDataPipeOptions* options, + MojoHandle* data_pipe_producer_handle, + MojoHandle* data_pipe_consumer_handle) { + uint32_t params[5]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 4; + params[1] = (uint32_t)(options); + params[2] = (uint32_t)(data_pipe_producer_handle); + params[3] = (uint32_t)(data_pipe_consumer_handle); + params[4] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoWriteData( + MojoHandle data_pipe_producer_handle, + const void* elements, + uint32_t* num_bytes, + MojoWriteDataFlags flags) { + uint32_t params[6]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 5; + params[1] = (uint32_t)(&data_pipe_producer_handle); + params[2] = (uint32_t)(elements); + params[3] = (uint32_t)(num_bytes); + params[4] = (uint32_t)(&flags); + params[5] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoBeginWriteData( + MojoHandle data_pipe_producer_handle, + void** buffer, + uint32_t* buffer_num_bytes, + MojoWriteDataFlags flags) { + uint32_t params[6]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 6; + params[1] = (uint32_t)(&data_pipe_producer_handle); + params[2] = (uint32_t)(buffer); + params[3] = (uint32_t)(buffer_num_bytes); + params[4] = (uint32_t)(&flags); + params[5] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoEndWriteData( + MojoHandle data_pipe_producer_handle, + uint32_t num_bytes_written) { + uint32_t params[4]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 7; + params[1] = (uint32_t)(&data_pipe_producer_handle); + params[2] = (uint32_t)(&num_bytes_written); + params[3] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoReadData( + MojoHandle data_pipe_consumer_handle, + void* elements, + uint32_t* num_bytes, + MojoReadDataFlags flags) { + uint32_t params[6]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 8; + params[1] = (uint32_t)(&data_pipe_consumer_handle); + params[2] = (uint32_t)(elements); + params[3] = (uint32_t)(num_bytes); + params[4] = (uint32_t)(&flags); + params[5] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoBeginReadData( + MojoHandle data_pipe_consumer_handle, + const void** buffer, + uint32_t* buffer_num_bytes, + MojoReadDataFlags flags) { + uint32_t params[6]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 9; + params[1] = (uint32_t)(&data_pipe_consumer_handle); + params[2] = (uint32_t)(buffer); + params[3] = (uint32_t)(buffer_num_bytes); + params[4] = (uint32_t)(&flags); + params[5] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoEndReadData( + MojoHandle data_pipe_consumer_handle, + uint32_t num_bytes_read) { + uint32_t params[4]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 10; + params[1] = (uint32_t)(&data_pipe_consumer_handle); + params[2] = (uint32_t)(&num_bytes_read); + params[3] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoTimeTicks irt_MojoGetTimeTicksNow() { + uint32_t params[2]; + MojoTimeTicks result = 0; + params[0] = 11; + params[1] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoClose(MojoHandle handle) { + uint32_t params[3]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 12; + params[1] = (uint32_t)(&handle); + params[2] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoWait( + MojoHandle handle, + MojoHandleSignals signals, + MojoDeadline deadline, + struct MojoHandleSignalsState* signals_state) { + uint32_t params[6]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 13; + params[1] = (uint32_t)(&handle); + params[2] = (uint32_t)(&signals); + params[3] = (uint32_t)(&deadline); + params[4] = (uint32_t)(signals_state); + params[5] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoWaitMany( + const MojoHandle* handles, + const MojoHandleSignals* signals, + uint32_t num_handles, + MojoDeadline deadline, + uint32_t* result_index, + struct MojoHandleSignalsState* signals_states) { + uint32_t params[8]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 14; + params[1] = (uint32_t)(handles); + params[2] = (uint32_t)(signals); + params[3] = (uint32_t)(&num_handles); + params[4] = (uint32_t)(&deadline); + params[5] = (uint32_t)(result_index); + params[6] = (uint32_t)(signals_states); + params[7] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoCreateMessagePipe( + const struct MojoCreateMessagePipeOptions* options, + MojoHandle* message_pipe_handle0, + MojoHandle* message_pipe_handle1) { + uint32_t params[5]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 15; + params[1] = (uint32_t)(options); + params[2] = (uint32_t)(message_pipe_handle0); + params[3] = (uint32_t)(message_pipe_handle1); + params[4] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoWriteMessage( + MojoHandle message_pipe_handle, + const void* bytes, + uint32_t num_bytes, + const MojoHandle* handles, + uint32_t num_handles, + MojoWriteMessageFlags flags) { + uint32_t params[8]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 16; + params[1] = (uint32_t)(&message_pipe_handle); + params[2] = (uint32_t)(bytes); + params[3] = (uint32_t)(&num_bytes); + params[4] = (uint32_t)(handles); + params[5] = (uint32_t)(&num_handles); + params[6] = (uint32_t)(&flags); + params[7] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt_MojoReadMessage( + MojoHandle message_pipe_handle, + void* bytes, + uint32_t* num_bytes, + MojoHandle* handles, + uint32_t* num_handles, + MojoReadMessageFlags flags) { + uint32_t params[8]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 17; + params[1] = (uint32_t)(&message_pipe_handle); + params[2] = (uint32_t)(bytes); + params[3] = (uint32_t)(num_bytes); + params[4] = (uint32_t)(handles); + params[5] = (uint32_t)(num_handles); + params[6] = (uint32_t)(&flags); + params[7] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +static MojoResult irt__MojoGetInitialHandle(MojoHandle* handle) { + uint32_t params[3]; + MojoResult result = MOJO_RESULT_INVALID_ARGUMENT; + params[0] = 18; + params[1] = (uint32_t)(handle); + params[2] = (uint32_t)(&result); + DoMojoCall(params, sizeof(params)); + return result; +}; + +struct nacl_irt_mojo kIrtMojo = { + &irt_MojoCreateSharedBuffer, + &irt_MojoDuplicateBufferHandle, + &irt_MojoMapBuffer, + &irt_MojoUnmapBuffer, + &irt_MojoCreateDataPipe, + &irt_MojoWriteData, + &irt_MojoBeginWriteData, + &irt_MojoEndWriteData, + &irt_MojoReadData, + &irt_MojoBeginReadData, + &irt_MojoEndReadData, + &irt_MojoGetTimeTicksNow, + &irt_MojoClose, + &irt_MojoWait, + &irt_MojoWaitMany, + &irt_MojoCreateMessagePipe, + &irt_MojoWriteMessage, + &irt_MojoReadMessage, + &irt__MojoGetInitialHandle, +}; + + +size_t mojo_irt_query(const char* interface_ident, + void* table, + size_t tablesize) { + static const size_t size = sizeof(kIrtMojo); + if (0 == strcmp(interface_ident, NACL_IRT_MOJO_v0_1)) { + if (size <= tablesize) { + memcpy(table, &kIrtMojo, size); + return size; + } + } + return 0; +}
diff --git a/nacl_bindings/mojo_syscall.cc b/nacl_bindings/mojo_syscall.cc new file mode 100644 index 0000000..34fcccb --- /dev/null +++ b/nacl_bindings/mojo_syscall.cc
@@ -0,0 +1,879 @@ +// 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. + +// WARNING this file was generated by generate_nacl_bindings.py +// Do not edit by hand. + +#include "nacl_bindings/mojo_syscall.h" + +#include <stdio.h> + +#include "mojo/public/c/system/core.h" +#include "nacl_bindings/mojo_syscall_internal.h" +#include "native_client/src/public/chrome_main.h" +#include "native_client/src/public/nacl_app.h" +#include "native_client/src/trusted/desc/nacl_desc_custom.h" + +MojoHandle g_mojo_handle = MOJO_HANDLE_INVALID; + +namespace { + +MojoResult _MojoGetInitialHandle(MojoHandle* handle) { + *handle = g_mojo_handle; + return MOJO_RESULT_OK; +} + +void MojoDescDestroy(void* handle) { +} + +ssize_t MojoDescSendMsg(void* handle, + const struct NaClImcTypedMsgHdr* msg, + int flags) { + struct NaClApp* nap = static_cast<struct NaClApp*>(handle); + + if (msg->iov_length != 1 || msg->ndesc_length != 0) { + return -1; + } + + uint32_t volatile* params = static_cast<uint32_t volatile*>(msg->iov[0].base); + size_t num_params = msg->iov[0].length / sizeof(*params); + + if (num_params < 1) { + return -1; + } + + uint32_t msg_type = params[0]; + switch (msg_type) { + case 0: { + if (num_params != 5) { + return -1; + } + const struct MojoCreateSharedBufferOptions* options; + uint64_t num_bytes_value; + MojoHandle volatile* shared_buffer_handle_ptr; + MojoHandle shared_buffer_handle_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) { + return -1; + } + if (!ConvertScalarInput(nap, params[2], &num_bytes_value)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[3], false, + &shared_buffer_handle_value, + &shared_buffer_handle_ptr)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { + return -1; + } + } + + result_value = MojoCreateSharedBuffer(options, num_bytes_value, + &shared_buffer_handle_value); + + { + ScopedCopyLock copy_lock(nap); + *shared_buffer_handle_ptr = shared_buffer_handle_value; + *result_ptr = result_value; + } + + return 0; + } + case 1: { + if (num_params != 5) { + return -1; + } + MojoHandle buffer_handle_value; + const struct MojoDuplicateBufferHandleOptions* options; + MojoHandle volatile* new_buffer_handle_ptr; + MojoHandle new_buffer_handle_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], &buffer_handle_value)) { + return -1; + } + if (!ConvertExtensibleStructInput(nap, params[2], true, &options)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[3], false, &new_buffer_handle_value, + &new_buffer_handle_ptr)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { + return -1; + } + } + + result_value = MojoDuplicateBufferHandle(buffer_handle_value, options, + &new_buffer_handle_value); + + { + ScopedCopyLock copy_lock(nap); + *new_buffer_handle_ptr = new_buffer_handle_value; + *result_ptr = result_value; + } + + return 0; + } + case 2: { + if (num_params != 7) { + return -1; + } + MojoHandle buffer_handle_value; + uint64_t offset_value; + uint64_t num_bytes_value; + void* volatile* buffer_ptr; + void* buffer_value; + MojoMapBufferFlags flags_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], &buffer_handle_value)) { + return -1; + } + if (!ConvertScalarInput(nap, params[2], &offset_value)) { + return -1; + } + if (!ConvertScalarInput(nap, params[3], &num_bytes_value)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[4], false, &buffer_value, + &buffer_ptr)) { + return -1; + } + if (!ConvertScalarInput(nap, params[5], &flags_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[6], false, &result_ptr)) { + return -1; + } + } + + result_value = MojoMapBuffer(buffer_handle_value, offset_value, + num_bytes_value, &buffer_value, flags_value); + + { + ScopedCopyLock copy_lock(nap); + *buffer_ptr = buffer_value; + *result_ptr = result_value; + } + + return 0; + } + case 3: { + if (num_params != 3) { + return -1; + } + void* buffer_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], &buffer_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[2], false, &result_ptr)) { + return -1; + } + } + + result_value = MojoUnmapBuffer(buffer_value); + + { + ScopedCopyLock copy_lock(nap); + *result_ptr = result_value; + } + + return 0; + } + case 4: { + if (num_params != 5) { + return -1; + } + const struct MojoCreateDataPipeOptions* options; + MojoHandle volatile* data_pipe_producer_handle_ptr; + MojoHandle data_pipe_producer_handle_value; + MojoHandle volatile* data_pipe_consumer_handle_ptr; + MojoHandle data_pipe_consumer_handle_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[2], false, + &data_pipe_producer_handle_value, + &data_pipe_producer_handle_ptr)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[3], false, + &data_pipe_consumer_handle_value, + &data_pipe_consumer_handle_ptr)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { + return -1; + } + } + + result_value = + MojoCreateDataPipe(options, &data_pipe_producer_handle_value, + &data_pipe_consumer_handle_value); + + { + ScopedCopyLock copy_lock(nap); + *data_pipe_producer_handle_ptr = data_pipe_producer_handle_value; + *data_pipe_consumer_handle_ptr = data_pipe_consumer_handle_value; + *result_ptr = result_value; + } + + return 0; + } + case 5: { + if (num_params != 6) { + return -1; + } + MojoHandle data_pipe_producer_handle_value; + const void* elements; + uint32_t volatile* num_bytes_ptr; + uint32_t num_bytes_value; + MojoWriteDataFlags flags_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], + &data_pipe_producer_handle_value)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[3], false, &num_bytes_value, + &num_bytes_ptr)) { + return -1; + } + if (!ConvertScalarInput(nap, params[4], &flags_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) { + return -1; + } + if (!ConvertArray(nap, params[2], num_bytes_value, 1, false, + &elements)) { + return -1; + } + } + + result_value = MojoWriteData(data_pipe_producer_handle_value, elements, + &num_bytes_value, flags_value); + + { + ScopedCopyLock copy_lock(nap); + *num_bytes_ptr = num_bytes_value; + *result_ptr = result_value; + } + + return 0; + } + case 6: { + if (num_params != 6) { + return -1; + } + MojoHandle data_pipe_producer_handle_value; + void* volatile* buffer_ptr; + void* buffer_value; + uint32_t volatile* buffer_num_bytes_ptr; + uint32_t buffer_num_bytes_value; + MojoWriteDataFlags flags_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], + &data_pipe_producer_handle_value)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[2], false, &buffer_value, + &buffer_ptr)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[3], false, &buffer_num_bytes_value, + &buffer_num_bytes_ptr)) { + return -1; + } + if (!ConvertScalarInput(nap, params[4], &flags_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) { + return -1; + } + } + + result_value = + MojoBeginWriteData(data_pipe_producer_handle_value, &buffer_value, + &buffer_num_bytes_value, flags_value); + + { + ScopedCopyLock copy_lock(nap); + *buffer_ptr = buffer_value; + *buffer_num_bytes_ptr = buffer_num_bytes_value; + *result_ptr = result_value; + } + + return 0; + } + case 7: { + if (num_params != 4) { + return -1; + } + MojoHandle data_pipe_producer_handle_value; + uint32_t num_bytes_written_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], + &data_pipe_producer_handle_value)) { + return -1; + } + if (!ConvertScalarInput(nap, params[2], &num_bytes_written_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) { + return -1; + } + } + + result_value = MojoEndWriteData(data_pipe_producer_handle_value, + num_bytes_written_value); + + { + ScopedCopyLock copy_lock(nap); + *result_ptr = result_value; + } + + return 0; + } + case 8: { + if (num_params != 6) { + return -1; + } + MojoHandle data_pipe_consumer_handle_value; + void* elements; + uint32_t volatile* num_bytes_ptr; + uint32_t num_bytes_value; + MojoReadDataFlags flags_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], + &data_pipe_consumer_handle_value)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[3], false, &num_bytes_value, + &num_bytes_ptr)) { + return -1; + } + if (!ConvertScalarInput(nap, params[4], &flags_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) { + return -1; + } + if (!ConvertArray(nap, params[2], num_bytes_value, 1, false, + &elements)) { + return -1; + } + } + + result_value = MojoReadData(data_pipe_consumer_handle_value, elements, + &num_bytes_value, flags_value); + + { + ScopedCopyLock copy_lock(nap); + *num_bytes_ptr = num_bytes_value; + *result_ptr = result_value; + } + + return 0; + } + case 9: { + if (num_params != 6) { + return -1; + } + MojoHandle data_pipe_consumer_handle_value; + const void* volatile* buffer_ptr; + const void* buffer_value; + uint32_t volatile* buffer_num_bytes_ptr; + uint32_t buffer_num_bytes_value; + MojoReadDataFlags flags_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], + &data_pipe_consumer_handle_value)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[2], false, &buffer_value, + &buffer_ptr)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[3], false, &buffer_num_bytes_value, + &buffer_num_bytes_ptr)) { + return -1; + } + if (!ConvertScalarInput(nap, params[4], &flags_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) { + return -1; + } + } + + result_value = + MojoBeginReadData(data_pipe_consumer_handle_value, &buffer_value, + &buffer_num_bytes_value, flags_value); + + { + ScopedCopyLock copy_lock(nap); + *buffer_ptr = buffer_value; + *buffer_num_bytes_ptr = buffer_num_bytes_value; + *result_ptr = result_value; + } + + return 0; + } + case 10: { + if (num_params != 4) { + return -1; + } + MojoHandle data_pipe_consumer_handle_value; + uint32_t num_bytes_read_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], + &data_pipe_consumer_handle_value)) { + return -1; + } + if (!ConvertScalarInput(nap, params[2], &num_bytes_read_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[3], false, &result_ptr)) { + return -1; + } + } + + result_value = MojoEndReadData(data_pipe_consumer_handle_value, + num_bytes_read_value); + + { + ScopedCopyLock copy_lock(nap); + *result_ptr = result_value; + } + + return 0; + } + case 11: { + if (num_params != 2) { + return -1; + } + MojoTimeTicks volatile* result_ptr; + MojoTimeTicks result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarOutput(nap, params[1], false, &result_ptr)) { + return -1; + } + } + + result_value = MojoGetTimeTicksNow(); + + { + ScopedCopyLock copy_lock(nap); + *result_ptr = result_value; + } + + return 0; + } + case 12: { + if (num_params != 3) { + return -1; + } + MojoHandle handle_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], &handle_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[2], false, &result_ptr)) { + return -1; + } + } + + result_value = MojoClose(handle_value); + + { + ScopedCopyLock copy_lock(nap); + *result_ptr = result_value; + } + + return 0; + } + case 13: { + if (num_params != 6) { + return -1; + } + MojoHandle handle_value; + MojoHandleSignals signals_value; + MojoDeadline deadline_value; + MojoHandleSignalsState volatile* signals_state_ptr; + MojoHandleSignalsState signals_state_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], &handle_value)) { + return -1; + } + if (!ConvertScalarInput(nap, params[2], &signals_value)) { + return -1; + } + if (!ConvertScalarInput(nap, params[3], &deadline_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[4], true, &signals_state_ptr)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[5], false, &result_ptr)) { + return -1; + } + } + + result_value = MojoWait(handle_value, signals_value, deadline_value, + signals_state_ptr ? &signals_state_value : NULL); + + { + ScopedCopyLock copy_lock(nap); + if (signals_state_ptr != NULL) { + memcpy_volatile_out(signals_state_ptr, &signals_state_value, + sizeof(MojoHandleSignalsState)); + } + *result_ptr = result_value; + } + + return 0; + } + case 14: { + if (num_params != 8) { + return -1; + } + const MojoHandle* handles; + const MojoHandleSignals* signals; + uint32_t num_handles_value; + MojoDeadline deadline_value; + uint32_t volatile* result_index_ptr; + uint32_t result_index_value; + struct MojoHandleSignalsState* signals_states; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[3], &num_handles_value)) { + return -1; + } + if (!ConvertScalarInput(nap, params[4], &deadline_value)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[5], true, &result_index_value, + &result_index_ptr)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) { + return -1; + } + if (!ConvertArray(nap, params[1], num_handles_value, sizeof(*handles), + false, &handles)) { + return -1; + } + if (!ConvertArray(nap, params[2], num_handles_value, sizeof(*signals), + false, &signals)) { + return -1; + } + if (!ConvertArray(nap, params[6], num_handles_value, + sizeof(*signals_states), true, &signals_states)) { + return -1; + } + } + + result_value = MojoWaitMany( + handles, signals, num_handles_value, deadline_value, + result_index_ptr ? &result_index_value : NULL, signals_states); + + { + ScopedCopyLock copy_lock(nap); + if (result_index_ptr != NULL) { + *result_index_ptr = result_index_value; + } + *result_ptr = result_value; + } + + return 0; + } + case 15: { + if (num_params != 5) { + return -1; + } + const struct MojoCreateMessagePipeOptions* options; + MojoHandle volatile* message_pipe_handle0_ptr; + MojoHandle message_pipe_handle0_value; + MojoHandle volatile* message_pipe_handle1_ptr; + MojoHandle message_pipe_handle1_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertExtensibleStructInput(nap, params[1], true, &options)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[2], false, + &message_pipe_handle0_value, + &message_pipe_handle0_ptr)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[3], false, + &message_pipe_handle1_value, + &message_pipe_handle1_ptr)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[4], false, &result_ptr)) { + return -1; + } + } + + result_value = MojoCreateMessagePipe(options, &message_pipe_handle0_value, + &message_pipe_handle1_value); + + { + ScopedCopyLock copy_lock(nap); + *message_pipe_handle0_ptr = message_pipe_handle0_value; + *message_pipe_handle1_ptr = message_pipe_handle1_value; + *result_ptr = result_value; + } + + return 0; + } + case 16: { + if (num_params != 8) { + return -1; + } + MojoHandle message_pipe_handle_value; + const void* bytes; + uint32_t num_bytes_value; + const MojoHandle* handles; + uint32_t num_handles_value; + MojoWriteMessageFlags flags_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], &message_pipe_handle_value)) { + return -1; + } + if (!ConvertScalarInput(nap, params[3], &num_bytes_value)) { + return -1; + } + if (!ConvertScalarInput(nap, params[5], &num_handles_value)) { + return -1; + } + if (!ConvertScalarInput(nap, params[6], &flags_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) { + return -1; + } + if (!ConvertArray(nap, params[2], num_bytes_value, 1, true, &bytes)) { + return -1; + } + if (!ConvertArray(nap, params[4], num_handles_value, sizeof(*handles), + true, &handles)) { + return -1; + } + } + + result_value = + MojoWriteMessage(message_pipe_handle_value, bytes, num_bytes_value, + handles, num_handles_value, flags_value); + + { + ScopedCopyLock copy_lock(nap); + *result_ptr = result_value; + } + + return 0; + } + case 17: { + if (num_params != 8) { + return -1; + } + MojoHandle message_pipe_handle_value; + void* bytes; + uint32_t volatile* num_bytes_ptr; + uint32_t num_bytes_value; + MojoHandle* handles; + uint32_t volatile* num_handles_ptr; + uint32_t num_handles_value; + MojoReadMessageFlags flags_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInput(nap, params[1], &message_pipe_handle_value)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[3], true, &num_bytes_value, + &num_bytes_ptr)) { + return -1; + } + if (!ConvertScalarInOut(nap, params[5], true, &num_handles_value, + &num_handles_ptr)) { + return -1; + } + if (!ConvertScalarInput(nap, params[6], &flags_value)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[7], false, &result_ptr)) { + return -1; + } + if (!ConvertArray(nap, params[2], num_bytes_value, 1, true, &bytes)) { + return -1; + } + if (!ConvertArray(nap, params[4], num_handles_value, sizeof(*handles), + true, &handles)) { + return -1; + } + } + + result_value = MojoReadMessage( + message_pipe_handle_value, bytes, + num_bytes_ptr ? &num_bytes_value : NULL, handles, + num_handles_ptr ? &num_handles_value : NULL, flags_value); + + { + ScopedCopyLock copy_lock(nap); + if (num_bytes_ptr != NULL) { + *num_bytes_ptr = num_bytes_value; + } + if (num_handles_ptr != NULL) { + *num_handles_ptr = num_handles_value; + } + *result_ptr = result_value; + } + + return 0; + } + case 18: { + if (num_params != 3) { + return -1; + } + MojoHandle volatile* handle_ptr; + MojoHandle handle_value; + MojoResult volatile* result_ptr; + MojoResult result_value; + { + ScopedCopyLock copy_lock(nap); + if (!ConvertScalarInOut(nap, params[1], false, &handle_value, + &handle_ptr)) { + return -1; + } + if (!ConvertScalarOutput(nap, params[2], false, &result_ptr)) { + return -1; + } + } + + result_value = _MojoGetInitialHandle(&handle_value); + + { + ScopedCopyLock copy_lock(nap); + *handle_ptr = handle_value; + *result_ptr = result_value; + } + + return 0; + } + } + + return -1; +} + +ssize_t MojoDescRecvMsg(void* handle, + struct NaClImcTypedMsgHdr* msg, + int flags) { + return -1; +} + +struct NaClDesc* MakeMojoDesc(struct NaClApp* nap) { + struct NaClDescCustomFuncs funcs = NACL_DESC_CUSTOM_FUNCS_INITIALIZER; + funcs.Destroy = MojoDescDestroy; + funcs.SendMsg = MojoDescSendMsg; + funcs.RecvMsg = MojoDescRecvMsg; + return NaClDescMakeCustomDesc(nap, &funcs); +} + +void MojoDisabledDescDestroy(void* handle) { +} + +ssize_t MojoDisabledDescSendMsg(void* handle, + const struct NaClImcTypedMsgHdr* msg, + int flags) { + fprintf(stderr, "Mojo is not currently supported."); + abort(); +} + +ssize_t MojoDisabledDescRecvMsg(void* handle, + struct NaClImcTypedMsgHdr* msg, + int flags) { + fprintf(stderr, "Mojo is not currently supported."); + abort(); +} + +struct NaClDesc* MakeDisabledMojoDesc(struct NaClApp* nap) { + struct NaClDescCustomFuncs funcs = NACL_DESC_CUSTOM_FUNCS_INITIALIZER; + funcs.Destroy = MojoDisabledDescDestroy; + funcs.SendMsg = MojoDisabledDescSendMsg; + funcs.RecvMsg = MojoDisabledDescRecvMsg; + return NaClDescMakeCustomDesc(nap, &funcs); +} + +} // namespace + +// The value for this FD must not conflict with uses inside Chromium. However, +// mojo/nacl doesn't depend on any Chromium headers, so we can't use a #define +// from there. +#define NACL_MOJO_DESC (NACL_CHROME_DESC_BASE + 3) + +void InjectMojo(struct NaClApp* nap) { + NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeMojoDesc(nap)); + g_mojo_handle = MOJO_HANDLE_INVALID; +} + +void InjectMojo(struct NaClApp* nap, MojoHandle handle) { + NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeMojoDesc(nap)); + g_mojo_handle = handle; +} + +void InjectDisabledMojo(struct NaClApp* nap) { + NaClAppSetDesc(nap, NACL_MOJO_DESC, MakeDisabledMojoDesc(nap)); +}
diff --git a/mojo/nacl/mojo_syscall.h b/nacl_bindings/mojo_syscall.h similarity index 96% rename from mojo/nacl/mojo_syscall.h rename to nacl_bindings/mojo_syscall.h index 2902337..700d191 100644 --- a/mojo/nacl/mojo_syscall.h +++ b/nacl_bindings/mojo_syscall.h
@@ -23,4 +23,4 @@ // more straightforward in the case where Mojo is not enabled for NaCl plugins. void InjectDisabledMojo(struct NaClApp* nap); -#endif // MOJO_NACL_MOJO_SYSCALL_H_ +#endif // MOJO_NACL_MOJO_SYSCALL_H_
diff --git a/mojo/nacl/mojo_syscall_internal.h b/nacl_bindings/mojo_syscall_internal.h similarity index 62% rename from mojo/nacl/mojo_syscall_internal.h rename to nacl_bindings/mojo_syscall_internal.h index 8aa32d1..9200c1a 100644 --- a/mojo/nacl/mojo_syscall_internal.h +++ b/nacl_bindings/mojo_syscall_internal.h
@@ -15,18 +15,16 @@ explicit ScopedCopyLock(struct NaClApp* nap) : nap_(nap) { NaClCopyTakeLock(nap_); } - ~ScopedCopyLock() { - NaClCopyDropLock(nap_); - } + ~ScopedCopyLock() { NaClCopyDropLock(nap_); } + private: struct NaClApp* nap_; }; -static inline uintptr_t NaClUserToSysAddrArray( - struct NaClApp* nap, - uint32_t uaddr, - size_t count, - size_t size) { +static inline uintptr_t NaClUserToSysAddrArray(struct NaClApp* nap, + uint32_t uaddr, + size_t count, + size_t size) { // TODO(ncbray): overflow checking size_t range = count * size; return NaClUserToSysAddrRange(nap, uaddr, range); @@ -42,10 +40,9 @@ // time of check vs. time of use problems, or worse. For this binding code in // particular, where memcpy is being called with a constant size, it is entirely // conceivable the function will be inlined, unrolled, and optimized. -static inline void memcpy_volatile_out( - void volatile* dst, - const void* src, - size_t n) { +static inline void memcpy_volatile_out(void volatile* dst, + const void* src, + size_t n) { char volatile* c_dst = static_cast<char volatile*>(dst); const char* c_src = static_cast<const char*>(src); for (size_t i = 0; i < n; i++) { @@ -53,10 +50,8 @@ } } -template <typename T> bool ConvertScalarInput( - struct NaClApp* nap, - uint32_t user_ptr, - T* value) { +template <typename T> +bool ConvertScalarInput(struct NaClApp* nap, uint32_t user_ptr, T* value) { if (user_ptr) { uintptr_t temp = NaClUserToSysAddrRange(nap, user_ptr, sizeof(T)); if (temp != kNaClBadAddress) { @@ -67,11 +62,11 @@ return false; } -template <typename T> bool ConvertScalarOutput( - struct NaClApp* nap, - uint32_t user_ptr, - bool optional, - T volatile** sys_ptr) { +template <typename T> +bool ConvertScalarOutput(struct NaClApp* nap, + uint32_t user_ptr, + bool optional, + T volatile** sys_ptr) { if (user_ptr) { uintptr_t temp = NaClUserToSysAddrRange(nap, user_ptr, sizeof(T)); if (temp != kNaClBadAddress) { @@ -82,16 +77,16 @@ *sys_ptr = 0; return true; } - *sys_ptr = 0; // Paranoia. + *sys_ptr = 0; // Paranoia. return false; } -template <typename T> bool ConvertScalarInOut( - struct NaClApp* nap, - uint32_t user_ptr, - bool optional, - T* value, - T volatile** sys_ptr) { +template <typename T> +bool ConvertScalarInOut(struct NaClApp* nap, + uint32_t user_ptr, + bool optional, + T* value, + T volatile** sys_ptr) { if (user_ptr) { uintptr_t temp = NaClUserToSysAddrRange(nap, user_ptr, sizeof(T)); if (temp != kNaClBadAddress) { @@ -102,24 +97,24 @@ } } else if (optional) { *sys_ptr = 0; - *value = static_cast<T>(0); // Paranoia. + *value = static_cast<T>(0); // Paranoia. return true; } - *sys_ptr = 0; // Paranoia. - *value = static_cast<T>(0); // Paranoia. + *sys_ptr = 0; // Paranoia. + *value = static_cast<T>(0); // Paranoia. return false; } -template <typename T> bool ConvertArray( - struct NaClApp* nap, - uint32_t user_ptr, - uint32_t length, - size_t element_size, - bool optional, - T** sys_ptr) { +template <typename T> +bool ConvertArray(struct NaClApp* nap, + uint32_t user_ptr, + uint32_t length, + size_t element_size, + bool optional, + T** sys_ptr) { if (user_ptr) { - uintptr_t temp = NaClUserToSysAddrArray(nap, user_ptr, length, - element_size); + uintptr_t temp = + NaClUserToSysAddrArray(nap, user_ptr, length, element_size); if (temp != kNaClBadAddress) { *sys_ptr = reinterpret_cast<T*>(temp); return true; @@ -131,12 +126,12 @@ return false; } -template <typename T> bool ConvertBytes( - struct NaClApp* nap, - uint32_t user_ptr, - uint32_t length, - bool optional, - T** sys_ptr) { +template <typename T> +bool ConvertBytes(struct NaClApp* nap, + uint32_t user_ptr, + uint32_t length, + bool optional, + T** sys_ptr) { if (user_ptr) { uintptr_t temp = NaClUserToSysAddrRange(nap, user_ptr, length); if (temp != kNaClBadAddress) { @@ -152,11 +147,11 @@ // TODO(ncbray): size validation and complete copy. // TODO(ncbray): ensure non-null / missized structs are covered by a test case. -template <typename T> bool ConvertExtensibleStructInput( - struct NaClApp* nap, - uint32_t user_ptr, - bool optional, - T** sys_ptr) { +template <typename T> +bool ConvertExtensibleStructInput(struct NaClApp* nap, + uint32_t user_ptr, + bool optional, + T** sys_ptr) { if (user_ptr) { uintptr_t temp = NaClUserToSysAddrRange(nap, user_ptr, sizeof(T)); if (temp != kNaClBadAddress) { @@ -170,6 +165,6 @@ return false; } -} // namespace +} // namespace -#endif // MOJO_NACL_MOJO_SYSCALL_INTERNAL_H_ +#endif // MOJO_NACL_MOJO_SYSCALL_INTERNAL_H_
diff --git a/mojo/nacl/monacl_sel_main.cc b/nacl_bindings/monacl_sel_main.cc similarity index 88% rename from mojo/nacl/monacl_sel_main.cc rename to nacl_bindings/monacl_sel_main.cc index 631fa61..100f161 100644 --- a/mojo/nacl/monacl_sel_main.cc +++ b/nacl_bindings/monacl_sel_main.cc
@@ -2,9 +2,9 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -#include "mojo/nacl/monacl_sel_main.h" +#include "nacl_bindings/monacl_sel_main.h" -#include "mojo/nacl/mojo_syscall.h" +#include "nacl_bindings/mojo_syscall.h" #include "native_client/src/public/chrome_main.h" #include "native_client/src/public/nacl_app.h" @@ -36,4 +36,4 @@ ::NaClExit(code); } -} // namespace mojo +} // namespace mojo
diff --git a/mojo/nacl/monacl_sel_main.h b/nacl_bindings/monacl_sel_main.h similarity index 90% rename from mojo/nacl/monacl_sel_main.h rename to nacl_bindings/monacl_sel_main.h index eac17c6..d376f64 100644 --- a/mojo/nacl/monacl_sel_main.h +++ b/nacl_bindings/monacl_sel_main.h
@@ -20,6 +20,6 @@ void NaClExit(int code); -} // namespace mojo +} // namespace mojo -#endif // MOJO_NACL_MONACL_SEL_MAIN_H_ +#endif // MOJO_NACL_MONACL_SEL_MAIN_H_
diff --git a/mojo/nacl/generator/generate_nacl_bindings.py b/nacl_bindings_generator/generate_nacl_bindings.py similarity index 88% rename from mojo/nacl/generator/generate_nacl_bindings.py rename to nacl_bindings_generator/generate_nacl_bindings.py index ee6189c..e06ffa9 100755 --- a/mojo/nacl/generator/generate_nacl_bindings.py +++ b/nacl_bindings_generator/generate_nacl_bindings.py
@@ -6,36 +6,28 @@ # pylint: disable=W0104,W0106,F0401,R0201 import errno -import optparse import os.path import sys import interface -def _ScriptDir(): +def ScriptDir(): return os.path.dirname(os.path.abspath(__file__)) -def _GetDirAbove(dirname): - """Returns the directory "above" this file containing |dirname| (which must - also be "above" this file).""" - path = _ScriptDir() - while True: - path, tail = os.path.split(path) - assert tail - if tail == dirname: - return path +def RepoRoot(): + return os.path.dirname(ScriptDir()) def _AddThirdPartyImportPath(): - sys.path.append(os.path.join(_GetDirAbove('mojo'), 'third_party')) + sys.path.append(os.path.join(RepoRoot(), 'third_party')) _AddThirdPartyImportPath() import jinja2 -loader = jinja2.FileSystemLoader(_ScriptDir()) +loader = jinja2.FileSystemLoader(ScriptDir()) jinja_env = jinja2.Environment(loader=loader, keep_trailing_newline=True) @@ -103,7 +95,7 @@ # Untrusted library which thunks from the public Mojo API to the IRT interface # implementing the public Mojo API. -def GenerateLibMojo(functions, out): +def GenerateLibMojo(functions, common_vars, out): template = jinja_env.get_template('libmojo.cc.tmpl') code = CodeWriter() @@ -125,8 +117,8 @@ body = code.GetValue() text = template.render( - generator_warning=GeneratorWarning(), - body=body) + body=body, + **common_vars) out.write(text) @@ -308,7 +300,7 @@ # A trusted wrapper that validates the arguments passed from untrusted code # before passing them to the underlying public Mojo API. -def GenerateMojoSyscall(functions, out): +def GenerateMojoSyscall(functions, common_vars, out): template = jinja_env.get_template('mojo_syscall.cc.tmpl') code = CodeWriter() @@ -377,13 +369,13 @@ body = code.GetValue() text = template.render( - generator_warning=GeneratorWarning(), - body=body) + body=body, + **common_vars) out.write(text) # A header declaring the IRT interface for accessing Mojo functions. -def GenerateMojoIrtHeader(functions, out): +def GenerateMojoIrtHeader(functions, common_vars, out): template = jinja_env.get_template('mojo_irt.h.tmpl') code = CodeWriter() @@ -400,12 +392,12 @@ body = code.GetValue() text = template.render( - generator_warning=GeneratorWarning(), - body=body) + body=body, + **common_vars) out.write(text) # IRT interface which implements the Mojo public API. -def GenerateMojoIrtImplementation(functions, out): +def GenerateMojoIrtImplementation(functions, common_vars, out): template = jinja_env.get_template('mojo_irt.c.tmpl') code = CodeWriter() @@ -459,8 +451,8 @@ body = code.GetValue() text = template.render( - generator_warning=GeneratorWarning(), - body=body) + body=body, + **common_vars) out.write(text) @@ -472,36 +464,40 @@ # There may have been a race to create this directory. if e.errno != errno.EEXIST: raise - return open(os.path.join(dir_path, name), 'w') + full_path = os.path.join(dir_path, name) + print full_path + return open(full_path, 'w') -def main(args): - usage = 'usage: %prog [options]' - parser = optparse.OptionParser(usage=usage) - parser.add_option( - '-d', - dest='out_dir', - metavar='DIR', - help='output generated code into directory DIR') - options, args = parser.parse_args(args=args) - if not options.out_dir: - parser.error('-d is required') - if args: - parser.error('unexpected positional arguments: %s' % ' '.join(args)) +def main(): + root_dir = RepoRoot() + + platform_dir = 'mojo/public/platform/nacl' + bindings_dir = 'nacl_bindings' + + full_platform_dir = os.path.join(root_dir, platform_dir) + full_bindings_dir = os.path.join(root_dir, bindings_dir) + + common_vars = dict( + generator_warning=GeneratorWarning(), + platform_dir=platform_dir, + platform_dir_header_path=platform_dir.replace("/", "_").upper(), + bindings_dir=bindings_dir, + ) mojo = interface.MakeInterface() - out = OutFile(options.out_dir, 'libmojo.cc') - GenerateLibMojo(mojo.functions, out) + out = OutFile(full_platform_dir, 'libmojo.cc') + GenerateLibMojo(mojo.functions, common_vars, out) - out = OutFile(options.out_dir, 'mojo_syscall.cc') - GenerateMojoSyscall(mojo.functions, out) + out = OutFile(full_bindings_dir, 'mojo_syscall.cc') + GenerateMojoSyscall(mojo.functions, common_vars, out) - out = OutFile(options.out_dir, 'mojo_irt.h') - GenerateMojoIrtHeader(mojo.functions, out) + out = OutFile(full_platform_dir, 'mojo_irt.h') + GenerateMojoIrtHeader(mojo.functions, common_vars, out) - out = OutFile(options.out_dir, 'mojo_irt.c') - GenerateMojoIrtImplementation(mojo.functions, out) + out = OutFile(full_bindings_dir, 'mojo_irt.c') + GenerateMojoIrtImplementation(mojo.functions, common_vars, out) if __name__ == '__main__': - main(sys.argv[1:]) + main()
diff --git a/mojo/nacl/generator/interface.py b/nacl_bindings_generator/interface.py similarity index 100% rename from mojo/nacl/generator/interface.py rename to nacl_bindings_generator/interface.py
diff --git a/mojo/nacl/generator/interface_dsl.py b/nacl_bindings_generator/interface_dsl.py similarity index 100% rename from mojo/nacl/generator/interface_dsl.py rename to nacl_bindings_generator/interface_dsl.py
diff --git a/mojo/nacl/generator/libmojo.cc.tmpl b/nacl_bindings_generator/libmojo.cc.tmpl similarity index 96% rename from mojo/nacl/generator/libmojo.cc.tmpl rename to nacl_bindings_generator/libmojo.cc.tmpl index a012798..a486c7e 100644 --- a/mojo/nacl/generator/libmojo.cc.tmpl +++ b/nacl_bindings_generator/libmojo.cc.tmpl
@@ -4,8 +4,8 @@ {{generator_warning}} -#include "mojo/nacl/mojo_irt.h" #include "mojo/public/c/system/core.h" +#include "{{platform_dir}}/mojo_irt.h" #include "native_client/src/public/chrome_main.h" #include "native_client/src/public/imc_syscalls.h" #include "native_client/src/public/imc_types.h"
diff --git a/mojo/nacl/generator/mojo_irt.c.tmpl b/nacl_bindings_generator/mojo_irt.c.tmpl similarity index 96% rename from mojo/nacl/generator/mojo_irt.c.tmpl rename to nacl_bindings_generator/mojo_irt.c.tmpl index e205496..7885751 100644 --- a/mojo/nacl/generator/mojo_irt.c.tmpl +++ b/nacl_bindings_generator/mojo_irt.c.tmpl
@@ -7,8 +7,8 @@ #include <stdio.h> #include <string.h> -#include "mojo/nacl/mojo_irt.h" #include "mojo/public/c/system/core.h" +#include "{{platform_dir}}/mojo_irt.h" #include "native_client/src/public/chrome_main.h" #include "native_client/src/public/imc_syscalls.h" #include "native_client/src/public/imc_types.h"
diff --git a/mojo/nacl/generator/mojo_irt.h.tmpl b/nacl_bindings_generator/mojo_irt.h.tmpl similarity index 80% rename from mojo/nacl/generator/mojo_irt.h.tmpl rename to nacl_bindings_generator/mojo_irt.h.tmpl index 09dbe69..b742ebe 100644 --- a/mojo/nacl/generator/mojo_irt.h.tmpl +++ b/nacl_bindings_generator/mojo_irt.h.tmpl
@@ -4,10 +4,9 @@ {{generator_warning}} -#ifndef MOJO_NACL_MOJO_IRT_H_ -#define MOJO_NACL_MOJO_IRT_H_ +#ifndef {{platform_dir_header_path}}_MOJO_IRT_H_ +#define {{platform_dir_header_path}}_MOJO_IRT_H_ -#include "mojo/common/mojo_common_export.h" #include "mojo/public/c/system/buffer.h" #include "mojo/public/c/system/data_pipe.h" #include "mojo/public/c/system/message_pipe.h" @@ -29,4 +28,4 @@ } #endif -#endif // MOJO_NACL_MOJO_IRT_H_ +#endif // {{platform_dir_header_path}}_MOJO_IRT_H_
diff --git a/mojo/nacl/generator/mojo_syscall.cc.tmpl b/nacl_bindings_generator/mojo_syscall.cc.tmpl similarity index 96% rename from mojo/nacl/generator/mojo_syscall.cc.tmpl rename to nacl_bindings_generator/mojo_syscall.cc.tmpl index 84c1577..4ef183f 100644 --- a/mojo/nacl/generator/mojo_syscall.cc.tmpl +++ b/nacl_bindings_generator/mojo_syscall.cc.tmpl
@@ -4,11 +4,11 @@ {{generator_warning}} -#include "mojo/nacl/mojo_syscall.h" +#include "{{bindings_dir}}/mojo_syscall.h" #include <stdio.h> -#include "mojo/nacl/mojo_syscall_internal.h" +#include "{{bindings_dir}}/mojo_syscall_internal.h" #include "mojo/public/c/system/core.h" #include "native_client/src/public/chrome_main.h" #include "native_client/src/public/nacl_app.h"
diff --git a/services/nacl/BUILD.gn b/services/nacl/BUILD.gn index c5aa369..a30fe86 100644 --- a/services/nacl/BUILD.gn +++ b/services/nacl/BUILD.gn
@@ -16,11 +16,11 @@ "//mojo/application:application", "//mojo/application:content_handler", "//mojo/common", - "//mojo/nacl:monacl_sel", "//mojo/services/network/public/interfaces", + "//nacl_bindings:monacl_sel", "//url", ] - data_deps = [ "//mojo/nacl:irt_mojo(//native_client/build/toolchain/nacl:irt_${cpu_arch})" ] + data_deps = [ "//nacl_bindings:irt_mojo(//native_client/build/toolchain/nacl:irt_${cpu_arch})" ] } }
diff --git a/services/nacl/content_handler_main.cc b/services/nacl/content_handler_main.cc index 4947087..a418ddf 100644 --- a/services/nacl/content_handler_main.cc +++ b/services/nacl/content_handler_main.cc
@@ -10,13 +10,13 @@ #include "mojo/application/content_handler_factory.h" #include "mojo/common/data_pipe_utils.h" #include "mojo/common/message_pump_mojo.h" -#include "mojo/nacl/monacl_sel_main.h" #include "mojo/public/c/system/main.h" #include "mojo/public/cpp/application/application_connection.h" #include "mojo/public/cpp/application/application_delegate.h" #include "mojo/public/cpp/application/application_impl.h" #include "mojo/services/network/public/interfaces/network_service.mojom.h" #include "mojo/services/network/public/interfaces/url_loader.mojom.h" +#include "nacl_bindings/monacl_sel_main.h" #include "native_client/src/public/nacl_desc.h" #include "url/gurl.h"