Quelle est la différence de section et de segment au format de fichier ELF
À partir du wiki format exécutable et linkable :
Les segments contiennent les informations nécessaires à l'exécution du fichier au moment de l'exécution, tandis que les sections contiennent des données importantes pour la liaison et la relocalisation. Tout octet dans le fichier entier peut appartenir à au plus une section, et il peut y avoir des octets orphelins qui n'appartiennent à aucune section.
Mais quelle est la différence entre la section et le segment? Dans un fichier ELF exécutable, un segment contient-il une ou plusieurs sections?
Mais quelle est la différence entre la section et le segment?
Exactement ce que vous avez cité: les segments contiennent les informations nécessaires à l'exécution, tandis que les sections contiennent les informations nécessaires lors de la liaison.
un segment contient-il une ou plusieurs sections?
Un segment peut contenir 0 ou plusieurs sections. Exemple:
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
Ici, PHDR segment contient 0 sections, INTERP segment contient .interp section, et le premier LOAD segment contient tout un tas de sections.
Lectures complémentaires avec un Nice illustration .
La section contient des données statiques pour l'éditeur de liens, des données dynamiques de segment pour le système d'exploitation
La citation est correcte, mais pour réellement comprendre la différence, vous devez essayer de comprendre les champs des entrées d'en-tête de section et d'en-tête de programme (segment), et comment ils sont utilisés par l'éditeur de liens (sections) et le système d'exploitation (segment) .
Les informations particulièrement importantes sont (outre les longueurs):
section: indiquez à l'éditeur de liens si une section est:
- données brutes à charger en mémoire, par ex.
.data,.text, etc. - ou des métadonnées formatées sur d'autres sections, qui seront utilisées par l'éditeur de liens, mais disparaissent au moment de l'exécution, par exemple
.symtab,.srttab,.rela.text
- données brutes à charger en mémoire, par ex.
segment: indique au système d'exploitation:
- où un segment doit-il être chargé dans la mémoire virtuelle
- quelles autorisations les segments ont (lire, écrire, exécuter). N'oubliez pas que cela peut être efficacement appliqué par le processeur: Comment fonctionne la pagination x86?
J'ai écrit un tutoriel qui couvre cela plus en détail à: http://www.cirosantilli.com/elf-hello-world/
Un segment contient-il une ou plusieurs sections?
Oui, et c'est l'éditeur de liens qui met les sections en segments.
Dans Binutils, la façon dont les sections sont mises en segments par ld est déterminée par un fichier texte appelé script de l'éditeur de liens. Documents: https://sourceware.org/binutils/docs/ld/Scripts.html
Vous pouvez obtenir celui par défaut avec ld --verbose, et définissez-en un personnalisé avec -T.
Par exemple, mon script de l'éditeur de liens Ubuntu 17.04 par défaut contient:
.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.*)
}
qui indique à l'éditeur de liens de mettre des sections nommées .text.unlikely, .text.*_unlikely, .text.exit, etc. dans le .text segment.
Le développement du système d'exploitation est un cas où les scripts personnalisés sont utiles, exemple minimal: https://github.com/cirosantilli/x86-bare-metal-examples/blob/d217b180be4220a0b4a453f31275d38e697a99e0/linker.ld
Une fois que l'exécutable est lié, il n'est possible de savoir quelle section est allée à quel segment si l'éditeur de liens stocke l'en-tête de section facultatif dans l'exécutable: Où est le "mappage de section à segment" stocké dans les fichiers ELF? =