1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
/*
* This file is part of ltrace.
* Copyright (C) 2010,2011,2012 Petr Machata, Red Hat Inc.
* Copyright (C) 2010 Joe Damato
* Copyright (C) 1998,2001,2008,2009 Juan Cespedes
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*/
#ifndef _PROC_H_
#define _PROC_H_
#if defined(HAVE_LIBUNWIND)
# include <libunwind.h>
#endif /* defined(HAVE_LIBUNWIND) */
#include "ltrace.h"
#include "dict.h"
struct library;
/* XXX Move this somewhere where it makes sense. When the mess in
* common.h is disentangled, that would actually be a good place for
* this. */
enum callback_status {
CBS_STOP, /* The iteration should stop. */
CBS_CONT, /* The iteration should continue. */
};
struct event_handler {
/* Event handler that overrides the default one. Should
* return NULL if the event was handled, otherwise the
* returned event is passed to the default handler. */
Event *(*on_event)(struct event_handler *self, Event *event);
/* Called when the event handler removal is requested. */
void (*destroy)(struct event_handler *self);
};
enum process_state {
STATE_ATTACHED = 0,
STATE_BEING_CREATED,
STATE_IGNORED /* ignore this process (it's a fork and no -f was used) */
};
struct callstack_element {
union {
int syscall;
struct library_symbol * libfunc;
} c_un;
int is_syscall;
void * return_addr;
struct timeval time_spent;
void * arch_ptr;
};
/* XXX We should get rid of this. */
#define MAX_CALLDEPTH 64
/* XXX We would rather have this all organized a little differently,
* have Process for the whole group and Task for what's there for
* per-thread stuff. But for now this is the less invasive way of
* structuring it. */
typedef struct Process Process;
struct Process {
enum process_state state;
Process * parent; /* needed by STATE_BEING_CREATED */
char * filename;
pid_t pid;
/* Dictionary of breakpoints (which is a mapping
* address->breakpoint). This is NULL for non-leader
* processes. */
Dict * breakpoints;
int mask_32bit; /* 1 if 64-bit ltrace is tracing 32-bit process */
unsigned int personality;
int tracesysgood; /* signal indicating a PTRACE_SYSCALL trap */
int callstack_depth;
struct callstack_element callstack[MAX_CALLDEPTH];
struct library *libraries;
/* Arch-dependent: */
void * debug; /* arch-dep process debug struct */
long debug_state; /* arch-dep debug state */
void * instruction_pointer;
void * stack_pointer; /* To get return addr, args... */
void * return_addr;
void * arch_ptr;
short e_machine;
#ifdef __arm__
int thumb_mode; /* ARM execution mode: 0: ARM, 1: Thumb */
#endif
#if defined(HAVE_LIBUNWIND)
/* libunwind address space */
unw_addr_space_t unwind_as;
void *unwind_priv;
#endif /* defined(HAVE_LIBUNWIND) */
/* Set in leader. */
struct event_handler *event_handler;
/**
* Process chaining.
**/
Process * next;
/* LEADER points to the leader thread of the POSIX.1 process.
If X->LEADER == X, then X is the leader thread and the
Process structures chained by NEXT represent other threads,
up until, but not including, the next leader thread.
LEADER may be NULL after the leader has already exited. In
that case this process is waiting to be collected. */
Process * leader;
};
int process_init(struct Process *proc,
const char *filename, pid_t pid, int enable_breakpoints);
Process * open_program(const char *filename, pid_t pid, int enable_breakpoints);
void open_pid(pid_t pid);
Process * pid2proc(pid_t pid);
/* Clone the contents of PROC into the memory referenced by RETP.
* Returns 0 on success or a negative value on failure. */
int process_clone(struct Process *retp, struct Process *proc, pid_t pid);
/* Iterate through the processes that ltrace currently traces. CB is
* called for each process. Tasks are considered to be processes for
* the purpose of this iterator.
*
* Notes on this iteration interface: The iteration starts after the
* process designated by START_AFTER, or at the first process if
* START_AFTER is NULL. DATA is passed verbatim to CB. If CB returns
* CBS_STOP, the iteration stops and the current iterator is returned.
* That iterator can then be used to restart the iteration. NULL is
* returned when iteration ends.
*
* There's no provision for returning error states. Errors need to be
* signaled to the caller via DATA, together with any other data that
* the callback needs. */
Process *each_process(Process *start_after,
enum callback_status (*cb)(struct Process *proc,
void *data),
void *data);
/* Iterate through list of tasks of given process PROC. Restarts are
* supported via START_AFTER (see each_process for details of
* iteration interface). */
Process *each_task(struct Process *proc, struct Process *start_after,
enum callback_status (*cb)(struct Process *proc,
void *data),
void *data);
void add_process(Process *proc);
void change_process_leader(Process *proc, Process *leader);
void remove_process(Process *proc);
void install_event_handler(Process *proc, struct event_handler *handler);
void destroy_event_handler(Process *proc);
/* Add a library LIB to the list of PROC's libraries. */
void proc_add_library(struct Process *proc, struct library *lib);
/* Remove LIB from list of PROC's libraries. Returns 0 if the library
* was found and unlinked, otherwise returns a negative value. */
int proc_remove_library(struct Process *proc, struct library *lib);
/* Iterate through the libraries of PROC. See each_process for
* detailed description of the iteration interface. */
struct library *proc_each_library(struct Process *proc, struct library *start,
enum callback_status (*cb)(struct Process *p,
struct library *l,
void *data),
void *data);
#endif /* _PROC_H_ */
|
