Fixed null pointer reference in executor

[casparcg] / common / executor.h

diff --git a/common/executor.h b/common/executor.h
index 28d3d3fb81bb10f8044a944bd95e25dbda4d4b42..e67a0afa708e8adb04a458ea2382efe52a158c3a 100644 (file)
--- a/common/executor.h
+++ b/common/executor.h
@@ -21,6 +21,7 @@
 
 #pragma once
 
+#include "os/general_protection_fault.h"
 #include "except.h"
 #include "log.h"
 #include "blocking_bounded_queue_adapter.h"
@@ -59,7 +60,8 @@ class executor final
        tbb::atomic<bool>                                                                                       is_running_;
        boost::thread                                                                                           thread_;        
        function_queue_t                                                                                        execution_queue_;
-               
+       tbb::atomic<bool>                                                                                       currently_in_task_;
+
 public:                
        executor(const std::wstring& name)
                : name_(name)
@@ -73,23 +75,32 @@ public:
                })
        {
                is_running_ = true;
+               currently_in_task_ = false;
                thread_ = boost::thread([this]{run();});
        }
        
        ~executor()
        {
+               CASPAR_LOG(debug) << L"Shutting down " << name_;
+
                try
                {
-                       internal_begin_invoke([=]
-                       {
-                               is_running_ = false;
-                       }).wait();
+                       if (is_running_)
+                               internal_begin_invoke([=]
+                               {
+                                       is_running_ = false;
+                               }).wait();
                }
                catch(...)
                {
                        CASPAR_LOG_CURRENT_EXCEPTION();
                }
                
+               join();
+       }
+
+       void join()
+       {
                thread_.join();
        }
 
@@ -160,7 +171,7 @@ public:
        {
                return execution_queue_.size(); 
        }
-               
+
        bool is_running() const
        {
                return is_running_; 
@@ -170,6 +181,16 @@ public:
        {
                return boost::this_thread::get_id() == thread_.get_id();
        }
+
+       bool is_currently_in_task() const
+       {
+               return currently_in_task_;
+       }
+
+       std::wstring name() const
+       {
+               return name_;
+       }
                
 private:       
 
@@ -218,7 +239,7 @@ private:
 
                if (!execution_queue_.try_push(priority, function))
                {
-                       CASPAR_LOG(debug) << print() << L" Overflow. Blocking caller.";
+                       CASPAR_LOG(warning) << print() << L" Overflow. Blocking caller.";
                        execution_queue_.push(priority, function);
                }
 
@@ -229,27 +250,47 @@ private:
                                function();
                        }
 
-                       return future.get();
+                       try
+                       {
+                               return future.get();
+                       }
+                       catch (const caspar_exception& e)
+                       {
+                               if (!is_current()) // Add context information from this thread before rethrowing.
+                               {
+                                       auto ctx_info = boost::get_error_info<context_info_t>(e);
+
+                                       if (ctx_info)
+                                               e << context_info(get_context() + *ctx_info);
+                                       else
+                                               e << context_info(get_context());
+                               }
+
+                               throw;
+                       }
                });
        }
 
        void run() // noexcept
        {
-               win32_exception::install_handler();             
+               ensure_gpf_handler_installed_for_thread(u8(name_).c_str());
                while(is_running_)
                {
                        try
                        {
                                std::function<void ()> func;
                                execution_queue_.pop(func);
+                               currently_in_task_ = true;
                                func();
                        }
                        catch(...)
                        {
                                CASPAR_LOG_CURRENT_EXCEPTION();
                        }
+
+                       currently_in_task_ = false;
                }
        }       
 };
 
-}
\ No newline at end of file
+}