Merge branch 'main' into GH-1091-block-nack

Author: heifner

libraries/chain/controller.cpp

@@ -3078,8 +3078,10 @@ struct controller_impl {
             } else {
                transaction_receipt_header r;
                r.status = transaction_receipt::executed;
-               r.cpu_usage_us = trx_context.billed_cpu_time_us;
-               r.net_usage_words = trace->net_usage / 8;
+               if (!trx->is_read_only()) {
+                  r.cpu_usage_us = trx_context.billed_cpu_time_us;
+                  r.net_usage_words = trace->net_usage / 8;
+               }
                trace->receipt = r;
             }
 
@@ -4533,7 +4535,7 @@ struct controller_impl {
       // validated.
       if (applying_block) {
          ilog("Interrupting apply block");
-         main_thread_timer.expire_now();
+         main_thread_timer.interrupt_timer();
       }
    }
 

libraries/chain/include/eosio/chain/platform_timer.hpp

@@ -7,8 +7,6 @@
 
 #include <atomic>
 
-#include <signal.h>
-
 namespace eosio { namespace chain {
 
 struct platform_timer {
@@ -17,7 +15,7 @@ struct platform_timer {
 
    void start(fc::time_point tp);
    void stop();
-   void expire_now();
+   void interrupt_timer();
 
    /* Sets a callback for when timer expires. Be aware this could might fire from a signal handling context and/or
       on any particular thread. Only a single callback can be registered at once; trying to register more will
@@ -35,9 +33,19 @@ struct platform_timer {
       _expiration_callback_data = user;
    }
 
-   std::atomic_bool expired = true;
+   enum class state_t {
+      running,
+      timed_out,
+      interrupted,
+      stopped
+   };
+   state_t timer_state() const { return _state; }
 
 private:
+   void expire_now();
+
+   std::atomic<state_t> _state = state_t::stopped;
+
    struct impl;
    constexpr static size_t fwd_size = 8;
    fc::fwd<impl,fwd_size> my;

libraries/chain/include/eosio/chain/transaction_context.hpp

@@ -20,12 +20,13 @@ namespace eosio::chain {
          void start(fc::time_point tp);
          void stop();
 
+         platform_timer::state_t timer_state() const { return _timer.timer_state(); }
+
          /* Sets a callback for when timer expires. Be aware this could might fire from a signal handling context and/or
             on any particular thread. Only a single callback can be registered at once; trying to register more will
             result in an exception. Use nullptr to disable a previously set callback. */
          void set_expiration_callback(void(*func)(void*), void* user);
 
-         std::atomic_bool& expired;
       private:
          platform_timer& _timer;
 

libraries/chain/include/eosio/chain/wasm_interface_private.hpp

@@ -125,7 +125,7 @@ struct eosvmoc_tier {
                if (executing_code_hash.load() == code_id) {
                   ilog("EOS VM OC tier up interrupting ${id}", ("id", code_id));
                   eos_vm_oc_compile_interrupt = true;
-                  main_thread_timer.expire_now();
+                  main_thread_timer.interrupt_timer();
                }
             });
          }
@@ -148,10 +148,6 @@ struct eosvmoc_tier {
                m.whitelisted = context.is_eos_vm_oc_whitelisted();
                m.high_priority = m.whitelisted && context.is_applying_block();
                m.write_window = context.control.is_write_window();
-               auto timer_pause = fc::make_scoped_exit([&](){
-                  context.trx_context.resume_billing_timer();
-               });
-               context.trx_context.pause_billing_timer();
                cd = eosvmoc->cc.get_descriptor_for_code(m, code_hash, vm_version, failure);
             } catch (...) {
                // swallow errors here, if EOS VM OC has gone in to the weeds we shouldn't bail: continue to try and run baseline
@@ -181,7 +177,7 @@ struct eosvmoc_tier {
          try {
             get_instantiated_module(code_hash, vm_type, vm_version, context.trx_context)->apply(context);
          } catch (const interrupt_exception& e) {
-            if (allow_oc_interrupt && eos_vm_oc_compile_interrupt) {
+            if (allow_oc_interrupt && eos_vm_oc_compile_interrupt && main_thread_timer.timer_state() == platform_timer::state_t::interrupted) {
                ++eos_vm_oc_compile_interrupt_count;
                dlog("EOS VM OC compile complete interrupt of ${r} <= ${a}::${act} code ${h}, interrupt #${c}",
                     ("r", context.get_receiver())("a", context.get_action().account)

libraries/chain/platform_timer_accuracy.cpp

@@ -39,9 +39,10 @@ void compute_and_print_timer_accuracy(platform_timer& timer) {
       for(unsigned int i = 0; i < loops; ++i) {
          auto start = std::chrono::high_resolution_clock::now();
          timer.start(fc::time_point(fc::time_point::now().time_since_epoch() + fc::microseconds(interval)));
-         while(!timer.expired) {}
+         while(timer.timer_state() == platform_timer::state_t::running) {}
          auto end = std::chrono::high_resolution_clock::now();
          int timer_slop = std::chrono::duration_cast<std::chrono::microseconds>(end-start).count() - interval;
+         timer.stop();
 
          //since more samples are run for the shorter expirations, weigh the longer expirations accordingly. This
          //helps to make a few results more fair. Two such examples: AWS c4&i5 xen instances being rather stable

libraries/chain/platform_timer_asio_fallback.cpp

@@ -57,14 +57,14 @@ platform_timer::~platform_timer() {
 
 void platform_timer::start(fc::time_point tp) {
    if(tp == fc::time_point::maximum()) {
-      expired = false;
+      _state = state_t::running;
       return;
    }
    fc::microseconds x = tp.time_since_epoch() - fc::time_point::now().time_since_epoch();
    if(x.count() <= 0)
-      expired = true;
+      _state = state_t::timed_out;
    else {
-      expired = false;
+      _state = state_t::running;
       my->timer->expires_after(std::chrono::microseconds(x.count()));
       my->timer->async_wait([this](const boost::system::error_code& ec) {
          if(ec)
@@ -75,18 +75,25 @@ void platform_timer::start(fc::time_point tp) {
 }
 
 void platform_timer::expire_now() {
-   bool expected = false;
-   if (expired.compare_exchange_strong(expected, true)) {
+   state_t expected = state_t::running;
+   if (_state.compare_exchange_strong(expected, state_t::timed_out)) {
+      call_expiration_callback();
+   }
+}
+
+void platform_timer::interrupt_timer() {
+   state_t expected = state_t::running;
+   if (_state.compare_exchange_strong(expected, state_t::interrupted)) {
       call_expiration_callback();
    }
 }
 
 void platform_timer::stop() {
-   if(expired)
+   if(_state == state_t::stopped)
       return;
 
    my->timer->cancel();
-   expired = true;
+   _state = state_t::stopped;
 }
 
 }}

libraries/chain/platform_timer_kqueue.cpp

@@ -106,20 +106,27 @@ void platform_timer::start(fc::time_point tp) {
 }
 
 void platform_timer::expire_now() {
-   bool expected = false;
-   if (expired.compare_exchange_strong(expected, true)) {
+   state_t expected = state_t::running;
+   if (_state.compare_exchange_strong(expected, state_t::timed_out)) {
+      call_expiration_callback();
+   }
+}
+
+void platform_timer::interrupt_timer() {
+   state_t expected = state_t::running;
+   if (_state.compare_exchange_strong(expected, state_t::interrupted)) {
       call_expiration_callback();
    }
 }
 
 void platform_timer::stop() {
-   if(expired)
+   if(_state == state_t::stopped)
       return;
 
    struct kevent64_s stop_timer_event;
    EV_SET64(&stop_timer_event, my->timerid, EVFILT_TIMER, EV_DELETE, 0, 0, 0, 0, 0);
    kevent64(kqueue_fd, &stop_timer_event, 1, NULL, 0, KEVENT_FLAG_IMMEDIATE, NULL);
-   expired = true;
+   _state = state_t::stopped;
 }
 
 }}

libraries/chain/platform_timer_posix.cpp

@@ -55,36 +55,44 @@ platform_timer::~platform_timer() {
 }
 
 void platform_timer::start(fc::time_point tp) {
+   assert(_state == state_t::stopped);
    if(tp == fc::time_point::maximum()) {
-      expired = false;
+      _state = state_t::running;
       return;
    }
    fc::microseconds x = tp.time_since_epoch() - fc::time_point::now().time_since_epoch();
    if(x.count() <= 0)
-      expired = true;
+      _state = state_t::timed_out;
    else {
       time_t secs = x.count() / 1000000;
       long nsec = (x.count() - (secs*1000000)) * 1000;
       struct itimerspec enable = {{0, 0}, {secs, nsec}};
-      expired = false;
+      _state = state_t::running;
       if(timer_settime(my->timerid, 0, &enable, NULL) != 0)
-         expired = true;
+         _state = state_t::timed_out;
    }
 }
 
 void platform_timer::expire_now() {
-   bool expected = false;
-   if (expired.compare_exchange_strong(expected, true)) {
+   state_t expected = state_t::running;
+   if (_state.compare_exchange_strong(expected, state_t::timed_out)) {
+      call_expiration_callback();
+   }
+}
+
+void platform_timer::interrupt_timer() {
+   state_t expected = state_t::running;
+   if (_state.compare_exchange_strong(expected, state_t::interrupted)) {
       call_expiration_callback();
    }
 }
 
 void platform_timer::stop() {
-   if(expired)
+   if(_state == state_t::stopped)
       return;
    struct itimerspec disable = {{0, 0}, {0, 0}};
    timer_settime(my->timerid, 0, &disable, NULL);
-   expired = true;
+   _state = state_t::stopped;
 }
 
 }

libraries/chain/transaction_context.cpp

@@ -14,8 +14,7 @@
 namespace eosio::chain {
 
    transaction_checktime_timer::transaction_checktime_timer(platform_timer& timer)
-         : expired(timer.expired), _timer(timer) {
-      expired = 0;
+         : _timer(timer) {
    }
 
    void transaction_checktime_timer::start(fc::time_point tp) {
@@ -441,10 +440,12 @@ namespace eosio::chain {
    void transaction_context::squash() {
       if (undo_session) undo_session->squash();
       control.apply_trx_block_context(trx_blk_context);
+      transaction_timer.stop();
    }
 
    void transaction_context::undo() {
       if (undo_session) undo_session->undo();
+      transaction_timer.stop();
    }
 
    void transaction_context::check_net_usage()const {
@@ -489,11 +490,12 @@ namespace eosio::chain {
    }
 
    void transaction_context::checktime()const {
-      if(BOOST_LIKELY(transaction_timer.expired == false))
+      platform_timer::state_t expired = transaction_timer.timer_state();
+      if(BOOST_LIKELY(expired == platform_timer::state_t::running))
          return;
 
       auto now = fc::time_point::now();
-      if (explicit_billed_cpu_time && block_deadline > now) {
+      if (expired == platform_timer::state_t::interrupted) {
          EOS_THROW( interrupt_exception, "interrupt signaled, ran ${bt}us, start ${s}",
                     ("bt", now - pseudo_start)("s", start) );
       } else if( explicit_billed_cpu_time || deadline_exception_code == deadline_exception::code_value ) {

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

@@ -29,7 +29,8 @@ namespace {
         guard(transaction_checktime_timer& timer, F&& func)
            : _timer(timer), _func(std::forward<F>(func)) {
            _timer.set_expiration_callback(&callback, this);
-           if(_timer.expired) {
+           platform_timer::state_t expired = _timer.timer_state();
+           if(expired == platform_timer::state_t::timed_out || expired == platform_timer::state_t::interrupted) {
               _func(); // it's harmless if _func is invoked twice
            }
         }

libraries/eos-vm

@@ -3410,7 +3410,6 @@ namespace eosio {
       peer_fork_db_head_block_num = msg.fork_db_head_num;
       fc::unique_lock g_conn( conn_mtx );
       last_handshake_recv = msg;
-      auto c_time = last_handshake_sent.time;
       g_conn.unlock();
 
       set_state(connection_state::connected);
@@ -3452,35 +3451,7 @@ namespace eosio {
                fc::unique_lock g_check_conn( check->conn_mtx );
                fc_dlog( logger, "dup check: connected ${c}, ${l} =? ${r}",
                         ("c", check->connected())("l", check->last_handshake_recv.node_id)("r", msg.node_id) );
-               if(check->connected() && check->last_handshake_recv.node_id == msg.node_id) {
-                  if (net_version < proto_dup_goaway_resolution || msg.network_version < proto_dup_goaway_resolution) {
-                     // It's possible that both peers could arrive here at relatively the same time, so
-                     // we need to avoid the case where they would both tell a different connection to go away.
-                     // Using the sum of the initial handshake times of the two connections, we will
-                     // arbitrarily (but consistently between the two peers) keep one of them.
-
-                     auto check_time = check->last_handshake_sent.time + check->last_handshake_recv.time;
-                     g_check_conn.unlock();
-                     if (msg.time + c_time <= check_time)
-                        return false;
-                  } else if (net_version < proto_dup_node_id_goaway || msg.network_version < proto_dup_node_id_goaway) {
-                     if (listen_address < msg.p2p_address) {
-                        fc_dlog( logger, "listen_address '${lhs}' < msg.p2p_address '${rhs}'",
-                                 ("lhs", listen_address)( "rhs", msg.p2p_address ) );
-                        // only the connection from lower p2p_address to higher p2p_address will be considered as a duplicate,
-                        // so there is no chance for both connections to be closed
-                        return false;
-                     }
-                  } else if (my_impl->node_id < msg.node_id) {
-                     fc_dlog( logger, "not duplicate, my_impl->node_id '${lhs}' < msg.node_id '${rhs}'",
-                              ("lhs", my_impl->node_id)("rhs", msg.node_id) );
-                     // only the connection from lower node_id to higher node_id will be considered as a duplicate,
-                     // so there is no chance for both connections to be closed
-                     return false;
-                  }
-                  return true;
-               }
-               return false;
+               return check->connected() && check->last_handshake_recv.node_id == msg.node_id;
             };
             if (my_impl->connections.any_of_connections(std::move(is_duplicate))) {
                peer_dlog( this, "sending go_away duplicate, msg.p2p_address: ${add}", ("add", msg.p2p_address) );

plugins/net_plugin/net_plugin.cpp

@@ -44,6 +44,39 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/Error"
+  /producer/pause_at_block:
+    post:
+      summary: pause_at_block
+      description: |
+        Pause node at the specified block. Use /producer/resume to un-pause. If specified block is less than head then returns an error.
+        
+        ### Usage
+        
+        Note that this pauses all nodes not just producer nodes. The common use case is to use on non-producer nodes as a way of freezing state. For example, a user might wish to download all the rows of a table. This would allow the user to freeze at a block number and then iterate through an entire table.
+      operationId: pause_at_block
+      requestBody:
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                block_num:
+                  type: integer
+                  description: Block number
+                  example: 5102
+      responses:
+        "201":
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/OK"
+        "400":
+          description: client error
+          content:
+            application/json:
+              schema:
+                $ref: "#/components/schemas/Error"
   /producer/resume:
     post:
       summary: resume

plugins/producer_api_plugin/producer.swagger.yaml

@@ -119,10 +119,9 @@ void producer_api_plugin::plugin_startup() {
    app().get_plugin<http_plugin>().add_api({
        CALL_WITH_400(producer, producer_rw, producer, pause,
             INVOKE_V_V(producer, pause), 201),
-      // TODO: Enable for Spring 2.0.0
-      // CALL_WITH_400(producer, producer_rw, producer, pause_at_block,
-      //       INVOKE_V_R(producer, pause_at_block, producer_plugin::pause_at_block_params), 201),
-      CALL_WITH_400(producer, producer_rw, producer, resume,
+       CALL_WITH_400(producer, producer_rw, producer, pause_at_block,
+            INVOKE_V_R(producer, pause_at_block, producer_plugin::pause_at_block_params), 201),
+       CALL_WITH_400(producer, producer_rw, producer, resume,
             INVOKE_V_V(producer, resume), 201),
        CALL_WITH_400(producer, producer_rw, producer, update_runtime_options,
             INVOKE_V_R(producer, update_runtime_options, producer_plugin::runtime_options), 201),