sysio::chain::eosvmoc::executor Class Reference

#include <executor.hpp>

Public Member Functions
	executor (const code_cache_base &cc)
	~executor ()
void	execute (const code_descriptor &code, memory &mem, apply_context &context)

Detailed Description

Definition at line 24 of file executor.hpp.

Constructor & Destructor Documentation

executor()

sysio::chain::eosvmoc::executor::executor

(

const code_cache_base &

cc

)

Definition at line 136 of file executor.cpp.

                                            {
   //if we're the first executor created, go setup the signal handling. For now we'll just leave this attached forever
   static executor_signal_init the_executor_signal_init;
 
   uint64_t current_gs;
   if(arch_prctl(ARCH_GET_GS, &current_gs) || current_gs)
      wlog("x86_64 GS register is not set as expected. SYS VM OC may not run correctly on this platform");
 
   struct stat s;
   FC_ASSERT(fstat(cc.fd(), &s) == 0, "executor failed to get code cache size");
   code_mapping = (uint8_t*)mmap(nullptr, s.st_size, PROT_EXEC|PROT_READ, MAP_SHARED, cc.fd(), 0);
   FC_ASSERT(code_mapping != MAP_FAILED, "failed to map code cache in to executor");
   code_mapping_size = s.st_size;
   mapping_is_executable = true;
}

Here is the call graph for this function:

~executor()

sysio::chain::eosvmoc::executor::~executor

(

)

Definition at line 265 of file executor.cpp.

                    {
   arch_prctl(ARCH_SET_GS, nullptr);
}

Here is the call graph for this function:

Member Function Documentation

execute()

void sysio::chain::eosvmoc::executor::execute	(	const code_descriptor &	code,
		memory &	mem,
		apply_context &	context )

Definition at line 152 of file executor.cpp.

                                                                                       {
   if(mapping_is_executable == false) {
      mprotect(code_mapping, code_mapping_size, PROT_EXEC|PROT_READ);
      mapping_is_executable = true;
   }
 
   uint64_t max_call_depth = sysio::chain::wasm_constraints::maximum_call_depth+1;
   uint64_t max_pages = sysio::chain::wasm_constraints::maximum_linear_memory/sysio::chain::wasm_constraints::wasm_page_size;
   if(context.control.is_builtin_activated(builtin_protocol_feature_t::configurable_wasm_limits)) {
      const wasm_config& config = context.control.get_global_properties().wasm_configuration;
      max_call_depth = config.max_call_depth;
      max_pages = config.max_pages;
   }
   stack.reset(max_call_depth);
   SYS_ASSERT(code.starting_memory_pages <= (int)max_pages, wasm_execution_error, "Initial memory out of range");
 
   //prepare initial memory, mutable globals, and table data
   if(code.starting_memory_pages > 0 ) {
      uint64_t initial_page_offset = std::min(static_cast<std::size_t>(code.starting_memory_pages), mem.size_of_memory_slice_mapping()/memory::stride - 1);
      if(initial_page_offset < static_cast<uint64_t>(code.starting_memory_pages)) {
         mprotect(mem.full_page_memory_base() + initial_page_offset * sysio::chain::wasm_constraints::wasm_page_size,
                  (code.starting_memory_pages - initial_page_offset) * sysio::chain::wasm_constraints::wasm_page_size, PROT_READ | PROT_WRITE);
      }
      arch_prctl(ARCH_SET_GS, (unsigned long*)(mem.zero_page_memory_base()+initial_page_offset*memory::stride));
      memset(mem.full_page_memory_base(), 0, 64u*1024u*code.starting_memory_pages);
   }
   else
      arch_prctl(ARCH_SET_GS, (unsigned long*)mem.zero_page_memory_base());
 
   void* globals;
   if(code.initdata_prologue_size > memory::max_prologue_size) {
      globals_buffer.resize(code.initdata_prologue_size);
      memcpy(globals_buffer.data(), code_mapping + code.initdata_begin, code.initdata_prologue_size);
      memcpy(mem.full_page_memory_base() - memory::max_prologue_size,
             code_mapping + code.initdata_begin + code.initdata_prologue_size - memory::max_prologue_size,
             code.initdata_size - code.initdata_prologue_size + memory::max_prologue_size);
      globals = globals_buffer.data() + globals_buffer.size();
   } else {
      memcpy(mem.full_page_memory_base() - code.initdata_prologue_size, code_mapping + code.initdata_begin, code.initdata_size);
      globals = mem.full_page_memory_base();
   }
 
   control_block* const cb = mem.get_control_block();
   cb->magic = signal_sentinel;
   cb->execution_thread_code_start = (uintptr_t)code_mapping;
   cb->execution_thread_code_length = code_mapping_size;
   cb->execution_thread_memory_start = (uintptr_t)mem.start_of_memory_slices();
   cb->execution_thread_memory_length = mem.size_of_memory_slice_mapping();
   cb->ctx = &context;
   executors_exception_ptr = nullptr;
   cb->eptr = &executors_exception_ptr;
   cb->current_call_depth_remaining = max_call_depth + 1;
   cb->current_linear_memory_pages = code.starting_memory_pages;
   cb->max_linear_memory_pages = max_pages;
   cb->first_invalid_memory_address = code.starting_memory_pages*64*1024;
   cb->full_linear_memory_start = (char*)mem.full_page_memory_base();
   cb->jmp = &executors_sigjmp_buf;
   cb->bounce_buffers = &executors_bounce_buffers;
   cb->running_code_base = (uintptr_t)(code_mapping + code.code_begin);
   cb->is_running = true;
   cb->globals = globals;
 
   context.trx_context.transaction_timer.set_expiration_callback([](void* user) {
      executor* self = (executor*)user;
      syscall(SYS_mprotect, self->code_mapping, self->code_mapping_size, PROT_NONE);
      self->mapping_is_executable = false;
   }, this);
   context.trx_context.checktime(); //catch any expiration that might have occurred before setting up callback
 
   auto cleanup = fc::make_scoped_exit([cb, &tt=context.trx_context.transaction_timer, &mem=mem](){
      cb->is_running = false;
      cb->bounce_buffers->clear();
      tt.set_expiration_callback(nullptr, nullptr);
 
      uint64_t base_pages = mem.size_of_memory_slice_mapping()/memory::stride - 1;
      if(cb->current_linear_memory_pages > base_pages) {
         mprotect(mem.full_page_memory_base() + base_pages * sysio::chain::wasm_constraints::wasm_page_size,
                  (cb->current_linear_memory_pages - base_pages) * sysio::chain::wasm_constraints::wasm_page_size, PROT_NONE);
      }
   });
 
   void(*apply_func)(uint64_t, uint64_t, uint64_t) = (void(*)(uint64_t, uint64_t, uint64_t))(cb->running_code_base + code.apply_offset);
 
   switch(sigsetjmp(*cb->jmp, 0)) {
      case 0:
         stack.run([&]{
            std::visit(overloaded {
               [&](const no_offset&) {},
               [&](const intrinsic_ordinal& i) {
                  void(*start_func)() = (void(*)())(*(uintptr_t*)((uintptr_t)mem.zero_page_memory_base() - memory::first_intrinsic_offset - i.ordinal*8));
                  start_func();
               },
               [&](const code_offset& offs) {
                  void(*start_func)() = (void(*)())(cb->running_code_base + offs.offset);
                  start_func();
               }
            }, code.start);
            apply_func(context.get_receiver().to_uint64_t(), context.get_action().account.to_uint64_t(), context.get_action().name.to_uint64_t());
         });
         break;
      //case 1: clean sysio_exit
      case SYSVMOC_EXIT_CHECKTIME_FAIL:
         context.trx_context.checktime();
         break;
      case SYSVMOC_EXIT_SEGV:
         SYS_ASSERT(false, wasm_execution_error, "access violation");
         break;
      case SYSVMOC_EXIT_EXCEPTION: //exception
         std::rethrow_exception(*cb->eptr);
         break;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• libraries/chain/include/sysio/chain/webassembly/sys-vm-oc/executor.hpp
• libraries/chain/webassembly/runtimes/sys-vm-oc/executor.cpp