trace_syscalls.c 11.8 KB
Newer Older
1
#include <trace/syscall.h>
2
#include <linux/kernel.h>
3
#include <linux/ftrace.h>
4
#include <linux/perf_counter.h>
5
6
7
8
9
#include <asm/syscall.h>

#include "trace_output.h"
#include "trace.h"

10
static DEFINE_MUTEX(syscall_trace_lock);
11
12
13
14
static int sys_refcount_enter;
static int sys_refcount_exit;
static DECLARE_BITMAP(enabled_enter_syscalls, FTRACE_SYSCALL_MAX);
static DECLARE_BITMAP(enabled_exit_syscalls, FTRACE_SYSCALL_MAX);
15

16
17
18
19
20
21
22
23
24
enum print_line_t
print_syscall_enter(struct trace_iterator *iter, int flags)
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *ent = iter->ent;
	struct syscall_trace_enter *trace;
	struct syscall_metadata *entry;
	int i, ret, syscall;

25
	trace = (typeof(trace))ent;
26
27
	syscall = trace->nr;
	entry = syscall_nr_to_meta(syscall);
28

29
30
31
	if (!entry)
		goto end;

32
33
34
35
36
	if (entry->enter_id != ent->type) {
		WARN_ON_ONCE(1);
		goto end;
	}

37
38
39
40
41
42
	ret = trace_seq_printf(s, "%s(", entry->name);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	for (i = 0; i < entry->nb_args; i++) {
		/* parameter types */
43
		if (trace_flags & TRACE_ITER_VERBOSE) {
44
45
46
47
48
			ret = trace_seq_printf(s, "%s ", entry->types[i]);
			if (!ret)
				return TRACE_TYPE_PARTIAL_LINE;
		}
		/* parameter values */
49
		ret = trace_seq_printf(s, "%s: %lx%s", entry->args[i],
50
				       trace->args[i],
51
				       i == entry->nb_args - 1 ? "" : ", ");
52
53
54
55
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

56
57
58
59
	ret = trace_seq_putc(s, ')');
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

60
end:
61
62
63
64
	ret =  trace_seq_putc(s, '\n');
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

65
66
67
68
69
70
71
72
73
74
75
76
77
	return TRACE_TYPE_HANDLED;
}

enum print_line_t
print_syscall_exit(struct trace_iterator *iter, int flags)
{
	struct trace_seq *s = &iter->seq;
	struct trace_entry *ent = iter->ent;
	struct syscall_trace_exit *trace;
	int syscall;
	struct syscall_metadata *entry;
	int ret;

78
	trace = (typeof(trace))ent;
79
80
	syscall = trace->nr;
	entry = syscall_nr_to_meta(syscall);
81

82
83
84
85
86
	if (!entry) {
		trace_seq_printf(s, "\n");
		return TRACE_TYPE_HANDLED;
	}

87
88
89
90
91
	if (entry->exit_id != ent->type) {
		WARN_ON_ONCE(1);
		return TRACE_TYPE_UNHANDLED;
	}

92
93
94
95
96
97
98
99
	ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
				trace->ret);
	if (!ret)
		return TRACE_TYPE_PARTIAL_LINE;

	return TRACE_TYPE_HANDLED;
}

100
101
102
103
104
105
106
extern char *__bad_type_size(void);

#define SYSCALL_FIELD(type, name)					\
	sizeof(type) != sizeof(trace.name) ?				\
		__bad_type_size() :					\
		#type, #name, offsetof(typeof(trace), name), sizeof(trace.name)

107
int syscall_enter_format(struct ftrace_event_call *call, struct trace_seq *s)
108
109
110
{
	int i;
	int nr;
111
	int ret;
112
	struct syscall_metadata *entry;
113
114
	struct syscall_trace_enter trace;
	int offset = offsetof(struct syscall_trace_enter, args);
115

116
	nr = syscall_name_to_nr(call->data);
117
118
119
	entry = syscall_nr_to_meta(nr);

	if (!entry)
120
121
122
123
124
125
		return 0;

	ret = trace_seq_printf(s, "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
			       SYSCALL_FIELD(int, nr));
	if (!ret)
		return 0;
126
127
128
129
130
131

	for (i = 0; i < entry->nb_args; i++) {
		ret = trace_seq_printf(s, "\tfield:%s %s;", entry->types[i],
				        entry->args[i]);
		if (!ret)
			return 0;
132
		ret = trace_seq_printf(s, "\toffset:%d;\tsize:%zu;\n", offset,
133
134
135
136
137
138
				       sizeof(unsigned long));
		if (!ret)
			return 0;
		offset += sizeof(unsigned long);
	}

139
	trace_seq_puts(s, "\nprint fmt: \"");
140
	for (i = 0; i < entry->nb_args; i++) {
141
		ret = trace_seq_printf(s, "%s: 0x%%0%zulx%s", entry->args[i],
142
				        sizeof(unsigned long),
143
					i == entry->nb_args - 1 ? "" : ", ");
144
145
146
		if (!ret)
			return 0;
	}
147
	trace_seq_putc(s, '"');
148
149

	for (i = 0; i < entry->nb_args; i++) {
150
151
		ret = trace_seq_printf(s, ", ((unsigned long)(REC->%s))",
				       entry->args[i]);
152
153
154
155
		if (!ret)
			return 0;
	}

156
	return trace_seq_putc(s, '\n');
157
158
}

159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
int syscall_exit_format(struct ftrace_event_call *call, struct trace_seq *s)
{
	int ret;
	struct syscall_trace_exit trace;

	ret = trace_seq_printf(s,
			       "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n"
			       "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
			       SYSCALL_FIELD(int, nr),
			       SYSCALL_FIELD(unsigned long, ret));
	if (!ret)
		return 0;

	return trace_seq_printf(s, "\nprint fmt: \"0x%%lx\", REC->ret\n");
}

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
204
205
206
207
208
209
210
211
212
213
214
215
216
217
int syscall_enter_define_fields(struct ftrace_event_call *call)
{
	struct syscall_trace_enter trace;
	struct syscall_metadata *meta;
	int ret;
	int nr;
	int i;
	int offset = offsetof(typeof(trace), args);

	nr = syscall_name_to_nr(call->data);
	meta = syscall_nr_to_meta(nr);

	if (!meta)
		return 0;

	ret = trace_define_common_fields(call);
	if (ret)
		return ret;

	for (i = 0; i < meta->nb_args; i++) {
		ret = trace_define_field(call, meta->types[i],
					 meta->args[i], offset,
					 sizeof(unsigned long), 0);
		offset += sizeof(unsigned long);
	}

	return ret;
}

int syscall_exit_define_fields(struct ftrace_event_call *call)
{
	struct syscall_trace_exit trace;
	int ret;

	ret = trace_define_common_fields(call);
	if (ret)
		return ret;

	ret = trace_define_field(call, SYSCALL_FIELD(unsigned long, ret), 0);

	return ret;
}

218
void ftrace_syscall_enter(struct pt_regs *regs, long id)
219
{
220
221
222
223
	struct syscall_trace_enter *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
	int size;
224
225
226
	int syscall_nr;

	syscall_nr = syscall_get_nr(current, regs);
227
228
	if (!test_bit(syscall_nr, enabled_enter_syscalls))
		return;
229

230
231
232
233
234
235
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

	size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;

236
	event = trace_current_buffer_lock_reserve(sys_data->enter_id, size,
237
238
239
240
241
242
243
244
							0, 0);
	if (!event)
		return;

	entry = ring_buffer_event_data(event);
	entry->nr = syscall_nr;
	syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);

245
246
	if (!filter_current_check_discard(sys_data->enter_event, entry, event))
		trace_current_buffer_unlock_commit(event, 0, 0);
247
248
}

249
void ftrace_syscall_exit(struct pt_regs *regs, long ret)
250
{
251
252
253
	struct syscall_trace_exit *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
254
255
256
	int syscall_nr;

	syscall_nr = syscall_get_nr(current, regs);
257
258
	if (!test_bit(syscall_nr, enabled_exit_syscalls))
		return;
259

260
261
262
263
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

264
	event = trace_current_buffer_lock_reserve(sys_data->exit_id,
265
266
267
268
269
270
271
272
				sizeof(*entry), 0, 0);
	if (!event)
		return;

	entry = ring_buffer_event_data(event);
	entry->nr = syscall_nr;
	entry->ret = syscall_get_return_value(current, regs);

273
274
	if (!filter_current_check_discard(sys_data->exit_event, entry, event))
		trace_current_buffer_unlock_commit(event, 0, 0);
275
276
}

277
int reg_event_syscall_enter(void *ptr)
278
{
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
	int ret = 0;
	int num;
	char *name;

	name = (char *)ptr;
	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
	if (!sys_refcount_enter)
		ret = register_trace_syscall_enter(ftrace_syscall_enter);
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall entry trace point");
	} else {
		set_bit(num, enabled_enter_syscalls);
		sys_refcount_enter++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
299
300
}

301
void unreg_event_syscall_enter(void *ptr)
302
{
303
304
	int num;
	char *name;
305

306
307
308
309
310
311
312
313
314
315
316
	name = (char *)ptr;
	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return;
	mutex_lock(&syscall_trace_lock);
	sys_refcount_enter--;
	clear_bit(num, enabled_enter_syscalls);
	if (!sys_refcount_enter)
		unregister_trace_syscall_enter(ftrace_syscall_enter);
	mutex_unlock(&syscall_trace_lock);
}
317

318
int reg_event_syscall_exit(void *ptr)
319
{
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
	int ret = 0;
	int num;
	char *name;

	name = (char *)ptr;
	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
	if (!sys_refcount_exit)
		ret = register_trace_syscall_exit(ftrace_syscall_exit);
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall exit trace point");
	} else {
		set_bit(num, enabled_exit_syscalls);
		sys_refcount_exit++;
337
	}
338
339
340
	mutex_unlock(&syscall_trace_lock);
	return ret;
}
341

342
343
344
345
void unreg_event_syscall_exit(void *ptr)
{
	int num;
	char *name;
346

347
348
349
350
351
352
353
354
355
356
	name = (char *)ptr;
	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return;
	mutex_lock(&syscall_trace_lock);
	sys_refcount_exit--;
	clear_bit(num, enabled_exit_syscalls);
	if (!sys_refcount_exit)
		unregister_trace_syscall_exit(ftrace_syscall_exit);
	mutex_unlock(&syscall_trace_lock);
357
}
358
359
360
361
362
363
364
365

struct trace_event event_syscall_enter = {
	.trace			= print_syscall_enter,
};

struct trace_event event_syscall_exit = {
	.trace			= print_syscall_exit,
};
366
367

#ifdef CONFIG_EVENT_PROFILE
368

369
370
371
372
373
374
375
static DECLARE_BITMAP(enabled_prof_enter_syscalls, FTRACE_SYSCALL_MAX);
static DECLARE_BITMAP(enabled_prof_exit_syscalls, FTRACE_SYSCALL_MAX);
static int sys_prof_refcount_enter;
static int sys_prof_refcount_exit;

static void prof_syscall_enter(struct pt_regs *regs, long id)
{
376
	struct syscall_trace_enter *rec;
377
378
	struct syscall_metadata *sys_data;
	int syscall_nr;
379
	int size;
380
381
382
383
384
385
386
387
388

	syscall_nr = syscall_get_nr(current, regs);
	if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

389
390
391
392
393
394
395
396
397
398
399
	/* get the size after alignment with the u32 buffer size field */
	size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
	size = ALIGN(size + sizeof(u32), sizeof(u64));
	size -= sizeof(u32);

	do {
		char raw_data[size];

		/* zero the dead bytes from align to not leak stack to user */
		*(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL;

400
401
402
403
		rec = (struct syscall_trace_enter *) raw_data;
		tracing_generic_entry_update(&rec->ent, 0, 0);
		rec->ent.type = sys_data->enter_id;
		rec->nr = syscall_nr;
404
405
406
407
		syscall_get_arguments(current, regs, 0, sys_data->nb_args,
				       (unsigned long *)&rec->args);
		perf_tpcounter_event(sys_data->enter_id, 0, 1, rec, size);
	} while(0);
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
}

int reg_prof_syscall_enter(char *name)
{
	int ret = 0;
	int num;

	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return -ENOSYS;

	mutex_lock(&syscall_trace_lock);
	if (!sys_prof_refcount_enter)
		ret = register_trace_syscall_enter(prof_syscall_enter);
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall entry trace point");
	} else {
		set_bit(num, enabled_prof_enter_syscalls);
		sys_prof_refcount_enter++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

void unreg_prof_syscall_enter(char *name)
{
	int num;

	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return;

	mutex_lock(&syscall_trace_lock);
	sys_prof_refcount_enter--;
	clear_bit(num, enabled_prof_enter_syscalls);
	if (!sys_prof_refcount_enter)
		unregister_trace_syscall_enter(prof_syscall_enter);
	mutex_unlock(&syscall_trace_lock);
}

static void prof_syscall_exit(struct pt_regs *regs, long ret)
{
	struct syscall_metadata *sys_data;
452
	struct syscall_trace_exit rec;
453
454
455
456
457
458
459
460
461
462
	int syscall_nr;

	syscall_nr = syscall_get_nr(current, regs);
	if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
		return;

	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

463
464
465
	tracing_generic_entry_update(&rec.ent, 0, 0);
	rec.ent.type = sys_data->exit_id;
	rec.nr = syscall_nr;
466
467
468
	rec.ret = syscall_get_return_value(current, regs);

	perf_tpcounter_event(sys_data->exit_id, 0, 1, &rec, sizeof(rec));
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
}

int reg_prof_syscall_exit(char *name)
{
	int ret = 0;
	int num;

	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return -ENOSYS;

	mutex_lock(&syscall_trace_lock);
	if (!sys_prof_refcount_exit)
		ret = register_trace_syscall_exit(prof_syscall_exit);
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall entry trace point");
	} else {
		set_bit(num, enabled_prof_exit_syscalls);
		sys_prof_refcount_exit++;
	}
	mutex_unlock(&syscall_trace_lock);
	return ret;
}

void unreg_prof_syscall_exit(char *name)
{
	int num;

	num = syscall_name_to_nr(name);
	if (num < 0 || num >= FTRACE_SYSCALL_MAX)
		return;

	mutex_lock(&syscall_trace_lock);
	sys_prof_refcount_exit--;
	clear_bit(num, enabled_prof_exit_syscalls);
	if (!sys_prof_refcount_exit)
		unregister_trace_syscall_exit(prof_syscall_exit);
	mutex_unlock(&syscall_trace_lock);
}

#endif