[1.0.2 -> main] P2P: Resolve on reconnect - Take 2

libraries/chain/controller.cpp

@@ -1142,8 +1142,19 @@ struct controller_impl {
  }
 
  bool fork_db_validated_block_exists( const block_id_type& id ) const {
+ return fork_db.apply<bool>([&](const auto& forkdb) {
+ auto bsp = forkdb.get_block(id);
+ return bsp ? bsp->is_valid() : false;
+ });
+ }
+
+ // precondition: claimed_id is either id, or an ancestor of id
+ // returns true if block `id`, or one of its ancestors not older than claimed_id, is found in fork_db
+ // and `is_valid()`
+ // ------------------------------------------------------------------------------------------------------
+ bool fork_db_validated_block_exists( const block_id_type& id, const block_id_type& claimed_id ) const {
  return fork_db.apply<bool>([&](const auto& forkdb) {
- return forkdb.validated_block_exists(id);
+ return forkdb.validated_block_exists(id, claimed_id);
  });
  }
 
@@ -4230,14 +4241,14 @@ struct controller_impl {
  if (use_thread_pool == use_thread_pool_t::yes && async_voting == async_t::yes) {
  boost::asio::post(thread_pool.get_executor(), [this, bsp=bsp]() {
  const auto& latest_qc_claim__block_ref = bsp->core.get_block_reference(bsp->core.latest_qc_claim().block_num);
- if (fork_db_validated_block_exists(latest_qc_claim__block_ref.block_id)) {
+ if (fork_db_validated_block_exists(bsp->previous(), latest_qc_claim__block_ref.block_id)) {
  create_and_send_vote_msg(bsp);
  }
  });
  } else {
  // bsp can be used directly instead of copy needed for post
  const auto& latest_qc_claim__block_ref = bsp->core.get_block_reference(bsp->core.latest_qc_claim().block_num);
- if (fork_db_validated_block_exists(latest_qc_claim__block_ref.block_id)) {
+ if (fork_db_validated_block_exists(bsp->previous(), latest_qc_claim__block_ref.block_id)) {
  create_and_send_vote_msg(bsp);
  }
  }

libraries/chain/fork_database.cpp

@@ -99,7 +99,7 @@ namespace eosio::chain {
 
  bsp_t get_block_impl( const block_id_type& id, include_root_t include_root = include_root_t::no ) const;
  bool block_exists_impl( const block_id_type& id ) const;
- bool validated_block_exists_impl( const block_id_type& id ) const;
+ bool validated_block_exists_impl( const block_id_type& id, const block_id_type& claimed_id ) const;
  void reset_root_impl( const bsp_t& root_bs );
  void advance_root_impl( const block_id_type& id );
  void remove_impl( const block_id_type& id );
@@ -603,15 +603,30 @@ namespace eosio::chain {
  }
 
  template<class BSP>
- bool fork_database_t<BSP>::validated_block_exists(const block_id_type& id) const {
+ bool fork_database_t<BSP>::validated_block_exists(const block_id_type& id, const block_id_type& claimed_id) const {
  std::lock_guard g( my->mtx );
- return my->validated_block_exists_impl(id);
+ return my->validated_block_exists_impl(id, claimed_id);
  }
 
+ // precondition: claimed_id is either id, or an ancestor of id
+ // returns true if block `id`, or one of its ancestors not older than claimed_id, is found in fork_db
+ // and `is_valid()`.
+ // ------------------------------------------------------------------------------------------------------
  template<class BSP>
- bool fork_database_impl<BSP>::validated_block_exists_impl(const block_id_type& id) const {
- auto itr = index.find( id );
- return itr != index.end() && (*itr)->is_valid();
+ bool fork_database_impl<BSP>::validated_block_exists_impl(const block_id_type& id, const block_id_type& claimed_id) const {
+ bool id_present = false;
+
+ for (auto i = index.find(id); i != index.end(); i = index.find((*i)->previous())) {
+ id_present = true;
+ if ((*i)->is_valid())
+ return true;
+ if ((*i)->id() == claimed_id)
+ return false;
+ }
+
+ // if we return `true`, let's validate the precondition and make sure claimed_id is not in another branch
+ assert(!id_present || block_header::num_from_id(claimed_id) <= block_header::num_from_id(root->id()));
+ return id_present || id == root->id();
  }
 
 // ------------------ fork_database -------------------------

libraries/chain/include/eosio/chain/block_state.hpp

@@ -87,8 +87,6 @@ struct block_state : public block_header_state { // block_header_state provi
  std::optional<digest_type> base_digest; // For finality_data sent to SHiP, computed on demand in get_finality_data()
 
  // ------ private methods -----------------------------------------------------------
- void set_valid(bool v) { validated.store(v); }
- bool is_valid() const { return validated.load(); }
  bool is_pub_keys_recovered() const { return pub_keys_recovered; }
  deque<transaction_metadata_ptr> extract_trxs_metas();
  void set_trxs_metas(deque<transaction_metadata_ptr>&& trxs_metas, bool keys_recovered);
@@ -97,9 +95,9 @@ struct block_state : public block_header_state { // block_header_state provi
  friend struct test_block_state_accessor;
  friend struct fc::reflector<block_state>;
  friend struct controller_impl;
- template <typename BS> friend struct fork_database_impl;
  friend struct completed_block;
  friend struct building_block;
+
 public:
  // ------ functions -----------------------------------------------------------------
  const block_id_type& id() const { return block_header_state::id(); }
@@ -115,6 +113,9 @@ struct block_state : public block_header_state { // block_header_state provi
  uint32_t latest_qc_block_num() const { return core.latest_qc_claim().block_num; }
  block_timestamp_type latest_qc_block_timestamp() const { return core.latest_qc_block_timestamp(); }
 
+ void set_valid(bool v) { validated.store(v); }
+ bool is_valid() const { return validated.load(); }
+
  std::optional<qc_t> get_best_qc() const { return aggregating_qc.get_best_qc(block_num()); } // thread safe
  bool received_qc_is_strong() const { return aggregating_qc.received_qc_is_strong(); } // thread safe
  // return true if better qc, thread safe

libraries/chain/include/eosio/chain/block_state_legacy.hpp

@@ -51,20 +51,17 @@ namespace eosio::chain {
  const producer_authority_schedule* pending_schedule_auth() const { return &block_header_state_legacy::pending_schedule.schedule; }
  const deque<transaction_metadata_ptr>& trxs_metas() const { return _cached_trxs; }
 
-
+ void set_valid(bool v) { validated.store(v); }
+ bool is_valid() const { return validated.load(); }
+
  using fork_db_block_state_accessor_t = block_state_legacy_accessor;
+
  private: // internal use only, not thread safe
- friend struct block_state_legacy_accessor;
  friend struct fc::reflector<block_state_legacy>;
  friend struct controller_impl;
- template <typename BS> friend struct fork_database_impl;
  friend struct completed_block;
  friend struct block_state;
 
- // not thread safe, expected to only be called from main thread
- void set_valid(bool v) { validated = v; }
- bool is_valid() const { return validated; }
-
  bool is_pub_keys_recovered()const { return _pub_keys_recovered; }
 
  deque<transaction_metadata_ptr> extract_trxs_metas() {
@@ -78,7 +75,7 @@ namespace eosio::chain {
  _cached_trxs = std::move( trxs_metas );
  }
 
- bool  validated = false;
+ copyable_atomic<bool> validated{false};
 
  bool _pub_keys_recovered = false;
  /// this data is redundant with the data stored in block, but facilitates

libraries/chain/include/eosio/chain/fork_database.hpp

@@ -51,7 +51,7 @@ namespace eosio::chain {
 
  bsp_t get_block( const block_id_type& id, include_root_t include_root = include_root_t::no ) const;
  bool block_exists( const block_id_type& id ) const;
- bool validated_block_exists( const block_id_type& id ) const;
+ bool validated_block_exists( const block_id_type& id, const block_id_type& claimed_id ) const;
 
  /**
  * Purges any existing blocks from the fork database and resets the root block_header_state to the provided value.

libraries/chain/webassembly/runtimes/eos-vm-oc/executor.cpp

@@ -139,10 +139,6 @@ executor::executor(const code_cache_base& cc) {
  //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. EOS 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);