it-swarm.com.de

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

Aus Wiki ausführbares und verknüpfbares Format :

Die Segmente enthalten Informationen, die für die Ausführung der Datei zur Laufzeit erforderlich sind, während Abschnitte wichtige Daten für das 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?

60
tsing

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 beim Verknüpfen 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 enthält das Segment PHDR 0 Abschnitte, das Segment INTERP enthält .interp section und das erste LOAD -Segment enthält eine ganze Reihe von Abschnitten.

Weiterführende Literatur mit einem Nizza Illustration .

54

Abschnitt enthält statische Daten für den Linker, segmentdynamische Daten für das Betriebssystem

Das Zitat ist korrekt, aber um den Unterschied zu verstehen, sollten Sie versuchen, die Felder der Abschnittsüberschriften und Programmüberschriften (Segmente) zu verstehen und wie sie vom Linker (Abschnitte) und vom Betriebssystem (Segmente) verwendet werden. .

Besonders wichtige Informationen sind (neben Längen):

  • section: Teilen Sie dem Linker mit, ob ein Abschnitt Folgendes enthält:

    • rohdaten, die in den Speicher geladen werden sollen, z.B. .data, .text, etc.
    • oder formatierte Metadaten zu anderen Abschnitten, die vom Linker verwendet werden, jedoch zur Laufzeit verschwinden, z. .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 genauer 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 von ld in Segmente unterteilt werden, durch eine Textdatei mit dem Namen linker script bestimmt. Docs: https://sourceware.org/binutils/docs/ld/Scripts.html

Sie können die Standardeinstellung mit ld --verbose, und legen Sie eine benutzerdefinierte mit -T.

Zum Beispiel enthält mein Ubuntu 17.04-Standard-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 den Linker anweist, Abschnitte mit dem Namen .text.unlikely, .text.*_unlikely, .text.exit usw. im .text Segment.

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

Sobald die ausführbare Datei verknüpft ist, ist es nur möglich zu wissen, welcher Abschnitt zu welchem ​​Segment gehörte, wenn der Linker die optionale Abschnittsüberschrift in der ausführbaren Datei speichert: Wo ist die "Zuordnung von Abschnitt zu Segment" in ELF-Dateien gespeichert? =