Debug panico in Symbian OS utilizzando Carbide.c ++

Question

C'è un modo per entrare nel debugger quando qualsiasi di panico si verifica come se ci fosse un punto di interruzione?

sto usando Carbide.c ++ 2.3.0. Conosco i Configurazioni Debug> Eccezioni x86, ma copre solo una piccola frazione di quello che può realmente accadere in un'applicazione reale. Ad esempio, non panico utente trappola o panic ALLOC quando chiusura dell'applicazione con perdite di memoria.

Answer 1

Se si sta utilizzando l'emulatore, è possibile eseguire il debug panico attivando 'debug just-in-time. Questo viene fatto aggiungendo la seguente riga alla epoc32\data\epoc.ini:

JustInTime debug

Per maggiori dettagli, vedere la di riferimento epoc.ini nella documentazione di SDK .

Answer 2

Per quanto a mia conoscenza non può essere fatto.

Quello che ho fatto è semplice funzione dell'uso tracciare la logica in modo che quando un panico accade ho una traccia dello stack nel punto del panico nel mio codice di movimentazione di panico (che ho Esci). Questo metodo funziona bene tranne per il fatto che si deve ricordare di aggiungere le macro della all'inizio di ogni funzione.

per es.

#ifndef NDEBUG
class __FTrace
{
    __FTrace(const char* function)
    {
        TraceManager::GetInstance().EnterFunction(function);
    }
    ~__FTrace()
    {
        TraceManager::GetInstance().LeaveFunction(function);
    }
};    

#define FTRACE() __FTrace(__PRETTY_FUNCTION__)
#else
#define FTRACE()
#endif

void Func()
{
    FTRACE();
    ...
}

Per ALLOC di, ho avuto un sacco di successo con la Agganciare Logger sotto l'emulatore. E 'un vero e proprio dolore per l'installazione e l'uso, ma renderà più facile reale per rintracciare le perdite di memoria ALLOC.

UPDATE: Come richiesto, qui è che cosa la manipolazione mio panico sguardi codice come. Nota che la mia applicazione deve eseguire in background per tutto il tempo, quindi è l'installazione per riavviare l'applicazione quando succede qualcosa di brutto. Anche questo codice funziona per 3rd Edition SDK, non l'ho provato su versioni successive del SDK.

Il punto è quello di eseguire l'applicazione principale in un altro thread e quindi attendere che per uscire. Quindi controllare per vedere perché il thread, è il filo come uscito per ragioni sconosciute, roba di registro come il mio stack trace e riavviare l'applicazione.

TInt StartMainThread(TAny*)
    {
    FTRACE();
    __LOGSTR_TOFILE("Main Thread Start");
    TInt result(KErrNone);

    TRAPD(err, result = EikStart::RunApplication(NewApplication));

    if(KErrNone != err || KErrNone != result )
        {
        __LOGSTR_TOFILE("EikStart::RunApplication error: trap(%d), %d", err, result);
        }

    __LOGSTR_TOFILE("Main Thread End");
    return result;
    }

const TInt KMainThreadToLiveInSeconds = 10;

} // namespace *unnamed*

LOCAL_C CApaApplication* NewApplication()
    {
    FTRACE();
    return new CMainApplication;
    }


GLDEF_C TInt E32Main()
    {
#ifdef NDEBUG
    __LOGSTR_TOFILE("Application Start (release)");
#else   
    __LOGSTR_TOFILE("Application Start (debug)");
#endif  

#ifndef NO_TRACING
    __TraceManager::NewL();
#endif // !NO_TRACING

    RHeap& heap(User::Heap());
    TInt heapsize=heap.MaxLength();

    TInt exitReason(KErrNone);

    TTime timeToLive;
    timeToLive.UniversalTime();
    timeToLive += TTimeIntervalSeconds(KMainThreadToLiveInSeconds);

    LManagedHandle<RThread> mainThread;
    TInt err = mainThread->Create(_L("Main Thread"), StartMainThread, KDefaultStackSize, KMinHeapSize, heapsize, NULL);
    if (KErrNone != err) 
        {
        __LOGSTR_TOFILE("MainThread failed : %d", err);
        return err;
        }

    mainThread->SetPriority(EPriorityNormal);
    TRequestStatus status; 
    mainThread->Logon(status);

    mainThread->Resume();

    User::WaitForRequest(status);

    exitReason = mainThread->ExitReason();
TExitCategoryName category(mainThread->ExitCategory());

switch(mainThread->ExitType())
    {
    case EExitKill:
        __LOGSTR_TOFILE("ExitKill : (%S) : %d", &category, exitReason);
        break;

    case EExitTerminate:
        __LOGSTR_TOFILE("ExitTerminate : (%S) : %d", &category, exitReason);
        break;

    case EExitPanic:
        __LOGSTR_TOFILE("ExitPanic : (%S) : %d", &category, exitReason);
        break;

    default:
        __LOGSTR_TOFILE("ExitUnknown : (%S) : %d", &category, exitReason);
        break;
    }

#ifndef NO_TRACING
    __TraceManager::GetInstance().LogStackTrace();
#endif // NO_TRACING


    if( KErrNone != status.Int() )
        {
        TTime now;
        now.UniversalTime();

        if (timeToLive > now)
            {
            TTimeIntervalMicroSeconds diff = timeToLive.MicroSecondsFrom(now);
            __LOGSTR_TOFILE("Exiting due to TTL : (%Lu)", diff.Int64());
            }
        else
            {
            RProcess current;
            RProcess restart;
            err = restart.Create(current.FileName(), _L(""));
            if( KErrNone == err )
                {
                __LOGSTR_TOFILE("Restarting...");
                restart.Resume();
                return KErrNone;
                }
            else
                {
                __LOGSTR_TOFILE("Failed to start app: %d", err);
                }
            }
        }

    __LOGSTR_TOFILE("Application End");
    return exitReason;
    }