1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * vdso2c - A vdso image preparation tool |
4 | * Copyright (c) 2014 Andy Lutomirski and others |
5 | * |
6 | * vdso2c requires stripped and unstripped input. It would be trivial |
7 | * to fully strip the input in here, but, for reasons described below, |
8 | * we need to write a section table. Doing this is more or less |
9 | * equivalent to dropping all non-allocatable sections, but it's |
10 | * easier to let objcopy handle that instead of doing it ourselves. |
11 | * If we ever need to do something fancier than what objcopy provides, |
12 | * it would be straightforward to add here. |
13 | * |
14 | * We're keep a section table for a few reasons: |
15 | * |
16 | * The Go runtime had a couple of bugs: it would read the section |
17 | * table to try to figure out how many dynamic symbols there were (it |
18 | * shouldn't have looked at the section table at all) and, if there |
19 | * were no SHT_SYNDYM section table entry, it would use an |
20 | * uninitialized value for the number of symbols. An empty DYNSYM |
21 | * table would work, but I see no reason not to write a valid one (and |
22 | * keep full performance for old Go programs). This hack is only |
23 | * needed on x86_64. |
24 | * |
25 | * The bug was introduced on 2012-08-31 by: |
26 | * https://code.google.com/p/go/source/detail?r=56ea40aac72b |
27 | * and was fixed on 2014-06-13 by: |
28 | * https://code.google.com/p/go/source/detail?r=fc1cd5e12595 |
29 | * |
30 | * Binutils has issues debugging the vDSO: it reads the section table to |
31 | * find SHT_NOTE; it won't look at PT_NOTE for the in-memory vDSO, which |
32 | * would break build-id if we removed the section table. Binutils |
33 | * also requires that shstrndx != 0. See: |
34 | * https://sourceware.org/bugzilla/show_bug.cgi?id=17064 |
35 | * |
36 | * elfutils might not look for PT_NOTE if there is a section table at |
37 | * all. I don't know whether this matters for any practical purpose. |
38 | * |
39 | * For simplicity, rather than hacking up a partial section table, we |
40 | * just write a mostly complete one. We omit non-dynamic symbols, |
41 | * though, since they're rather large. |
42 | * |
43 | * Once binutils gets fixed, we might be able to drop this for all but |
44 | * the 64-bit vdso, since build-id only works in kernel RPMs, and |
45 | * systems that update to new enough kernel RPMs will likely update |
46 | * binutils in sync. build-id has never worked for home-built kernel |
47 | * RPMs without manual symlinking, and I suspect that no one ever does |
48 | * that. |
49 | */ |
50 | |
51 | #include <inttypes.h> |
52 | #include <stdint.h> |
53 | #include <unistd.h> |
54 | #include <stdarg.h> |
55 | #include <stdlib.h> |
56 | #include <stdio.h> |
57 | #include <string.h> |
58 | #include <fcntl.h> |
59 | #include <err.h> |
60 | |
61 | #include <sys/mman.h> |
62 | #include <sys/types.h> |
63 | |
64 | #include <tools/le_byteshift.h> |
65 | |
66 | #include <linux/elf.h> |
67 | #include <linux/types.h> |
68 | #include <linux/kernel.h> |
69 | |
70 | const char *outfilename; |
71 | |
72 | /* Symbols that we need in vdso2c. */ |
73 | enum { |
74 | sym_vvar_start, |
75 | sym_vvar_page, |
76 | sym_pvclock_page, |
77 | sym_hvclock_page, |
78 | sym_timens_page, |
79 | }; |
80 | |
81 | const int special_pages[] = { |
82 | sym_vvar_page, |
83 | sym_pvclock_page, |
84 | sym_hvclock_page, |
85 | sym_timens_page, |
86 | }; |
87 | |
88 | struct vdso_sym { |
89 | const char *name; |
90 | bool export; |
91 | }; |
92 | |
93 | struct vdso_sym required_syms[] = { |
94 | [sym_vvar_start] = {"vvar_start" , true}, |
95 | [sym_vvar_page] = {.name: "vvar_page" , true}, |
96 | [sym_pvclock_page] = {.name: "pvclock_page" , true}, |
97 | [sym_hvclock_page] = {.name: "hvclock_page" , true}, |
98 | [sym_timens_page] = {.name: "timens_page" , true}, |
99 | {"VDSO32_NOTE_MASK" , true}, |
100 | {"__kernel_vsyscall" , true}, |
101 | {"__kernel_sigreturn" , true}, |
102 | {"__kernel_rt_sigreturn" , true}, |
103 | {"int80_landing_pad" , true}, |
104 | {"vdso32_rt_sigreturn_landing_pad" , true}, |
105 | {"vdso32_sigreturn_landing_pad" , true}, |
106 | }; |
107 | |
108 | __attribute__((format(printf, 1, 2))) __attribute__((noreturn)) |
109 | static void fail(const char *format, ...) |
110 | { |
111 | va_list ap; |
112 | va_start(ap, format); |
113 | fprintf(stderr, format: "Error: " ); |
114 | vfprintf(stderr, format: format, arg: ap); |
115 | if (outfilename) |
116 | unlink(name: outfilename); |
117 | exit(status: 1); |
118 | va_end(ap); |
119 | } |
120 | |
121 | /* |
122 | * Evil macros for little-endian reads and writes |
123 | */ |
124 | #define GLE(x, bits, ifnot) \ |
125 | __builtin_choose_expr( \ |
126 | (sizeof(*(x)) == bits/8), \ |
127 | (__typeof__(*(x)))get_unaligned_le##bits(x), ifnot) |
128 | |
129 | extern void bad_get_le(void); |
130 | #define LAST_GLE(x) \ |
131 | __builtin_choose_expr(sizeof(*(x)) == 1, *(x), bad_get_le()) |
132 | |
133 | #define GET_LE(x) \ |
134 | GLE(x, 64, GLE(x, 32, GLE(x, 16, LAST_GLE(x)))) |
135 | |
136 | #define PLE(x, val, bits, ifnot) \ |
137 | __builtin_choose_expr( \ |
138 | (sizeof(*(x)) == bits/8), \ |
139 | put_unaligned_le##bits((val), (x)), ifnot) |
140 | |
141 | extern void bad_put_le(void); |
142 | #define LAST_PLE(x, val) \ |
143 | __builtin_choose_expr(sizeof(*(x)) == 1, *(x) = (val), bad_put_le()) |
144 | |
145 | #define PUT_LE(x, val) \ |
146 | PLE(x, val, 64, PLE(x, val, 32, PLE(x, val, 16, LAST_PLE(x, val)))) |
147 | |
148 | |
149 | #define NSYMS ARRAY_SIZE(required_syms) |
150 | |
151 | #define BITSFUNC3(name, bits, suffix) name##bits##suffix |
152 | #define BITSFUNC2(name, bits, suffix) BITSFUNC3(name, bits, suffix) |
153 | #define BITSFUNC(name) BITSFUNC2(name, ELF_BITS, ) |
154 | |
155 | #define INT_BITS BITSFUNC2(int, ELF_BITS, _t) |
156 | |
157 | #define ELF_BITS_XFORM2(bits, x) Elf##bits##_##x |
158 | #define ELF_BITS_XFORM(bits, x) ELF_BITS_XFORM2(bits, x) |
159 | #define ELF(x) ELF_BITS_XFORM(ELF_BITS, x) |
160 | |
161 | #define ELF_BITS 64 |
162 | #include "vdso2c.h" |
163 | #undef ELF_BITS |
164 | |
165 | #define ELF_BITS 32 |
166 | #include "vdso2c.h" |
167 | #undef ELF_BITS |
168 | |
169 | static void go(void *raw_addr, size_t raw_len, |
170 | void *stripped_addr, size_t stripped_len, |
171 | FILE *outfile, const char *name) |
172 | { |
173 | Elf64_Ehdr *hdr = (Elf64_Ehdr *)raw_addr; |
174 | |
175 | if (hdr->e_ident[EI_CLASS] == ELFCLASS64) { |
176 | go64(raw_addr, raw_len, stripped_addr, stripped_len, |
177 | outfile, image_name: name); |
178 | } else if (hdr->e_ident[EI_CLASS] == ELFCLASS32) { |
179 | go32(raw_addr, raw_len, stripped_addr, stripped_len, |
180 | outfile, image_name: name); |
181 | } else { |
182 | fail(format: "unknown ELF class\n" ); |
183 | } |
184 | } |
185 | |
186 | static void map_input(const char *name, void **addr, size_t *len, int prot) |
187 | { |
188 | off_t tmp_len; |
189 | |
190 | int fd = open(file: name, O_RDONLY); |
191 | if (fd == -1) |
192 | err(status: 1, format: "open(%s)" , name); |
193 | |
194 | tmp_len = lseek(fd: fd, offset: 0, SEEK_END); |
195 | if (tmp_len == (off_t)-1) |
196 | err(status: 1, format: "lseek" ); |
197 | *len = (size_t)tmp_len; |
198 | |
199 | *addr = mmap(NULL, len: tmp_len, prot: prot, MAP_PRIVATE, fd: fd, offset: 0); |
200 | if (*addr == MAP_FAILED) |
201 | err(status: 1, format: "mmap" ); |
202 | |
203 | close(fd: fd); |
204 | } |
205 | |
206 | int main(int argc, char **argv) |
207 | { |
208 | size_t raw_len, stripped_len; |
209 | void *raw_addr, *stripped_addr; |
210 | FILE *outfile; |
211 | char *name, *tmp; |
212 | int namelen; |
213 | |
214 | if (argc != 4) { |
215 | printf(format: "Usage: vdso2c RAW_INPUT STRIPPED_INPUT OUTPUT\n" ); |
216 | return 1; |
217 | } |
218 | |
219 | /* |
220 | * Figure out the struct name. If we're writing to a .so file, |
221 | * generate raw output instead. |
222 | */ |
223 | name = strdup(s: argv[3]); |
224 | namelen = strlen(s: name); |
225 | if (namelen >= 3 && !strcmp(s1: name + namelen - 3, s2: ".so" )) { |
226 | name = NULL; |
227 | } else { |
228 | tmp = strrchr(s: name, c: '/'); |
229 | if (tmp) |
230 | name = tmp + 1; |
231 | tmp = strchr(s: name, c: '.'); |
232 | if (tmp) |
233 | *tmp = '\0'; |
234 | for (tmp = name; *tmp; tmp++) |
235 | if (*tmp == '-') |
236 | *tmp = '_'; |
237 | } |
238 | |
239 | map_input(name: argv[1], addr: &raw_addr, len: &raw_len, PROT_READ); |
240 | map_input(name: argv[2], addr: &stripped_addr, len: &stripped_len, PROT_READ); |
241 | |
242 | outfilename = argv[3]; |
243 | outfile = fopen(filename: outfilename, modes: "w" ); |
244 | if (!outfile) |
245 | err(status: 1, format: "fopen(%s)" , outfilename); |
246 | |
247 | go(raw_addr, raw_len, stripped_addr, stripped_len, outfile, name); |
248 | |
249 | munmap(addr: raw_addr, len: raw_len); |
250 | munmap(addr: stripped_addr, len: stripped_len); |
251 | fclose(stream: outfile); |
252 | |
253 | return 0; |
254 | } |
255 | |