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
193
194
195
196
197
198
199
200
201
202
203
|
/*
* The main module for truss. Suprisingly simple, but, then, the other
* files handle the bulk of the work. And, of course, the kernel has to
* do a lot of the work :).
*/
/*
* $Id: main.c,v 1.4 1997/12/06 17:13:54 sef Exp $
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <err.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/pioctl.h>
extern int setup_and_wait(char **);
extern int start_tracing(int, int);
extern void i386_syscall_entry(int, int);
extern void i386_syscall_exit(int, int);
extern void i386_linux_syscall_entry(int, int);
extern void i386_linux_syscall_exit(int, int);
/*
* These should really be parameterized -- I don't like having globals,
* but this is the easiest way, right now, to deal with them.
*/
int pid = 0;
int nosigs = 0;
FILE *outfile = stderr;
char *prog;
int Procfd;
char progtype[50]; /* OS and type of executable */
static inline void
usage(void) {
fprintf(stderr, "usage: %s [-o <file>] [-S] { [-p <pid> ] | "
"[ <command> <args>] }\n", prog);
exit(1);
}
struct ex_types {
char *type;
void (*enter_syscall)(int, int);
void (*exit_syscall)(int, int);
} ex_types[] = {
{ "FreeBSD a.out", i386_syscall_entry, i386_syscall_exit },
{ "FreeBSD ELF", i386_syscall_entry, i386_syscall_exit },
{ "Linux ELF", i386_linux_syscall_entry, i386_linux_syscall_exit },
{ 0, 0, 0 },
};
/*
* Set the execution type. This is called after every exec, and when
* a process is first monitored. The procfs pseudo-file "etype" has
* the execution module type -- see /proc/curproc/etype for an example.
*/
static struct ex_types *
set_etype() {
struct ex_types *funcs;
char etype[24];
char progtype[32];
int fd;
sprintf(etype, "/proc/%d/etype", pid);
if ((fd = open(etype, O_RDONLY)) == -1) {
strcpy(progtype, "FreeBSD a.out");
} else {
int len = read(fd, progtype, sizeof(progtype));
progtype[len-1] = '\0';
close(fd);
}
for (funcs = ex_types; funcs->type; funcs++)
if (!strcmp(funcs->type, progtype))
break;
return funcs;
}
main(int ac, char **av) {
int mask;
int c;
int i;
char **command;
struct procfs_status pfs;
char etype[25];
struct ex_types *funcs;
int fd;
int in_exec = 0;
prog = av[0];
while ((c = getopt(ac, av, "p:o:S")) != EOF) {
switch (c) {
case 'p': /* specified pid */
pid = atoi(optarg);
break;
case 'o': /* Specified output file */
if ((outfile = fopen(optarg, "w")) == NULL) {
fprintf (stderr, "%s: cannot open %s\n", av[0], optarg);
exit(1);
}
break;
case 'S': /* Don't trace signals */
nosigs = 1;
break;
default:
usage();
}
}
ac -= optind; av += optind;
if ((pid == 0 && ac == 0) || (pid != 0 && ac != 0))
usage();
/*
* If truss starts the process itself, it will ignore some signals --
* they should be passed off to the process, which may or may not
* exit. If, however, we are examining an already-running process,
* then we restore the event mask on these same signals.
*/
if (pid == 0) { /* Start a command ourselves */
command = av;
pid = setup_and_wait(command);
signal(SIGINT, SIG_IGN);
signal(SIGTERM, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
} else {
extern void restore_proc(int);
signal(SIGINT, restore_proc);
signal(SIGTERM, restore_proc);
signal(SIGQUIT, restore_proc);
}
/*
* At this point, if we started the process, it is stopped waiting to
* be woken up, either in exit() or in execve().
*/
Procfd = start_tracing(pid, S_EXEC | S_SCE | S_SCX | S_CORE | S_EXIT |
(nosigs ? 0 : S_SIG));
pfs.why = 0;
funcs = set_etype();
/*
* At this point, it's a simple loop, waiting for the process to
* stop, finding out why, printing out why, and then continuing it.
* All of the grunt work is done in the support routines.
*/
do {
int val = 0;
if (ioctl(Procfd, PIOCWAIT, &pfs) == -1)
perror("PIOCWAIT top of loop");
else {
switch(i = pfs.why) {
case S_SCE:
funcs->enter_syscall(pid, pfs.val);
break;
case S_SCX:
/*
* This is so we don't get two messages for an exec -- one
* for the S_EXEC, and one for the syscall exit. It also,
* conveniently, ensures that the first message printed out
* isn't the return-from-syscall used to create the process.
*/
if (in_exec) {
in_exec = 0;
break;
}
funcs->exit_syscall(pid, pfs.val);
break;
case S_SIG:
fprintf(outfile, "SIGNAL %d\n", pfs.val);
break;
case S_EXIT:
fprintf (outfile, "process exit, rval = %d\n", pfs.val);
break;
case S_EXEC:
funcs = set_etype();
in_exec = 1;
break;
default:
fprintf (outfile, "Process stopped because of: %d\n", i);
break;
}
}
if (ioctl(Procfd, PIOCCONT, val) == -1)
perror("PIOCCONT");
} while (pfs.why != S_EXIT);
return 0;
}
|