ATF_TC_BODY(signal_forward, tc)
{
struct proc_handle *phdl;
int state, status;
phdl = start_prog(tc, true);
ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
/* The process should have been interrupted by a signal. */
state = proc_wstatus(phdl);
ATF_REQUIRE_EQ_MSG(state, PS_STOP, "process has unexpected state %d",
state);
/* Continue execution and allow the signal to be delivered. */
ATF_CHECK_EQ_MSG(proc_continue(phdl), 0, "failed to resume execution");
/*
* Make sure the process exited with status 0. If it didn't receive the
* SIGUSR1 that it sent to itself, it'll exit with a non-zero exit
* status, causing the test to fail.
*/
state = proc_wstatus(phdl);
ATF_REQUIRE_EQ_MSG(state, PS_UNDEAD, "process has unexpected state %d",
state);
status = proc_getwstat(phdl);
ATF_REQUIRE(status >= 0);
ATF_REQUIRE(WIFEXITED(status));
ATF_REQUIRE_EQ(WEXITSTATUS(status), 0);
proc_free(phdl);
}
int
t1_bkpt_d()
{
struct proc_handle *phdl;
char *targv[] = { "t1-bkpt-t", NULL};
unsigned long saved;
proc_create("./t1-bkpt", targv, NULL, NULL, &phdl);
assert(proc_bkptset(phdl, (uintptr_t)t1_bkpt_t, &saved) == 0);
proc_continue(phdl);
assert(proc_wstatus(phdl) == PS_STOP);
proc_bkptexec(phdl, saved);
proc_continue(phdl);
proc_wstatus(phdl);
proc_free(phdl);
}
/*
* Wait for the specified process to hit a breakpoint at the specified symbol.
*/
static void
verify_bkpt(struct proc_handle *phdl, GElf_Sym *sym, const char *symname,
const char *mapname)
{
char mapbname[MAXPATHLEN], *name;
GElf_Sym tsym;
prmap_t *map;
size_t namesz;
u_long addr;
int error, state;
state = proc_wstatus(phdl);
ATF_REQUIRE_EQ_MSG(state, PS_STOP, "process has state %d", state);
/* Get the program counter and decrement it. */
error = proc_regget(phdl, REG_PC, &addr);
ATF_REQUIRE_EQ_MSG(error, 0, "failed to obtain PC for '%s'",
target_prog_file);
proc_bkptregadj(&addr);
/*
* Make sure the PC matches the expected value obtained from the symbol
* definition we looked up earlier.
*/
ATF_CHECK_EQ_MSG(addr, sym->st_value,
"program counter 0x%lx doesn't match expected value 0x%jx",
addr, (uintmax_t)sym->st_value);
/*
* Ensure we can look up the r_debug_state symbol using its starting
* address and that the resulting symbol matches the one we found using
* a name lookup.
*/
namesz = strlen(symname) + 1;
name = malloc(namesz);
ATF_REQUIRE(name != NULL);
error = proc_addr2sym(phdl, addr, name, namesz, &tsym);
ATF_REQUIRE_EQ_MSG(error, 0, "failed to look up symbol at 0x%lx", addr);
ATF_REQUIRE_EQ(memcmp(sym, &tsym, sizeof(*sym)), 0);
ATF_REQUIRE_EQ_MSG(strcmp(symname, name), 0,
"expected symbol name '%s' doesn't match '%s'", symname, name);
free(name);
map = proc_addr2map(phdl, addr);
ATF_REQUIRE_MSG(map != NULL, "failed to look up map for address 0x%lx",
addr);
basename_r(map->pr_mapname, mapbname);
ATF_REQUIRE_EQ_MSG(strcmp(mapname, mapbname), 0,
"expected map name '%s' doesn't match '%s'", mapname, mapbname);
}
/*
* Step over the breakpoint.
*/
int
proc_bkptexec(struct proc_handle *phdl, unsigned long saved)
{
unsigned long pc;
unsigned long samesaved;
int status;
if (proc_regget(phdl, REG_PC, &pc) < 0) {
warn("ERROR: couldn't get PC register");
return (-1);
}
proc_bkptregadj(&pc);
if (proc_bkptdel(phdl, pc, saved) < 0) {
warn("ERROR: couldn't delete breakpoint");
return (-1);
}
/*
* Go back in time and step over the new instruction just
* set up by proc_bkptdel().
*/
proc_regset(phdl, REG_PC, pc);
if (ptrace(PT_STEP, proc_getpid(phdl), (caddr_t)1, 0) < 0) {
warn("ERROR: ptrace step failed");
return (-1);
}
proc_wstatus(phdl);
status = proc_getwstat(phdl);
if (!WIFSTOPPED(status)) {
warn("ERROR: don't know why process stopped");
return (-1);
}
/*
* Restore the breakpoint. The saved instruction should be
* the same as the one that we were passed in.
*/
if (proc_bkptset(phdl, pc, &samesaved) < 0) {
warn("ERROR: couldn't restore breakpoint");
return (-1);
}
assert(samesaved == saved);
return (0);
}
