Commit | Line | Data |
---|---|---|
da861e18 AL |
1 | /* |
2 | * vdso2c - A vdso image preparation tool | |
3 | * Copyright (c) 2014 Andy Lutomirski and others | |
4 | * Licensed under the GPL v2 | |
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 | ||
6f121e54 AL |
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 | ||
bdfb9bcc PA |
64 | #include <tools/le_byteshift.h> |
65 | ||
6f121e54 AL |
66 | #include <linux/elf.h> |
67 | #include <linux/types.h> | |
68 | ||
01156183 AL |
69 | const char *outfilename; |
70 | ||
6f121e54 | 71 | /* Symbols that we need in vdso2c. */ |
18d0a6fd | 72 | enum { |
e6577a7c | 73 | sym_vvar_start, |
18d0a6fd AL |
74 | sym_vvar_page, |
75 | sym_hpet_page, | |
dac16fba | 76 | sym_pvclock_page, |
bfad381c AL |
77 | sym_VDSO_FAKE_SECTION_TABLE_START, |
78 | sym_VDSO_FAKE_SECTION_TABLE_END, | |
18d0a6fd AL |
79 | }; |
80 | ||
81 | const int special_pages[] = { | |
82 | sym_vvar_page, | |
83 | sym_hpet_page, | |
dac16fba | 84 | sym_pvclock_page, |
18d0a6fd AL |
85 | }; |
86 | ||
bfad381c AL |
87 | struct vdso_sym { |
88 | const char *name; | |
89 | bool export; | |
90 | }; | |
91 | ||
92 | struct vdso_sym required_syms[] = { | |
e6577a7c | 93 | [sym_vvar_start] = {"vvar_start", true}, |
bfad381c AL |
94 | [sym_vvar_page] = {"vvar_page", true}, |
95 | [sym_hpet_page] = {"hpet_page", true}, | |
dac16fba | 96 | [sym_pvclock_page] = {"pvclock_page", true}, |
bfad381c AL |
97 | [sym_VDSO_FAKE_SECTION_TABLE_START] = { |
98 | "VDSO_FAKE_SECTION_TABLE_START", false | |
99 | }, | |
100 | [sym_VDSO_FAKE_SECTION_TABLE_END] = { | |
101 | "VDSO_FAKE_SECTION_TABLE_END", false | |
102 | }, | |
103 | {"VDSO32_NOTE_MASK", true}, | |
bfad381c AL |
104 | {"__kernel_vsyscall", true}, |
105 | {"__kernel_sigreturn", true}, | |
106 | {"__kernel_rt_sigreturn", true}, | |
8242c6c8 | 107 | {"int80_landing_pad", true}, |
6f121e54 AL |
108 | }; |
109 | ||
110 | __attribute__((format(printf, 1, 2))) __attribute__((noreturn)) | |
111 | static void fail(const char *format, ...) | |
112 | { | |
113 | va_list ap; | |
114 | va_start(ap, format); | |
115 | fprintf(stderr, "Error: "); | |
116 | vfprintf(stderr, format, ap); | |
da861e18 AL |
117 | if (outfilename) |
118 | unlink(outfilename); | |
6f121e54 AL |
119 | exit(1); |
120 | va_end(ap); | |
121 | } | |
122 | ||
add4eed0 | 123 | /* |
b4b31f61 | 124 | * Evil macros for little-endian reads and writes |
add4eed0 | 125 | */ |
c191920f | 126 | #define GLE(x, bits, ifnot) \ |
add4eed0 | 127 | __builtin_choose_expr( \ |
bdfb9bcc PA |
128 | (sizeof(*(x)) == bits/8), \ |
129 | (__typeof__(*(x)))get_unaligned_le##bits(x), ifnot) | |
add4eed0 | 130 | |
bdfb9bcc | 131 | extern void bad_get_le(void); |
b4b31f61 | 132 | #define LAST_GLE(x) \ |
bdfb9bcc | 133 | __builtin_choose_expr(sizeof(*(x)) == 1, *(x), bad_get_le()) |
add4eed0 | 134 | |
c191920f | 135 | #define GET_LE(x) \ |
b4b31f61 AL |
136 | GLE(x, 64, GLE(x, 32, GLE(x, 16, LAST_GLE(x)))) |
137 | ||
138 | #define PLE(x, val, bits, ifnot) \ | |
139 | __builtin_choose_expr( \ | |
140 | (sizeof(*(x)) == bits/8), \ | |
141 | put_unaligned_le##bits((val), (x)), ifnot) | |
142 | ||
143 | extern void bad_put_le(void); | |
144 | #define LAST_PLE(x, val) \ | |
145 | __builtin_choose_expr(sizeof(*(x)) == 1, *(x) = (val), bad_put_le()) | |
146 | ||
147 | #define PUT_LE(x, val) \ | |
148 | PLE(x, val, 64, PLE(x, val, 32, PLE(x, val, 16, LAST_PLE(x, val)))) | |
149 | ||
add4eed0 | 150 | |
6f121e54 AL |
151 | #define NSYMS (sizeof(required_syms) / sizeof(required_syms[0])) |
152 | ||
e6577a7c AL |
153 | #define BITSFUNC3(name, bits, suffix) name##bits##suffix |
154 | #define BITSFUNC2(name, bits, suffix) BITSFUNC3(name, bits, suffix) | |
155 | #define BITSFUNC(name) BITSFUNC2(name, ELF_BITS, ) | |
156 | ||
157 | #define INT_BITS BITSFUNC2(int, ELF_BITS, _t) | |
c1979c37 AL |
158 | |
159 | #define ELF_BITS_XFORM2(bits, x) Elf##bits##_##x | |
160 | #define ELF_BITS_XFORM(bits, x) ELF_BITS_XFORM2(bits, x) | |
161 | #define ELF(x) ELF_BITS_XFORM(ELF_BITS, x) | |
162 | ||
163 | #define ELF_BITS 64 | |
6f121e54 | 164 | #include "vdso2c.h" |
c1979c37 AL |
165 | #undef ELF_BITS |
166 | ||
167 | #define ELF_BITS 32 | |
6f121e54 | 168 | #include "vdso2c.h" |
c1979c37 | 169 | #undef ELF_BITS |
6f121e54 | 170 | |
da861e18 AL |
171 | static void go(void *raw_addr, size_t raw_len, |
172 | void *stripped_addr, size_t stripped_len, | |
173 | FILE *outfile, const char *name) | |
6f121e54 | 174 | { |
da861e18 | 175 | Elf64_Ehdr *hdr = (Elf64_Ehdr *)raw_addr; |
6f121e54 AL |
176 | |
177 | if (hdr->e_ident[EI_CLASS] == ELFCLASS64) { | |
da861e18 AL |
178 | go64(raw_addr, raw_len, stripped_addr, stripped_len, |
179 | outfile, name); | |
6f121e54 | 180 | } else if (hdr->e_ident[EI_CLASS] == ELFCLASS32) { |
da861e18 AL |
181 | go32(raw_addr, raw_len, stripped_addr, stripped_len, |
182 | outfile, name); | |
6f121e54 | 183 | } else { |
01156183 | 184 | fail("unknown ELF class\n"); |
6f121e54 AL |
185 | } |
186 | } | |
187 | ||
da861e18 AL |
188 | static void map_input(const char *name, void **addr, size_t *len, int prot) |
189 | { | |
190 | off_t tmp_len; | |
191 | ||
192 | int fd = open(name, O_RDONLY); | |
193 | if (fd == -1) | |
194 | err(1, "%s", name); | |
195 | ||
196 | tmp_len = lseek(fd, 0, SEEK_END); | |
197 | if (tmp_len == (off_t)-1) | |
198 | err(1, "lseek"); | |
199 | *len = (size_t)tmp_len; | |
200 | ||
201 | *addr = mmap(NULL, tmp_len, prot, MAP_PRIVATE, fd, 0); | |
202 | if (*addr == MAP_FAILED) | |
203 | err(1, "mmap"); | |
204 | ||
205 | close(fd); | |
206 | } | |
207 | ||
6f121e54 AL |
208 | int main(int argc, char **argv) |
209 | { | |
da861e18 AL |
210 | size_t raw_len, stripped_len; |
211 | void *raw_addr, *stripped_addr; | |
6f121e54 | 212 | FILE *outfile; |
6f121e54 AL |
213 | char *name, *tmp; |
214 | int namelen; | |
215 | ||
da861e18 AL |
216 | if (argc != 4) { |
217 | printf("Usage: vdso2c RAW_INPUT STRIPPED_INPUT OUTPUT\n"); | |
6f121e54 AL |
218 | return 1; |
219 | } | |
220 | ||
221 | /* | |
222 | * Figure out the struct name. If we're writing to a .so file, | |
223 | * generate raw output insted. | |
224 | */ | |
da861e18 | 225 | name = strdup(argv[3]); |
6f121e54 AL |
226 | namelen = strlen(name); |
227 | if (namelen >= 3 && !strcmp(name + namelen - 3, ".so")) { | |
228 | name = NULL; | |
229 | } else { | |
230 | tmp = strrchr(name, '/'); | |
231 | if (tmp) | |
232 | name = tmp + 1; | |
233 | tmp = strchr(name, '.'); | |
234 | if (tmp) | |
235 | *tmp = '\0'; | |
236 | for (tmp = name; *tmp; tmp++) | |
237 | if (*tmp == '-') | |
238 | *tmp = '_'; | |
239 | } | |
240 | ||
da861e18 AL |
241 | map_input(argv[1], &raw_addr, &raw_len, PROT_READ); |
242 | map_input(argv[2], &stripped_addr, &stripped_len, PROT_READ); | |
6f121e54 | 243 | |
da861e18 | 244 | outfilename = argv[3]; |
01156183 | 245 | outfile = fopen(outfilename, "w"); |
6f121e54 AL |
246 | if (!outfile) |
247 | err(1, "%s", argv[2]); | |
248 | ||
da861e18 | 249 | go(raw_addr, raw_len, stripped_addr, stripped_len, outfile, name); |
6f121e54 | 250 | |
da861e18 AL |
251 | munmap(raw_addr, raw_len); |
252 | munmap(stripped_addr, stripped_len); | |
6f121e54 AL |
253 | fclose(outfile); |
254 | ||
01156183 | 255 | return 0; |
6f121e54 | 256 | } |