Was ist der Unterschied zwischen Abschnitt und Segment im ELF-Dateiformat?

72

Aus dem Wiki Ausführbares und verlinkbares Format :

Die Segmente enthalten Informationen, die für die Laufzeitausführung der Datei erforderlich sind, während Abschnitte wichtige Daten zum Verknüpfen und Verschieben enthalten. Jedes Byte in der gesamten Datei kann höchstens einem Abschnitt gehören, und es kann verwaiste Bytes geben, die keinem Abschnitt gehören.

Aber was ist der Unterschied zwischen Abschnitt und Segment? Enthält ein Segment in einer ausführbaren ELF-Datei einen oder mehrere Abschnitte?

linux debian gnu elf abi tsing
quelle
"Segmente enthalten Informationen, die für die Laufzeitausführung erforderlich sind, während Abschnitte ... zum Verknüpfen eines Umzugs" - daher lautet die eigentliche Frage: "Was wird zur Laufzeit benötigt und was zum Verknüpfen und Verschieben?" Antwort darauf, dass der Unterschied zwischen Abschnitt und Segment deutlicher werden sollte.
Xealits

Antworten:

66

Aber was ist der Unterschied zwischen Abschnitt und Segment?

Genau das, was Sie zitiert haben: Die Segmente enthalten Informationen, die zur Laufzeit benötigt werden, während die Abschnitte Informationen enthalten, die während der Verknüpfung benötigt werden.

Enthält ein Segment einen oder mehrere Abschnitte?

Ein Segment kann 0 oder mehr Abschnitte enthalten. Beispiel:

readelf -l /bin/date

Elf file type is EXEC (Executable file)
Entry point 0x402000
There are 9 program headers, starting at offset 64

Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  PHDR           0x0000000000000040 0x0000000000400040 0x0000000000400040
                 0x00000000000001f8 0x00000000000001f8  R E    8
  INTERP         0x0000000000000238 0x0000000000400238 0x0000000000400238
                 0x000000000000001c 0x000000000000001c  R      1
      [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
  LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
                 0x000000000000d5ac 0x000000000000d5ac  R E    200000
  LOAD           0x000000000000de10 0x000000000060de10 0x000000000060de10
                 0x0000000000000440 0x0000000000000610  RW     200000
  DYNAMIC        0x000000000000de38 0x000000000060de38 0x000000000060de38
                 0x00000000000001a0 0x00000000000001a0  RW     8
  NOTE           0x0000000000000254 0x0000000000400254 0x0000000000400254
                 0x0000000000000044 0x0000000000000044  R      4
  GNU_EH_FRAME   0x000000000000c700 0x000000000040c700 0x000000000040c700
                 0x00000000000002a4 0x00000000000002a4  R      4
  GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
                 0x0000000000000000 0x0000000000000000  RW     8
  GNU_RELRO      0x000000000000de10 0x000000000060de10 0x000000000060de10
                 0x00000000000001f0 0x00000000000001f0  R      1

 Section to Segment mapping:
  Segment Sections...
   00     
   01     .interp 
   02     .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame 
   03     .ctors .dtors .jcr .dynamic .got .got.plt .data .bss 
   04     .dynamic 
   05     .note.ABI-tag .note.gnu.build-id 
   06     .eh_frame_hdr 
   07     
   08     .ctors .dtors .jcr .dynamic .got

Hier PHDRenthält das Segment 0 Abschnitte, das INTERPSegment enthält .interpAbschnitte und das erste LOADSegment enthält eine ganze Reihe von Abschnitten.

Weiterführende Literatur mit einer schönen Illustration .

Angestellt Russisch
quelle
7
Die Tatsache, dass "segments contain information needed at runtime"und "sections contain information needed during linking"scheint ein strittiger Punkt zu sein, wenn man bedenkt, dass Abschnitte mit Segmenten enthalten sind. Es ist sinnvoll, sie wie beschrieben zu betrachten, wenn man bedenkt, dass die Art der Informationen nicht eng miteinander verbunden ist. Wenn man jedoch die Tatsache berücksichtigt, dass eine die andere enthält, wird dies etwas verwirrender.
Sherlellbc
1
Wenn man sich auf die Segmente bezieht, ist das tatsächlich loadableetwas sinnvoller. Betrachten Sie diese großartige Darstellung von Abschnitten / Segmenten. Danke für deinen Beitrag!
Sherlellbc
Wirklich nützliche Bilder.
Bulat M.
@sherrellbc Für eine bessere Qualität: nairobi-embedded.org/img/elf/elf_link_vs_exec_view.jpg
Andy
Die Links waren für mich kaputt. Ich glaube, das Bild kann hier gefunden werden: github.com/johndpope/REFE/blob/master/notes/day1/…
Omer
35

Der Abschnitt enthält statische Daten für den Linker und segmentiert dynamische Daten für das Betriebssystem

Das Zitat ist korrekt, aber um den Unterschied tatsächlich zu verstehen, sollten Sie versuchen, die Felder der Einträge für Abschnittsüberschriften und Programmüberschriften (Segmente) und deren Verwendung durch den Linker (Abschnitte) und das Betriebssystem (Segment) zu verstehen. .

Besonders wichtige Informationen sind (neben den Längen):

  • Abschnitt: Teilen Sie dem Linker mit, ob ein Abschnitt einer der folgenden ist:

    • Rohdaten in dem Speicher geladen, zum Beispiel werden .data, .textusw.
    • oder formatiert Metadaten über andere Abschnitte, die von den Linker verwendet werden, aber verschwinden zur Laufzeit zB .symtab, .srttab,.rela.text

  • Segment: teilt dem Betriebssystem mit:

    • Wo soll ein Segment in den virtuellen Speicher geladen werden?
    • Welche Berechtigungen haben die Segmente (Lesen, Schreiben, Ausführen)? Denken Sie daran, dass dies vom Prozessor effizient erzwungen werden kann: Wie funktioniert x86-Paging?

Ich habe ein Tutorial geschrieben, das dies ausführlicher behandelt: http://www.cirosantilli.com/elf-hello-world/

Enthält ein Segment einen oder mehrere Abschnitte?

Ja, und es ist der Linker, der Abschnitte in Segmente unterteilt.

In Binutils wird die Art und Weise, wie Abschnitte in Segmente eingefügt werden, lddurch eine Textdatei bestimmt, die als Linkerskript bezeichnet wird . Dokumente: https://sourceware.org/binutils/docs/ld/Scripts.html

Sie können die Standardeinstellung mit abrufen ld --verboseund eine benutzerdefinierte mit festlegen -T.

Zum Beispiel enthält mein Standard-Ubuntu 17.04-Linker-Skript:

  .text           :                                                                                                                                                             
  {                                                                                                                                                                             
    *(.text.unlikely .text.*_unlikely .text.unlikely.*)                                                                                                                         
    *(.text.exit .text.exit.*)                                                                                                                                                  
    *(.text.startup .text.startup.*)                                                                                                                                            
    *(.text.hot .text.hot.*)                                                                                                                                                    
    *(.text .stub .text.* .gnu.linkonce.t.*)                                                                                                                                                                                                                                                                                               
  }

was sagt den Linker an Put Abschnitte genannt .text.unlikely, .text.*_unlikely, .text.exitetc. im .textSegment.

Die Betriebssystementwicklung ist ein Fall, in dem benutzerdefinierte Skripte nützlich sind, minimales Beispiel: https://github.com/cirosantilli/x86-bare-metal-examples/blob/d217b180be4220a0b4a453f31275d38e697a99e0/linker.ld

Sobald die ausführbare Datei verknüpft ist, kann nur festgestellt werden, welcher Abschnitt zu welchem ​​Segment gegangen ist, wenn der Linker den optionalen Abschnittsheader in der ausführbaren Datei speichert: Wo ist die Zuordnung von Abschnitt zu Segment in ELF-Dateien gespeichert?

Ciro Santilli 郝海东 冠状 病 六四 事件 法轮功
quelle
Hmm, wie werden die Namen der Segmente festgelegt? Theoretisch haben Segmente keine Namen und readelfzeigen sie ohne Namen. Ich denke, lddiese Namen werden als Platzhalter / Variablen im Skript verwendet, oder?
Newlog
@newlog ja, ich denke, die Ausgabe-ELF speichert einfach keine Namen für Segmente. Es wäre interessant, Beispiele für Linker-Skripte zu sehen, in denen die Namen verwendet werden, aber ich habe sie nicht. Ich bin auch neugierig, warum ldweiß, dass .textExecute-Berechtigung hat, aber nicht Write.
Ciro Santilli 法轮功 冠状 病 六四 事件 31
0

Bitte korrigieren Sie mich, wenn ich falsch liege, da ich mich nicht als Experte für dieses Thema betrachten würde, aber nach meinen Recherchen scheinen einige Aussagen in den Antworten / Kommentaren nicht ganz korrekt zu sein. Um dies zu erläutern, zitiere ich Sätze und kommentiere sie:

Der Abschnitt enthält statische Daten für den Linker und segmentiert dynamische Daten für das Betriebssystem

Gemäß diesem LWN-Artikel verwendet der Kernel nur den Segmentheader vom Typ PT_INTERP, PT_LOAD und PT_GNU_STACK, um ausführbare Dateien in den Speicher zu laden. Es gibt jedoch auch andere Segmenttypen wie PHDR, DYNAMIC, NOTE, GNU_EH_FRAME, GNU_PROPERTY, GNU_RELRO, die ignoriert werden.

Afaiu, das GNU_RELRO-Segment ist wie ein Dummy-Segment; Wenn es vorhanden ist, verwendet der Loader dies als Flag, um die Umzugsdaten schreibgeschützt zu machen. Aber der Loader ist nicht Teil des Betriebssystems, zumindest für Linux.

Bei den anderen Segmenttypen habe ich nicht herausgefunden, wofür sie tatsächlich verwendet werden. Sie erscheinen mir überflüssig, da es entsprechende Abschnitte gibt, die im Grunde die gleichen oder mehr Informationen enthalten.

Nach meinem Verständnis ist diese Antwort daher nur eine vereinfachte Annäherung an eine chaotischere Wahrheit.

Abschnitte sind mit Segmenten enthalten

Sie können ausführbare ELF-Dateien ohne Abschnittskopf haben, und verschiebbare (* .o) Dateien haben normalerweise keinen Segmentkopf. Darüber hinaus kann man in der Readelf-Ausgabe in der akzeptierten Antwort den Abschnitt .interp in mehreren Segmenten sehen. Ich sehe keine Eindämmungsbeschränkung.

Die Segmente enthalten Informationen, die zur Laufzeit benötigt werden, während die Abschnitte Informationen enthalten, die während der Verknüpfung benötigt werden.

Auch dies scheint eine Vereinfachung zu sein. Der Runtime Loader (oder "Interpreter") benötigt auch die Abschnitte zum Laden gemeinsam genutzter Bibliotheken, zum Auflösen von Symbolen, zum Verschieben usw.

Zusammenfassend lässt sich sagen, dass die gegebenen Antworten wahrscheinlich vernünftige allgemeine Annäherungen sind, es jedoch anscheinend komplizierter wird, wenn man sich die Details ansieht.

zse
quelle