callback support for checktime timer expiry

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

@@ -1,6 +1,11 @@
 #pragma once
 #include <fc/time.hpp>
 #include <fc/fwd.hpp>
+#include <fc/scoped_exit.hpp>
+
+#include <eosio/chain/exceptions.hpp>
+
+#include <atomic>
 
 #include <signal.h>
 
@@ -13,12 +18,43 @@ struct platform_timer {
    void start(fc::time_point tp);
    void stop();
 
+   /* 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. Setting to nullptr disables any current set callback */
+   void set_expiration_callback(void(*func)(void*), void* user) {
+      bool expect_false = false;
+      while(!atomic_compare_exchange_strong(&_callback_variables_busy, &expect_false, true))
+         expect_false = false;
+      auto reset_busy = fc::make_scoped_exit([this]() {
+         _callback_variables_busy.store(false, std::memory_order_release);
+      });
+      EOS_ASSERT(!(func && _expiration_callback), misc_exception, "Setting a platform_timer callback when one already exists");
+
+      _expiration_callback = func;
+      _expiration_callback_data = user;
+   }
+
    volatile sig_atomic_t expired = 1;
 
 private:
    struct impl;
    constexpr static size_t fwd_size = 8;
    fc::fwd<impl,fwd_size> my;
+
+   void call_expiration_callback() {
+      bool expect_false = false;
+      if(atomic_compare_exchange_strong(&_callback_variables_busy, &expect_false, true)) {
+         void(*cb)(void*) = _expiration_callback;
+         void* cb_data = _expiration_callback_data;
+         _callback_variables_busy.store(false, std::memory_order_release);
+         if(cb)
+            cb(cb_data);
+      }
+   }
+
+   std::atomic_bool _callback_variables_busy = false;
+   void(*_expiration_callback)(void*) = nullptr;
+   void* _expiration_callback_data;
 };
 
 }}

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

@@ -16,6 +16,11 @@ namespace eosio { namespace chain {
          void start(fc::time_point tp);
          void stop();
 
+         /* 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);
+
          volatile sig_atomic_t& expired;
       private:
          platform_timer& _timer;
@@ -125,6 +130,8 @@ namespace eosio { namespace chain {
          int64_t                       billed_cpu_time_us = 0;
          bool                          explicit_billed_cpu_time = false;
 
+         transaction_checktime_timer   transaction_timer;
+
       private:
          bool                          is_initialized = false;
 
@@ -145,8 +152,6 @@ namespace eosio { namespace chain {
          fc::time_point                pseudo_start;
          fc::microseconds              billed_time;
          fc::microseconds              billing_timer_duration_limit;
-
-         transaction_checktime_timer   transaction_timer;
    };
 
 } }

libraries/chain/platform_timer_asio_fallback.cpp

@@ -76,6 +76,7 @@ void platform_timer::start(fc::time_point tp) {
          if(ec)
             return;
          expired = 1;
+         call_expiration_callback();
       });
    }
 }

libraries/chain/platform_timer_macos.cpp

@@ -47,8 +47,11 @@ platform_timer::platform_timer() {
             struct kevent64_s anEvent;
             int c = kevent64(kqueue_fd, NULL, 0, &anEvent, 1, 0, NULL);
 
-            if(c == 1 && anEvent.filter == EVFILT_TIMER)
-               *(sig_atomic_t*)(anEvent.udata) = 1;
+            if(c == 1 && anEvent.filter == EVFILT_TIMER) {
+               platform_timer* self = (platform_timer*)anEvent.udata;
+               self->expired = 1;
+               self->call_expiration_callback();
+            }
             else if(c == 1 && anEvent.filter == EVFILT_USER)
                return;
             else if(c == -1 && errno == EINTR)
@@ -86,7 +89,7 @@ void platform_timer::start(fc::time_point tp) {
       expired = 1;
    else {
       struct kevent64_s aTimerEvent;
-      EV_SET64(&aTimerEvent, my->timerid, EVFILT_TIMER, EV_ADD|EV_ENABLE|EV_ONESHOT, NOTE_USECONDS|NOTE_CRITICAL, (int)x.count(), (uint64_t)&expired, 0, 0);
+      EV_SET64(&aTimerEvent, my->timerid, EVFILT_TIMER, EV_ADD|EV_ENABLE|EV_ONESHOT, NOTE_USECONDS|NOTE_CRITICAL, (int)x.count(), (uint64_t)this, 0, 0);
 
       expired = 0;
       if(kevent64(kqueue_fd, &aTimerEvent, 1, NULL, 0, KEVENT_FLAG_IMMEDIATE, NULL) != 0)

libraries/chain/platform_timer_posix.cpp

@@ -16,7 +16,9 @@ struct platform_timer::impl {
    timer_t timerid;
 
    static void sig_handler(int, siginfo_t* si, void*) {
-      *(sig_atomic_t*)(si->si_value.sival_ptr) = 1;
+      platform_timer* self = (platform_timer*)si->si_value.sival_ptr;
+      self->expired = 1;
+      self->call_expiration_callback();
    }
 };
 
@@ -38,7 +40,7 @@ platform_timer::platform_timer() {
    struct sigevent se;
    se.sigev_notify = SIGEV_SIGNAL;
    se.sigev_signo = SIGRTMIN;
-   se.sigev_value.sival_ptr = (void*)&expired;
+   se.sigev_value.sival_ptr = (void*)this;
 
    FC_ASSERT(timer_create(CLOCK_REALTIME, &se, &my->timerid) == 0, "failed to create timer");
 

libraries/chain/transaction_context.cpp

@@ -34,8 +34,13 @@ namespace eosio { namespace chain {
       _timer.stop();
    }
 
+   void transaction_checktime_timer::set_expiration_callback(void(*func)(void*), void* user) {
+      _timer.set_expiration_callback(func, user);
+   }
+
    transaction_checktime_timer::~transaction_checktime_timer() {
       stop();
+      _timer.set_expiration_callback(nullptr, nullptr);
    }
 
    transaction_context::transaction_context( controller& c,
@@ -49,9 +54,9 @@ namespace eosio { namespace chain {
    ,undo_session()
    ,trace(std::make_shared<transaction_trace>())
    ,start(s)
+   ,transaction_timer(std::move(tmr))
    ,net_usage(trace->net_usage)
    ,pseudo_start(s)
-   ,transaction_timer(std::move(tmr))
    {
       if (!c.skip_db_sessions()) {
          undo_session = c.mutable_db().start_undo_session(true);