Merge remote-tracking branch 'spring/main' into HEAD

Author: spoonincode

.cicd/defaults.json

@@ -1,6 +1,6 @@
 {
     "cdt":{
-       "target":"main",
+       "target":"4.1",
        "prerelease":true
     },
     "referencecontracts":{

.github/workflows/build.yaml

@@ -151,12 +151,14 @@ jobs:
         with:
           name: ${{matrix.cfg.builddir}}-build
       - name: Run Parallel Tests
+        env:
+          IS_SAN: ${{endsWith(matrix.cfg.name, 'san') && 'yes' || ''}}
         run: |
           # https://github.com/actions/runner/issues/2033  -- need this because of full version label test looking at git revs
           chown -R $(id -u):$(id -g) $PWD
           zstdcat build.tar.zst | tar x
           cd build
-          ctest --output-on-failure -j $(nproc) -LE "(nonparallelizable_tests|long_running_tests)" --timeout 480
+          ctest --output-on-failure -j $(nproc) -LE "(nonparallelizable_tests|long_running_tests)" ${IS_SAN:+-E 'eos-vm$'} --timeout 480
       - name: Upload core files from failed tests
         uses: actions/upload-artifact@v4
         if: failure()
@@ -166,7 +168,9 @@ jobs:
           path: /cores
           compression-level: 0
       - name: Check CPU Features
-        run: awk 'BEGIN {err = 1} /bmi2/ && /adx/ {err = 0} END {exit err}' /proc/cpuinfo
+        run: |
+          awk 'BEGIN {err = 1} /bmi2/ && /adx/ {err = 0} END {exit err}' /proc/cpuinfo
+          build/tools/fsgsbase-enabled
 
   np-tests:
     name: NP Tests (${{matrix.cfg.name}})

CMakeModules/VersionUtils.cmake

@@ -1,5 +1,3 @@
-cmake_minimum_required(VERSION 3.5)
-
 function(GENERATE_VERSION_METADATA)
    # Execute `git` to grab the corresponding data.
    execute_process(

libraries/appbase

@@ -163,11 +163,6 @@ foreach(RUNTIME ${EOSIO_WASM_RUNTIMES})
    target_compile_definitions(eosio_chain PUBLIC "EOSIO_${RUNTIMEUC}_RUNTIME_ENABLED")
 endforeach()
 
-if(EOSVMOC_ENABLE_DEVELOPER_OPTIONS)
-   message(WARNING "EOS VM OC Developer Options are enabled; these are NOT supported")
-   target_compile_definitions(eosio_chain PUBLIC EOSIO_EOS_VM_OC_DEVELOPER)
-endif()
-
 install( TARGETS eosio_chain
    RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_BINDIR} COMPONENT dev EXCLUDE_FROM_ALL
    LIBRARY DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR} COMPONENT dev EXCLUDE_FROM_ALL

libraries/chain/CMakeLists.txt

@@ -1090,16 +1090,21 @@ action_name apply_context::get_sender() const {
    return action_name();
 }
 
+bool apply_context::is_eos_vm_oc_whitelisted() const {
+   return receiver.prefix() == config::system_account_name || // "eosio"_n
+          control.is_eos_vm_oc_whitelisted(receiver);
+}
+
 // Context             |    OC?
 //-------------------------------------------------------------------------------
-// Building block      | baseline, OC for eosio.*
-// Applying block      | OC unless a producer, OC for eosio.* including producers
-// Speculative API trx | baseline, OC for eosio.*
-// Speculative P2P trx | baseline, OC for eosio.*
-// Compute trx         | baseline, OC for eosio.*
+// Building block      | baseline, OC for whitelisted
+// Applying block      | OC unless a producer, OC for whitelisted including producers
+// Speculative API trx | baseline, OC for whitelisted
+// Speculative P2P trx | baseline, OC for whitelisted
+// Compute trx         | baseline, OC for whitelisted
 // Read only trx       | OC
 bool apply_context::should_use_eos_vm_oc()const {
-   return receiver.prefix() == config::system_account_name // "eosio"_n, all cases use OC
+   return is_eos_vm_oc_whitelisted() // all whitelisted accounts use OC always
           || (is_applying_block() && !control.is_producer_node()) // validating/applying block
           || trx_context.is_read_only();
 }

libraries/chain/apply_context.cpp

@@ -94,7 +94,7 @@ namespace eosio::chain {
 
       void             open_impl( const char* desc, const std::filesystem::path& fork_db_file, fc::cfile_datastream& ds, validator_t& validator );
       void             close_impl( std::ofstream& out );
-      bool             add_impl( const bsp_t& n, ignore_duplicate_t ignore_duplicate, bool validate, validator_t& validator );
+      fork_db_add_t    add_impl( const bsp_t& n, ignore_duplicate_t ignore_duplicate, bool validate, validator_t& validator );
       bool             is_valid() const;
 
       bsp_t            get_block_impl( const block_id_type& id, include_root_t include_root = include_root_t::no ) const;
@@ -192,10 +192,11 @@ namespace eosio::chain {
 
    template<class BSP>
    void fork_database_impl<BSP>::reset_root_impl( const bsp_t& root_bsp ) {
-      index.clear();
       assert(root_bsp);
       root = root_bsp;
       root->set_valid(true);
+      pending_savanna_lib_id = block_id_type{};
+      index.clear();
    }
 
    template<class BSP>
@@ -240,8 +241,8 @@ namespace eosio::chain {
    }
 
    template <class BSP>
-   bool fork_database_impl<BSP>::add_impl(const bsp_t& n, ignore_duplicate_t ignore_duplicate,
-                                          bool validate, validator_t& validator) {
+   fork_db_add_t fork_database_impl<BSP>::add_impl(const bsp_t& n, ignore_duplicate_t ignore_duplicate,
+                                                   bool validate, validator_t& validator) {
       EOS_ASSERT( root, fork_database_exception, "root not yet set" );
       EOS_ASSERT( n, fork_database_exception, "attempt to add null block state" );
 
@@ -277,15 +278,25 @@ namespace eosio::chain {
          EOS_RETHROW_EXCEPTIONS( fork_database_exception, "serialized fork database is incompatible with configured protocol features" )
       }
 
+      auto prev_head = head_impl(include_root_t::yes);
+
       auto inserted = index.insert(n);
       EOS_ASSERT(ignore_duplicate == ignore_duplicate_t::yes || inserted.second, fork_database_exception,
                  "duplicate block added: ${id}", ("id", n->id()));
 
-      return inserted.second && n == head_impl(include_root_t::no);
+      if (!inserted.second)
+         return fork_db_add_t::duplicate;
+      const bool new_head = n == head_impl(include_root_t::no);
+      if (new_head && n->previous() == prev_head->id())
+         return fork_db_add_t::appended_to_head;
+      if (new_head)
+         return fork_db_add_t::fork_switch;
+
+      return fork_db_add_t::added;
    }
 
    template<class BSP>
-   bool fork_database_t<BSP>::add( const bsp_t& n, ignore_duplicate_t ignore_duplicate ) {
+   fork_db_add_t fork_database_t<BSP>::add( const bsp_t& n, ignore_duplicate_t ignore_duplicate ) {
       std::lock_guard g( my->mtx );
       return my->add_impl(n, ignore_duplicate, false,
                           [](block_timestamp_type         timestamp,
@@ -448,8 +459,8 @@ namespace eosio::chain {
    BSP fork_database_impl<BSP>::search_on_branch_impl( const block_id_type& h, uint32_t block_num, include_root_t include_root ) const {
       if (!root)
          return {};
-      if( include_root == include_root_t::yes && root->id() == h && root->block_num() == block_num ) {
-         return root;
+      if( include_root == include_root_t::yes && root->block_num() == block_num ) {
+         return root; // root is root of every branch, no need to check h
       }
       if (block_num <= root->block_num())
          return {};
@@ -582,7 +593,7 @@ namespace eosio::chain {
    template<class BSP>
    BSP fork_database_impl<BSP>::get_block_impl(const block_id_type& id,
                                                include_root_t include_root /* = include_root_t::no */) const {
-      if( include_root == include_root_t::yes && root->id() == id ) {
+      if( include_root == include_root_t::yes && root && root->id() == id ) {
          return root;
       }
       auto itr = index.find( id );

libraries/chain/controller.cpp

@@ -601,6 +601,7 @@ class apply_context {
       action_name get_sender() const;
 
       bool is_applying_block() const { return trx_context.explicit_billed_cpu_time; }
+      bool is_eos_vm_oc_whitelisted() const;
       bool should_use_eos_vm_oc()const;
 
    /// Fields:

libraries/chain/fork_database.cpp

@@ -96,6 +96,7 @@ namespace eosio::chain {
    using resource_limits::resource_limits_manager;
    using apply_handler = std::function<void(apply_context&)>;
 
+   enum class fork_db_add_t;
    using forked_callback_t = std::function<void(const transaction_metadata_ptr&)>;
 
    // lookup transaction_metadata via supplied function to avoid re-creation
@@ -155,6 +156,7 @@ namespace eosio::chain {
             wasm_interface::vm_type  wasm_runtime = chain::config::default_wasm_runtime;
             eosvmoc::config          eosvmoc_config;
             wasm_interface::vm_oc_enable eosvmoc_tierup     = wasm_interface::vm_oc_enable::oc_auto;
+            flat_set<account_name>   eos_vm_oc_whitelist_suffixes;
 
             db_read_mode             read_mode              = db_read_mode::HEAD;
             validation_mode          block_validation_mode  = validation_mode::FULL;
@@ -206,8 +208,8 @@ namespace eosio::chain {
           */
          deque<transaction_metadata_ptr> abort_block();
 
-         /// Expected to be called from signal handler
-         void interrupt_transaction();
+         /// Expected to be called from signal handler, or producer_plugin
+         void interrupt_apply_block_transaction();
 
        /**
         *
@@ -234,16 +236,17 @@ namespace eosio::chain {
          void set_async_aggregation(async_t val);
 
          struct accepted_block_result {
-            const bool is_new_best_head = false; // true if new best head
+            const fork_db_add_t add_result;
             std::optional<block_handle> block;   // empty optional if block is unlinkable
          };
          // thread-safe
          accepted_block_result accept_block( const block_id_type& id, const signed_block_ptr& b ) const;
 
          /// Apply any blocks that are ready from the fork_db
          enum class apply_blocks_result {
-            complete,  // all ready blocks in forkdb have been applied
-            incomplete // time limit reached, additional blocks may be available in forkdb to process
+            complete,   // all ready blocks in forkdb have been applied
+            incomplete, // time limit reached, additional blocks may be available in forkdb to process
+            paused      // apply blocks currently paused
          };
          apply_blocks_result apply_blocks(const forked_callback_t& cb, const trx_meta_cache_lookup& trx_lookup);
 
@@ -420,6 +423,8 @@ namespace eosio::chain {
 
          bool is_profiling(account_name name) const;
 
+         bool is_eos_vm_oc_whitelisted(const account_name& n) const;
+
          chain_id_type get_chain_id()const;
 
          // thread safe
@@ -473,7 +478,10 @@ namespace eosio::chain {
       void replace_account_keys( name account, name permission, const public_key_type& key );
 
       void set_producer_node(bool is_producer_node);
-      bool is_producer_node()const;
+      bool is_producer_node()const; // thread safe, set at program initialization
+
+      void set_pause_at_block_num(block_num_type block_num);
+      block_num_type get_pause_at_block_num()const;
 
       void set_db_read_only_mode();
       void unset_db_read_only_mode();

libraries/chain/include/eosio/chain/apply_context.hpp

@@ -141,10 +141,6 @@
        \
        virtual std::shared_ptr<fc::exception> dynamic_copy_exception()const\
        { return std::make_shared<TYPE>( *this ); } \
-       virtual NO_RETURN void     dynamic_rethrow_exception()const \
-       { if( code() == CODE ) throw *this;\
-         else fc::exception::dynamic_rethrow_exception(); \
-       } \
        std::optional<uint64_t> error_code; \
    };
 
@@ -394,6 +390,8 @@ namespace eosio { namespace chain {
                                     3080010, "Read-only transaction eos-vm-oc compile permanent failure" )
       FC_DECLARE_DERIVED_EXCEPTION( interrupt_exception, resource_exhausted_exception,
                                     3080011, "Transaction interrupted by signal" )
+      FC_DECLARE_DERIVED_EXCEPTION( interrupt_oc_exception, resource_exhausted_exception,
+                                    3080012, "Transaction interrupted by oc compile" )
 
    FC_DECLARE_DERIVED_EXCEPTION( authorization_exception, chain_exception,
                                  3090000, "Authorization exception" )
@@ -611,6 +609,8 @@ namespace eosio { namespace chain {
                                     3170015, "Invalid snapshot request" )
       FC_DECLARE_DERIVED_EXCEPTION( snapshot_execution_exception,  producer_exception,
                                     3170016, "Snapshot execution exception" )
+      FC_DECLARE_DERIVED_EXCEPTION( invalid_pause_at_block_request, producer_exception,
+                                    3170017, "Invalid pause at block request" )
 
    FC_DECLARE_DERIVED_EXCEPTION( reversible_blocks_exception,           chain_exception,
                                  3180000, "Reversible Blocks exception" )

libraries/chain/include/eosio/chain/controller.hpp

@@ -12,6 +12,13 @@ namespace eosio::chain {
    using block_branch_t = std::vector<signed_block_ptr>;
    enum class ignore_duplicate_t { no, yes };
    enum class include_root_t { no, yes };
+   enum class fork_db_add_t {
+      failure,            // add failed
+      duplicate,          // already added and ignore_duplicate=true
+      added,              // inserted into an existing branch or started a new branch, but not best branch
+      appended_to_head,   // new best head of current best branch; no fork switch
+      fork_switch         // new best head of new branch, fork switch to new branch
+   };
 
    // Used for logging of comparison values used for best fork determination
    std::string log_fork_comparison(const block_state& bs);
@@ -67,9 +74,11 @@ namespace eosio::chain {
       /**
        *  Add block state to fork database.
        *  Must link to existing block in fork database or the root.
-       *  @return true if n becomes the new best head (and was not the best head before)
+       *  @returns fork_db_add_t - result of the add
+       *  @throws unlinkable_block_exception - unlinkable to any branch
+       *  @throws fork_database_exception - no root, n is nullptr, protocol feature error, duplicate when ignore_duplicate=false
        */
-      bool add( const bsp_t& n, ignore_duplicate_t ignore_duplicate );
+      fork_db_add_t add( const bsp_t& n, ignore_duplicate_t ignore_duplicate );
 
       void remove( const block_id_type& id );
 
@@ -306,3 +315,6 @@ namespace eosio::chain {
       static constexpr uint32_t max_supported_version = 3;
    };
 } /// eosio::chain
+
+FC_REFLECT_ENUM( eosio::chain::fork_db_add_t,
+                 (failure)(duplicate)(added)(appended_to_head)(fork_switch) )

libraries/chain/include/eosio/chain/exceptions.hpp

@@ -110,6 +110,44 @@ namespace eosio::chain {
 
          return name{ result };
       }
+
+      /**
+       *  Returns the suffix.
+       *  for example:
+       *    "eosio.any" -> "any"
+       *    "eosio" -> "eosio"
+       */
+      constexpr name suffix() const {
+         uint32_t remaining_bits_after_last_actual_dot = 0;
+         uint32_t tmp                                  = 0;
+         for (int32_t remaining_bits = 59; remaining_bits >= 4; remaining_bits -= 5) { // Note: remaining_bits must remain signed integer
+            // Get characters one-by-one in name in order from left to right (not including the 13th character)
+            auto c = (value >> remaining_bits) & 0x1Full;
+            if (!c) { // if this character is a dot
+               tmp = static_cast<uint32_t>(remaining_bits);
+            } else { // if this character is not a dot
+               remaining_bits_after_last_actual_dot = tmp;
+            }
+         }
+
+         uint64_t thirteenth_character = value & 0x0Full;
+         if (thirteenth_character) { // if 13th character is not a dot
+            remaining_bits_after_last_actual_dot = tmp;
+         }
+
+         if (remaining_bits_after_last_actual_dot == 0) // there is no actual dot in the %name other than potentially leading dots
+            return name{ value };
+
+         // At this point remaining_bits_after_last_actual_dot has to be within the range of 4 to 59 (and restricted to
+         // increments of 5).
+
+         // Mask for remaining bits corresponding to characters after last actual dot, except for 4 least significant bits
+         // (corresponds to 13th character).
+         uint64_t mask  = (1ull << remaining_bits_after_last_actual_dot) - 16;
+         uint32_t shift = 64 - remaining_bits_after_last_actual_dot;
+
+         return name{ ((value & mask) << shift) + (thirteenth_character << (shift - 1)) };
+      }
    };
 
    // Each char of the string is encoded into 5-bit chunk and left-shifted