Wie erkennt man mögliche / potentielle Stapelüberlaufprobleme in einem c / c ++ Programm?

Ist es ein standard-Weg, um zu sehen, wie viel stack-Speicher für Ihre app und, was der höchsten Wasserzeichen für die stack-Nutzung ist es beim laufen?

Auch in die gefürchtete Falle des tatsächlichen überlauf was passiert?

Stuerzt es ab, eine Ausnahme auszulösen, oder signal? Gibt es da einen standard oder ist es bei den verschiedenen Systemen und Compilern?

Ich bin auf der Suche speziell für Windows, Linux und Macintosh.

InformationsquelleAutor der Frage KPexEA | 2008-10-14

c c++memory overflow stack

Auf Windows ein stack-überlauf Ausnahme generiert werden.

Den folgenden windows-code veranschaulicht dies:

#include <stdio.h>
#include <windows.h>

void StackOverFlow()
{
  CONTEXT context;

  //we are interested control registers
  context.ContextFlags = CONTEXT_CONTROL;

  //get the details
  GetThreadContext(GetCurrentThread(), &context);

  //print the stack pointer
  printf("Esp: %X\n", context.Esp);

  //this will eventually overflow the stack
  StackOverFlow();
}

DWORD ExceptionFilter(EXCEPTION_POINTERS *pointers, DWORD dwException)
{
  return EXCEPTION_EXECUTE_HANDLER;
}

void main()
{
  CONTEXT context;

  //we are interested control registers
  context.ContextFlags = CONTEXT_CONTROL;

  //get the details
  GetThreadContext(GetCurrentThread(), &context);

  //print the stack pointer
  printf("Esp: %X\n", context.Esp);

  __try
  {
    //cause a stack overflow
    StackOverFlow();
  }
  __except(ExceptionFilter(GetExceptionInformation(), GetExceptionCode()))
  {
    printf("\n****** ExceptionFilter fired ******\n");
  }
}

Wenn diese exe-Datei ausführen, wird die folgende Ausgabe generiert:

Esp: 12FC4C
Esp: 12F96C
Esp: 12F68C
.....
Esp: 33D8C
Esp: 33AAC
Esp: 337CC

****** ExceptionFilter fired ******

InformationsquelleAutor der Antwort jussij

11

Unter Linux erhalten Sie einen segmentation fault, wenn der code versucht zu schreiben, hinter den stack.

Die Größe des stack ist eine Eigenschaft geerbt, die zwischen Prozessen. Wenn Sie Lesen oder ändern können es in der shell mit Befehlen wie ulimit -s (in shkshzsh) oder limit stacksize (tcshzsh).

Aus einem Programm, die Größe des stack gelesen werden können, mit
```
#include <sys/resource.h>
#include <stdio.h>

struct rlimit l;
getrlimit(RLIMIT_STACK, &l);
printf("stack_size = %d\n", l.rlim_cur);
```
Ich kenne keine standard-Weg, um die Größe des verfügbaren Stapel.

Dem Stapel beginnt mit argc gefolgt von den Inhalt argv und eine Kopie von der Umwelt, und dann die Variablen. Jedoch, da der kernel kann, mischen Sie die Position des anfangs des Stapels, und es kann einige dummy-Werte über argc es wäre falsch, davon auszugehen, dass Sie l.rlim_cur bytes verfügbar unter &argc.

Einer Weise abzurufen, die genaue Lage der stack ist ein Blick auf die Datei /proc/1234/maps (wo 1234 ist die Prozess-ID des Programms). Sobald Sie wissen, diese Schranken können Sie berechnen, wie viel von Ihrem Stapel verwendet wird, indem man die Adresse der aktuellen lokalen Variablen.

InformationsquelleAutor der Antwort adl
8

gcc stellen einen zusätzlichen Speicherblock, der zwischen der Rückkehr-Adresse und die normalen Variablen, die in "unsichere" Funktion Aufrufe, wie (in diesem Beispiel ist die Funktion void test() {char a[10]; b[20]}:
```
call stack:
-----------
return address
dummy
char b[10]
char a[20]
```
Wenn die Funktion write-36 bytes der pointer "a", der überlauf "korrupten" die Rückkehr-Adresse (mögliche Verletzung der Sicherheit). Aber es wird auch ändern Sie den Wert des 'dummy', das ist zwischen dem Zeiger und der Rückkehr-Adresse, so dass das Programm stürzt mit einer Warnung (Sie können diese deaktivieren, mit ein -fno-stack-protector)

InformationsquelleAutor der Antwort
5

Unter Linux, die Gnu libsigsegv Bibliothek beinhaltet die Funktion stackoverflow_install_handlerdie erkennen können (und in einigen Fällen helfen Sie wiederherstellen aus) stack-überlauf.

InformationsquelleAutor der Antwort Norman Ramsey
4

Stack-überlauf ist wohl die übelste Art von Ausnahme zu behandeln-denn Ihre exception-handler zu kämpfen hat, mit einer minimalen Menge von stapeln (in der Regel nur eine einzelne Seite ist, für diesen Zweck reserviert).

Für eine interessante Diskussion der Schwierigkeiten Umgang mit dieser Art von Ausnahme siehe diese Blogbeiträge: Eins und Zwei von Chris Brumme, die sich auf die Frage aus dem .NETTO-Perspektive, besonders das hosting der CLR.

InformationsquelleAutor der Antwort Rob Walker

Unter windows, ist der stack (für den thread) wächst on-demand, bis der stack-Größe für diesen thread vor seiner Schaffung erreicht wurde.

On-demand wächst, ist impelmented mit guard-Seiten, dass es nur ein fragment der stack zuerst, gefolgt von einem Wächter Seite, die, sobald Sie getroffen werden, lösen eine Ausnahme, diese Ausnahme ist das Besondere, und übernimmt das system für Sie die Abwicklung erhöht die verfügbaren Stapelspeicher (auch aktiviert, wenn eine Grenze erreicht ist!) und die Lesen-operation wiederholt wird.

Sobald das limit erreicht ist, gibt es keine mehr wachsen, die Ergebnisse in einer stack-overflow-exception.
Die aktuelle stack-base-und limit sind gespeichert in thread environment block, in einem struct namens _NT_TIB (thread information block).
Wenn Sie eine debugger-praktisch, das ist, was Sie sehen:

0:000> dt ntdll!_teb @$teb nttib.
   +0x000 NtTib  : 
      +0x000 ExceptionList : 0x0012e030 _EXCEPTION_REGISTRATION_RECORD
      +0x004 StackBase : 0x00130000 
      +0x008 StackLimit : 0x0011e000 
      +0x00c SubSystemTib : (null) 
      +0x010 FiberData : 0x00001e00 
      +0x010 Version : 0x1e00
      +0x014 ArbitraryUserPointer : (null) 
      +0x018 Self   : 0x7ffdf000 _NT_TIB

Dem StackLimit-Attribut wird aktualisiert on-demand.
Wenn Sie überprüfen Sie die Attribute, die auf diesen Speicher-block, sehen Sie etwas ähnliches wie:

0:000> !address 0x0011e000 
    00030000 : 0011e000 - 00012000
                    Type     00020000 MEM_PRIVATE
                    Protect  00000004 PAGE_READWRITE
                    State    00001000 MEM_COMMIT
                    Usage    RegionUsageStack
                    Pid.Tid  abc.560

Und Prüfung einer Seite neben darin offenbart sich das guard-Attribut:

0:000> !address 0x0011e000-1000
    00030000 : 0011d000 - 00001000
                    Type     00020000 MEM_PRIVATE
                    Protect  00000104 PAGE_READWRITE | PAGE_GUARD
                    State    00001000 MEM_COMMIT
                    Usage    RegionUsageStack
                    Pid.Tid  abc.560

Hoffe, es hilft.

InformationsquelleAutor der Antwort deemok

1

Ich würde dir empfehlen für die Verwendung von alternativen-signal-stack wenn Sie auf linux.
1. In diesem Fall alle Signale, die behandelt werden, über alternativen stack.
2. Im Fall von stack-overflow Auftritt, das system generiert ein SEGV-signal, dieses kann gehandhabt werden, über alternativen stack.
3. Wenn Sie ihn nicht verwenden ... dann können Sie nicht in der Lage zum verarbeiten des Signals, und das Programm kann Abstürzen, ohne handling - /Fehler-reporting.
InformationsquelleAutor der Antwort Shyam Sunder Verma
1

Ist es möglich mit editbin in Visual Studio ändern Sie die stack-Größe. Die Informationen können an gefunden werden msdn.microsoft.com/en-us/library/35yc2tc3.aspx.

InformationsquelleAutor der Antwort Richard
0

Einige Compiler unterstützen stackavail () - Funktion gibt die Menge der verbleibenden freien Speicherplatz des Stacks. Mit dieser Funktion können Sie vor dem aufrufen von Funktionen in Ihre Programme, die erfordern viel stack-Speicher, um festzustellen, ob es sicher ist, Sie zu nennen

InformationsquelleAutor der Antwort dmityugov

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.