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