Mais quelle est la différence entre section et segment ?
Exactement ce que vous avez cité :les segments contiennent les informations nécessaires au moment de 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 le segment contient 0 sections, INTERP le segment contient .interp section, et le premier LOAD segment contient tout un tas de sections.
A lire avec une belle 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 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 :indique à l'éditeur de liens si une section est soit :
- 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 ex.
.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
- les autorisations dont disposent les segments (lecture, écriture, exécution). N'oubliez pas que cela peut être appliqué efficacement 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 place les sections dans les segments.
Dans Binutils, comment les sections sont mises en segments par ld est déterminé par un fichier texte appelé script de lien . 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 liaison 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 dit à l'éditeur de liens de mettre des sections nommées .text.unlikely , .text.*_unlikely , .text.exit , etc. dans le .text segment.
Le développement d'OS 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 l'exécutable lié, il n'est possible de savoir quelle section est allée à quel segment que si l'éditeur de liens stocke l'en-tête de section facultatif dans l'exécutable :Où se trouve le "Correspondance de section à segment" stocké dans les fichiers ELF ?