What is an ABI, and Why Should You Care?

Presented at Open Source Summit Europe (OSS EU) 2024

Transcript

1. What is an ABI, and Why Should You Care? Shung-Hsi Yu OSS EU 2024 1
2. 2 Why does (compiled) program from 10 years ago still runs on the latest system?
3. 3 Why does upgrading my system to the next major version broke my program?
4. 4 ABI
5. About me Shung-Hsi Yu @shunghsiyu(@fosstodon.org) Based in Taitung, Taiwan Works at SUSE Kernel Engineer Maintains (e)BPF stack in SLES and openSUSE 5
6. 6 Background
7. 7 API
8. 8 Application Programming Interface
9. 9 Web API
10. 10 List repository tree - Repositories API | GitLab
11. 11 API
12. 12 Ranges — Built-in Types — Python 3.12.4 documentation
13. 13 Formatted Output Functions (The GNU C Library)
14. 14 API
15. 15 ABI
16. 16 ABI 🤔
17. 17 Application Binary Interface
18. 18 Application Binary Interface Application Programming Interface
19. 19 Binary Programming Application Interface
20. 20 Binary Programming Application Interface
21. 21 Interface
22. 22 Specification
23. 23 Guarantee
24. 24 Guarantee GitLab’s /tree endpoint return files in the repo
25. 25 Guarantee Python’s range(2) starts from 0 GitLab’s /tree endpoint return files in the repo
26. 26 Guarantee Python’s range(2) starts from 0 GitLab’s /tree endpoint return files in the repo gilbc’s printf() writes to stdout
27. 27 Binary Programming Application Interface
28. 28 Binary Programming Application Interface
29. 29 Binary Programming
30. 30 Binary Programming source code
31. 31 Binary Programming machine code source code
32. 32 Binary Programming long x_square(struct point *p) { return p->x * p->x; } machine code
33. 33 Binary Programming long x_square(struct point *p) { return p->x * p->x; } 00000000100001010011010100000011 00000010101001010000010100110011 00000000000000001000000001100111
34. 34 Binary Programming long x_square(struct point *p) { return p->x * p->x; } assembly code
35. 35 Binary Programming long x_square(struct point *p) { return p->x * p->x; } x_square: ld a0, 0(a0) mul a0, a0, a0 ret
36. 36 Binary Programming x_square: ld a0, 0(a0) mul a0, a0, a0 ret long x_square(struct point *p) { return p->x * p->x; }
37. long x_square(struct point *p) { return p->x * p->x; } x_square: ld a0, 8(a0) mul a0, a0, a0 ret 37 Binary Programming compiler
38. 38 Example
39. 39 Application business logic
40. 40 Library helper routine Application business logic
41. 41 Library helper routine Application business logic
42. 42 Library helper routine Application business logic
43. 43 Library helper routine Application business logic
44. 44 Development Header helper routine (declaration) Shared Library helper routine (implementation) Application business logic
45. 45 Development Header helper routine (declaration) Shared Library helper routine (implementation) Application business logic
46. 46 Development Header helper routine (declaration) Shared Library helper routine (implementation) Application business logic
47. 47 Development Header helper routine (declaration) Shared Library helper routine (implementation) Application business logic
48. 48 Development Header helper routine (declaration) Application business logic // geo.c #include <geo-v1.h> long x_square(struct point *p) { return p->x * p->x; }
49. 49 Development Header helper routine (declaration) Application business logic // geo.c #include <geo-v1.h> long x_square(struct point *p) { return p->x * p->x; }
50. 50 Development Header helper routine (declaration) // geo.c #include <geo-v1.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo-v1.h> int main(void) { struct point p = ... point p = { ... }; long x2 = x_square(&p); return arr[x2]; }
51. 51 Development Header helper routine (declaration) // geo.c #include <geo-v1.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo-v1.h> int main(void) { struct point p = ... point p = { ... }; long x2 = x_square(&p); return arr[x2]; }
52. 52 Development Header helper routine (declaration) // geo.c #include <geo-v1.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo-v1.h> int main(void) { struct point p = ... point p = { ... }; long x2 = x_square(&p); return arr[x2]; }
53. 53 // geo.h struct point { long x; long y; }; // geo.c #include <geo-v1.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo-v1.h> int main(void) { struct point p = ... point p = { ... }; long x2 = x_square(&p); return arr[x2]; }
54. 54 // geo.c #include <geo.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo.h> int main(void) { struct point p = ... point p = { ... }; long x2 = x_square(&p); return arr[x2]; } // geo.h struct point { long x; long y; };
55. 55 // geo.c #include <geo.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo.h> int main(void) { struct point p = { .x = 2, .y = 1, }; }; long x2 = x_square(&p); return arr[x2]; } // geo.h struct point { long x; long y; };
56. 56 // geo.c #include <geo.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo.h> int main(void) { struct point p = { .x = 2, .y = 1, }; }; long x2 = x_square(&p); return arr[x2]; } // geo.h struct point { long x; long y; };
57. 57 // geo.c #include <geo.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo.h> int main(void) { struct point p = { .x = 2, .y = 1, }; }; /* you get x2 == 4 */ long x2 = x_square(&p); return arr[x2]; } // geo.h struct point { long x; long y; };
58. 58 // geo.c #include <geo.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo.h> int main(void) { struct point p = { .x = 2, .y = 1, }; /* you get x2 == 4 */ long x2 = x_square(&p); /* use x2 to index arr*/ return arr[x2]; } // geo.h struct point { long x; long y; };
59. 59 // geo.h struct point { long x; long y; }; // geo.c #include <geo.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo.h> long arr[] = { 0, 1, 2, 3, 4 }; // n-th element = n int main(void) { struct point p = { .x = 2, .y = 1, }; printf("Calculating\n"); /* you get x2 == 4 */ long x2 = x_square(&p); /* arr[4] == 4 */ return arr[x2]; }
60. 60 // geo.h struct point { long x; long y; }; long x_square(struct point *); // geo.c #include <geo.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo.h> long arr[] = { 0, 1, 2, 3, 4 }; // n-th element = n int main(void) { struct point p = { .x = 2, .y = 1, }; printf("Calculating\n"); /* you get x2 == 4 */ long x2 = x_square(&p); /* arr[4] == 4 */ return arr[x2]; }
61. 61 // geo.h struct point { long x; long y; }; long x_square(struct point *); // geo.c #include <geo.h> long x_square(struct point *p) { return p->x * p->x; } // main.c #include <geo.h> long arr[] = { 0, 1, 2, 3, 4 }; // n-th element = n int main(void) { struct point p = { .x = 2, .y = 1, }; printf("Calculating\n"); /* you get x2 == 4 */ long x2 = x_square(&p); /* arr[4] == 4 */ return arr[x2]; }
62. 62 # Compile the library -> libgeo.so $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c
63. 63 # Compile the library -> libgeo.so $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c # Compile application which uses the library -> main $ gcc -I$(pwd) -o ./main libgeo.so main.c
64. 64 # Compile the library -> libgeo.so $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c # Compile application which uses the library -> main $ gcc -I$(pwd) -o ./main libgeo.so main.c # Run the application $ ./main; echo $? Calculating 4 # 2 * 2 = 4 and arr[4] = 4, no surprise here
65. 65 Now for some fun
66. 66 long x_square(struct point *p); long x_2(struct point *p);
67. 67 # Re-compile the library that has x_2() $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c
68. 68 # Re-compile the library that has x_2() $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c # Run the application, WITHOUT re-compiling $ ./main; echo $?
69. 69 # Re-compile the library that has x_2() $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c # Run the application, WITHOUT re-compiling # It’s not ran at all (no “Calculating”) $ ./main; echo $? ./main: symbol lookup error: ./main: undefined symbol: x_square
70. 70 symbol lookup error: undefined symbol: x_square
71. 71 ABI Breakage
72. 72 long x_square(struct point *p);
73. 73 long x_square(struct point *p); ?
74. 74 What’s in a name?
75. 75 long x_square(struct point *p); long x_square(long x);
76. 76 long x_square(struct point *p) { return p->x * p->x; } long x_square(long x) { return x * x; }
77. 77 # Re-compile the library that has x_square(long x) $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c
78. 78 # Re-compile the library that has x_square(long x) $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c # Run the application, WITHOUT re-compiling $ ./main; echo $?
79. 79 # Re-compile the library that has x_square(long x) $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c # Run the application, WITHOUT re-compiling # Started running, but crashes $ ./main; echo $? Calculating Segmentation fault (core dumped) 139
80. 80 ABI Breakage
81. 81 What about data structure?
82. 82 struct point { long x; long y; }; struct point { long z; long x; long y; };
83. 83 struct point { long x; long y; }; struct point { long z; long x; long y; }; 😏
84. 84 # Re-compile the library, z is first field in point $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c
85. 85 # Re-compile the library, z is first field in point $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c # Run the application, WITHOUT re-compiling $ ./main; echo $?
86. 86 # Re-compile the library, z is first field in point $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c # Run the application, WITHOUT re-compiling # No crash, just wrong $ ./main; echo $? Calculating 1 # returns 1 instead of 4
87. 87 ABI Breakage
88. 88 struct point { long x; long y; }; struct point { long x; long y; long z; };
89. 89 struct point { long x; long y; }; struct point { long x; long y; long z; };
90. 90 # Re-compile the library, z is last field in point $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c
91. 91 # Re-compile the library, z is last field in point $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c # Run the application, without re-compiling $ ./main; echo $?
92. 92 # Re-compile the library, z is last field in point $ gcc -I$(pwd) -shared -o ./libgeo.so geo.c # Run the application, without re-compiling # No crash, everything works $ ./main; echo $? Calculating 4 # returns 4 as expected
93. 93 ABI Compatible
94. 94 Why?
95. 95 Under the hood
96. 96 struct point { long x; long y; }; struct point { long z; long x; long y; };
97. 97 struct point { long x; long y; }; struct point { long x; long y; long z; };
98. 98 What’s going on?
99. 99 Binary Programming long x_square(struct point *p) { return p->x * p->x; } x_square: ld a0, 0(a0) mul a0, a0, a0 ret
100. 100 By Mc681 - Own work, CC BY-SA 4.0
101. 101 By Mc681 - Own work, CC BY-SA 4.0
102. 102 copy paste By Mc681 - Own work, CC BY-SA 4.0
103. 103 store to register load from register By Mc681 - Own work, CC BY-SA 4.0
104. 104 Binary Programming long x_square(struct point *p) { return p->x * p->x; } x_square: ld a0, 0(a0) # load x mul a0, a0, a0 # x*x ret
105. 105 Binary Programming int main(void) { struct point p = { .x = 2, .y = 1, }; ... } main: # a0 points to p li a1, 2 # get 2 sd a1, 0(a0) # store x li a1, 1 # get 1 sd a1, 8(a0) # store y ...
106. 106 Binary Programming int main(void) { struct point p = { .x = 2, .y = 1, }; ... } main: # a0 points to p li a1, 2 # get 2 sd a1, 0(a0) # store x li a1, 1 # get 1 sd a1, 8(a0) # store y ...
107. 107 Binary Programming int main(void) { struct point p = { .x = 2, .y = 1, }; ... } main: # a0 points to p li a1, 2 # get 2 sd a1, 0(a0) # store x li a1, 1 # get 1 sd a1, 8(a0) # store y ...
108. 108 Binary Programming long x_square(struct point *p) { return p->x * p->x; } x_square: ld a0, 0(a0) # load x mul a0, a0, a0 # x*x ret
109. 109 Binary Programming long x_square(struct point *p) { return p->x * p->x; } x_square: ld a0, 0(a0) # load x mul a0, a0, a0 # x*x ret
110. 110 struct point { long x; long y; }; struct point { long z; long x; long y; };
111. 111 struct point { long x; long y; }; struct point { long z; long x; long y; };
112. 112 Binary Programming long x_square(struct point *p) { return p->x * p->x; } x_square: ld a0, 8(a0) mul a0, a0, a0 ret
113. 113 Binary Programming long x_square(struct point *p) { return p->x * p->x; } x_square: ld a0, 8(a0) mul a0, a0, a0 ret
114. 114 Binary Programming int main(void) { struct point p = { .x = 2, .y = 1, }; ... } main: # a0 points to p li a1, 2 # get 2 sd a1, 0(a0) # store x li a1, 1 # get 1 sd a1, 8(a0) # store y ...
115. 115 Binary Programming int main(void) { struct point p = { .x = 2, .y = 1, }; ... } main: # a0 points to p li a1, 2 # get 2 sd a1, 0(a0) # store x li a1, 1 # get 1 sd a1, 8(a0) # store y ...
116. 116 struct point { long x; // 0 long y; // 8 }; struct point { long z; // 0 long x; // 8 long y; // 16 };
117. 117 struct point { long x; // 0 long y; // 8 }; struct point { long z; // 0 long x; // 8 long y; // 16 };
118. 118 Other the other hand…
119. 119 struct point { long x; // 0 long y; // 8 }; struct point { long x; // 0 long y; // 8 long z; // 16 };
120. 120 Solution
121. 121 Recompile!
122. 122 Recompile!
123. 123 xkcd #303 - Compiling by Randall Munroe
124. 124 Recompile!
125. 125 Workarounds
126. 126 long x_square(struct point *p) long x_square(long x)
127. 127 Name Mangling (C++ and Java)
128. 128 long x_square(struct point *p); long x_square(long x);
129. 129 long _Z8x_squareP5point(struct point *p); long _Z8x_squarel(long x);
130. 130 Symbol Versioning
131. 131 long x_square(struct point *p) long x_square(long x)
132. 132 long x_square(struct point *p)
133. 133 long x_square@0.1(struct point *p)
134. 134 long x_square@0.1(struct point *p)
135. 135 long x_square@0.1(struct point *p) long x_square@0.2(long x)
136. 136 $ rpm -q --provides glibc libc.so.6(GLIBC_2.10)(64bit) libc.so.6(GLIBC_2.11)(64bit) ... libc.so.6(GLIBC_2.39)(64bit) libc.so.6(GLIBC_2.4)(64bit) libc.so.6(GLIBC_2.5)(64bit) libc.so.6(GLIBC_2.6)(64bit) libc.so.6(GLIBC_2.7)(64bit) libc.so.6(GLIBC_2.8)(64bit) ...
137. 137 $ rpm -q --requires bash ... libc.so.6()(64bit) libc.so.6(GLIBC_2.11)(64bit) libc.so.6(GLIBC_2.14)(64bit) libc.so.6(GLIBC_2.15)(64bit) libc.so.6(GLIBC_2.2.5)(64bit) libc.so.6(GLIBC_2.25)(64bit) libc.so.6(GLIBC_2.3)(64bit) libc.so.6(GLIBC_2.3.4)(64bit) ...
138. 138 Keep ABI compatible
139. 139 struct point { long x; // 0 long y; // 8 }; struct point { long x; // 0 long y; // 8 long z; // 16 };
140. 140 Opaque type
141. 141 struct point { long :64; /* unnamed bitfields long :64; */ };
142. 142 Or… just don’t change forever
143. 143 int openat(int dirfd, const char *pathname, int flags, ... /* mode_t mode */ );
144. int openat(int dirfd, const char *pathname, int flags, ... /* mode_t mode */ ); int openat2(int dirfd, const char *pathname, const struct open_how *how, size_t size); 144
145. 145 ABI Checker
146. 146 readelf -s | some_magic
147. 147 libabigail
148. 148 abidiff
149. 149 Why ABI matters
150. 150 Why should you care?
151. 151 Things break
152. 152 Visibly
153. 153 Visibly 👍
154. 154 Silently
155. 155 Silently 😱
156. 156 It might not be you
157. 157 Chain of Dependency
158. 158 Machine ABI Kernel ABI Library ABI Application ABI
159. 159 Machine ABI Kernel ABI Library ABI Application ABI
160. 160 Machine ABI Kernel ABI Library ABI Application ABI glibc, libgeo.so Linux Kernel x86-64 main.c
161. 161 Machine ABI Kernel ABI Library ABI Application ABI
162. 162 Arch i386 x86-64 aarch64 riscv
163. 163 Call Convention
164. 164 How are arguments passed
165. 165 Arch/ABI arg1 arg2 arg3 arg4 arg5 arg6 i386 ebx ecx edx esi edi ebp x86-64 rdi rsi rdx r10 r8 r9 aarch64 x0 x1 x2 x3 x4 x5 riscv a0 a1 a2 a3 a4 a5
166. 166 Arch/ABI arg1 arg2 arg3 arg4 arg5 arg6 i386 ebx ecx edx esi edi ebp x86-64 rdi rsi rdx r10 r8 r9 aarch64 x0 x1 x2 x3 x4 x5 riscv a0 a1 a2 a3 a4 a5
167. 167 Arch/ABI arg1 arg2 arg3 arg4 i386 ebx ecx edx esi x86-64 rdi rsi rdx r10 aarch64 x0 x1 x2 x3 riscv a0 a1 a2 a3
168. 168 Machine ABI Kernel ABI Library ABI Application ABI breaking change
169. 169 Machine ABI Kernel ABI Library ABI Application ABI breaking change ?
170. 170 Machine ABI Kernel ABI Library ABI Application ABI breaking change
171. 171 Who guarantees ABI?
172. 172 ABI Stability
173. 173 Machine ABI Kernel ABI Library ABI Application ABI
174. 174 Hardware Vendors
175. 175 Machine ABI Kernel ABI Library ABI Application ABI Linux Kernel
176. 176 Linux Kernel Maintainers
177. 177 Machine ABI Kernel ABI Library ABI Application ABI
178. 178 Library Maintainers
179. 179 Machine ABI Kernel ABI Library ABI Application ABI
180. 180 Linux Distribution Providers
181. 181 Linux Distribution Providers Hi!
182. 182 Machine ABI Kernel ABI Library ABI Application ABI
183. 183 CVE
184. 184 Machine ABI Kernel ABI Library ABI Application ABI Linux Kernel Module
185. 185 kABI
186. kABI 186 Hi!
187. 187 Real-world Examples
188. 188 Y2038 problem
189. 189 Blank tombstone by Jo Naylor, CC BY 2.0
190. 190 typedef time_t int32_t;
191. 191 typedef time_t int32_t; typedef time_t int64_t;
192. 192 typedef time_t int32_t; typedef time_t int64_t; ABI Breakage
193. 193 typedef time_t int32_t; typedef time_t int64_t; Recompile!
194. 194 Real-world Examples (the good ones)
195. 195 Emulators
196. 196 Wine
198. 198 QEMU
199. 199 Rosetta 2 (macOS)
200. 200 Foreign Function Interface FFI
201. 201 #include <stdio.h> int main(void) { /* Can you use printf in Python? */ printf("Hello %s!\n", "world"); }
202. 202 #!/usr/bin/python3 import ctypes # We can load _any_ shared library # Let's use the ubiquitous libc here libc = ctypes.CDLL('libc.so.6') # This is the _exact_ same printf you # get in C libc.printf(b'Hello %s!\n', b'world')
203. 203 Ruby → C
204. 204 Ruby → C Java → C Go → C
205. 205 Ruby → C Java → C Go → C Python → Swift Julia → Rust
206. 206 Takeaways
207. 207 When ABI breaks Program don’t work correctly
208. 208 You might not even notice
209. 209 Use caution & tools
210. 210 Recompile (if possible)
211. Thank you 211
212. 212 Resources
213. 213 A 10-minute guide to the Linux ABI by Alison Chaiken Binary Banshees and Digital Demons by JeanHeyd Meneide C Isn't A Programming Language Anymore by Aria Desires To Save C, We Must Save ABI by JeanHeyd Meneide Pair Your Compilers At The ABI Café by Aria Desires The Lost Art of Structure Packing by Eric S. Raymond Application binary interface compatibility testing with libabigail by Frank Eigler ABI stable symbols - Linux Kernel Documentation A look at dynamic linking - LWN.net by Daroc Alden
214. 214 Appendix
215. Can’t break ABI if there’s no ABI 215
216. 216 Single Executable
217. 217 Single Executable
218. 218 Arch i386 x86-64 aarch64 riscv bpf wasm