Segmentation fault when catching exceptions in a libpthread linked app ( linux, C++ )

Question

Hi

I have this piece of code here:

These are functions used to create and stop a pthread:

void WatchdogController::conscious_process_handler_start() {

    if ( debug ) cout << "WatchdogController: starting conscious process thread" << endl;

    cn_pr_thread_active = true;

    if ( pthread_create( &cn_pr_thread, NULL, conscious_process_handler, this ) < 0 ) {
     cn_pr_thread_active = false;
     throw WatchdogException( "Unable to start new thread" );
    }
}

void WatchdogController::conscious_process_handler_stop() {

    if ( debug ) cout << "WatchdogController: stopping conscious process thread" << endl;

    cn_pr_thread_active = false;

    int *retval;

    pthread_join( cn_pr_thread, ( void ** )&retval );

    if ( *retval < 0 ) {
     delete retval;
     string err = string( "Error returned by conscious_process_handler(): " ) + string( pthread_err );
     throw WatchdogException( err.c_str() );
    }

    delete retval;
}

I use select() in function passed to pthread, and when stopped it returns an error resulting in return value from pthread being negative, but that's not the issue, I'll fix it later - problem is, that when the exception is thrown here:

throw WatchdogException( err.c_str() );

and caught here:

try {
     watchdog_controller->hardware_watchdog_stop();
     watchdog_controller->unconscious_process_handler_stop();
     watchdog_controller->conscious_process_handler_stop();
    }
    catch ( HardwareWatchdogException &e ) {
     cerr << "Error stopping hardware watchdog!" << endl;
     cerr << e.get_reason() << endl;
     string err = string( "Exception thrown by hardware watchdog controller" ) + string( e.get_reason() );
     if ( log ) write_log( err.c_str() );
     delete watchdog_controller;
     return -1;
    }
    catch ( WatchdogException &e ) {
     cerr << "Exception cought when exiting!" << endl;
     cerr << e.get_reason() << endl;
     string err = string( "Exception cought when exiting" ) + string( e.get_reason() );
     if ( log ) write_log( err.c_str() );
     delete watchdog_controller;
     return -1;
    }

I get segmentation fault then trying to access the object at this point:

cerr << e.get_reason() << endl;

What could be the reason?

Reference &e points to something, but it seems as if the address was invalid.

Here's the exception class:

class WatchdogException {

    public:

     /**
      @brief  Default constructor
     */
     WatchdogException() : reason() {
     }

     /**
      @brief  Overloaded constructor - setting the error message
      @param  why   Error message
     */
     WatchdogException( const char *why ) : reason( why ) {
     }

     /**
      @brief  The destructor
     */
     virtual ~WatchdogException() {
     }

     /**
      @brief  A getter for the error message
      @return  Returns a string containing error description
     */
     virtual std::string get_reason() const {
      return reason;
     }

    protected:

     /**
      @var  reason  String containing the error message
     */
     std::string reason;

};

Answer 1

In WatchDogException's constructor, are you remembering the pointer to the c-string passed in or are you making a copy of it.

If you're simply storing the pointer then when "err" goes out of scope when the exception is thrown the pointer returned by c_str() will be bad, hence your seg fault when you try and use it.

Answer 2

I am guessing that you are not properly allocating memory for retval, or that somehow you are returning an invalid pointer from cn_pr_thread, and that is why you get a segmentation fault when you call pthread_join.