Quelle est la différence entre section et segment dans le format de fichier ELF ?

Question

De wiki Format exécutable et lisible :

Les segments contiennent les informations nécessaires à l'exécution du fichier, tandis que les sections contiennent des données importantes pour la liaison et la relocalisation. Tout octet du fichier entier peut appartenir à une section au maximum, et il peut y avoir des octets orphelins qui n'appartiennent à aucune section.

Mais quelle est la différence entre section et segment ? Dans un fichier ELF exécutable, un segment contient-il une ou plusieurs sections ?

Answer 1

Mais quelle est la différence entre section et 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 à 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 section, INTERP Le segment contient .interp et la première LOAD Le segment contient tout un tas de sections.

Autres lectures avec une belle illustration :

Answer 2

La section contient des données statiques pour l'éditeur de liens et des données dynamiques pour le système d'exploitation.

La citation est correcte, mais pour bien 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 au linker si une section est soit :

  • les 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 disparaîtront au moment de l'exécution, par exemple .symtab , .srttab , .rela.text

• segment : indique le système d'exploitation :

  • où un segment doit être chargé dans la mémoire virtuelle
  • les permissions dont disposent les segments (lecture, écriture, exécution). Rappelez-vous que cela peut être efficacement mis en œuvre par le processeur : Comment fonctionne la pagination sur x86 ?

J'ai écrit un tutoriel qui couvre cela plus en détail à l'adresse suivante : http://www.cirosantilli.com/elf-hello-world/

Un segment contient-il une ou plusieurs sections ?

Oui, et c'est le linker qui met les sections dans les segments.

Dans Binutils, comment les sections sont mises en segments par ld est déterminé par un fichier texte appelé linker script . Docs : https://sourceware.org/binutils/docs/ld/scripts.html

Vous pouvez obtenir celui par défaut avec ld --verbose et en définir un personnalisé avec -T .

Par exemple, mon linker par défaut Ubuntu 17.04 script 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 les 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 optionnel dans l'exécutable : Où est stockée la "Section to segment mapping" dans les fichiers ELF ?

Answer 3

Veuillez me corriger si je me trompe, car je ne me considère pas comme un expert en la matière, mais d'après mes recherches, certaines affirmations données dans les réponses/commentaires semblent ne pas être tout à fait exactes. Pour développer, je vais citer des phrases et les commenter :

La section contient des données statiques pour l'éditeur de liens et des données dynamiques pour le système d'exploitation.

Selon este LWN, le noyau utilise uniquement l'en-tête de segment de type PT_INTERP, PT_LOAD et PT_GNU_STACK pour charger les exécutables en mémoire. Mais il existe d'autres types de segments, comme PHDR, DYNAMIC, NOTE, GNU_EH_FRAME, GNU_PROPERTY, GNU_RELRO, qui sont ignorés.

En fait, le segment GNU_RELRO est comme un segment fictif ; s'il est présent, le chargeur l'utilise comme un drapeau pour rendre les données de relocalisation en lecture seule. Mais le chargeur ne fait pas partie du système d'exploitation, du moins pour Linux.

Quant aux autres types de segments, je n'ai pas trouvé à quoi ils servent réellement. Ils me semblent redondants, car il existe des sections correspondantes qui contiennent essentiellement les mêmes informations, voire plus.

Ainsi, selon moi, cette réponse n'est qu'une approximation simplifiée d'une vérité plus complexe.

les sections sont contenues dans des segments

Vous pouvez avoir des exécutables ELF avec pas d'en-tête de section et les fichiers relocalisables (*.o) n'ont généralement pas d'en-tête de segment. De plus, dans la sortie readelf de la réponse acceptée, on peut voir la section .interp en plusieurs segments. Je ne vois pas de restriction de confinement.

les segments contiennent les informations nécessaires à l'exécution, tandis que les sections contiennent les informations nécessaires à la liaison.

Là encore, il s'agit d'une simplification. Le chargeur d'exécution (ou "interpréteur") a également besoin des sections pour charger les bibliothèques partagées, résoudre les symboles, effectuer les relocalisations, etc.

En conclusion, si les réponses données sont probablement des approximations générales raisonnables, les choses se compliquent apparemment lorsqu'on examine les détails.