common.h revision 94078ecce3a103c28457e6f90f1e5b0dacc61146 
1/*
2 * This file is part of ltrace.
3 * Copyright (C) 2011,2012 Petr Machata, Red Hat Inc.
4 * Copyright (C) 2010 Joe Damato
5 * Copyright (C) 2009 Juan Cespedes
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License as
9 * published by the Free Software Foundation; either version 2 of the
10 * License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20 * 02110-1301 USA
21 */
22
23#ifndef COMMON_H
24#define COMMON_H
25
26#include <config.h>
27
28#include <sys/types.h>
29#include <sys/time.h>
30#include <stdio.h>
31
32#include "ltrace.h"
33#include "defs.h"
34#include "dict.h"
35#include "sysdep.h"
36#include "debug.h"
37#include "ltrace-elf.h"
38#include "read_config_file.h"
39#include "proc.h"
40#include "forward.h"
41
42#if defined HAVE_LIBSUPC__ || defined HAVE_LIBSTDC__
43# define USE_CXA_DEMANGLE
44#endif
45#if defined HAVE_LIBIBERTY || defined USE_CXA_DEMANGLE
46# define USE_DEMANGLE
47#endif
48
49extern char * command;
50
51extern int exiting;  /* =1 if we have to exit ASAP */
52
53enum tof {
54	LT_TOF_NONE = 0,
55	LT_TOF_FUNCTION,	/* A real library function */
56	LT_TOF_FUNCTIONR,	/* Return from a real library function */
57	LT_TOF_SYSCALL,		/* A syscall */
58	LT_TOF_SYSCALLR,	/* Return from a syscall */
59	LT_TOF_STRUCT		/* Not a function; read args from struct */
60};
61
62typedef struct Function Function;
63struct Function {
64	const char * name;
65	struct arg_type_info *return_info;
66	int num_params;
67	struct arg_type_info *arg_info[MAX_ARGS];
68	int params_right;
69	Function * next;
70};
71
72extern Function * list_of_functions;
73extern char *PLTs_initialized_by_here;
74
75struct opt_c_struct {
76	int count;
77	struct timeval tv;
78};
79
80#include "options.h"
81#include "output.h"
82#ifdef USE_DEMANGLE
83#include "demangle.h"
84#endif
85
86extern Dict * dict_opt_c;
87
88enum process_status {
89	ps_invalid,	/* Failure.  */
90	ps_stop,	/* Job-control stop.  */
91	ps_tracing_stop,
92	ps_sleeping,
93	ps_zombie,
94	ps_other,	/* Necessary other states can be added as needed.  */
95};
96
97/* Events  */
98enum ecb_status {
99	ecb_cont, /* The iteration should continue.  */
100	ecb_yield, /* The iteration should stop, yielding this
101		    * event.  */
102	ecb_deque, /* Like ecb_stop, but the event should be removed
103		    * from the queue.  */
104};
105extern Event * next_event(void);
106extern Event * each_qd_event(enum ecb_status (* cb)(Event * event, void * data),
107			     void * data);
108extern void enque_event(Event * event);
109extern void handle_event(Event * event);
110
111extern pid_t execute_program(const char * command, char ** argv);
112
113extern void show_summary(void);
114
115struct breakpoint;
116struct library_symbol;
117
118struct breakpoint;
119
120/* Arch-dependent stuff: */
121extern char * pid2name(pid_t pid);
122extern pid_t process_leader(pid_t pid);
123extern int process_tasks(pid_t pid, pid_t **ret_tasks, size_t *ret_n);
124extern int process_stopped(pid_t pid);
125extern enum process_status process_status(pid_t pid);
126extern void trace_set_options(struct Process *proc);
127extern int wait_for_proc(pid_t pid);
128extern void trace_me(void);
129extern int trace_pid(pid_t pid);
130extern void untrace_pid(pid_t pid);
131extern void get_arch_dep(Process * proc);
132extern void * get_instruction_pointer(Process * proc);
133extern void set_instruction_pointer(Process * proc, void * addr);
134extern void * get_stack_pointer(Process * proc);
135extern void * get_return_addr(Process * proc, void * stack_pointer);
136extern void set_return_addr(Process * proc, void * addr);
137extern void enable_breakpoint(struct Process *proc, struct breakpoint *sbp);
138extern void disable_breakpoint(struct Process *proc, struct breakpoint *sbp);
139extern int syscall_p(Process * proc, int status, int * sysnum);
140extern void continue_process(pid_t pid);
141extern void continue_after_signal(pid_t pid, int signum);
142extern void continue_after_syscall(Process *proc, int sysnum, int ret_p);
143extern void continue_after_breakpoint(struct Process *proc, struct breakpoint *sbp);
144extern void continue_after_vfork(Process * proc);
145extern long gimme_arg(enum tof type, Process *proc, int arg_num,
146		      struct arg_type_info *info);
147extern void save_register_args(enum tof type, Process * proc);
148extern int umovestr(Process * proc, void * addr, int len, void * laddr);
149extern int umovelong(Process *proc, void *addr, long *result,
150		     struct arg_type_info *info);
151extern size_t umovebytes (Process *proc, void * addr, void * laddr, size_t count);
152extern int ffcheck(void * maddr);
153extern void * sym2addr(Process *, struct library_symbol *);
154extern int linkmap_init(struct Process *proc, void *dyn_addr);
155extern void arch_check_dbg(Process *proc);
156extern int task_kill (pid_t pid, int sig);
157
158/* Called when trace_me or primary trace_pid fail.  This may plug in
159 * any platform-specific knowledge of why it could be so.  */
160void trace_fail_warning(pid_t pid);
161
162/* A pair of functions called to initiate a detachment request when
163 * ltrace is about to exit.  Their job is to undo any effects that
164 * tracing had and eventually detach process, perhaps by way of
165 * installing a process handler.
166 *
167 * OS_LTRACE_EXITING_SIGHANDLER is called from a signal handler
168 * context right after the signal was captured.  It returns 1 if the
169 * request was handled or 0 if it wasn't.
170 *
171 * If the call to OS_LTRACE_EXITING_SIGHANDLER didn't handle the
172 * request, OS_LTRACE_EXITING is called when the next event is
173 * generated.  Therefore it's called in "safe" context, without
174 * re-entrancy concerns, but it's only called after an event is
175 * generated.  */
176int os_ltrace_exiting_sighandler(void);
177void os_ltrace_exiting(void);
178
179int arch_elf_init(struct ltelf *lte, struct library *lib);
180void arch_elf_destroy(struct ltelf *lte);
181
182enum plt_status {
183	plt_fail,
184	plt_ok,
185	plt_default,
186};
187
188enum plt_status arch_elf_add_plt_entry(struct Process *p, struct ltelf *l,
189				       const char *n, GElf_Rela *r, size_t i,
190				       struct library_symbol **ret);
191
192int arch_breakpoint_init(struct Process *proc, struct breakpoint *sbp);
193void arch_breakpoint_destroy(struct breakpoint *sbp);
194int arch_breakpoint_clone(struct breakpoint *retp, struct breakpoint *sbp);
195
196void arch_library_init(struct library *lib);
197void arch_library_destroy(struct library *lib);
198void arch_library_clone(struct library *retp, struct library *lib);
199
200int arch_library_symbol_init(struct library_symbol *libsym);
201void arch_library_symbol_destroy(struct library_symbol *libsym);
202int arch_library_symbol_clone(struct library_symbol *retp,
203			      struct library_symbol *libsym);
204
205int arch_process_init(struct Process *proc);
206void arch_process_destroy(struct Process *proc);
207int arch_process_clone(struct Process *retp, struct Process *proc);
208int arch_process_exec(struct Process *proc);
209
210/* This is called after the dynamic linker is done with the
211 * process startup.  */
212void arch_dynlink_done(struct Process *proc);
213
214/* Format VALUE into STREAM.  The dictionary of all arguments is given
215 * for purposes of evaluating array lengths and other dynamic
216 * expressions.  Returns number of characters outputted, -1 in case of
217 * failure.  */
218int format_argument(FILE *stream, struct value *value,
219		    struct value_dict *arguments);
220
221#endif
222