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