1 /*-
2 * Copyright (c) 2014-2017 Mark Johnston <markj@FreeBSD.org>
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 */
26
27 #include <sys/types.h>
28 #include <sys/wait.h>
29
30 #include <libgen.h>
31 #include <stdio.h>
32 #include <stdint.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <atf-c.h>
36 #include <libelf.h>
37 #include <libproc.h>
38
39 static const char *aout_object = "a.out";
40 static const char *ldelf_object = "ld-elf.so.1";
41 static const char *target_prog_file = "target_prog";
42
43 /*
44 * Run the test program. If the sig parameter is set to true, the test program
45 * will deliver SIGUSR1 to itself during execution.
46 */
47 static struct proc_handle *
start_prog(const struct atf_tc * tc,bool sig)48 start_prog(const struct atf_tc *tc, bool sig)
49 {
50 char *argv[3];
51 struct proc_handle *phdl;
52 int error;
53
54 asprintf(&argv[0], "%s/%s", atf_tc_get_config_var(tc, "srcdir"),
55 target_prog_file);
56 ATF_REQUIRE(argv[0] != NULL);
57
58 if (sig) {
59 argv[1] = strdup("-s");
60 argv[2] = NULL;
61 } else {
62 argv[1] = NULL;
63 }
64
65 error = proc_create(argv[0], argv, NULL, NULL, NULL, &phdl);
66 ATF_REQUIRE_EQ_MSG(error, 0, "failed to run '%s'", target_prog_file);
67 ATF_REQUIRE(phdl != NULL);
68
69 free(argv[0]);
70 free(argv[1]);
71
72 return (phdl);
73 }
74
75 static void
set_bkpt(struct proc_handle * phdl,uintptr_t addr,u_long * saved)76 set_bkpt(struct proc_handle *phdl, uintptr_t addr, u_long *saved)
77 {
78 int error;
79
80 error = proc_bkptset(phdl, addr, saved);
81 ATF_REQUIRE_EQ_MSG(error, 0, "failed to set breakpoint at 0x%jx",
82 (uintmax_t)addr);
83 }
84
85 static void
remove_bkpt(struct proc_handle * phdl,uintptr_t addr,u_long val)86 remove_bkpt(struct proc_handle *phdl, uintptr_t addr, u_long val)
87 {
88 int error;
89
90 error = proc_bkptdel(phdl, addr, val);
91 ATF_REQUIRE_EQ_MSG(error, 0,
92 "failed to delete breakpoint at 0x%jx", (uintmax_t)addr);
93
94 error = proc_regset(phdl, REG_PC, addr);
95 ATF_REQUIRE_EQ_MSG(error, 0, "failed to reset program counter");
96 }
97
98 /*
99 * Wait for the specified process to hit a breakpoint at the specified symbol.
100 */
101 static void
verify_bkpt(struct proc_handle * phdl,GElf_Sym * sym,const char * symname,const char * mapname)102 verify_bkpt(struct proc_handle *phdl, GElf_Sym *sym, const char *symname,
103 const char *mapname)
104 {
105 char *name, *mapname_copy, *mapbname;
106 GElf_Sym tsym;
107 prmap_t *map;
108 size_t namesz;
109 u_long addr;
110 int error, state;
111
112 state = proc_wstatus(phdl);
113 ATF_REQUIRE_EQ_MSG(state, PS_STOP, "process has state %d", state);
114
115 /* Get the program counter and decrement it. */
116 error = proc_regget(phdl, REG_PC, &addr);
117 ATF_REQUIRE_EQ_MSG(error, 0, "failed to obtain PC for '%s'",
118 target_prog_file);
119 proc_bkptregadj(&addr);
120
121 /*
122 * Make sure the PC matches the expected value obtained from the symbol
123 * definition we looked up earlier.
124 */
125 ATF_CHECK_EQ_MSG(addr, sym->st_value,
126 "program counter 0x%lx doesn't match expected value 0x%jx",
127 addr, (uintmax_t)sym->st_value);
128
129 /*
130 * Ensure we can look up the r_debug_state symbol using its starting
131 * address and that the resulting symbol matches the one we found using
132 * a name lookup.
133 */
134 namesz = strlen(symname) + 1;
135 name = malloc(namesz);
136 ATF_REQUIRE(name != NULL);
137
138 error = proc_addr2sym(phdl, addr, name, namesz, &tsym);
139 ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up symbol at 0x%lx", addr);
140 ATF_REQUIRE_EQ(memcmp(sym, &tsym, sizeof(*sym)), 0);
141 ATF_REQUIRE_EQ(strcmp(symname, name), 0);
142 free(name);
143
144 map = proc_addr2map(phdl, addr);
145 ATF_REQUIRE_MSG(map != NULL, "failed to look up map for address 0x%lx",
146 addr);
147 mapname_copy = strdup(map->pr_mapname);
148 mapbname = basename(mapname_copy);
149 ATF_REQUIRE_EQ_MSG(strcmp(mapname, mapbname), 0,
150 "expected map name '%s' doesn't match '%s'", mapname, mapbname);
151 free(mapname_copy);
152 }
153
154 ATF_TC(map_alias_name2map);
ATF_TC_HEAD(map_alias_name2map,tc)155 ATF_TC_HEAD(map_alias_name2map, tc)
156 {
157 atf_tc_set_md_var(tc, "descr",
158 "Callers are supposed to be able to use \"a.out\" as an alias for "
159 "the program executable. Make sure that proc_name2map() handles "
160 "this properly.");
161 }
ATF_TC_BODY(map_alias_name2map,tc)162 ATF_TC_BODY(map_alias_name2map, tc)
163 {
164 struct proc_handle *phdl;
165 prmap_t *map1, *map2;
166
167 phdl = start_prog(tc, false);
168
169 /* Initialize the rtld_db handle. */
170 (void)proc_rdagent(phdl);
171
172 /* Ensure that "target_prog" and "a.out" return the same map. */
173 map1 = proc_name2map(phdl, target_prog_file);
174 ATF_REQUIRE_MSG(map1 != NULL, "failed to look up map for '%s'",
175 target_prog_file);
176 map2 = proc_name2map(phdl, aout_object);
177 ATF_REQUIRE_MSG(map2 != NULL, "failed to look up map for '%s'",
178 aout_object);
179 ATF_CHECK_EQ(strcmp(map1->pr_mapname, map2->pr_mapname), 0);
180
181 ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
182
183 proc_detach(phdl, 0);
184 }
185
186 ATF_TC(map_prefix_name2map);
ATF_TC_HEAD(map_prefix_name2map,tc)187 ATF_TC_HEAD(map_prefix_name2map, tc)
188 {
189 atf_tc_set_md_var(tc, "descr",
190 "Verify that proc_name2map() returns prefix matches of the "
191 "basename of loaded objects if no full matches are found.");
192 }
ATF_TC_BODY(map_prefix_name2map,tc)193 ATF_TC_BODY(map_prefix_name2map, tc)
194 {
195 struct proc_handle *phdl;
196 prmap_t *map1, *map2;
197
198 phdl = start_prog(tc, false);
199
200 /* Initialize the rtld_db handle. */
201 (void)proc_rdagent(phdl);
202
203 /* Make sure that "ld-elf" and "ld-elf.so" return the same map. */
204 map1 = proc_name2map(phdl, "ld-elf");
205 ATF_REQUIRE_MSG(map1 != NULL, "failed to look up map for 'ld-elf'");
206 map2 = proc_name2map(phdl, "ld-elf.so");
207 ATF_REQUIRE_MSG(map2 != NULL, "failed to look up map for 'ld-elf.so'");
208 ATF_CHECK_EQ(strcmp(map1->pr_mapname, map2->pr_mapname), 0);
209
210 ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
211
212 proc_detach(phdl, 0);
213 }
214
215 ATF_TC(map_alias_name2sym);
ATF_TC_HEAD(map_alias_name2sym,tc)216 ATF_TC_HEAD(map_alias_name2sym, tc)
217 {
218 atf_tc_set_md_var(tc, "descr",
219 "Callers are supposed to be able to use \"a.out\" as an alias for "
220 "the program executable. Make sure that proc_name2sym() handles "
221 "this properly.");
222 }
ATF_TC_BODY(map_alias_name2sym,tc)223 ATF_TC_BODY(map_alias_name2sym, tc)
224 {
225 GElf_Sym sym1, sym2;
226 prsyminfo_t si1, si2;
227 struct proc_handle *phdl;
228 int error;
229
230 phdl = start_prog(tc, false);
231
232 /* Initialize the rtld_db handle. */
233 (void)proc_rdagent(phdl);
234
235 /*
236 * Make sure that "target_prog:main" and "a.out:main" return the same
237 * symbol.
238 */
239 error = proc_name2sym(phdl, target_prog_file, "main", &sym1, &si1);
240 ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up 'main' via %s",
241 target_prog_file);
242 error = proc_name2sym(phdl, aout_object, "main", &sym2, &si2);
243 ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up 'main' via %s",
244 aout_object);
245
246 ATF_CHECK_EQ(memcmp(&sym1, &sym2, sizeof(sym1)), 0);
247 ATF_CHECK_EQ(si1.prs_id, si2.prs_id);
248
249 ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
250
251 proc_detach(phdl, 0);
252 }
253
254 ATF_TC(symbol_lookup);
ATF_TC_HEAD(symbol_lookup,tc)255 ATF_TC_HEAD(symbol_lookup, tc)
256 {
257 atf_tc_set_md_var(tc, "descr",
258 "Look up a couple of well-known symbols in the test program, place "
259 "breakpoints on them, and verify that we hit the breakpoints. Also "
260 "make sure that we can use the breakpoint address to look up the "
261 "corresponding symbol.");
262 }
ATF_TC_BODY(symbol_lookup,tc)263 ATF_TC_BODY(symbol_lookup, tc)
264 {
265 GElf_Sym main_sym, r_debug_state_sym;
266 struct proc_handle *phdl;
267 u_long saved;
268 int error;
269
270 phdl = start_prog(tc, false);
271
272 error = proc_name2sym(phdl, target_prog_file, "main", &main_sym, NULL);
273 ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up 'main'");
274
275 error = proc_name2sym(phdl, ldelf_object, "r_debug_state",
276 &r_debug_state_sym, NULL);
277 ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up 'r_debug_state'");
278
279 set_bkpt(phdl, r_debug_state_sym.st_value, &saved);
280 ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
281 verify_bkpt(phdl, &r_debug_state_sym, "r_debug_state", ldelf_object);
282 remove_bkpt(phdl, r_debug_state_sym.st_value, saved);
283
284 set_bkpt(phdl, main_sym.st_value, &saved);
285 ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
286 verify_bkpt(phdl, &main_sym, "main", target_prog_file);
287 remove_bkpt(phdl, main_sym.st_value, saved);
288
289 ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
290
291 proc_detach(phdl, 0);
292 }
293
294 ATF_TC(symbol_lookup_fail);
ATF_TC_HEAD(symbol_lookup_fail,tc)295 ATF_TC_HEAD(symbol_lookup_fail, tc)
296 {
297 atf_tc_set_md_var(tc, "descr",
298 "Verify that proc_addr2sym() returns an error when given an offset "
299 "that it cannot resolve.");
300 }
ATF_TC_BODY(symbol_lookup_fail,tc)301 ATF_TC_BODY(symbol_lookup_fail, tc)
302 {
303 char symname[32];
304 GElf_Sym sym;
305 struct proc_handle *phdl;
306 prmap_t *map;
307 int error;
308
309 phdl = start_prog(tc, false);
310
311 /* Initialize the rtld_db handle. */
312 (void)proc_rdagent(phdl);
313
314 map = proc_name2map(phdl, target_prog_file);
315 ATF_REQUIRE_MSG(map != NULL, "failed to look up map for '%s'",
316 target_prog_file);
317
318 /*
319 * We shouldn't be able to find symbols at the beginning of a mapped
320 * file.
321 */
322 error = proc_addr2sym(phdl, map->pr_vaddr, symname, sizeof(symname),
323 &sym);
324 ATF_REQUIRE_MSG(error != 0, "unexpectedly found a symbol");
325
326 ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
327
328 proc_detach(phdl, 0);
329 }
330
331 ATF_TC(signal_forward);
ATF_TC_HEAD(signal_forward,tc)332 ATF_TC_HEAD(signal_forward, tc)
333 {
334 atf_tc_set_md_var(tc, "descr",
335 "Run the test program in a mode which causes it to send a signal "
336 "to itself. Make sure that we intercept the signal and that "
337 "proc_continue() forwards it to the process.");
338 }
ATF_TC_BODY(signal_forward,tc)339 ATF_TC_BODY(signal_forward, tc)
340 {
341 struct proc_handle *phdl;
342 int state, status;
343
344 phdl = start_prog(tc, true);
345 ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
346
347 /* The process should have been interrupted by a signal. */
348 state = proc_wstatus(phdl);
349 ATF_REQUIRE_EQ_MSG(state, PS_STOP, "process has unexpected state %d",
350 state);
351
352 /* Continue execution and allow the signal to be delivered. */
353 ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
354
355 /*
356 * Make sure the process exited with status 0. If it didn't receive the
357 * SIGUSR1 that it sent to itself, it'll exit with a non-zero exit
358 * status, causing the test to fail.
359 */
360 state = proc_wstatus(phdl);
361 ATF_REQUIRE_EQ_MSG(state, PS_UNDEAD, "process has unexpected state %d",
362 state);
363
364 status = proc_getwstat(phdl);
365 ATF_REQUIRE(status >= 0);
366 ATF_REQUIRE(WIFEXITED(status));
367 ATF_REQUIRE_EQ(WEXITSTATUS(status), 0);
368
369 proc_detach(phdl, 0);
370 }
371
372 ATF_TC(symbol_sort_local);
ATF_TC_HEAD(symbol_sort_local,tc)373 ATF_TC_HEAD(symbol_sort_local, tc)
374 {
375 atf_tc_set_md_var(tc, "descr",
376 "Ensure that proc_addr2sym() returns the non-local alias when "
377 "the address resolves to multiple symbols.");
378 }
ATF_TC_BODY(symbol_sort_local,tc)379 ATF_TC_BODY(symbol_sort_local, tc)
380 {
381 char symname[32];
382 GElf_Sym bar_sym;
383 struct proc_handle *phdl;
384 int error;
385
386 phdl = start_prog(tc, true);
387
388 error = proc_name2sym(phdl, target_prog_file, "bar", &bar_sym, NULL);
389 ATF_REQUIRE_MSG(error == 0, "failed to look up 'bar' in %s",
390 target_prog_file);
391 ATF_REQUIRE(GELF_ST_BIND(bar_sym.st_info) == STB_LOCAL);
392
393 error = proc_addr2sym(phdl, bar_sym.st_value, symname, sizeof(symname),
394 &bar_sym);
395 ATF_REQUIRE_MSG(error == 0, "failed to resolve 'bar' by addr");
396
397 ATF_REQUIRE_MSG(strcmp(symname, "baz") == 0,
398 "unexpected symbol name '%s'", symname);
399 ATF_REQUIRE(GELF_ST_BIND(bar_sym.st_info) == STB_GLOBAL);
400
401 proc_detach(phdl, 0);
402 }
403
404 ATF_TC(symbol_sort_prefix);
ATF_TC_HEAD(symbol_sort_prefix,tc)405 ATF_TC_HEAD(symbol_sort_prefix, tc)
406 {
407 atf_tc_set_md_var(tc, "descr",
408 "Ensure that proc_addr2sym() returns the alias whose name is not "
409 "prefixed with '$' if one exists.");
410 }
ATF_TC_BODY(symbol_sort_prefix,tc)411 ATF_TC_BODY(symbol_sort_prefix, tc)
412 {
413 char symname[32];
414 GElf_Sym qux_sym;
415 struct proc_handle *phdl;
416 int error;
417
418 phdl = start_prog(tc, true);
419
420 error = proc_name2sym(phdl, target_prog_file, "$qux", &qux_sym, NULL);
421 ATF_REQUIRE_MSG(error == 0, "failed to look up '$qux' in %s",
422 target_prog_file);
423
424 error = proc_addr2sym(phdl, qux_sym.st_value, symname, sizeof(symname),
425 &qux_sym);
426 ATF_REQUIRE_MSG(error == 0, "failed to resolve 'qux' by addr");
427
428 ATF_REQUIRE_MSG(strcmp(symname, "qux") == 0,
429 "unexpected symbol name '%s'", symname);
430
431 proc_detach(phdl, 0);
432 }
433
434 ATF_TC(symbol_sort_underscore);
ATF_TC_HEAD(symbol_sort_underscore,tc)435 ATF_TC_HEAD(symbol_sort_underscore, tc)
436 {
437 atf_tc_set_md_var(tc, "descr",
438 "Ensure that proc_addr2sym() returns the alias with fewest leading "
439 "underscores in the name when the address resolves to multiple "
440 "symbols.");
441 }
ATF_TC_BODY(symbol_sort_underscore,tc)442 ATF_TC_BODY(symbol_sort_underscore, tc)
443 {
444 char symname[32];
445 GElf_Sym foo_sym;
446 struct proc_handle *phdl;
447 int error;
448
449 phdl = start_prog(tc, true);
450
451 error = proc_name2sym(phdl, target_prog_file, "foo", &foo_sym, NULL);
452 ATF_REQUIRE_MSG(error == 0, "failed to look up 'foo' in %s",
453 target_prog_file);
454
455 error = proc_addr2sym(phdl, foo_sym.st_value, symname, sizeof(symname),
456 &foo_sym);
457 ATF_REQUIRE_MSG(error == 0, "failed to resolve 'foo' by addr");
458
459 ATF_REQUIRE_MSG(strcmp(symname, "foo") == 0,
460 "unexpected symbol name '%s'", symname);
461
462 proc_detach(phdl, 0);
463 }
464
ATF_TP_ADD_TCS(tp)465 ATF_TP_ADD_TCS(tp)
466 {
467
468 ATF_TP_ADD_TC(tp, map_alias_name2map);
469 ATF_TP_ADD_TC(tp, map_prefix_name2map);
470 ATF_TP_ADD_TC(tp, map_alias_name2sym);
471 ATF_TP_ADD_TC(tp, symbol_lookup);
472 ATF_TP_ADD_TC(tp, symbol_lookup_fail);
473 ATF_TP_ADD_TC(tp, signal_forward);
474 ATF_TP_ADD_TC(tp, symbol_sort_local);
475 ATF_TP_ADD_TC(tp, symbol_sort_prefix);
476 ATF_TP_ADD_TC(tp, symbol_sort_underscore);
477
478 return (atf_no_error());
479 }
480