Qt World Summit: Submit your Presentation

Segmentation fault SIGSEGV, what can it be?

  • Lifetime Qt Champion

    What happens if you remove device->rfPower4x1.clear();?

  • Then, the error occurs consequently at "device->rfPower4x1.append( data );"...

  • Lifetime Qt Champion

    Silly question, but did you properly initialize device ? Is it deleted somewhere ?

  • Hi SGaist, no, it's not a silly question, but the answer could, potentially, lead to a silly answer. ;)

    The device was dynamically initialized with "new" and works fine to all other aspects. So private data is happily accessed in read and write operations as well as method calls. The device is used without problems before and after the questionable calls to the rfPower4x1 field. Also the subobjects are working fine, its just this QByteArray...


  • Hi, back to the multithreading again. I figured, that indeed the data I am processing comes back asynchronously. So the data is transferred using "emit" into a signal / function. But from there, I just access the device object which works fine for all other data. Now, all threads of my application share the same memory map, don't they? And device as wenn as the rfPower4x1 are dynamically reserved, so they are on the heap? That's why I don't see a problem in there, am I right with my suggestion?

    Then, maybe I can get some closer to a solution wondering would be the situation if I don't use dynamic memory but us the objects directly instead? Aren't they then placed on the stack? How do different threads then find where the object is, without getting confused by various heights that the stack can have?

    Regards, Stephan

  • Lifetime Qt Champion

    Can you share your code ?

    Where are you accessing device ? Where is it allocated ?

  • Sure, its only rather complex already and I don't really see how to strip it down as it involves communication with an external device...

    The definition for the device pointer is in the mainwindow.h:

    ...    wbstlDevice *device;
        QByteArray tmpBuffer, rfPower4x1;
        QString fl7TextBuffer;

    The instantiation is in the constructor for the mainwindow.cpp:

    MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) {
        device  = new wbstlDevice( this );

    I use dynamic instantiation to allow the device having access back to the window via the pointer.

    Then wbstlDevice is defined like this:

    #ifndef WBSTLDEVICE_H
    #define WBSTLDEVICE_H
    #include <QObject>
    #include <QByteArray>
    #include <QString>
    class wbstlDevice {
        wbstlDevice( QObject *parent = 0 );
        virtual ~wbstlDevice();
        void reset();
        bool convert2IdTo3Id( unsigned char devketId, unsigned char rfId );
        bool isInitialized();
        bool initDevice();
        bool supportsFpSync();
        bool supportsClockCorrection();
        bool usesTestTone();
        bool usesTestMode();
        bool needsTestMode4TransmissionTest();
        bool canUseTestTone();
        virtual void addRFPower4X1( QByteArray data );
        virtual unsigned int convertSvcCmdIdToCmdInt( unsigned int svcCmd );
        virtual unsigned int getChannelFreqMHz( unsigned int channel );
        virtual unsigned int rfPower4x1Length(); // returns length in indices! One index contains 6 bytes / 12 nibbles
        bool isRfPower4x1Valid();
        QString convertSvcCmdIdToCmdStr( unsigned int svcCmd );
        unsigned int convertCmdIdToSvcCmd( unsigned int rawCmd );
        unsigned int convertCmdStrToSvcCmd( QString cmdStr );
        QString getSWVersionStr();
        void setSWVersion( QByteArray data );
        char getAdaptivePower();
        bool deviceNameChanged, serialIDChanged, autoLockChanged, pairingChanged, identifyChanged, walktestChanged, debugScreenChanged;
        bool initialized, testMode, validEEVersion, needsDectModeCorrection;
        char deviceId, marketId, rfId, devketId, fpSync;
        char swVersion[ 3 ];
        QString errorString;
        int freqStart, freqStep, freqCount;
        wbstlDevice *currentDevice, *deviceSRX1G9, *deviceSRX2G4, *devicePRX1G9, *devicePTX1G9, *devicePTX2G4;
        QByteArray rfPower4x1;
    #endif // WBSTLDEVICE_H

    As I said for simplification I do access the rfPower4x1 field directly (public). The method "isRfPower4x1Valid" is defined like this:

    bool wbstlDevice::isRfPower4x1Valid() {
        bool ret = true;
        int idx1, idx2, sum, expLength;
        expLength = ( currentDevice->rfPower4x1Length() * WbstlConst::RF_POWER_4X1_INDEX_LENGTH );
        if ( rfPower4x1.length() != expLength )
            ret = false;
        idx1 = 0;
        while ( idx1 < expLength ) {
            sum = 0;
            for ( idx2 = 0; idx2 < WbstlConst::RF_POWER_4X1_INDEX_LENGTH; idx1++, idx2++ )
                sum += rfPower4x1.at( idx1 );
            if ( ( sum == 0x00 ) || ( sum == 0xFF ) )
                ret = false;
        return ret;

    And in the mainwindow is did like this:

            device->rfPower4x1.append( data );
            appendLog( ants::printHex( device->rfPower4x1 ) );
            appendLog( QString( "%1" ).arg( device->rfPower4x1.length() ) );
            if ( device->isRfPower4x1Valid() )
                appendLog( "RF power 4x1:          ok" );
                appendLog( QString( "RF power 4x1 contains some errors: %1" ).arg( ants::printHex( data ) ) );

    Even rfPower4x1 is statically instantiated, I get the SIGSEGV only when I clear the array... any more ideas?


  • Lifetime Qt Champion

    "I use dynamic instantiation to allow the device having access back to the window via the pointer" - no need for dynamic allocation. Do:

    MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow), wbstlDevice( this )

    In general, Device should not know anything about MainWindow - else it is bad design. If you need to communicate from Device to MainWindow you should emit signals in Device which MainWindow connects to own slots. This way Device does not care about MainWindow implementation (if you change something in MainWindow you do not have to change Device).

  • @jsulm Ok, I am aware that there is some redesign suitable. Also with respect to the device and the sub-class structure. But does this helps us with regard to the segmentation fault? I was planning to do that in a refactoring session some time down the line, but if you think that it is essential for the function I would have to reschedule...?


  • Lifetime Qt Champion

    You could try to change wbstlDevice to an instance variable instead of pointer and see whether is still crashes.

  • The few lines of code you shown so far didn't seem to have any error.
    As you where talking about asynchronus data filling this error may be thread-related.
    How is the method in MainWindow called that deals with device ?

  • @jsulm I have made it an object member instead of a pointer now. Did the same to the "device" object which was a pointer before but which - I think - doesn't have much to do with it.

    Anyway, both did not show any effect. I also added some initial data to the QByteArray in the constructor - this data is still there (the debugger shows it) when I want to add more data. Even, now I only add one more static byte - just to try it. Still I receive the segmentation fault...

    No more ideas, anyone else?


  • @Gerd Well, the object "device" is basically used everywhere in the mainwindow class as it holds some information used in a lot of cases. For the specific method I do call a slot using a signal, then its a method of the mainwindow and that has direct access to "device". As this holds the QByteArray I can access it without any (compiler) problems, but I get the segmentation fault...


  • As you are talking about multithreading did you try to use a queued connection when connecting the involved Signals/Slots?

  • Hi, me again...

    I have run a quick test... removed the line of

    device.rfPower4x1.append( 0x74 );


    device.appendRfPower4x1( 0x74 );

    Now, obviously I had to introduce this method like this:

    void wbstlDevice::appendRfPower4x1(char data) {
        rfPower4x1.append( data );

    The result is, that I still get a segmentation fault but this occurs actually a few lines further down - things that were working fine before??? I feels to me like there is some issue with thread safety, threads in general I am not completely aware off. Does that ring a bell for anyone?


  • Could it be a problem in general, that I use "device" as a member variable of the "mainwindow" after I have connected one method of "mainwindow" to another? Now I tried both, to use "device" as a member variable and as an argument that I have transferred via the emit call. So there is multithreading coming into place, is there anything behind I haven't considered yet?


  • Look two posts above....

  • @Gerd Right, I still had this on my list to try it out... I have now changed the "connect" to this:

        connect( this,                      SIGNAL( rcvProdTestFromCOM( QString, QByteArray ) ),  this, SLOT( rcvProdTestFromCOMSlot( QString, QByteArray ) ), Qt::QueuedConnection );

    From my perspective that's all I have to do to make it queued, right? Nothing else to change in the definitions for signals or slots?

    Tried this out: Same effect, still get a segmentation fault... :-(

    Can somebody confirm if there is any issue behind I may have overseen when using the SAME object in the code BEFORE calling EMIT and in the code of the SLOT?


  • Moderators

    This post is deleted!

  • Hi, i was experiencing the same strange thing... i was using Qt headers and non Qt headers, and placing before the Qt headers seemed to have solved the problem.