sysio::chain::eosvmoc::compile_monitor_session Struct Reference

Public Member Functions
	compile_monitor_session (boost::asio::io_context &context, local::datagram_protocol::socket &&n, wrapped_fd &&c, wrapped_fd &t)
	~compile_monitor_session ()
void	read_message_from_nodeop ()
void	kick_compile_off (const code_tuple &code_id, wrapped_fd &&wasm_code)
void	read_message_from_compile_task (std::list< std::tuple< code_tuple, local::datagram_protocol::socket > >::iterator current_compile_it)

Public Attributes
boost::signals2::signal< void()>	connection_dead_signal

Detailed Description

Definition at line 36 of file compile_monitor.cpp.

Constructor & Destructor Documentation

compile_monitor_session()

sysio::chain::eosvmoc::compile_monitor_session::compile_monitor_session ( boost::asio::io_context & context, local::datagram_protocol::socket && n, wrapped_fd && c, wrapped_fd & t )

inline

Definition at line 37 of file compile_monitor.cpp.

                                                                                                                          :
      _ctx(context),
      _nodeop_instance_socket(std::move(n)),
      _cache_fd(std::move(c)),
      _trampoline_socket(t) {
 
      struct stat st;
      FC_ASSERT(fstat(_cache_fd, &st) == 0, "failed to stat cache fd");
      _code_size = st.st_size;
      _code_mapping = (char*)mmap(nullptr, _code_size, PROT_READ|PROT_WRITE, MAP_SHARED, _cache_fd, 0);
      FC_ASSERT(_code_mapping != MAP_FAILED, "failed to mmap cache file");
      _allocator = reinterpret_cast<allocator_t*>(_code_mapping);
      
      read_message_from_nodeop();
   }

Here is the call graph for this function:

~compile_monitor_session()

sysio::chain::eosvmoc::compile_monitor_session::~compile_monitor_session ( )

inline

Definition at line 53 of file compile_monitor.cpp.

                              {
      munmap(_code_mapping, _code_size);
   }

Member Function Documentation

kick_compile_off()

void sysio::chain::eosvmoc::compile_monitor_session::kick_compile_off ( const code_tuple & code_id, wrapped_fd && wasm_code )

inline

Definition at line 93 of file compile_monitor.cpp.

                                                                            {
      //prepare a requst to go out to the trampoline
      int socks[2];
      socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC, 0, socks);
      local::datagram_protocol::socket response_socket(_ctx);
      response_socket.assign(local::datagram_protocol(), socks[0]);
      std::vector<wrapped_fd> fds_pass_to_trampoline;
      fds_pass_to_trampoline.emplace_back(socks[1]);
      fds_pass_to_trampoline.emplace_back(std::move(wasm_code));
 
      eosvmoc_message trampoline_compile_request = compile_wasm_message{code_id};
      if(write_message_with_fds(_trampoline_socket, trampoline_compile_request, fds_pass_to_trampoline) == false) {
         wasm_compilation_result_message reply{code_id, compilation_result_unknownfailure{}, _allocator->get_free_memory()};
         write_message_with_fds(_nodeop_instance_socket, reply);
         return;
      }
 
      current_compiles.emplace_front(code_id, std::move(response_socket));
      read_message_from_compile_task(current_compiles.begin());
   }

Here is the call graph for this function:

Here is the caller graph for this function:

read_message_from_compile_task()

void sysio::chain::eosvmoc::compile_monitor_session::read_message_from_compile_task ( std::list< std::tuple< code_tuple, local::datagram_protocol::socket > >::iterator current_compile_it )

inline

Definition at line 114 of file compile_monitor.cpp.

                                                                                                                               {
      auto& [code, socket] = *current_compile_it;
      socket.async_wait(local::datagram_protocol::socket::wait_read, [this, current_compile_it](auto ec) {
         //at this point we only expect 1 of 2 things to happen: we either get a reply (success), or we get no reply (failure)
         auto& [code, socket] = *current_compile_it;
         auto [success, message, fds] = read_message_with_fds(socket);
         
         wasm_compilation_result_message reply{code, compilation_result_unknownfailure{}, _allocator->get_free_memory()};
         
         void* code_ptr = nullptr;
         void* mem_ptr = nullptr;
         try {
            if(success && std::holds_alternative<code_compilation_result_message>(message) && fds.size() == 2) {
               code_compilation_result_message& result = std::get<code_compilation_result_message>(message);
               code_ptr = _allocator->allocate(get_size_of_fd(fds[0]));
               mem_ptr = _allocator->allocate(get_size_of_fd(fds[1]));
 
               if(code_ptr == nullptr || mem_ptr == nullptr) {
                  _allocator->deallocate(code_ptr);
                  _allocator->deallocate(mem_ptr);
                  reply.result = compilation_result_toofull();
               }
               else {
                  copy_memfd_contents_to_pointer(code_ptr, fds[0]);
                  copy_memfd_contents_to_pointer(mem_ptr, fds[1]);
 
                  reply.result = code_descriptor {
                     code.code_id,
                     code.vm_version,
                     current_codegen_version,
                     (uintptr_t)code_ptr - (uintptr_t)_code_mapping,
                     result.start,
                     result.apply_offset,
                     result.starting_memory_pages,
                     (uintptr_t)mem_ptr - (uintptr_t)_code_mapping,
                     (unsigned)get_size_of_fd(fds[1]),
                     result.initdata_prologue_size
                  };
               }
            }
         }
         catch(...) {
            _allocator->deallocate(code_ptr);
            _allocator->deallocate(mem_ptr);
         }
 
         write_message_with_fds(_nodeop_instance_socket, reply);
 
         //either way, we are done
         _ctx.post([this, current_compile_it]() {
            current_compiles.erase(current_compile_it);
         });
      });
 
   }

Here is the call graph for this function:

Here is the caller graph for this function:

read_message_from_nodeop()

void sysio::chain::eosvmoc::compile_monitor_session::read_message_from_nodeop ( )

inline

Definition at line 57 of file compile_monitor.cpp.

                                   {
      _nodeop_instance_socket.async_wait(local::datagram_protocol::socket::wait_read, [this](auto ec) {
         if(ec) {
            connection_dead_signal();
            return;
         }
         auto [success, message, fds] = read_message_with_fds(_nodeop_instance_socket);
         if(!success) {
            connection_dead_signal();
            return;
         }
         std::visit(overloaded {
            [&, &fds=fds](const compile_wasm_message& compile) {
               if(fds.size() != 1) {
                  connection_dead_signal();
                  return;
               }
               kick_compile_off(compile.code, std::move(fds[0]));
            },
            [&](const evict_wasms_message& evict) {
               for(const code_descriptor& cd : evict.codes) {
                  _allocator->deallocate(_code_mapping + cd.code_begin);
                  _allocator->deallocate(_code_mapping + cd.initdata_begin);
               }
            },
            [&](const auto&) {
               //anything else is an error
               connection_dead_signal();
               return;
            }
         }, message);
 
         read_message_from_nodeop();
      });
   }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

connection_dead_signal

boost::signals2::signal<void()> sysio::chain::eosvmoc::compile_monitor_session::connection_dead_signal

Definition at line 170 of file compile_monitor.cpp.

---

The documentation for this struct was generated from the following file:

• libraries/chain/webassembly/runtimes/sys-vm-oc/compile_monitor.cpp