module-elf-format.rst 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315
  1. ===========================
  2. Livepatch module Elf format
  3. ===========================
  4. This document outlines the Elf format requirements that livepatch modules must follow.
  5. .. Table of Contents
  6. 1. Background and motivation
  7. 2. Livepatch modinfo field
  8. 3. Livepatch relocation sections
  9. 3.1 Livepatch relocation section format
  10. 4. Livepatch symbols
  11. 4.1 A livepatch module's symbol table
  12. 4.2 Livepatch symbol format
  13. 5. Symbol table and Elf section access
  14. 1. Background and motivation
  15. ============================
  16. Formerly, livepatch required separate architecture-specific code to write
  17. relocations. However, arch-specific code to write relocations already
  18. exists in the module loader, so this former approach produced redundant
  19. code. So, instead of duplicating code and re-implementing what the module
  20. loader can already do, livepatch leverages existing code in the module
  21. loader to perform the all the arch-specific relocation work. Specifically,
  22. livepatch reuses the apply_relocate_add() function in the module loader to
  23. write relocations. The patch module Elf format described in this document
  24. enables livepatch to be able to do this. The hope is that this will make
  25. livepatch more easily portable to other architectures and reduce the amount
  26. of arch-specific code required to port livepatch to a particular
  27. architecture.
  28. Since apply_relocate_add() requires access to a module's section header
  29. table, symbol table, and relocation section indices, Elf information is
  30. preserved for livepatch modules (see section 5). Livepatch manages its own
  31. relocation sections and symbols, which are described in this document. The
  32. Elf constants used to mark livepatch symbols and relocation sections were
  33. selected from OS-specific ranges according to the definitions from glibc.
  34. Why does livepatch need to write its own relocations?
  35. -----------------------------------------------------
  36. A typical livepatch module contains patched versions of functions that can
  37. reference non-exported global symbols and non-included local symbols.
  38. Relocations referencing these types of symbols cannot be left in as-is
  39. since the kernel module loader cannot resolve them and will therefore
  40. reject the livepatch module. Furthermore, we cannot apply relocations that
  41. affect modules not yet loaded at patch module load time (e.g. a patch to a
  42. driver that is not loaded). Formerly, livepatch solved this problem by
  43. embedding special "dynrela" (dynamic rela) sections in the resulting patch
  44. module Elf output. Using these dynrela sections, livepatch could resolve
  45. symbols while taking into account its scope and what module the symbol
  46. belongs to, and then manually apply the dynamic relocations. However this
  47. approach required livepatch to supply arch-specific code in order to write
  48. these relocations. In the new format, livepatch manages its own SHT_RELA
  49. relocation sections in place of dynrela sections, and the symbols that the
  50. relas reference are special livepatch symbols (see section 2 and 3). The
  51. arch-specific livepatch relocation code is replaced by a call to
  52. apply_relocate_add().
  53. 2. Livepatch modinfo field
  54. ==========================
  55. Livepatch modules are required to have the "livepatch" modinfo attribute.
  56. See the sample livepatch module in samples/livepatch/ for how this is done.
  57. Livepatch modules can be identified by users by using the 'modinfo' command
  58. and looking for the presence of the "livepatch" field. This field is also
  59. used by the kernel module loader to identify livepatch modules.
  60. Example:
  61. --------
  62. **Modinfo output:**
  63. ::
  64. % modinfo livepatch-meminfo.ko
  65. filename: livepatch-meminfo.ko
  66. livepatch: Y
  67. license: GPL
  68. depends:
  69. vermagic: 4.3.0+ SMP mod_unload
  70. 3. Livepatch relocation sections
  71. ================================
  72. A livepatch module manages its own Elf relocation sections to apply
  73. relocations to modules as well as to the kernel (vmlinux) at the
  74. appropriate time. For example, if a patch module patches a driver that is
  75. not currently loaded, livepatch will apply the corresponding livepatch
  76. relocation section(s) to the driver once it loads.
  77. Each "object" (e.g. vmlinux, or a module) within a patch module may have
  78. multiple livepatch relocation sections associated with it (e.g. patches to
  79. multiple functions within the same object). There is a 1-1 correspondence
  80. between a livepatch relocation section and the target section (usually the
  81. text section of a function) to which the relocation(s) apply. It is
  82. also possible for a livepatch module to have no livepatch relocation
  83. sections, as in the case of the sample livepatch module (see
  84. samples/livepatch).
  85. Since Elf information is preserved for livepatch modules (see Section 5), a
  86. livepatch relocation section can be applied simply by passing in the
  87. appropriate section index to apply_relocate_add(), which then uses it to
  88. access the relocation section and apply the relocations.
  89. Every symbol referenced by a rela in a livepatch relocation section is a
  90. livepatch symbol. These must be resolved before livepatch can call
  91. apply_relocate_add(). See Section 3 for more information.
  92. 3.1 Livepatch relocation section format
  93. =======================================
  94. Livepatch relocation sections must be marked with the SHF_RELA_LIVEPATCH
  95. section flag. See include/uapi/linux/elf.h for the definition. The module
  96. loader recognizes this flag and will avoid applying those relocation sections
  97. at patch module load time. These sections must also be marked with SHF_ALLOC,
  98. so that the module loader doesn't discard them on module load (i.e. they will
  99. be copied into memory along with the other SHF_ALLOC sections).
  100. The name of a livepatch relocation section must conform to the following
  101. format::
  102. .klp.rela.objname.section_name
  103. ^ ^^ ^ ^ ^
  104. |________||_____| |__________|
  105. [A] [B] [C]
  106. [A]
  107. The relocation section name is prefixed with the string ".klp.rela."
  108. [B]
  109. The name of the object (i.e. "vmlinux" or name of module) to
  110. which the relocation section belongs follows immediately after the prefix.
  111. [C]
  112. The actual name of the section to which this relocation section applies.
  113. Examples:
  114. ---------
  115. **Livepatch relocation section names:**
  116. ::
  117. .klp.rela.ext4.text.ext4_attr_store
  118. .klp.rela.vmlinux.text.cmdline_proc_show
  119. **`readelf --sections` output for a patch
  120. module that patches vmlinux and modules 9p, btrfs, ext4:**
  121. ::
  122. Section Headers:
  123. [Nr] Name Type Address Off Size ES Flg Lk Inf Al
  124. [ snip ]
  125. [29] .klp.rela.9p.text.caches.show RELA 0000000000000000 002d58 0000c0 18 AIo 64 9 8
  126. [30] .klp.rela.btrfs.text.btrfs.feature.attr.show RELA 0000000000000000 002e18 000060 18 AIo 64 11 8
  127. [ snip ]
  128. [34] .klp.rela.ext4.text.ext4.attr.store RELA 0000000000000000 002fd8 0000d8 18 AIo 64 13 8
  129. [35] .klp.rela.ext4.text.ext4.attr.show RELA 0000000000000000 0030b0 000150 18 AIo 64 15 8
  130. [36] .klp.rela.vmlinux.text.cmdline.proc.show RELA 0000000000000000 003200 000018 18 AIo 64 17 8
  131. [37] .klp.rela.vmlinux.text.meminfo.proc.show RELA 0000000000000000 003218 0000f0 18 AIo 64 19 8
  132. [ snip ] ^ ^
  133. | |
  134. [*] [*]
  135. [*]
  136. Livepatch relocation sections are SHT_RELA sections but with a few special
  137. characteristics. Notice that they are marked SHF_ALLOC ("A") so that they will
  138. not be discarded when the module is loaded into memory, as well as with the
  139. SHF_RELA_LIVEPATCH flag ("o" - for OS-specific).
  140. **`readelf --relocs` output for a patch module:**
  141. ::
  142. Relocation section '.klp.rela.btrfs.text.btrfs_feature_attr_show' at offset 0x2ba0 contains 4 entries:
  143. Offset Info Type Symbol's Value Symbol's Name + Addend
  144. 000000000000001f 0000005e00000002 R_X86_64_PC32 0000000000000000 .klp.sym.vmlinux.printk,0 - 4
  145. 0000000000000028 0000003d0000000b R_X86_64_32S 0000000000000000 .klp.sym.btrfs.btrfs_ktype,0 + 0
  146. 0000000000000036 0000003b00000002 R_X86_64_PC32 0000000000000000 .klp.sym.btrfs.can_modify_feature.isra.3,0 - 4
  147. 000000000000004c 0000004900000002 R_X86_64_PC32 0000000000000000 .klp.sym.vmlinux.snprintf,0 - 4
  148. [ snip ] ^
  149. |
  150. [*]
  151. [*]
  152. Every symbol referenced by a relocation is a livepatch symbol.
  153. 4. Livepatch symbols
  154. ====================
  155. Livepatch symbols are symbols referred to by livepatch relocation sections.
  156. These are symbols accessed from new versions of functions for patched
  157. objects, whose addresses cannot be resolved by the module loader (because
  158. they are local or unexported global syms). Since the module loader only
  159. resolves exported syms, and not every symbol referenced by the new patched
  160. functions is exported, livepatch symbols were introduced. They are used
  161. also in cases where we cannot immediately know the address of a symbol when
  162. a patch module loads. For example, this is the case when livepatch patches
  163. a module that is not loaded yet. In this case, the relevant livepatch
  164. symbols are resolved simply when the target module loads. In any case, for
  165. any livepatch relocation section, all livepatch symbols referenced by that
  166. section must be resolved before livepatch can call apply_relocate_add() for
  167. that reloc section.
  168. Livepatch symbols must be marked with SHN_LIVEPATCH so that the module
  169. loader can identify and ignore them. Livepatch modules keep these symbols
  170. in their symbol tables, and the symbol table is made accessible through
  171. module->symtab.
  172. 4.1 A livepatch module's symbol table
  173. =====================================
  174. Normally, a stripped down copy of a module's symbol table (containing only
  175. "core" symbols) is made available through module->symtab (See layout_symtab()
  176. in kernel/module.c). For livepatch modules, the symbol table copied into memory
  177. on module load must be exactly the same as the symbol table produced when the
  178. patch module was compiled. This is because the relocations in each livepatch
  179. relocation section refer to their respective symbols with their symbol indices,
  180. and the original symbol indices (and thus the symtab ordering) must be
  181. preserved in order for apply_relocate_add() to find the right symbol.
  182. For example, take this particular rela from a livepatch module:::
  183. Relocation section '.klp.rela.btrfs.text.btrfs_feature_attr_show' at offset 0x2ba0 contains 4 entries:
  184. Offset Info Type Symbol's Value Symbol's Name + Addend
  185. 000000000000001f 0000005e00000002 R_X86_64_PC32 0000000000000000 .klp.sym.vmlinux.printk,0 - 4
  186. This rela refers to the symbol '.klp.sym.vmlinux.printk,0', and the symbol index is encoded
  187. in 'Info'. Here its symbol index is 0x5e, which is 94 in decimal, which refers to the
  188. symbol index 94.
  189. And in this patch module's corresponding symbol table, symbol index 94 refers to that very symbol:
  190. [ snip ]
  191. 94: 0000000000000000 0 NOTYPE GLOBAL DEFAULT OS [0xff20] .klp.sym.vmlinux.printk,0
  192. [ snip ]
  193. 4.2 Livepatch symbol format
  194. ===========================
  195. Livepatch symbols must have their section index marked as SHN_LIVEPATCH, so
  196. that the module loader can identify them and not attempt to resolve them.
  197. See include/uapi/linux/elf.h for the actual definitions.
  198. Livepatch symbol names must conform to the following format::
  199. .klp.sym.objname.symbol_name,sympos
  200. ^ ^^ ^ ^ ^ ^
  201. |_______||_____| |_________| |
  202. [A] [B] [C] [D]
  203. [A]
  204. The symbol name is prefixed with the string ".klp.sym."
  205. [B]
  206. The name of the object (i.e. "vmlinux" or name of module) to
  207. which the symbol belongs follows immediately after the prefix.
  208. [C]
  209. The actual name of the symbol.
  210. [D]
  211. The position of the symbol in the object (as according to kallsyms)
  212. This is used to differentiate duplicate symbols within the same
  213. object. The symbol position is expressed numerically (0, 1, 2...).
  214. The symbol position of a unique symbol is 0.
  215. Examples:
  216. ---------
  217. **Livepatch symbol names:**
  218. ::
  219. .klp.sym.vmlinux.snprintf,0
  220. .klp.sym.vmlinux.printk,0
  221. .klp.sym.btrfs.btrfs_ktype,0
  222. **`readelf --symbols` output for a patch module:**
  223. ::
  224. Symbol table '.symtab' contains 127 entries:
  225. Num: Value Size Type Bind Vis Ndx Name
  226. [ snip ]
  227. 73: 0000000000000000 0 NOTYPE GLOBAL DEFAULT OS [0xff20] .klp.sym.vmlinux.snprintf,0
  228. 74: 0000000000000000 0 NOTYPE GLOBAL DEFAULT OS [0xff20] .klp.sym.vmlinux.capable,0
  229. 75: 0000000000000000 0 NOTYPE GLOBAL DEFAULT OS [0xff20] .klp.sym.vmlinux.find_next_bit,0
  230. 76: 0000000000000000 0 NOTYPE GLOBAL DEFAULT OS [0xff20] .klp.sym.vmlinux.si_swapinfo,0
  231. [ snip ] ^
  232. |
  233. [*]
  234. [*]
  235. Note that the 'Ndx' (Section index) for these symbols is SHN_LIVEPATCH (0xff20).
  236. "OS" means OS-specific.
  237. 5. Symbol table and Elf section access
  238. ======================================
  239. A livepatch module's symbol table is accessible through module->symtab.
  240. Since apply_relocate_add() requires access to a module's section headers,
  241. symbol table, and relocation section indices, Elf information is preserved for
  242. livepatch modules and is made accessible by the module loader through
  243. module->klp_info, which is a klp_modinfo struct. When a livepatch module loads,
  244. this struct is filled in by the module loader. Its fields are documented below::
  245. struct klp_modinfo {
  246. Elf_Ehdr hdr; /* Elf header */
  247. Elf_Shdr *sechdrs; /* Section header table */
  248. char *secstrings; /* String table for the section headers */
  249. unsigned int symndx; /* The symbol table section index */
  250. };