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
|
// Copyright (C) 2005-2008 Red Hat Inc.
// Copyright (C) 2006 Intel Corporation.
//
// This file is part of systemtap, and is free software. You can
// redistribute it and/or modify it under the terms of the GNU General
// Public License (GPL); either version 2, or (at your option) any
// later version.
#include <string.h>
extern int _stap_probe_sentinel;
#define STAP_PROBE_START() \
char *stap_sdt = getenv("SYSTEMTAP_SDT"); \
if (stap_sdt != NULL) \
_stap_probe_start ()
#if _LP64
#define STAP_PROBE_STRUCT_ARG \
__uint64_t probe_arg;
#else
#define STAP_PROBE_STRUCT_ARG \
long probe_arg __attribute__ ((aligned(8)));
#endif
#define STAP_PROBE_STRUCT(probe,type,argc) \
struct _probe_ ## probe \
{ \
char probe_name [strlen(#probe)+1]; \
int probe_type; \
STAP_PROBE_STRUCT_ARG \
}; \
static volatile struct _probe_ ## probe _probe_ ## probe __attribute__ ((section (".probes"))) = {#probe,type,argc};
#ifndef USE_STAP_DEBUGINFO_PROBE
#define STAP_PROBE(provider,probe) \
STAP_PROBE_STRUCT(probe,0,0) \
if (__builtin_expect(_stap_probe_sentinel, 0))\
_stap_probe_0 (_probe_ ## probe.probe_name);
#else
#define STAP_PROBE(provider,probe) \
_probe_ ## probe: \
asm volatile ("nop"); \
STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe)
#endif
#ifndef USE_STAP_DEBUGINFO_PROBE
#define STAP_PROBE1(provider,probe,arg1) \
STAP_PROBE_STRUCT(probe,0,1) \
if (__builtin_expect(_stap_probe_sentinel, 0))\
_stap_probe_1 (_probe_ ## probe.probe_name,(size_t)arg1);
#else
#define STAP_PROBE1(provider,probe,parm1) \
_probe_ ## probe: \
asm volatile ("nop"); \
volatile typeof(parm1) arg1 = parm1; \
STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \
asm volatile ("# %0" :: "r"(arg1)); \
asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
#endif
#ifndef USE_STAP_DEBUGINFO_PROBE
#define STAP_PROBE2(provider,probe,arg1,arg2) \
STAP_PROBE_STRUCT(probe,0,2) \
if (__builtin_expect(_stap_probe_sentinel, 0)) \
_stap_probe_2 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2);
#else
#define STAP_PROBE2(provider,probe,parm1,parm2) \
_probe_ ## probe: \
asm volatile ("nop"); \
volatile typeof(parm1) arg1 = parm1; \
volatile typeof(parm2) arg2 = parm2; \
STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe)\
asm volatile ("# %0" :: "r"(arg1)); \
asm volatile ("# %0" :: "r"(arg2)); \
asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
#endif
#ifndef USE_STAP_DEBUGINFO_PROBE
#define STAP_PROBE3(provider,probe,arg1,arg2,arg3) \
STAP_PROBE_STRUCT(probe,0,3) \
if (__builtin_expect(_stap_probe_sentinel, 0)) \
_stap_probe_3 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3);
#else
#define STAP_PROBE3(provider,probe,parm1,parm2,parm3) \
_probe_ ## probe: \
asm volatile ("nop"); \
volatile typeof(parm1) arg1 = parm1; \
volatile typeof(parm2) arg2 = parm2; \
volatile typeof(parm3) arg3 = parm3; \
STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \
asm volatile ("# %0" :: "r"(arg1)); \
asm volatile ("# %0" :: "r"(arg2)); \
asm volatile ("# %0" :: "r"(arg3)); \
asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
#endif
#ifndef USE_STAP_DEBUGINFO_PROBE
#define STAP_PROBE4(provider,probe,arg1,arg2,arg3,arg4) \
STAP_PROBE_STRUCT(probe,0,4) \
if (__builtin_expect(_stap_probe_sentinel, 0)) \
_stap_probe_4 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4);
#else
#define STAP_PROBE4(provider,probe,parm1,parm2,parm3) \
_probe_ ## probe: \
asm volatile ("nop"); \
volatile typeof(parm1) arg1 = parm1; \
volatile typeof(parm2) arg2 = parm2; \
volatile typeof(parm3) arg3 = parm3; \
volatile typeof(parm4) arg4 = parm4; \
STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \
asm volatile ("# %0" :: "r"(arg1)); \
asm volatile ("# %0" :: "r"(arg2)); \
asm volatile ("# %0" :: "r"(arg3)); \
asm volatile ("# %0" :: "r"(arg4)); \
asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
#endif
#ifndef USE_STAP_DEBUGINFO_PROBE
#define STAP_PROBE5(provider,probe,arg1,arg2,arg3,arg4,arg5) \
STAP_PROBE_STRUCT(probe,0,5) \
if (__builtin_expect(_stap_probe_sentinel, 0))\
_stap_probe_5 (_probe_ ## probe.probe_name,(size_t)arg1,(size_t)arg2,(size_t)arg3,(size_t)arg4,(size_t)arg5);
#else
#define STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \
_probe_ ## probe: \
asm volatile ("nop"); \
volatile typeof(parm1) arg1 = parm1; \
volatile typeof(parm2) arg2 = parm2; \
volatile typeof(parm3) arg3 = parm3; \
volatile typeof(parm4) arg4 = parm4; \
volatile typeof(parm5) arg5 = parm5; \
STAP_PROBE_STRUCT(probe,1,(size_t)&& _probe_ ## probe) \
asm volatile ("# %0" :: "r"(arg1)); \
asm volatile ("# %0" :: "r"(arg2)); \
asm volatile ("# %0" :: "r"(arg3)); \
asm volatile ("# %0" :: "r"(arg4)); \
asm volatile ("# %0" :: "r"(arg5)); \
asm volatile ("# %0" :: "m" ((_probe_ ## probe.probe_type)));
#endif
|
