trace_syscalls.c 13.2 KB
Newer Older
1
#include <trace/syscall.h>
2
#include <trace/events/syscalls.h>
3
#include <linux/kernel.h>
4
#include <linux/ftrace.h>
5
#include <linux/perf_event.h>
6
7
8
9
10
#include <asm/syscall.h>

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

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

17
18
19
20
21
22
23
24
25
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;

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

30
31
32
	if (!entry)
		goto end;

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

38
39
40
41
42
43
	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 */
44
		if (trace_flags & TRACE_ITER_VERBOSE) {
45
46
47
48
49
			ret = trace_seq_printf(s, "%s ", entry->types[i]);
			if (!ret)
				return TRACE_TYPE_PARTIAL_LINE;
		}
		/* parameter values */
50
		ret = trace_seq_printf(s, "%s: %lx%s", entry->args[i],
51
				       trace->args[i],
52
				       i == entry->nb_args - 1 ? "" : ", ");
53
54
55
56
		if (!ret)
			return TRACE_TYPE_PARTIAL_LINE;
	}

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

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

66
67
68
69
70
71
72
73
74
75
76
77
78
	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;

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

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

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

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

	return TRACE_TYPE_HANDLED;
}

101
102
103
104
105
106
107
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)

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

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

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

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

	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;
133
		ret = trace_seq_printf(s, "\toffset:%d;\tsize:%zu;\n", offset,
134
135
136
137
138
139
				       sizeof(unsigned long));
		if (!ret)
			return 0;
		offset += sizeof(unsigned long);
	}

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

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

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

160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
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");
}

176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
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,
198
199
					 sizeof(unsigned long), 0,
					 FILTER_OTHER);
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
		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;

215
216
	ret = trace_define_field(call, SYSCALL_FIELD(unsigned long, ret), 0,
				 FILTER_OTHER);
217
218
219
220

	return ret;
}

221
void ftrace_syscall_enter(struct pt_regs *regs, long id)
222
{
223
224
225
	struct syscall_trace_enter *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
226
	struct ring_buffer *buffer;
227
	int size;
228
229
230
	int syscall_nr;

	syscall_nr = syscall_get_nr(current, regs);
231
232
	if (syscall_nr < 0)
		return;
233
234
	if (!test_bit(syscall_nr, enabled_enter_syscalls))
		return;
235

236
237
238
239
240
241
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

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

242
243
	event = trace_current_buffer_lock_reserve(&buffer, sys_data->enter_id,
						  size, 0, 0);
244
245
246
247
248
249
250
	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);

251
252
253
	if (!filter_current_check_discard(buffer, sys_data->enter_event,
					  entry, event))
		trace_current_buffer_unlock_commit(buffer, event, 0, 0);
254
255
}

256
void ftrace_syscall_exit(struct pt_regs *regs, long ret)
257
{
258
259
260
	struct syscall_trace_exit *entry;
	struct syscall_metadata *sys_data;
	struct ring_buffer_event *event;
261
	struct ring_buffer *buffer;
262
263
264
	int syscall_nr;

	syscall_nr = syscall_get_nr(current, regs);
265
266
	if (syscall_nr < 0)
		return;
267
268
	if (!test_bit(syscall_nr, enabled_exit_syscalls))
		return;
269

270
271
272
273
	sys_data = syscall_nr_to_meta(syscall_nr);
	if (!sys_data)
		return;

274
	event = trace_current_buffer_lock_reserve(&buffer, sys_data->exit_id,
275
276
277
278
279
280
281
282
				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);

283
284
285
	if (!filter_current_check_discard(buffer, sys_data->exit_event,
					  entry, event))
		trace_current_buffer_unlock_commit(buffer, event, 0, 0);
286
287
}

288
int reg_event_syscall_enter(void *ptr)
289
{
290
291
292
293
294
295
	int ret = 0;
	int num;
	char *name;

	name = (char *)ptr;
	num = syscall_name_to_nr(name);
296
	if (num < 0 || num >= NR_syscalls)
297
298
299
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
	if (!sys_refcount_enter)
300
		ret = register_trace_sys_enter(ftrace_syscall_enter);
301
302
303
304
305
306
307
308
309
	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;
310
311
}

312
void unreg_event_syscall_enter(void *ptr)
313
{
314
315
	int num;
	char *name;
316

317
318
	name = (char *)ptr;
	num = syscall_name_to_nr(name);
319
	if (num < 0 || num >= NR_syscalls)
320
321
322
323
324
		return;
	mutex_lock(&syscall_trace_lock);
	sys_refcount_enter--;
	clear_bit(num, enabled_enter_syscalls);
	if (!sys_refcount_enter)
325
		unregister_trace_sys_enter(ftrace_syscall_enter);
326
327
	mutex_unlock(&syscall_trace_lock);
}
328

329
int reg_event_syscall_exit(void *ptr)
330
{
331
332
333
334
335
336
	int ret = 0;
	int num;
	char *name;

	name = (char *)ptr;
	num = syscall_name_to_nr(name);
337
	if (num < 0 || num >= NR_syscalls)
338
339
340
		return -ENOSYS;
	mutex_lock(&syscall_trace_lock);
	if (!sys_refcount_exit)
341
		ret = register_trace_sys_exit(ftrace_syscall_exit);
342
343
344
345
346
347
	if (ret) {
		pr_info("event trace: Could not activate"
				"syscall exit trace point");
	} else {
		set_bit(num, enabled_exit_syscalls);
		sys_refcount_exit++;
348
	}
349
350
351
	mutex_unlock(&syscall_trace_lock);
	return ret;
}
352

353
354
355
356
void unreg_event_syscall_exit(void *ptr)
{
	int num;
	char *name;
357

358
359
	name = (char *)ptr;
	num = syscall_name_to_nr(name);
360
	if (num < 0 || num >= NR_syscalls)
361
362
363
364
365
		return;
	mutex_lock(&syscall_trace_lock);
	sys_refcount_exit--;
	clear_bit(num, enabled_exit_syscalls);
	if (!sys_refcount_exit)
366
		unregister_trace_sys_exit(ftrace_syscall_exit);
367
	mutex_unlock(&syscall_trace_lock);
368
}
369
370
371
372
373
374
375
376

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

struct trace_event event_syscall_exit = {
	.trace			= print_syscall_exit,
};
377
378

#ifdef CONFIG_EVENT_PROFILE
379

380
381
static DECLARE_BITMAP(enabled_prof_enter_syscalls, NR_syscalls);
static DECLARE_BITMAP(enabled_prof_exit_syscalls, NR_syscalls);
382
383
384
385
386
387
static int sys_prof_refcount_enter;
static int sys_prof_refcount_exit;

static void prof_syscall_enter(struct pt_regs *regs, long id)
{
	struct syscall_metadata *sys_data;
388
389
390
	struct syscall_trace_enter *rec;
	unsigned long flags;
	char *raw_data;
391
	int syscall_nr;
392
	int size;
393
	int cpu;
394
395
396
397
398
399
400
401
402

	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;

403
404
405
406
407
	/* 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);

408
409
410
411
412
413
	if (WARN_ONCE(size > FTRACE_MAX_PROFILE_SIZE,
		      "profile buffer not large enough"))
		return;

	/* Protect the per cpu buffer, begin the rcu read side */
	local_irq_save(flags);
414

415
416
417
418
419
420
421
422
423
	cpu = smp_processor_id();

	if (in_nmi())
		raw_data = rcu_dereference(trace_profile_buf_nmi);
	else
		raw_data = rcu_dereference(trace_profile_buf);

	if (!raw_data)
		goto end;
424

425
426
427
428
429
430
431
432
433
434
435
	raw_data = per_cpu_ptr(raw_data, cpu);

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

	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;
	syscall_get_arguments(current, regs, 0, sys_data->nb_args,
			       (unsigned long *)&rec->args);
436
	perf_tp_event(sys_data->enter_id, 0, 1, rec, size);
437
438
439

end:
	local_irq_restore(flags);
440
441
442
443
444
445
446
447
}

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

	num = syscall_name_to_nr(name);
448
	if (num < 0 || num >= NR_syscalls)
449
450
451
452
		return -ENOSYS;

	mutex_lock(&syscall_trace_lock);
	if (!sys_prof_refcount_enter)
453
		ret = register_trace_sys_enter(prof_syscall_enter);
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
	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);
470
	if (num < 0 || num >= NR_syscalls)
471
472
473
474
475
476
		return;

	mutex_lock(&syscall_trace_lock);
	sys_prof_refcount_enter--;
	clear_bit(num, enabled_prof_enter_syscalls);
	if (!sys_prof_refcount_enter)
477
		unregister_trace_sys_enter(prof_syscall_enter);
478
479
480
481
482
483
	mutex_unlock(&syscall_trace_lock);
}

static void prof_syscall_exit(struct pt_regs *regs, long ret)
{
	struct syscall_metadata *sys_data;
484
485
	struct syscall_trace_exit *rec;
	unsigned long flags;
486
	int syscall_nr;
487
488
489
	char *raw_data;
	int size;
	int cpu;
490
491
492
493
494
495
496
497
498

	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;

499
500
501
	/* We can probably do that at build time */
	size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64));
	size -= sizeof(u32);
502

503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
	/*
	 * Impossible, but be paranoid with the future
	 * How to put this check outside runtime?
	 */
	if (WARN_ONCE(size > FTRACE_MAX_PROFILE_SIZE,
		"exit event has grown above profile buffer size"))
		return;

	/* Protect the per cpu buffer, begin the rcu read side */
	local_irq_save(flags);
	cpu = smp_processor_id();

	if (in_nmi())
		raw_data = rcu_dereference(trace_profile_buf_nmi);
	else
		raw_data = rcu_dereference(trace_profile_buf);

	if (!raw_data)
		goto end;

	raw_data = per_cpu_ptr(raw_data, cpu);

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

	rec = (struct syscall_trace_exit *)raw_data;

	tracing_generic_entry_update(&rec->ent, 0, 0);
	rec->ent.type = sys_data->exit_id;
	rec->nr = syscall_nr;
	rec->ret = syscall_get_return_value(current, regs);

535
	perf_tp_event(sys_data->exit_id, 0, 1, rec, size);
536
537
538

end:
	local_irq_restore(flags);
539
540
541
542
543
544
545
546
}

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

	num = syscall_name_to_nr(name);
547
	if (num < 0 || num >= NR_syscalls)
548
549
550
551
		return -ENOSYS;

	mutex_lock(&syscall_trace_lock);
	if (!sys_prof_refcount_exit)
552
		ret = register_trace_sys_exit(prof_syscall_exit);
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
	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);
569
	if (num < 0 || num >= NR_syscalls)
570
571
572
573
574
575
		return;

	mutex_lock(&syscall_trace_lock);
	sys_prof_refcount_exit--;
	clear_bit(num, enabled_prof_exit_syscalls);
	if (!sys_prof_refcount_exit)
576
		unregister_trace_sys_exit(prof_syscall_exit);
577
578
579
580
581
582
	mutex_unlock(&syscall_trace_lock);
}

#endif