1/*
2 * This file is part of ltrace.
3 * Copyright (C) 2011,2012,2013 Petr Machata, Red Hat Inc.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of the
8 * License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 * General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
18 * 02110-1301 USA
19 */
20
21#ifndef _LTRACE_LINUX_TRACE_H_
22#define _LTRACE_LINUX_TRACE_H_
23
24#include "proc.h"
25
26/* This publishes some Linux-specific data structures used for process
27 * handling.  */
28
29/**
30 * This is used for bookkeeping related to PIDs that the event
31 * handlers work with.
32 */
33struct pid_task {
34	pid_t pid;	/* This may be 0 for tasks that exited
35			 * mid-handling.  */
36	int sigstopped : 1;
37	int got_event : 1;
38	int delivered : 1;
39	int vforked : 1;
40	int sysret : 1;
41};
42
43struct pid_set {
44	struct pid_task *tasks;
45	size_t count;
46	size_t alloc;
47};
48
49/**
50 * Breakpoint re-enablement.  When we hit a breakpoint, we must
51 * disable it, single-step, and re-enable it.  That single-step can be
52 * done only by one task in a task group, while others are stopped,
53 * otherwise the processes would race for who sees the breakpoint
54 * disabled and who doesn't.  The following is to keep track of it
55 * all.
56 */
57struct process_stopping_handler
58{
59	struct event_handler super;
60
61	/* The task that is doing the re-enablement.  */
62	struct process *task_enabling_breakpoint;
63
64	/* The pointer being re-enabled.  */
65	struct breakpoint *breakpoint_being_enabled;
66
67	/* Software singlestep breakpoints, if any needed.  */
68	struct breakpoint *sws_bps[2];
69
70	/* When all tasks are stopped, this callback gets called.  */
71	void (*on_all_stopped)(struct process_stopping_handler *);
72
73	/* When we get a singlestep event, this is called to decide
74	 * whether to stop stepping, or whether to enable the
75	 * brakpoint, sink remaining signals, and continue
76	 * everyone.  */
77	enum callback_status (*keep_stepping_p)
78		(struct process_stopping_handler *);
79
80	/* Whether we need to use ugly workaround to get around
81	 * various problems with singlestepping.  */
82	enum callback_status (*ugly_workaround_p)
83		(struct process_stopping_handler *);
84
85	enum {
86		/* We are waiting for everyone to land in t/T.  */
87		PSH_STOPPING = 0,
88
89		/* We are doing the PTRACE_SINGLESTEP.  */
90		PSH_SINGLESTEP,
91
92		/* We are waiting for all the SIGSTOPs to arrive so
93		 * that we can sink them.  */
94		PSH_SINKING,
95
96		/* This is for tracking the ugly workaround.  */
97		PSH_UGLY_WORKAROUND,
98	} state;
99
100	int exiting;
101
102	struct pid_set pids;
103};
104
105/* Allocate a process stopping handler, initialize it and install it.
106 * Return 0 on success or a negative value on failure.  Pass NULL for
107 * each callback to use a default instead.  The default for
108 * ON_ALL_STOPPED is LINUX_PTRACE_DISABLE_AND_SINGLESTEP, the default
109 * for KEEP_STEPPING_P and UGLY_WORKAROUND_P is "no".  */
110int process_install_stopping_handler
111	(struct process *proc, struct breakpoint *sbp,
112	 void (*on_all_stopped)(struct process_stopping_handler *),
113	 enum callback_status (*keep_stepping_p)
114		 (struct process_stopping_handler *),
115	 enum callback_status (*ugly_workaround_p)
116		(struct process_stopping_handler *));
117
118void linux_ptrace_disable_and_singlestep(struct process_stopping_handler *self);
119void linux_ptrace_disable_and_continue(struct process_stopping_handler *self);
120
121/* When main binary needs to call an IFUNC function defined in the
122 * binary itself, a PLT entry is set up so that dynamic linker can get
123 * involved and resolve the symbol.  But unlike other PLT relocation,
124 * this one can't rely on symbol table being available.  So it doesn't
125 * reference the symbol by its name, but by its address, and
126 * correspondingly, has another type.  When arch backend wishes to
127 * support these IRELATIVE relocations, it should override
128 * arch_elf_add_plt_entry and dispatch to this function for IRELATIVE
129 * relocations.
130 *
131 * This function behaves as arch_elf_add_plt_entry, except that it
132 * doesn't take name for a parameter, but instead looks up the name in
133 * symbol tables in LTE.  */
134enum plt_status linux_elf_add_plt_entry_irelative(struct process *proc,
135						  struct ltelf *lte,
136						  GElf_Rela *rela, size_t ndx,
137						  struct library_symbol **ret);
138
139/* Service routine of the above.  Determines a name corresponding to
140 * ADDR, or invents a new one.  Returns NULL on failures, otherwise it
141 * returns a malloc'd pointer that the caller is responsible for
142 * freeing.  */
143char *linux_elf_find_irelative_name(struct ltelf *lte, GElf_Addr addr);
144
145/* Returns ${NAME}.IFUNC in a newly-malloc'd block, or NULL on
146 * failures.  */
147char *linux_append_IFUNC_to_name(const char *name);
148
149/* Returns a statically allocated prototype that represents the
150 * prototype "void *()".  Never fails.  */
151struct prototype *linux_IFUNC_prototype(void);
152
153
154#endif /* _LTRACE_LINUX_TRACE_H_ */
155