Wie kann ich die Pause auf UBSan Berichte in gdb, und weiter?

Neueren Versionen von GCC und Clang-Funktion Undefined Behavior Sanitizer (UBSan) das ist ein compile-flag (-fsanitize=undefined) fügt hinzu, dass Laufzeit-Instrumentierung von code. Auf Fehler, eine Warnung wie diese angezeigt:

packet-ber.c:1917:23: runtime error: Links-shift von 54645397829836991 von 8 stellen dargestellt werden können Typ 'long int'

Nun würde ich gerne Debuggen und erhalten Sie einen debug-break auf der besagten Linie. Für Address Sanitizer (ASAN) es ist ASAN_OPTIONS=abort_on_error=1 die Ergebnisse in ein fataler Fehler, abfangbar. Den nur UBSan option, die scheint brauchbar ist UBSAN_OPTIONS=print_stacktrace=1 die Ergebnisse in einem call-trace-dump für die Berichte. Dies ist jedoch nicht erlauben, mich zu inspizieren die lokalen Variablen und dann das Programm fortzusetzen. Verwendung von -fsanitize-undefined-trap-on-error daher nicht möglich.

Wie soll ich eine Pause in gdb auf UBSan berichten? Während break __sanitizer::SharedPrintfCode scheint zu funktionieren, der name sieht ganz interne.

Ich denke, dass, bis eine API implementiert und dokumentiert sind, ein guter Weg, um zu fangen, einen Aufruf an die UBSan runtime-Bibliothek, mit der Absicht, weiterhin Ihr Programm zu tun rbreak ^__ubsan_handle_, die Stoppt die Ausführung vor der Bibliothek ventures in C++ Gebiet, wobei es ordnet Instanzen der Diag-Klasse. Sie kramen alles, was Sie wollen, dann geben Sie return weiterhin Ihr Programm.
Für die Zukunft, abort_on_error scheint implementierte für UBSAN. Verwenden Sie dieses anstatt: UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1
Siehe auch How to break im debugger, wenn -fsanitize=undefined druckt so etwas? auf der Clang-Dev-mailing-Liste.
Welche GCC/Clang version verwenden Sie genau?
Sehr aktuelle Versionen auf Arch Linux, GCC 5.1.0, Klammerten sich 3.6.1.

InformationsquelleAutor Lekensteyn | 2015-06-12

20

Beim brechen, der auf die Erkennung von Funktionen (wie beschrieben durch @Mark Plotnick und @Iwillnotexist Idonotexist) ist eine option, ein besserer Ansatz ist zu brechen auf die Funktionen, Bericht diesen Fragen nach der Erkennung. Dieser Ansatz ist auch für ASAN, wo man möchte brechen auf __asan_report_error.

Zusammenfassung: stoppen Sie auf eine ubsan Bericht über einen Haltepunkt auf __ubsan::ScopedReport::~ScopedReport oder __ubsan::Diag::~Diag. Dies sind die privaten Implementierungsdetails, die möglicherweise in der Zukunft ändern aber. Getestet mit GCC 4.9, 5.1.0, 5.2.0 und Clang 3.3, 3.4, 3.6.2.

Für GCC 4.9.2 aus ppa:ubuntu-toolchain-r/test, müssen Sie libubsan0-dbg um die oben genannten Haltepunkte zur Verfügung. Ubuntu 14.04 mit Clang 3.3 und 3.4 nicht unterstützen __ubsan::ScopedReport::~ScopedReport Haltepunkte, so können Sie nur die Pause vor dem drucken die Nachricht mit __ubsan::Diag::~Diag.

Beispiel buggy-source-code und eine gdb-Sitzung:
```
$ cat undef.c
int main(void) { return 1 << 1000; }
$ clang --version
clang version 3.6.2 (tags/RELEASE_362/final)
Target: x86_64-unknown-linux-gnu
Thread model: posix
$ clang -w -fsanitize=undefined undef.c -g
$ gdb -q -ex break\ __ubsan::ScopedReport::~ScopedReport -ex r ./a.out 
Reading symbols from ./a.out...done.
Breakpoint 1 at 0x428fb0
Starting program: ./a.out 
undef.c:1:27: runtime error: shift exponent 1000 is too large for 32-bit type 'int'

Breakpoint 1, 0x0000000000428fb0 in __ubsan::ScopedReport::~ScopedReport() ()
(gdb) bt
#0  0x0000000000428fb0 in __ubsan::ScopedReport::~ScopedReport() ()
#1  0x000000000042affb in handleShiftOutOfBoundsImpl(__ubsan::ShiftOutOfBoundsData*, unsigned long, unsigned long, __ubsan::ReportOptions) ()
#2  0x000000000042a952 in __ubsan_handle_shift_out_of_bounds ()
#3  0x000000000042d057 in main () at undef.c:1
```
Detaillierte Analyse folgt. Beachten Sie, dass beide ASAN und ubsan beide stammen aus einem LLVM-Projekt, compiler-rt. Diese wird von Clang und endet in GCC als auch. Links in den folgenden Abschnitten Punkt für den compiler-rt-Projekt-code, Version 3.6.

ASAN hat seine internen __asan_report_error Teil der dokumentiert öffentlichen Schnittstelle. Diese Funktion wird immer aufgerufen, wenn eine Verletzung festgestellt wird, die Strömung setzt sich in lib/asan/asan_report.c:938:
```
void __asan_report_error(uptr pc, uptr bp, uptr sp, uptr addr, int is_write,
                         uptr access_size) {
  //Determine the error type.
  const char *bug_descr = "unknown-crash";
  ...

  ReportData report = { pc, sp, bp, addr, (bool)is_write, access_size,
                        bug_descr };
  ScopedInErrorReport in_report(&report);

  Decorator d;
  Printf("%s", d.Warning());
  Report("ERROR: AddressSanitizer: %s on address "
             "%p at pc %p bp %p sp %p\n",
             bug_descr, (void*)addr, pc, bp, sp);
  Printf("%s", d.EndWarning());

  u32 curr_tid = GetCurrentTidOrInvalid();
  char tname[128];
  Printf("%s%s of size %zu at %p thread T%d%s%s\n",
         d.Access(),
         access_size ? (is_write ? "WRITE" : "READ") : "ACCESS",
         access_size, (void*)addr, curr_tid,
         ThreadNameWithParenthesis(curr_tid, tname, sizeof(tname)),
         d.EndAccess());

  GET_STACK_TRACE_FATAL(pc, bp);
  stack.Print();

  DescribeAddress(addr, access_size);
  ReportErrorSummary(bug_descr, &stack);
  PrintShadowMemoryForAddress(addr);
}
```
ubsan auf der anderen Seite hat keine öffentliche Schnittstelle, aber Ihre derzeitige Umsetzung ist auch viel einfacher und begrenzt (weniger Optionen). Bei Fehlern einen stacktrace kann gedruckt werden, wenn die UBSAN_OPTIONS=print_stacktrace=1 Umgebungsvariable gesetzt ist. So, durch eine Suche im source-code für print_stacktrace findet man die Funktion MaybePrintStackTrace, die aufgerufen wird, wenn die ScopedReport Destruktor:
```
ScopedReport::~ScopedReport() {
  MaybePrintStackTrace(Opts.pc, Opts.bp);
  MaybeReportErrorSummary(SummaryLoc);
  CommonSanitizerReportMutex.Unlock();
  if (Opts.DieAfterReport || flags()->halt_on_error)
    Die();
}
```
Wie Sie sehen können, gibt es eine Methode, um das Programm zu töten, über die Fehler, aber leider gibt es keinen eingebauten Mechanismus zum auslösen einer debugger-Falle. Lassen Sie s finden Sie einen geeigneten Haltepunkt dann.

Dem GDB-Befehl info Funktionen <Funktionsname> machte es möglich, zu identifizieren MaybePrintStackTrace als Funktion auf, die ein Haltepunkt gesetzt werden kann. Ausführung info functions ScopedReport::~ScopedReport gab eine weitere Funktion: __ubsan::ScopedReport::~ScopedReport. Wenn keine dieser Funktionen scheinen vorhanden (auch mit debug-Symbole installiert), können Sie versuchen info functions ubsan oder info functions sanitizer alle zu erhalten (UndefinedBehavior)Desinfektionsmittel-Funktionen.
- +1. Springt es mir in den Sinn, dass Ihre Frage stellt, die Hilfe brauchen, und dieses Bedürfnis wäre erfüllt, wenn das Desinfektionsmittel hatte eine Kraft-keine-inline, extern-Gestänge, void-Rücksendung von leeren interne Funktion könnte breakpointed durch einen debugger, und dass diese Funktion aufgerufen werden mit Argumenten nützlich, um den debugger, wenn die Berichterstattung Wahnsinn. Etwas ähnlich wie der JIT-Anmeldung-Schnittstelle.
- Diese Antwort wäre nützlicher, wenn die Antwort auf die eigentliche Frage waren prominent.
- Ich bin offen für Vorschläge, konnte Sie klären, was Teil muss verbessert werden?
- klar, konkrete Schritte was tun, nicht durchsetzt mit einer Vielfalt von unzusammenhängenden Sachen über asan.
- Der erste Teil enthält alle Informationen, die Sie benötigen, um zu brechen auf UBSAN berichten. Der zweite Teil ist nur zu Informationszwecken, Sie können Sie ignorieren, wenn Sie nicht brauchen, um zu verstehen, wie Dinge funktionieren. Sollte die interne Implementierung in der Zukunft ändern, dann wird der zweite Teil soll dem Leser helfen, herauszufinden, wie Sie sich anpassen. ASAN und UBSan sind eng miteinander verwandt, also dachte ich, es würde Sinn machen zu vergleichen.
InformationsquelleAutor Lekensteyn
13

Als @Mark Plotnick Punkte aus, die Art und Weise dies zu tun ist Haltepunkt an UBSan ist Handler.

UBSan hat eine Reihe von Prozeduren, oder die magic-Funktion Einstiegspunkte, die aufgerufen werden, für Undefiniertes Verhalten. Der compiler Instrumente-code durch Einspritzen von Prüfungen als angemessen, Wenn die check-code erkennt, UB, ruft diese Prozeduren. Sie beginnen alle mit __ubsan_handle_ und sind definiert in libsanitizer/ubsan/ubsan_handlers.h. Hier ist ein link zum GCC Kopie von ubsan_handlers.h.

Hier die relevanten bits des UBSan header (breakpoint auf diesen):
```
#define UNRECOVERABLE(checkname, ...) \
  extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
    void __ubsan_handle_ ## checkname( __VA_ARGS__ );

#define RECOVERABLE(checkname, ...) \
  extern "C" SANITIZER_INTERFACE_ATTRIBUTE \
    void __ubsan_handle_ ## checkname( __VA_ARGS__ ); \
  extern "C" SANITIZER_INTERFACE_ATTRIBUTE NORETURN \
    void __ubsan_handle_ ## checkname ## _abort( __VA_ARGS__ );

///\brief Handle a runtime type check failure, caused by either a misaligned
///pointer, a null pointer, or a pointer to insufficient storage for the
///type.
RECOVERABLE(type_mismatch, TypeMismatchData *Data, ValueHandle Pointer)

///\brief Handle an integer addition overflow.
RECOVERABLE(add_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)

///\brief Handle an integer subtraction overflow.
RECOVERABLE(sub_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)

///\brief Handle an integer multiplication overflow.
RECOVERABLE(mul_overflow, OverflowData *Data, ValueHandle LHS, ValueHandle RHS)

///\brief Handle a signed integer overflow for a unary negate operator.
RECOVERABLE(negate_overflow, OverflowData *Data, ValueHandle OldVal)

///\brief Handle an INT_MIN/-1 overflow or division by zero.
RECOVERABLE(divrem_overflow, OverflowData *Data,
            ValueHandle LHS, ValueHandle RHS)

///\brief Handle a shift where the RHS is out of bounds or a left shift where
///the LHS is negative or overflows.
RECOVERABLE(shift_out_of_bounds, ShiftOutOfBoundsData *Data,
            ValueHandle LHS, ValueHandle RHS)

///\brief Handle an array index out of bounds error.
RECOVERABLE(out_of_bounds, OutOfBoundsData *Data, ValueHandle Index)

///\brief Handle a __builtin_unreachable which is reached.
UNRECOVERABLE(builtin_unreachable, UnreachableData *Data)
///\brief Handle reaching the end of a value-returning function.
UNRECOVERABLE(missing_return, UnreachableData *Data)

///\brief Handle a VLA with a non-positive bound.
RECOVERABLE(vla_bound_not_positive, VLABoundData *Data, ValueHandle Bound)

///\brief Handle overflow in a conversion to or from a floating-point type.
RECOVERABLE(float_cast_overflow, FloatCastOverflowData *Data, ValueHandle From)

///\brief Handle a load of an invalid value for the type.
RECOVERABLE(load_invalid_value, InvalidValueData *Data, ValueHandle Val)

RECOVERABLE(function_type_mismatch,
            FunctionTypeMismatchData *Data,
            ValueHandle Val)

///\brief Handle returning null from function with returns_nonnull attribute.
RECOVERABLE(nonnull_return, NonNullReturnData *Data)

///\brief Handle passing null pointer to function with nonnull attribute.
RECOVERABLE(nonnull_arg, NonNullArgData *Data)
```
ASan ist sogar noch einfacher. Wenn man sich in libsanitizer/include/sanitizer/asan_interface.h, die Sie durchsuchen hier, die Sie Lesen können, ein untrügliches Zeichen für einen Kommentar:
```
  //This is an internal function that is called to report an error.
  //However it is still a part of the interface because users may want to
  //set a breakpoint on this function in a debugger.
  void __asan_report_error(void *pc, void *bp, void *sp,
                           void *addr, int is_write, size_t access_size);
```
Zahlreiche weitere Funktionen in diesem header sind explizit kommentiert wurde öffentlich gemacht, so dass callable von einem debugger.

Ich auf jeden Fall raten, Sie zu erkunden, andere Header von libsanitizer/include/sanitizer hier. Es gibt zahlreiche goodies, um es musste sein.

Haltepunkte für UBSan und ASan Hinzugefügt werden können, wie folgt:
```
(gdb) rbreak ^__ubsan_handle_ __asan_report_error
(gdb) commands
(gdb) finish
(gdb) end
```
Dieser Haltepunkt wird auf dem Handler und finish sofort danach. Dies ermöglicht es der Bericht gedruckt werden, aber der debugger erhält die Kontrolle sofort danach gedruckt werden.
- Ich hatte gehofft, dass ein einzelner breakpoint oder Umgebungsvariable existiert für diese. Sowieso, können Sie zeigen ein Beispiel zur Verwendung dieser Funktion mit gdb? Es wäre toll, wenn ein Konzept (oder einfach gdbinit makro), wirkt wie ASAN. Das heißt, die Meldung angezeigt werden und brechen.
- Environment-Variablen können nicht injizieren Haltepunkte; und für eine einzelne breakpointable Funktion zu existieren, UBSan würde die Verwendung eines einzigen, multiplexing, varargs-Funktion (die nicht unbedingt gutes design, und verliert Sie die Fähigkeit, effizient Haltepunkt nur auf einige UB-Typen). Mit Bezug auf gdb/gdbinit, sicher, ich werde hinzufügen, dass in ein paar Stunden.
- Scheint, wie (gdb) rbreak __asan_report_error und (gdb) rbreak ^__ubsan unverblümt Haltepunkt alle Funktionen, die mit denen regexes. Es gibt keine Funktion, die aufgerufen wird, nachdem __asan_report_error gibt, so scheint es mir, dass man es irgendwie Programmieren müssen gdb sofort (gdb) finish nach der Kollision mit einem dieser Haltepunkte.
- Es gibt env vars wie UBSAN_OPTIONS unterstützt libsanitizer (nicht gdb oder so), die vars die ich mich beziehe, indem Sie "Umgebungsvariablen". Als für den Haltepunkt habe ich versucht rbreak ^__ubsan_handle_ commands finish end, aber irgendwie verhält sich seltsam mit einem sehr einfachen test-Programm (Funktion ist noch immer in der __ubsan_handle_... frame), während eine folgende info breakpoints irgendwie löst das drucken und änderungen des Rahmens. (GDB 7.9.1)
- UBSan hat eine unsigned-integer-überlauf-prüfen. Gibt es eine Möglichkeit zu sagen, dass ein Ausdruck mit unsigned-integer-überlauf in Ordnung ist? (So, dass es ignoriert wird, aus dem Bericht?).
- Ich bin schockiert. Unsigned overflow ist explizit definiert, und es ist definitiv nicht UB; Es ist definiert als modulo UINTMAX+1. Aber vielleicht könnten Sie versuchen -fno-sanitize=unsigned-integer-overflow? Ich glaube nicht, dass es möglich zu bestimmen, dass mit einem speziellen - Anweisung ignoriert werden, es sei denn, Sie ziehen es in eine Funktion und kompilieren Sie es in eine andere Datei mit verschiedenen Flaggen.
- Ja, die sind vollkommen korrekt, es ist nicht zu undefiniertem Verhalten. Jedoch, die meisten der Zeit, es ist noch ein bug, und das Desinfektionsmittel bieten eine opt-in - unsigned-integer-overflow überprüfen, die Sie verwenden können, um überprüfen Sie Ihren code. Diese Prüfung gefunden hat Tonnen von bugs in unseren Anwendungen. Nur weil Ihr Verhalten definiert ist, bedeutet nicht, dass es das macht, was Sie denken, es tut. Unsigned-integer-Arithmetik ist wirklich voll von fallen und Fällen Ecke.
- falls es Euch interessiert, ich habe eine Frage und bekam eine Antwort hier: stackoverflow.com/questions/33351891/...
- Cool; Statt der Trennung die Funktion in eine separate Datei, die Sie verwendet __attribute__ zu ändern, die compile-flags für eine bestimmte Funktion. Ich vergaß!
- Für das Protokoll, nicht alle Fehler generiert UBSAN haben eine offensichtliche Zuordnung zu __ubsan_handle*. Durch das setzen von mehreren breakpoints, fand ich heraus, dass die Bindung einer Referenz an nullptr löst __ubsan_handle_type_mismatch zum Beispiel.
InformationsquelleAutor Iwillnotexist Idonotexist
1

Einen Haltepunkt setzen an __asan_report_error ist nicht der hit für mich und das Programm existiert einfach nach dem drucken die Diagnose ohne den debugger auslösen. __asan::ReportGenericError vor dem Druck der Diagnostik und __sanitizer::Die nach dem drucken die Diagnose bekommen, Treffer, wie beschrieben, in die asan-wiki.

InformationsquelleAutor nwp

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.