sysio::chain::eosvmoc Namespace Reference

Namespaces
namespace	detail
namespace	LLVMJIT

Classes
class	code_cache_async
class	code_cache_base
struct	code_cache_header
class	code_cache_sync
struct	code_compilation_result_message
struct	code_descriptor
struct	code_offset
struct	code_tuple
struct	compilation_result_toofull
struct	compilation_result_unknownfailure
struct	compile_monitor
struct	compile_monitor_session
struct	compile_monitor_trampoline
struct	compile_wasm_message
struct	config
struct	evict_wasms_message
struct	execution_stack
class	executor
struct	executor_signal_init
struct	initalize_response_message
struct	initialize_message
struct	instantiated_code
struct	intrinsic
struct	intrinsic_entry
struct	intrinsic_ordinal
class	memory
struct	no_offset
struct	wasm_compilation_result_message
class	wrapped_fd

Typedefs
using	allocator_t = bip::rbtree_best_fit<bip::null_mutex_family, bip::offset_ptr<void>, alignof(std::max_align_t)>
using	intrinsic_map_t = std::map<std::string, intrinsic_entry>
using	wasm_compilation_result
using	eosvmoc_message
using	control_block = eos_vm_oc_control_block
using	eosvmoc_optional_offset_or_import_t = std::variant<no_offset, code_offset, intrinsic_ordinal>

Enumerations
enum	eosvmoc_exitcode : int { SYSVMOC_EXIT_CLEAN_EXIT = 1 , SYSVMOC_EXIT_CHECKTIME_FAIL , SYSVMOC_EXIT_SEGV , SYSVMOC_EXIT_EXCEPTION }

Functions
wrapped_fd	get_connection_to_compile_monitor (int cache_fd)
void	run_compile_trampoline (int fd)
const intrinsic_map_t &	get_intrinsic_map ()
constexpr auto	get_intrinsic_table ()
constexpr std::size_t	find_intrinsic_index (std::string_view hf)
constexpr std::size_t	intrinsic_table_size ()
std::tuple< bool, eosvmoc_message, std::vector< wrapped_fd > >	read_message_with_fds (boost::asio::local::datagram_protocol::socket &s)
std::tuple< bool, eosvmoc_message, std::vector< wrapped_fd > >	read_message_with_fds (int fd)
bool	write_message_with_fds (boost::asio::local::datagram_protocol::socket &s, const eosvmoc_message &message, const std::vector< wrapped_fd > &fds=std::vector< wrapped_fd >())
bool	write_message_with_fds (int fd_to_send_to, const eosvmoc_message &message, const std::vector< wrapped_fd > &fds=std::vector< wrapped_fd >())
template<typename T >
wrapped_fd	memfd_for_bytearray (const T &bytes)
std::vector< uint8_t >	vector_for_memfd (const wrapped_fd &memfd)
void	eosvmoc_switch_stack (void *stack, void(*fn)(void *), void *data)
struct sysio::chain::eosvmoc::code_cache_header	__attribute__ ((packed))
void	launch_compile_monitor (int nodeop_fd)
int	__real_main (int, char *[])
int	__wrap_main (int argc, char *argv[])
void	run_compile (wrapped_fd &&response_sock, wrapped_fd &&wasm_code) noexcept
	DEFINE_SYSVMOC_TRAP_INTRINSIC (eosvmoc_internal, depth_assert)
	DEFINE_SYSVMOC_TRAP_INTRINSIC (eosvmoc_internal, div0_or_overflow)
	DEFINE_SYSVMOC_TRAP_INTRINSIC (eosvmoc_internal, indirect_call_mismatch)
	DEFINE_SYSVMOC_TRAP_INTRINSIC (eosvmoc_internal, indirect_call_oob)
	DEFINE_SYSVMOC_TRAP_INTRINSIC (eosvmoc_internal, unreachable)

Typedef Documentation

allocator_t

using sysio::chain::eosvmoc::allocator_t = bip::rbtree_best_fit<bip::null_mutex_family, bip::offset_ptr<void>, alignof(std::max_align_t)>

Definition at line 35 of file code_cache.hpp.

control_block

using sysio::chain::eosvmoc::control_block = eos_vm_oc_control_block

Definition at line 21 of file sys-vm-oc.hpp.

eosvmoc_message

using sysio::chain::eosvmoc::eosvmoc_message

Initial value:

 std::variant<initialize_message,
                                     initalize_response_message,
                                     compile_wasm_message,
                                     evict_wasms_message,
                                     code_compilation_result_message,
                                     wasm_compilation_result_message>

Definition at line 54 of file ipc_protocol.hpp.

eosvmoc_optional_offset_or_import_t

using sysio::chain::eosvmoc::eosvmoc_optional_offset_or_import_t = std::variant<no_offset, code_offset, intrinsic_ordinal>

Definition at line 31 of file sys-vm-oc.hpp.

intrinsic_map_t

using sysio::chain::eosvmoc::intrinsic_map_t = std::map<std::string, intrinsic_entry>

Definition at line 24 of file intrinsic.hpp.

wasm_compilation_result

using sysio::chain::eosvmoc::wasm_compilation_result

Initial value:

 std::variant<code_descriptor,  
                                             compilation_result_unknownfailure,
                                             compilation_result_toofull>

Definition at line 44 of file ipc_protocol.hpp.

Enumeration Type Documentation

eosvmoc_exitcode

enum sysio::chain::eosvmoc::eosvmoc_exitcode : int

Enumerator
SYSVMOC_EXIT_CLEAN_EXIT
SYSVMOC_EXIT_CHECKTIME_FAIL
SYSVMOC_EXIT_SEGV
SYSVMOC_EXIT_EXCEPTION

Definition at line 46 of file sys-vm-oc.hpp.

                      : int {
   SYSVMOC_EXIT_CLEAN_EXIT = 1,
   SYSVMOC_EXIT_CHECKTIME_FAIL,
   SYSVMOC_EXIT_SEGV,
   SYSVMOC_EXIT_EXCEPTION
};

Function Documentation

__attribute__()

struct sysio::chain::eosvmoc::code_cache_header sysio::chain::eosvmoc::__attribute__

(

(packed)

)

__real_main()

int sysio::chain::eosvmoc::__real_main	(	int	,
		char *	[] )

__wrap_main()

int sysio::chain::eosvmoc::__wrap_main	(	int	argc,
		char *	argv[] )

Definition at line 299 of file compile_monitor.cpp.

                                                   {
 
 
   the_compile_monitor_trampoline.start();
   return __real_main(argc, argv);
}

Here is the call graph for this function:

Here is the caller graph for this function:

DEFINE_SYSVMOC_TRAP_INTRINSIC() [1/5]

sysio::chain::eosvmoc::DEFINE_SYSVMOC_TRAP_INTRINSIC	(	eosvmoc_internal	,
		depth_assert	)

Definition at line 102 of file executor.cpp.

                                                             {
   throw_internal_exception("Exceeded call depth maximum");
}

DEFINE_SYSVMOC_TRAP_INTRINSIC() [2/5]

sysio::chain::eosvmoc::DEFINE_SYSVMOC_TRAP_INTRINSIC	(	eosvmoc_internal	,
		div0_or_overflow	)

Definition at line 106 of file executor.cpp.

                                                                 {
   throw_internal_exception("Division by 0 or integer overflow trapped");
}

DEFINE_SYSVMOC_TRAP_INTRINSIC() [3/5]

sysio::chain::eosvmoc::DEFINE_SYSVMOC_TRAP_INTRINSIC	(	eosvmoc_internal	,
		indirect_call_mismatch	)

Definition at line 110 of file executor.cpp.

                                                                       {
   throw_internal_exception("Indirect call function type mismatch");
}

DEFINE_SYSVMOC_TRAP_INTRINSIC() [4/5]

sysio::chain::eosvmoc::DEFINE_SYSVMOC_TRAP_INTRINSIC	(	eosvmoc_internal	,
		indirect_call_oob	)

Definition at line 114 of file executor.cpp.

                                                                  {
   throw_internal_exception("Indirect call index out of bounds");
}

DEFINE_SYSVMOC_TRAP_INTRINSIC() [5/5]

sysio::chain::eosvmoc::DEFINE_SYSVMOC_TRAP_INTRINSIC	(	eosvmoc_internal	,
		unreachable	)

Definition at line 118 of file executor.cpp.

                                                            {
   throw_internal_exception("Unreachable reached");
}

eosvmoc_switch_stack()

void sysio::chain::eosvmoc::eosvmoc_switch_stack	(	void *	stack,
		void(*	fn )(void *),
		void *	data )

Here is the caller graph for this function:

find_intrinsic_index()

std::size_t sysio::chain::eosvmoc::find_intrinsic_index ( std::string_view hf )

inlineconstexpr

Definition at line 273 of file intrinsic_mapping.hpp.

                                                                   {
   constexpr auto hosts = get_intrinsic_table();
   for (  std::size_t i = 0; i < hosts.size(); ++i )
      if ( hosts[i] == hf )
         return i;
   return std::numeric_limits<std::size_t>::max();
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_connection_to_compile_monitor()

wrapped_fd sysio::chain::eosvmoc::get_connection_to_compile_monitor

(

int

cache_fd

)

Definition at line 306 of file compile_monitor.cpp.

                                                           {
   FC_ASSERT(the_compile_monitor_trampoline.compile_manager_pid >= 0, "SYS VM oop connection doesn't look active");
 
   int socks[2]; //0: our socket to compile_manager_session, 1: socket we'll give to compile_maanger_session
   socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0, socks);
   wrapped_fd socket_to_monitor_session(socks[0]);
   wrapped_fd socket_to_hand_to_monitor_session(socks[1]);
 
   //we don't own cache_fd, so try to be extra careful not to accidentally close it: don't stick it in a wrapped_fd
   // to hand off to write_message_with_fds even temporarily. make a copy of it.
   int dup_of_cache_fd = dup(cache_fd);
   FC_ASSERT(dup_of_cache_fd != -1, "failed to dup cache_fd");
   wrapped_fd dup_cache_fd(dup_of_cache_fd);
 
   std::vector<wrapped_fd> fds_to_pass; 
   fds_to_pass.emplace_back(std::move(socket_to_hand_to_monitor_session));
   fds_to_pass.emplace_back(std::move(dup_cache_fd));
   write_message_with_fds(the_compile_monitor_trampoline.compile_manager_fd, initialize_message(), fds_to_pass);
 
   auto [success, message, fds] = read_message_with_fds(the_compile_monitor_trampoline.compile_manager_fd);
   SYS_ASSERT(success, misc_exception, "failed to read response from monitor process");
   SYS_ASSERT(std::holds_alternative<initalize_response_message>(message), misc_exception, "unexpected response from monitor process");
   SYS_ASSERT(!std::get<initalize_response_message>(message).error_message, misc_exception, "Error message from monitor process: ${e}", ("e", *std::get<initalize_response_message>(message).error_message));
   return socket_to_monitor_session;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_intrinsic_map()

const intrinsic_map_t & sysio::chain::eosvmoc::get_intrinsic_map

(

)

Definition at line 10 of file intrinsic.cpp.

                                           {
   return the_intrinsic_map();
}

Here is the caller graph for this function:

get_intrinsic_table()

auto sysio::chain::eosvmoc::get_intrinsic_table ( )

inlineconstexpr

Definition at line 17 of file intrinsic_mapping.hpp.

                                            {
   return detail::generate_table(
      "eosvmoc_internal.unreachable",
      "eosvmoc_internal.grow_memory",
      "eosvmoc_internal.div0_or_overflow",
      "eosvmoc_internal.indirect_call_mismatch",
      "eosvmoc_internal.indirect_call_oob",
      "eosvmoc_internal.depth_assert",
      "sysio_injection.call_depth_assert",  //now unused; left for purposes of not upsetting existing code mappings
      "sysio_injection.checktime",          //now unused; left for purposes of not upsetting existing code mappings
      "env.__ashlti3",
      "env.__ashrti3",
      "env.__lshlti3",
      "env.__lshrti3",
      "env.__divti3",
      "env.__udivti3",
      "env.__modti3",
      "env.__umodti3",
      "env.__multi3",
      "env.__addtf3",
      "env.__subtf3",
      "env.__multf3",
      "env.__divtf3",
      "env.__eqtf2",
      "env.__netf2",
      "env.__getf2",
      "env.__gttf2",
      "env.__lttf2",
      "env.__letf2",
      "env.__cmptf2",
      "env.__unordtf2",
      "env.__negtf2",
      "env.__floatsitf",
      "env.__floatunsitf",
      "env.__floatditf",
      "env.__floatunditf",
      "env.__floattidf",
      "env.__floatuntidf",
      "env.__floatsidf",
      "env.__extendsftf2",
      "env.__extenddftf2",
      "env.__fixtfti",
      "env.__fixtfdi",
      "env.__fixtfsi",
      "env.__fixunstfti",
      "env.__fixunstfdi",
      "env.__fixunstfsi",
      "env.__fixsfti",
      "env.__fixdfti",
      "env.__fixunssfti",
      "env.__fixunsdfti",
      "env.__trunctfdf2",
      "env.__trunctfsf2",
      "env.is_feature_active",
      "env.activate_feature",
      "env.get_resource_limits",
      "env.set_resource_limits",
      "env.set_proposed_producers",
      "env.set_proposed_producers_ex",
      "env.get_blockchain_parameters_packed",
      "env.set_blockchain_parameters_packed",
      "env.is_privileged",
      "env.set_privileged",
      "env.preactivate_feature",
      "env.get_active_producers",
      "env.db_store_i64",
      "env.db_update_i64",
      "env.db_remove_i64",
      "env.db_get_i64",
      "env.db_next_i64",
      "env.db_previous_i64",
      "env.db_find_i64",
      "env.db_lowerbound_i64",
      "env.db_upperbound_i64",
      "env.db_end_i64",
      "env.db_idx64_store",
      "env.db_idx64_remove",
      "env.db_idx64_update",
      "env.db_idx64_find_primary",
      "env.db_idx64_find_secondary",
      "env.db_idx64_lowerbound",
      "env.db_idx64_upperbound",
      "env.db_idx64_end",
      "env.db_idx64_next",
      "env.db_idx64_previous",
      "env.db_idx128_store",
      "env.db_idx128_remove",
      "env.db_idx128_update",
      "env.db_idx128_find_primary",
      "env.db_idx128_find_secondary",
      "env.db_idx128_lowerbound",
      "env.db_idx128_upperbound",
      "env.db_idx128_end",
      "env.db_idx128_next",
      "env.db_idx128_previous",
      "env.db_idx_double_store",
      "env.db_idx_double_remove",
      "env.db_idx_double_update",
      "env.db_idx_double_find_primary",
      "env.db_idx_double_find_secondary",
      "env.db_idx_double_lowerbound",
      "env.db_idx_double_upperbound",
      "env.db_idx_double_end",
      "env.db_idx_double_next",
      "env.db_idx_double_previous",
      "env.db_idx_long_double_store",
      "env.db_idx_long_double_remove",
      "env.db_idx_long_double_update",
      "env.db_idx_long_double_find_primary",
      "env.db_idx_long_double_find_secondary",
      "env.db_idx_long_double_lowerbound",
      "env.db_idx_long_double_upperbound",
      "env.db_idx_long_double_end",
      "env.db_idx_long_double_next",
      "env.db_idx_long_double_previous",
      "env.db_idx256_store",
      "env.db_idx256_remove",
      "env.db_idx256_update",
      "env.db_idx256_find_primary",
      "env.db_idx256_find_secondary",
      "env.db_idx256_lowerbound",
      "env.db_idx256_upperbound",
      "env.db_idx256_end",
      "env.db_idx256_next",
      "env.db_idx256_previous",
      "env.assert_recover_key",
      "env.recover_key",
      "env.assert_sha256",
      "env.assert_sha1",
      "env.assert_sha512",
      "env.assert_ripemd160",
      "env.sha1",
      "env.sha256",
      "env.sha512",
      "env.ripemd160",
      "env.check_transaction_authorization",
      "env.check_permission_authorization",
      "env.get_permission_last_used",
      "env.get_account_creation_time",
      "env.current_time",
      "env.publication_time",
      "env.is_feature_activated",
      "env.get_sender",
      "env.abort",
      "env.sysio_assert",
      "env.sysio_assert_message",
      "env.sysio_assert_code",
      "env.sysio_exit",
      "env.read_action_data",
      "env.action_data_size",
      "env.current_receiver",
      "env.require_recipient",
      "env.require_auth",
      "env.require_auth2",
      "env.has_auth",
      "env.is_account",
      "env.prints",
      "env.prints_l",
      "env.printi",
      "env.printui",
      "env.printi128",
      "env.printui128",
      "env.printsf",
      "env.printdf",
      "env.printqf",
      "env.printn",
      "env.printhex",
      "env.read_transaction",
      "env.transaction_size",
      "env.expiration",
      "env.tapos_block_prefix",
      "env.tapos_block_num",
      "env.get_action",
      "env.send_inline",
      "env.send_context_free_inline",
      "env.send_deferred",
      "env.cancel_deferred",
      "env.get_context_free_data",
      "env.memcpy",
      "env.memmove",
      "env.memcmp",
      "env.memset",
      "sysio_injection._sysio_f32_add",
      "sysio_injection._sysio_f32_sub",
      "sysio_injection._sysio_f32_mul",
      "sysio_injection._sysio_f32_div",
      "sysio_injection._sysio_f32_min",
      "sysio_injection._sysio_f32_max",
      "sysio_injection._sysio_f32_copysign",
      "sysio_injection._sysio_f32_abs",
      "sysio_injection._sysio_f32_neg",
      "sysio_injection._sysio_f32_sqrt",
      "sysio_injection._sysio_f32_ceil",
      "sysio_injection._sysio_f32_floor",
      "sysio_injection._sysio_f32_trunc",
      "sysio_injection._sysio_f32_nearest",
      "sysio_injection._sysio_f32_eq",
      "sysio_injection._sysio_f32_ne",
      "sysio_injection._sysio_f32_lt",
      "sysio_injection._sysio_f32_le",
      "sysio_injection._sysio_f32_gt",
      "sysio_injection._sysio_f32_ge",
      "sysio_injection._sysio_f64_add",
      "sysio_injection._sysio_f64_sub",
      "sysio_injection._sysio_f64_mul",
      "sysio_injection._sysio_f64_div",
      "sysio_injection._sysio_f64_min",
      "sysio_injection._sysio_f64_max",
      "sysio_injection._sysio_f64_copysign",
      "sysio_injection._sysio_f64_abs",
      "sysio_injection._sysio_f64_neg",
      "sysio_injection._sysio_f64_sqrt",
      "sysio_injection._sysio_f64_ceil",
      "sysio_injection._sysio_f64_floor",
      "sysio_injection._sysio_f64_trunc",
      "sysio_injection._sysio_f64_nearest",
      "sysio_injection._sysio_f64_eq",
      "sysio_injection._sysio_f64_ne",
      "sysio_injection._sysio_f64_lt",
      "sysio_injection._sysio_f64_le",
      "sysio_injection._sysio_f64_gt",
      "sysio_injection._sysio_f64_ge",
      "sysio_injection._sysio_f32_promote",
      "sysio_injection._sysio_f64_demote",
      "sysio_injection._sysio_f32_trunc_i32s",
      "sysio_injection._sysio_f64_trunc_i32s",
      "sysio_injection._sysio_f32_trunc_i32u",
      "sysio_injection._sysio_f64_trunc_i32u",
      "sysio_injection._sysio_f32_trunc_i64s",
      "sysio_injection._sysio_f64_trunc_i64s",
      "sysio_injection._sysio_f32_trunc_i64u",
      "sysio_injection._sysio_f64_trunc_i64u",
      "sysio_injection._sysio_i32_to_f32",
      "sysio_injection._sysio_i64_to_f32",
      "sysio_injection._sysio_ui32_to_f32",
      "sysio_injection._sysio_ui64_to_f32",
      "sysio_injection._sysio_i32_to_f64",
      "sysio_injection._sysio_i64_to_f64",
      "sysio_injection._sysio_ui32_to_f64",
      "sysio_injection._sysio_ui64_to_f64",
      "env.set_action_return_value",
      "env.get_wasm_parameters_packed",
      "env.set_wasm_parameters_packed",
      "env.get_parameters_packed",
      "env.set_parameters_packed",
      "env.get_code_hash",
      "env.alt_bn128_add",
      "env.alt_bn128_mul",
      "env.alt_bn128_pair",
      "env.mod_exp",
      "env.sha3",
      "env.blake2_f",
      "env.k1_recover",
      "env.get_block_num"
   );
}

Here is the call graph for this function:

Here is the caller graph for this function:

intrinsic_table_size()

std::size_t sysio::chain::eosvmoc::intrinsic_table_size ( )

inlineconstexpr

Definition at line 281 of file intrinsic_mapping.hpp.

                                                  {
    return std::tuple_size<decltype(get_intrinsic_table())>::value;
}

Here is the call graph for this function:

launch_compile_monitor()

void sysio::chain::eosvmoc::launch_compile_monitor

(

int

nodeop_fd

)

Definition at line 235 of file compile_monitor.cpp.

                                           {
   prctl(PR_SET_NAME, "oc-monitor");
   prctl(PR_SET_PDEATHSIG, SIGKILL);
 
   //first off, let's disable shutdown signals to us; we want all shutdown indicators to come from
   // nodeop shutting us down
   sigset_t set;
   sigemptyset(&set);
   sigaddset(&set, SIGHUP);
   sigaddset(&set, SIGTERM);
   sigaddset(&set, SIGPIPE);
   sigaddset(&set, SIGINT);
   sigaddset(&set, SIGQUIT);
   sigprocmask(SIG_BLOCK, &set, nullptr);
 
   struct sigaction sa;
   sa.sa_handler =  SIG_DFL;
   sa.sa_flags = SA_NOCLDWAIT;
   sigaction(SIGCHLD, &sa, nullptr);
 
   int socks[2]; //0: local trampoline socket, 1: the one we give to trampoline
   socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0, socks);
   pid_t child = fork();
   if(child == 0) {
      close(socks[0]);
      run_compile_trampoline(socks[1]);
   }
   close(socks[1]);
 
   {
      boost::asio::io_context ctx;
      boost::asio::local::datagram_protocol::socket nodeop_socket(ctx);
      nodeop_socket.assign(boost::asio::local::datagram_protocol(), nodeop_fd);
      wrapped_fd trampoline_socket(socks[0]);
      compile_monitor monitor(ctx, std::move(nodeop_socket), std::move(trampoline_socket));
      ctx.run();
      if(monitor._compile_sessions.size())
         std::cerr << "ERROR: SYS VM OC compiler monitor exiting with active sessions" << std::endl;
   }
   
   _exit(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

memfd_for_bytearray()

template<typename T >

wrapped_fd sysio::chain::eosvmoc::memfd_for_bytearray

(

const T &

bytes

)

Definition at line 56 of file ipc_helpers.hpp.

                                               {
   int fd = syscall(SYS_memfd_create, "eosvmoc_code", MFD_CLOEXEC);
   FC_ASSERT(fd >= 0, "Failed to create memfd");
   FC_ASSERT(ftruncate(fd, bytes.size()) == 0, "failed to grow memfd");
   if(bytes.size()) {
      uint8_t* b = (uint8_t*)mmap(nullptr, bytes.size(), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
      FC_ASSERT(b != MAP_FAILED, "failed to mmap memfd");
      memcpy(b, bytes.data(), bytes.size());
      munmap(b, bytes.size());
   }
   return wrapped_fd(fd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_message_with_fds() [1/2]

std::tuple< bool, eosvmoc_message, std::vector< wrapped_fd > > sysio::chain::eosvmoc::read_message_with_fds

(

boost::asio::local::datagram_protocol::socket &

s

)

Definition at line 9 of file ipc_helpers.cpp.

                                                                                                                       {
   return read_message_with_fds(s.native_handle());
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_message_with_fds() [2/2]

std::tuple< bool, eosvmoc_message, std::vector< wrapped_fd > > sysio::chain::eosvmoc::read_message_with_fds

(

int

fd

)

Definition at line 13 of file ipc_helpers.cpp.

                                                                                     {
   char buff[max_message_size];
 
   struct msghdr msg = {};
   struct cmsghdr* cmsg;
 
   eosvmoc_message message;
   std::vector<wrapped_fd> fds;
 
   struct iovec io = {
      .iov_base = buff,
      .iov_len = sizeof(buff)
   };
   union {
      char buf[CMSG_SPACE(max_num_fds * sizeof(int))];
      struct cmsghdr align;
   } u;
 
   msg.msg_iov = &io;
   msg.msg_iovlen = 1;
   msg.msg_control = u.buf;
   msg.msg_controllen = sizeof(u.buf);
 
   int red;
   do {
      red = recvmsg(fd, &msg, 0);
   } while(red == -1 && errno == EINTR);
   if(red < 1 || static_cast<unsigned>(red) >= sizeof(buff))
      return {false, message, std::move(fds)};
   
   try {
      fc::datastream<char*> ds(buff, red);
      fc::raw::unpack(ds, message);
   }
   catch(...) {
      return {false, message, std::move(fds)};
   }
 
   if(msg.msg_controllen) {
      cmsg = CMSG_FIRSTHDR(&msg);
      unsigned num_of_fds = (cmsg->cmsg_len - CMSG_LEN(0))/sizeof(int);
      if(num_of_fds > max_num_fds)
         return {false, message, std::move(fds)};
      int* fd_ptr = (int*)CMSG_DATA(cmsg);
      for(unsigned i = 0; i < num_of_fds; ++i)
         fds.push_back(*fd_ptr++);
   }
 
   return {true, message, std::move(fds)};
}

Here is the call graph for this function:

run_compile()

void sysio::chain::eosvmoc::run_compile ( wrapped_fd && response_sock, wrapped_fd && wasm_code )

noexcept

Definition at line 20 of file compile_trampoline.cpp.

                                                                              {  //noexcept; we'll just blow up if anything tries to cross this boundry
   std::vector<uint8_t> wasm = vector_for_memfd(wasm_code);
 
   //ideally we catch exceptions and sent them upstream as strings for easier reporting
 
   Module module;
   Serialization::MemoryInputStream stream(wasm.data(), wasm.size());
   WASM::scoped_skip_checks no_check;
   WASM::serialize(stream, module);
   module.userSections.clear();
   wasm_injections::wasm_binary_injection injector(module);
   injector.inject();
 
   instantiated_code code = LLVMJIT::instantiateModule(module);
 
   code_compilation_result_message result_message;
 
   const std::map<unsigned, uintptr_t>& function_to_offsets = code.function_offsets;
 
   if(module.startFunctionIndex == UINTPTR_MAX)
      result_message.start = no_offset{};
   else if(module.startFunctionIndex < module.functions.imports.size()) {
      const auto& f = module.functions.imports[module.startFunctionIndex];
      const intrinsic_entry& ie = get_intrinsic_map().at(f.moduleName + "." + f.exportName);
      result_message.start = intrinsic_ordinal{ie.ordinal};
   }
   else
      result_message.start = code_offset{function_to_offsets.at(module.startFunctionIndex-module.functions.imports.size())};
 
   for(const Export& exprt : module.exports) {
      if(exprt.name == "apply")
         result_message.apply_offset = function_to_offsets.at(exprt.index-module.functions.imports.size());
   }
 
   result_message.starting_memory_pages = -1;
   if(module.memories.size())
      result_message.starting_memory_pages = module.memories.defs.at(0).type.size.min;
 
   std::vector<uint8_t> prologue(module.globals.defs.size() * 8); // Large enough to handle all mutable globals
   std::vector<uint8_t>::iterator prologue_it = prologue.end();
 
   //set up mutable globals
   union global_union {
      int64_t i64;
      int32_t i32;
      float f32;
      double f64;
   };
 
   for(const GlobalDef& global : module.globals.defs) {
      if(!global.type.isMutable)
         continue;
      prologue_it -= 8;
      global_union* const u = (global_union* const)&*prologue_it;
 
      switch(global.initializer.type) {
         case InitializerExpression::Type::i32_const: u->i32 = global.initializer.i32; break;
         case InitializerExpression::Type::i64_const: u->i64 = global.initializer.i64; break;
         case InitializerExpression::Type::f32_const: u->f32 = global.initializer.f32; break;
         case InitializerExpression::Type::f64_const: u->f64 = global.initializer.f64; break;
         default: break; //impossible
      }
   }
 
   struct table_entry {
      uintptr_t type;
      int64_t func;    //>= 0 means offset to code in wasm; < 0 means intrinsic call at offset address
   };
 
   for(const TableSegment& table_segment : module.tableSegments) {
      struct table_entry* table_index_0 = (struct table_entry*)(code.code.data() + code.table_offset);
 
      if(static_cast<uint64_t>(table_segment.baseOffset.i32) > module.tables.defs[0].type.size.min)
         return;
 
      if(static_cast<uint64_t>(table_segment.baseOffset.i32) > module.tables.defs[0].type.size.min)
         return;
 
      for(Uptr i = 0; i < table_segment.indices.size(); ++i) {
         const Uptr function_index = table_segment.indices[i];
         const uint64_t effective_table_index = table_segment.baseOffset.i32 + i;
 
         if(effective_table_index >= module.tables.defs[0].type.size.min)
            return;
 
         if(function_index < module.functions.imports.size()) {
            const auto& f = module.functions.imports[function_index];
            const intrinsic_entry& ie = get_intrinsic_map().at(f.moduleName + "." + f.exportName);
            table_index_0[effective_table_index].func = ie.ordinal*-8;
            table_index_0[effective_table_index].type = (uintptr_t)module.types[module.functions.imports[function_index].type.index];
         }
         else {
            table_index_0[effective_table_index].func = function_to_offsets.at(function_index - module.functions.imports.size());
            table_index_0[effective_table_index].type = (uintptr_t)module.types[module.functions.defs[function_index - module.functions.imports.size()].type.index];
         }
      }
   }
 
   //this is somewhat copy pasta from wasm_interface_private, with the asserts removed
   std::vector<uint8_t> initial_mem;
   for(const DataSegment& data_segment : module.dataSegments) {
      const U32 base_offset = data_segment.baseOffset.i32;
 
      if(base_offset + data_segment.data.size() > initial_mem.size())
         initial_mem.resize(base_offset + data_segment.data.size(), 0x00);
      memcpy(initial_mem.data() + base_offset, data_segment.data.data(), data_segment.data.size());
   }
 
   result_message.initdata_prologue_size = prologue.end() - prologue_it;
   std::vector<uint8_t> initdata_prep;
   std::move(prologue_it, prologue.end(), std::back_inserter(initdata_prep));
   std::move(initial_mem.begin(), initial_mem.end(), std::back_inserter(initdata_prep));
 
   std::vector<wrapped_fd> fds_to_send;
   fds_to_send.emplace_back(memfd_for_bytearray(code.code));
   fds_to_send.emplace_back(memfd_for_bytearray(initdata_prep));
   write_message_with_fds(response_sock, result_message, fds_to_send);
}

Here is the call graph for this function:

Here is the caller graph for this function:

run_compile_trampoline()

void sysio::chain::eosvmoc::run_compile_trampoline

(

int

fd

)

Definition at line 139 of file compile_trampoline.cpp.

                                    {
   prctl(PR_SET_NAME, "oc-trampoline");
   prctl(PR_SET_PDEATHSIG, SIGKILL);
 
   //squelching this for now, but it means we won't have ability to get compile metrics
   struct sigaction act;
   sigset_t set;
   sigemptyset(&set);
   act.sa_handler = SIG_IGN;
   act.sa_mask = set;
   act.sa_flags = SA_NOCLDWAIT;
   act.sa_sigaction = nullptr;
   sigaction(SIGCHLD, &act, nullptr);
 
   while(true) {
      auto [success, message, fds] = read_message_with_fds(fd);
      if(!success)
         break;
      
      if(!std::holds_alternative<compile_wasm_message>(message) || fds.size() != 2) {
         std::cerr << "SYS VM OC compile trampoline got unexpected message; ignoring" << std::endl;
         continue;
      }
 
      pid_t pid = fork();
      if(pid == 0) {
         prctl(PR_SET_NAME, "oc-compile");
         prctl(PR_SET_PDEATHSIG, SIGKILL);
 
         struct rlimit cpu_limits = {20u, 20u};
         setrlimit(RLIMIT_CPU, &cpu_limits);
 
         struct rlimit vm_limits = {512u*1024u*1024u, 512u*1024u*1024u};
         setrlimit(RLIMIT_AS, &vm_limits);
 
         struct rlimit core_limits = {0u, 0u};
         setrlimit(RLIMIT_CORE, &core_limits);
 
         run_compile(std::move(fds[0]), std::move(fds[1]));
         _exit(0);
      }
      else if(pid == -1)
         std::cerr << "SYS VM OC compile trampoline failed to spawn compile task" << std::endl;
   }
 
   _exit(0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

vector_for_memfd()

std::vector< uint8_t > sysio::chain::eosvmoc::vector_for_memfd

(

const wrapped_fd &

memfd

)

Definition at line 121 of file ipc_helpers.cpp.

                                                             {
   struct stat st;
   FC_ASSERT(fstat(memfd, &st) == 0, "failed to get memfd size");
 
   if(st.st_size == 0)
      return std::vector<uint8_t>();
 
   uint8_t* p = (uint8_t*)mmap(nullptr, st.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, memfd, 0);
   FC_ASSERT(p != MAP_FAILED, "failed to map memfd");
   std::vector<uint8_t> ret(p, p+st.st_size);
   munmap(p, st.st_size);
   return ret;
}

Here is the caller graph for this function:

write_message_with_fds() [1/2]

bool sysio::chain::eosvmoc::write_message_with_fds	(	boost::asio::local::datagram_protocol::socket &	s,
		const eosvmoc_message &	message,
		const std::vector< wrapped_fd > &	fds = std::vector<wrapped_fd>() )

Definition at line 64 of file ipc_helpers.cpp.

                                                                                                                                        {
   return write_message_with_fds(s.native_handle(), message, fds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

write_message_with_fds() [2/2]

bool sysio::chain::eosvmoc::write_message_with_fds	(	int	fd_to_send_to,
		const eosvmoc_message &	message,
		const std::vector< wrapped_fd > &	fds = std::vector<wrapped_fd>() )

Definition at line 68 of file ipc_helpers.cpp.

                                                                                                                 {
   struct msghdr msg = {};
   struct cmsghdr* cmsg;
 
   size_t sz = fc::raw::pack_size(message);
   if(sz > max_message_size)
      return false;
   char buff[max_message_size];
   try {
      fc::datastream<char*> ds(buff, max_message_size);
      fc::raw::pack(ds, message);
   }
   catch(...) {
      return false;
   }
 
   if(fds.size() > max_num_fds)
      return false;
 
   struct iovec io = {
      .iov_base = buff,
      .iov_len = sz
   };
   union {
      char buf[CMSG_SPACE(max_num_fds * sizeof(int))];
      struct cmsghdr align;
   } u;
 
   msg.msg_iov = &io;
   msg.msg_iovlen = 1;
   if(fds.size()) {
      msg.msg_control = u.buf;
      msg.msg_controllen = sizeof(u.buf);
      cmsg = CMSG_FIRSTHDR(&msg);
      cmsg->cmsg_level = SOL_SOCKET;
      cmsg->cmsg_type = SCM_RIGHTS;
      cmsg->cmsg_len = CMSG_LEN(sizeof(int) * fds.size());
      unsigned char* p = CMSG_DATA(cmsg);
      for(const wrapped_fd& fd : fds) {
         int thisfd = fd;
         memcpy(p, &thisfd, sizeof(thisfd));
         p += sizeof(thisfd);
      }
   }
 
   int wrote;
   do {
      wrote = sendmsg(fd_to_send_to, &msg, 0);
   } while(wrote == -1 && errno == EINTR);
 
   return wrote >= 0;
}

Here is the call graph for this function: