Frederic Weisbecker | 47788c5 | 2009-04-08 20:40:59 +0200 | [diff] [blame] | 1 | #include <trace/syscall.h> |
Josh Stone | 1c569f0 | 2009-08-24 14:43:14 -0700 | [diff] [blame] | 2 | #include <trace/events/syscalls.h> |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 3 | #include <linux/kernel.h> |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 4 | #include <linux/ftrace.h> |
Ingo Molnar | cdd6c48 | 2009-09-21 12:02:48 +0200 | [diff] [blame] | 5 | #include <linux/perf_event.h> |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 6 | #include <asm/syscall.h> |
| 7 | |
| 8 | #include "trace_output.h" |
| 9 | #include "trace.h" |
| 10 | |
Frederic Weisbecker | 5be71b6 | 2009-03-15 22:10:37 +0100 | [diff] [blame] | 11 | static DEFINE_MUTEX(syscall_trace_lock); |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 12 | static int sys_refcount_enter; |
| 13 | static int sys_refcount_exit; |
Jason Baron | 57421db | 2009-08-24 17:40:22 -0400 | [diff] [blame] | 14 | static DECLARE_BITMAP(enabled_enter_syscalls, NR_syscalls); |
| 15 | static DECLARE_BITMAP(enabled_exit_syscalls, NR_syscalls); |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 16 | |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 17 | enum print_line_t |
| 18 | print_syscall_enter(struct trace_iterator *iter, int flags) |
| 19 | { |
| 20 | struct trace_seq *s = &iter->seq; |
| 21 | struct trace_entry *ent = iter->ent; |
| 22 | struct syscall_trace_enter *trace; |
| 23 | struct syscall_metadata *entry; |
| 24 | int i, ret, syscall; |
| 25 | |
Jason Baron | 64c12e0 | 2009-08-10 16:52:53 -0400 | [diff] [blame] | 26 | trace = (typeof(trace))ent; |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 27 | syscall = trace->nr; |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 28 | entry = syscall_nr_to_meta(syscall); |
Jason Baron | 64c12e0 | 2009-08-10 16:52:53 -0400 | [diff] [blame] | 29 | |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 30 | if (!entry) |
| 31 | goto end; |
| 32 | |
Jason Baron | 64c12e0 | 2009-08-10 16:52:53 -0400 | [diff] [blame] | 33 | if (entry->enter_id != ent->type) { |
| 34 | WARN_ON_ONCE(1); |
| 35 | goto end; |
| 36 | } |
| 37 | |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 38 | ret = trace_seq_printf(s, "%s(", entry->name); |
| 39 | if (!ret) |
| 40 | return TRACE_TYPE_PARTIAL_LINE; |
| 41 | |
| 42 | for (i = 0; i < entry->nb_args; i++) { |
| 43 | /* parameter types */ |
Li Zefan | ba8b3a4 | 2009-08-17 16:55:18 +0800 | [diff] [blame] | 44 | if (trace_flags & TRACE_ITER_VERBOSE) { |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 45 | ret = trace_seq_printf(s, "%s ", entry->types[i]); |
| 46 | if (!ret) |
| 47 | return TRACE_TYPE_PARTIAL_LINE; |
| 48 | } |
| 49 | /* parameter values */ |
Li Zefan | 4539f07 | 2009-08-20 16:13:35 +0800 | [diff] [blame] | 50 | ret = trace_seq_printf(s, "%s: %lx%s", entry->args[i], |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 51 | trace->args[i], |
Li Zefan | 4539f07 | 2009-08-20 16:13:35 +0800 | [diff] [blame] | 52 | i == entry->nb_args - 1 ? "" : ", "); |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 53 | if (!ret) |
| 54 | return TRACE_TYPE_PARTIAL_LINE; |
| 55 | } |
| 56 | |
Li Zefan | 4539f07 | 2009-08-20 16:13:35 +0800 | [diff] [blame] | 57 | ret = trace_seq_putc(s, ')'); |
| 58 | if (!ret) |
| 59 | return TRACE_TYPE_PARTIAL_LINE; |
| 60 | |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 61 | end: |
Li Zefan | 4539f07 | 2009-08-20 16:13:35 +0800 | [diff] [blame] | 62 | ret = trace_seq_putc(s, '\n'); |
| 63 | if (!ret) |
| 64 | return TRACE_TYPE_PARTIAL_LINE; |
| 65 | |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 66 | return TRACE_TYPE_HANDLED; |
| 67 | } |
| 68 | |
| 69 | enum print_line_t |
| 70 | print_syscall_exit(struct trace_iterator *iter, int flags) |
| 71 | { |
| 72 | struct trace_seq *s = &iter->seq; |
| 73 | struct trace_entry *ent = iter->ent; |
| 74 | struct syscall_trace_exit *trace; |
| 75 | int syscall; |
| 76 | struct syscall_metadata *entry; |
| 77 | int ret; |
| 78 | |
Jason Baron | 64c12e0 | 2009-08-10 16:52:53 -0400 | [diff] [blame] | 79 | trace = (typeof(trace))ent; |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 80 | syscall = trace->nr; |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 81 | entry = syscall_nr_to_meta(syscall); |
Jason Baron | 64c12e0 | 2009-08-10 16:52:53 -0400 | [diff] [blame] | 82 | |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 83 | if (!entry) { |
| 84 | trace_seq_printf(s, "\n"); |
| 85 | return TRACE_TYPE_HANDLED; |
| 86 | } |
| 87 | |
Jason Baron | 64c12e0 | 2009-08-10 16:52:53 -0400 | [diff] [blame] | 88 | if (entry->exit_id != ent->type) { |
| 89 | WARN_ON_ONCE(1); |
| 90 | return TRACE_TYPE_UNHANDLED; |
| 91 | } |
| 92 | |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 93 | ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name, |
| 94 | trace->ret); |
| 95 | if (!ret) |
| 96 | return TRACE_TYPE_PARTIAL_LINE; |
| 97 | |
| 98 | return TRACE_TYPE_HANDLED; |
| 99 | } |
| 100 | |
Li Zefan | e697196 | 2009-08-19 15:52:25 +0800 | [diff] [blame] | 101 | extern char *__bad_type_size(void); |
| 102 | |
| 103 | #define SYSCALL_FIELD(type, name) \ |
| 104 | sizeof(type) != sizeof(trace.name) ? \ |
| 105 | __bad_type_size() : \ |
| 106 | #type, #name, offsetof(typeof(trace), name), sizeof(trace.name) |
| 107 | |
Li Zefan | 10a5b66 | 2009-08-19 15:53:05 +0800 | [diff] [blame] | 108 | int syscall_enter_format(struct ftrace_event_call *call, struct trace_seq *s) |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 109 | { |
| 110 | int i; |
| 111 | int nr; |
Li Zefan | e697196 | 2009-08-19 15:52:25 +0800 | [diff] [blame] | 112 | int ret; |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 113 | struct syscall_metadata *entry; |
Li Zefan | e697196 | 2009-08-19 15:52:25 +0800 | [diff] [blame] | 114 | struct syscall_trace_enter trace; |
| 115 | int offset = offsetof(struct syscall_trace_enter, args); |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 116 | |
Li Zefan | e697196 | 2009-08-19 15:52:25 +0800 | [diff] [blame] | 117 | nr = syscall_name_to_nr(call->data); |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 118 | entry = syscall_nr_to_meta(nr); |
| 119 | |
| 120 | if (!entry) |
Li Zefan | e697196 | 2009-08-19 15:52:25 +0800 | [diff] [blame] | 121 | return 0; |
| 122 | |
| 123 | ret = trace_seq_printf(s, "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n", |
| 124 | SYSCALL_FIELD(int, nr)); |
| 125 | if (!ret) |
| 126 | return 0; |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 127 | |
| 128 | for (i = 0; i < entry->nb_args; i++) { |
| 129 | ret = trace_seq_printf(s, "\tfield:%s %s;", entry->types[i], |
| 130 | entry->args[i]); |
| 131 | if (!ret) |
| 132 | return 0; |
Li Zefan | e697196 | 2009-08-19 15:52:25 +0800 | [diff] [blame] | 133 | ret = trace_seq_printf(s, "\toffset:%d;\tsize:%zu;\n", offset, |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 134 | sizeof(unsigned long)); |
| 135 | if (!ret) |
| 136 | return 0; |
| 137 | offset += sizeof(unsigned long); |
| 138 | } |
| 139 | |
Li Zefan | 4539f07 | 2009-08-20 16:13:35 +0800 | [diff] [blame] | 140 | trace_seq_puts(s, "\nprint fmt: \""); |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 141 | for (i = 0; i < entry->nb_args; i++) { |
Li Zefan | e697196 | 2009-08-19 15:52:25 +0800 | [diff] [blame] | 142 | ret = trace_seq_printf(s, "%s: 0x%%0%zulx%s", entry->args[i], |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 143 | sizeof(unsigned long), |
Li Zefan | 4539f07 | 2009-08-20 16:13:35 +0800 | [diff] [blame] | 144 | i == entry->nb_args - 1 ? "" : ", "); |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 145 | if (!ret) |
| 146 | return 0; |
| 147 | } |
Li Zefan | 4539f07 | 2009-08-20 16:13:35 +0800 | [diff] [blame] | 148 | trace_seq_putc(s, '"'); |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 149 | |
| 150 | for (i = 0; i < entry->nb_args; i++) { |
Li Zefan | 4539f07 | 2009-08-20 16:13:35 +0800 | [diff] [blame] | 151 | ret = trace_seq_printf(s, ", ((unsigned long)(REC->%s))", |
| 152 | entry->args[i]); |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 153 | if (!ret) |
| 154 | return 0; |
| 155 | } |
| 156 | |
Li Zefan | 4539f07 | 2009-08-20 16:13:35 +0800 | [diff] [blame] | 157 | return trace_seq_putc(s, '\n'); |
Frederic Weisbecker | dc4ddb4 | 2009-08-11 19:03:54 +0200 | [diff] [blame] | 158 | } |
| 159 | |
Li Zefan | 10a5b66 | 2009-08-19 15:53:05 +0800 | [diff] [blame] | 160 | int syscall_exit_format(struct ftrace_event_call *call, struct trace_seq *s) |
| 161 | { |
| 162 | int ret; |
| 163 | struct syscall_trace_exit trace; |
| 164 | |
| 165 | ret = trace_seq_printf(s, |
| 166 | "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n" |
| 167 | "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n", |
| 168 | SYSCALL_FIELD(int, nr), |
Tom Zanussi | ee949a8 | 2009-10-06 01:00:49 -0500 | [diff] [blame] | 169 | SYSCALL_FIELD(long, ret)); |
Li Zefan | 10a5b66 | 2009-08-19 15:53:05 +0800 | [diff] [blame] | 170 | if (!ret) |
| 171 | return 0; |
| 172 | |
| 173 | return trace_seq_printf(s, "\nprint fmt: \"0x%%lx\", REC->ret\n"); |
| 174 | } |
| 175 | |
Li Zefan | 540b7b8 | 2009-08-19 15:54:51 +0800 | [diff] [blame] | 176 | int syscall_enter_define_fields(struct ftrace_event_call *call) |
| 177 | { |
| 178 | struct syscall_trace_enter trace; |
| 179 | struct syscall_metadata *meta; |
| 180 | int ret; |
| 181 | int nr; |
| 182 | int i; |
| 183 | int offset = offsetof(typeof(trace), args); |
| 184 | |
| 185 | nr = syscall_name_to_nr(call->data); |
| 186 | meta = syscall_nr_to_meta(nr); |
| 187 | |
| 188 | if (!meta) |
| 189 | return 0; |
| 190 | |
| 191 | ret = trace_define_common_fields(call); |
| 192 | if (ret) |
| 193 | return ret; |
| 194 | |
| 195 | for (i = 0; i < meta->nb_args; i++) { |
| 196 | ret = trace_define_field(call, meta->types[i], |
| 197 | meta->args[i], offset, |
Li Zefan | 43b51ea | 2009-08-07 10:33:22 +0800 | [diff] [blame] | 198 | sizeof(unsigned long), 0, |
| 199 | FILTER_OTHER); |
Li Zefan | 540b7b8 | 2009-08-19 15:54:51 +0800 | [diff] [blame] | 200 | offset += sizeof(unsigned long); |
| 201 | } |
| 202 | |
| 203 | return ret; |
| 204 | } |
| 205 | |
| 206 | int syscall_exit_define_fields(struct ftrace_event_call *call) |
| 207 | { |
| 208 | struct syscall_trace_exit trace; |
| 209 | int ret; |
| 210 | |
| 211 | ret = trace_define_common_fields(call); |
| 212 | if (ret) |
| 213 | return ret; |
| 214 | |
Tom Zanussi | ee949a8 | 2009-10-06 01:00:49 -0500 | [diff] [blame] | 215 | ret = trace_define_field(call, SYSCALL_FIELD(long, ret), 0, |
Li Zefan | 43b51ea | 2009-08-07 10:33:22 +0800 | [diff] [blame] | 216 | FILTER_OTHER); |
Li Zefan | 540b7b8 | 2009-08-19 15:54:51 +0800 | [diff] [blame] | 217 | |
| 218 | return ret; |
| 219 | } |
| 220 | |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 221 | void ftrace_syscall_enter(struct pt_regs *regs, long id) |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 222 | { |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 223 | struct syscall_trace_enter *entry; |
| 224 | struct syscall_metadata *sys_data; |
| 225 | struct ring_buffer_event *event; |
Steven Rostedt | e77405a | 2009-09-02 14:17:06 -0400 | [diff] [blame] | 226 | struct ring_buffer *buffer; |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 227 | int size; |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 228 | int syscall_nr; |
| 229 | |
| 230 | syscall_nr = syscall_get_nr(current, regs); |
Hendrik Brueckner | cd0980f | 2009-08-25 14:50:27 +0200 | [diff] [blame] | 231 | if (syscall_nr < 0) |
| 232 | return; |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 233 | if (!test_bit(syscall_nr, enabled_enter_syscalls)) |
| 234 | return; |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 235 | |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 236 | sys_data = syscall_nr_to_meta(syscall_nr); |
| 237 | if (!sys_data) |
| 238 | return; |
| 239 | |
| 240 | size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args; |
| 241 | |
Steven Rostedt | e77405a | 2009-09-02 14:17:06 -0400 | [diff] [blame] | 242 | event = trace_current_buffer_lock_reserve(&buffer, sys_data->enter_id, |
| 243 | size, 0, 0); |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 244 | if (!event) |
| 245 | return; |
| 246 | |
| 247 | entry = ring_buffer_event_data(event); |
| 248 | entry->nr = syscall_nr; |
| 249 | syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args); |
| 250 | |
Steven Rostedt | e77405a | 2009-09-02 14:17:06 -0400 | [diff] [blame] | 251 | if (!filter_current_check_discard(buffer, sys_data->enter_event, |
| 252 | entry, event)) |
| 253 | trace_current_buffer_unlock_commit(buffer, event, 0, 0); |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 254 | } |
| 255 | |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 256 | void ftrace_syscall_exit(struct pt_regs *regs, long ret) |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 257 | { |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 258 | struct syscall_trace_exit *entry; |
| 259 | struct syscall_metadata *sys_data; |
| 260 | struct ring_buffer_event *event; |
Steven Rostedt | e77405a | 2009-09-02 14:17:06 -0400 | [diff] [blame] | 261 | struct ring_buffer *buffer; |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 262 | int syscall_nr; |
| 263 | |
| 264 | syscall_nr = syscall_get_nr(current, regs); |
Hendrik Brueckner | cd0980f | 2009-08-25 14:50:27 +0200 | [diff] [blame] | 265 | if (syscall_nr < 0) |
| 266 | return; |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 267 | if (!test_bit(syscall_nr, enabled_exit_syscalls)) |
| 268 | return; |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 269 | |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 270 | sys_data = syscall_nr_to_meta(syscall_nr); |
| 271 | if (!sys_data) |
| 272 | return; |
| 273 | |
Steven Rostedt | e77405a | 2009-09-02 14:17:06 -0400 | [diff] [blame] | 274 | event = trace_current_buffer_lock_reserve(&buffer, sys_data->exit_id, |
Frederic Weisbecker | bed1ffc | 2009-03-13 15:42:11 +0100 | [diff] [blame] | 275 | sizeof(*entry), 0, 0); |
| 276 | if (!event) |
| 277 | return; |
| 278 | |
| 279 | entry = ring_buffer_event_data(event); |
| 280 | entry->nr = syscall_nr; |
| 281 | entry->ret = syscall_get_return_value(current, regs); |
| 282 | |
Steven Rostedt | e77405a | 2009-09-02 14:17:06 -0400 | [diff] [blame] | 283 | if (!filter_current_check_discard(buffer, sys_data->exit_event, |
| 284 | entry, event)) |
| 285 | trace_current_buffer_unlock_commit(buffer, event, 0, 0); |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 286 | } |
| 287 | |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 288 | int reg_event_syscall_enter(void *ptr) |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 289 | { |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 290 | int ret = 0; |
| 291 | int num; |
| 292 | char *name; |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 293 | |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 294 | name = (char *)ptr; |
| 295 | num = syscall_name_to_nr(name); |
Jason Baron | 57421db | 2009-08-24 17:40:22 -0400 | [diff] [blame] | 296 | if (num < 0 || num >= NR_syscalls) |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 297 | return -ENOSYS; |
| 298 | mutex_lock(&syscall_trace_lock); |
| 299 | if (!sys_refcount_enter) |
Josh Stone | 1c569f0 | 2009-08-24 14:43:14 -0700 | [diff] [blame] | 300 | ret = register_trace_sys_enter(ftrace_syscall_enter); |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 301 | if (ret) { |
| 302 | pr_info("event trace: Could not activate" |
| 303 | "syscall entry trace point"); |
| 304 | } else { |
| 305 | set_bit(num, enabled_enter_syscalls); |
| 306 | sys_refcount_enter++; |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 307 | } |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 308 | mutex_unlock(&syscall_trace_lock); |
| 309 | return ret; |
Frederic Weisbecker | ee08c6e | 2009-03-07 05:52:59 +0100 | [diff] [blame] | 310 | } |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 311 | |
| 312 | void unreg_event_syscall_enter(void *ptr) |
| 313 | { |
| 314 | int num; |
| 315 | char *name; |
| 316 | |
| 317 | name = (char *)ptr; |
| 318 | num = syscall_name_to_nr(name); |
Jason Baron | 57421db | 2009-08-24 17:40:22 -0400 | [diff] [blame] | 319 | if (num < 0 || num >= NR_syscalls) |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 320 | return; |
| 321 | mutex_lock(&syscall_trace_lock); |
| 322 | sys_refcount_enter--; |
| 323 | clear_bit(num, enabled_enter_syscalls); |
| 324 | if (!sys_refcount_enter) |
Josh Stone | 1c569f0 | 2009-08-24 14:43:14 -0700 | [diff] [blame] | 325 | unregister_trace_sys_enter(ftrace_syscall_enter); |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 326 | mutex_unlock(&syscall_trace_lock); |
| 327 | } |
| 328 | |
| 329 | int reg_event_syscall_exit(void *ptr) |
| 330 | { |
| 331 | int ret = 0; |
| 332 | int num; |
| 333 | char *name; |
| 334 | |
| 335 | name = (char *)ptr; |
| 336 | num = syscall_name_to_nr(name); |
Jason Baron | 57421db | 2009-08-24 17:40:22 -0400 | [diff] [blame] | 337 | if (num < 0 || num >= NR_syscalls) |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 338 | return -ENOSYS; |
| 339 | mutex_lock(&syscall_trace_lock); |
| 340 | if (!sys_refcount_exit) |
Josh Stone | 1c569f0 | 2009-08-24 14:43:14 -0700 | [diff] [blame] | 341 | ret = register_trace_sys_exit(ftrace_syscall_exit); |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 342 | if (ret) { |
| 343 | pr_info("event trace: Could not activate" |
| 344 | "syscall exit trace point"); |
| 345 | } else { |
| 346 | set_bit(num, enabled_exit_syscalls); |
| 347 | sys_refcount_exit++; |
| 348 | } |
| 349 | mutex_unlock(&syscall_trace_lock); |
| 350 | return ret; |
| 351 | } |
| 352 | |
| 353 | void unreg_event_syscall_exit(void *ptr) |
| 354 | { |
| 355 | int num; |
| 356 | char *name; |
| 357 | |
| 358 | name = (char *)ptr; |
| 359 | num = syscall_name_to_nr(name); |
Jason Baron | 57421db | 2009-08-24 17:40:22 -0400 | [diff] [blame] | 360 | if (num < 0 || num >= NR_syscalls) |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 361 | return; |
| 362 | mutex_lock(&syscall_trace_lock); |
| 363 | sys_refcount_exit--; |
| 364 | clear_bit(num, enabled_exit_syscalls); |
| 365 | if (!sys_refcount_exit) |
Josh Stone | 1c569f0 | 2009-08-24 14:43:14 -0700 | [diff] [blame] | 366 | unregister_trace_sys_exit(ftrace_syscall_exit); |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 367 | mutex_unlock(&syscall_trace_lock); |
| 368 | } |
| 369 | |
| 370 | struct trace_event event_syscall_enter = { |
| 371 | .trace = print_syscall_enter, |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 372 | }; |
| 373 | |
| 374 | struct trace_event event_syscall_exit = { |
| 375 | .trace = print_syscall_exit, |
Jason Baron | fb34a08 | 2009-08-10 16:52:47 -0400 | [diff] [blame] | 376 | }; |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 377 | |
| 378 | #ifdef CONFIG_EVENT_PROFILE |
Frederic Weisbecker | 19007a6 | 2009-08-11 20:22:53 +0200 | [diff] [blame] | 379 | |
Jason Baron | 57421db | 2009-08-24 17:40:22 -0400 | [diff] [blame] | 380 | static DECLARE_BITMAP(enabled_prof_enter_syscalls, NR_syscalls); |
| 381 | static DECLARE_BITMAP(enabled_prof_exit_syscalls, NR_syscalls); |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 382 | static int sys_prof_refcount_enter; |
| 383 | static int sys_prof_refcount_exit; |
| 384 | |
| 385 | static void prof_syscall_enter(struct pt_regs *regs, long id) |
| 386 | { |
| 387 | struct syscall_metadata *sys_data; |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 388 | struct syscall_trace_enter *rec; |
| 389 | unsigned long flags; |
| 390 | char *raw_data; |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 391 | int syscall_nr; |
Frederic Weisbecker | 19007a6 | 2009-08-11 20:22:53 +0200 | [diff] [blame] | 392 | int size; |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 393 | int cpu; |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 394 | |
| 395 | syscall_nr = syscall_get_nr(current, regs); |
| 396 | if (!test_bit(syscall_nr, enabled_prof_enter_syscalls)) |
| 397 | return; |
| 398 | |
| 399 | sys_data = syscall_nr_to_meta(syscall_nr); |
| 400 | if (!sys_data) |
| 401 | return; |
| 402 | |
Frederic Weisbecker | 19007a6 | 2009-08-11 20:22:53 +0200 | [diff] [blame] | 403 | /* get the size after alignment with the u32 buffer size field */ |
| 404 | size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec); |
| 405 | size = ALIGN(size + sizeof(u32), sizeof(u64)); |
| 406 | size -= sizeof(u32); |
| 407 | |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 408 | if (WARN_ONCE(size > FTRACE_MAX_PROFILE_SIZE, |
| 409 | "profile buffer not large enough")) |
| 410 | return; |
Frederic Weisbecker | 19007a6 | 2009-08-11 20:22:53 +0200 | [diff] [blame] | 411 | |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 412 | /* Protect the per cpu buffer, begin the rcu read side */ |
| 413 | local_irq_save(flags); |
Frederic Weisbecker | 19007a6 | 2009-08-11 20:22:53 +0200 | [diff] [blame] | 414 | |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 415 | cpu = smp_processor_id(); |
| 416 | |
| 417 | if (in_nmi()) |
| 418 | raw_data = rcu_dereference(trace_profile_buf_nmi); |
| 419 | else |
| 420 | raw_data = rcu_dereference(trace_profile_buf); |
| 421 | |
| 422 | if (!raw_data) |
| 423 | goto end; |
| 424 | |
| 425 | raw_data = per_cpu_ptr(raw_data, cpu); |
| 426 | |
| 427 | /* zero the dead bytes from align to not leak stack to user */ |
| 428 | *(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL; |
| 429 | |
| 430 | rec = (struct syscall_trace_enter *) raw_data; |
| 431 | tracing_generic_entry_update(&rec->ent, 0, 0); |
| 432 | rec->ent.type = sys_data->enter_id; |
| 433 | rec->nr = syscall_nr; |
| 434 | syscall_get_arguments(current, regs, 0, sys_data->nb_args, |
| 435 | (unsigned long *)&rec->args); |
Linus Torvalds | 43c1266 | 2009-09-21 09:15:07 -0700 | [diff] [blame] | 436 | perf_tp_event(sys_data->enter_id, 0, 1, rec, size); |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 437 | |
| 438 | end: |
| 439 | local_irq_restore(flags); |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 440 | } |
| 441 | |
| 442 | int reg_prof_syscall_enter(char *name) |
| 443 | { |
| 444 | int ret = 0; |
| 445 | int num; |
| 446 | |
| 447 | num = syscall_name_to_nr(name); |
Jason Baron | 57421db | 2009-08-24 17:40:22 -0400 | [diff] [blame] | 448 | if (num < 0 || num >= NR_syscalls) |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 449 | return -ENOSYS; |
| 450 | |
| 451 | mutex_lock(&syscall_trace_lock); |
| 452 | if (!sys_prof_refcount_enter) |
Josh Stone | 1c569f0 | 2009-08-24 14:43:14 -0700 | [diff] [blame] | 453 | ret = register_trace_sys_enter(prof_syscall_enter); |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 454 | if (ret) { |
| 455 | pr_info("event trace: Could not activate" |
| 456 | "syscall entry trace point"); |
| 457 | } else { |
| 458 | set_bit(num, enabled_prof_enter_syscalls); |
| 459 | sys_prof_refcount_enter++; |
| 460 | } |
| 461 | mutex_unlock(&syscall_trace_lock); |
| 462 | return ret; |
| 463 | } |
| 464 | |
| 465 | void unreg_prof_syscall_enter(char *name) |
| 466 | { |
| 467 | int num; |
| 468 | |
| 469 | num = syscall_name_to_nr(name); |
Jason Baron | 57421db | 2009-08-24 17:40:22 -0400 | [diff] [blame] | 470 | if (num < 0 || num >= NR_syscalls) |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 471 | return; |
| 472 | |
| 473 | mutex_lock(&syscall_trace_lock); |
| 474 | sys_prof_refcount_enter--; |
| 475 | clear_bit(num, enabled_prof_enter_syscalls); |
| 476 | if (!sys_prof_refcount_enter) |
Josh Stone | 1c569f0 | 2009-08-24 14:43:14 -0700 | [diff] [blame] | 477 | unregister_trace_sys_enter(prof_syscall_enter); |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 478 | mutex_unlock(&syscall_trace_lock); |
| 479 | } |
| 480 | |
| 481 | static void prof_syscall_exit(struct pt_regs *regs, long ret) |
| 482 | { |
| 483 | struct syscall_metadata *sys_data; |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 484 | struct syscall_trace_exit *rec; |
| 485 | unsigned long flags; |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 486 | int syscall_nr; |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 487 | char *raw_data; |
| 488 | int size; |
| 489 | int cpu; |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 490 | |
| 491 | syscall_nr = syscall_get_nr(current, regs); |
| 492 | if (!test_bit(syscall_nr, enabled_prof_exit_syscalls)) |
| 493 | return; |
| 494 | |
| 495 | sys_data = syscall_nr_to_meta(syscall_nr); |
| 496 | if (!sys_data) |
| 497 | return; |
| 498 | |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 499 | /* We can probably do that at build time */ |
| 500 | size = ALIGN(sizeof(*rec) + sizeof(u32), sizeof(u64)); |
| 501 | size -= sizeof(u32); |
Frederic Weisbecker | 19007a6 | 2009-08-11 20:22:53 +0200 | [diff] [blame] | 502 | |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 503 | /* |
| 504 | * Impossible, but be paranoid with the future |
| 505 | * How to put this check outside runtime? |
| 506 | */ |
| 507 | if (WARN_ONCE(size > FTRACE_MAX_PROFILE_SIZE, |
| 508 | "exit event has grown above profile buffer size")) |
| 509 | return; |
| 510 | |
| 511 | /* Protect the per cpu buffer, begin the rcu read side */ |
| 512 | local_irq_save(flags); |
| 513 | cpu = smp_processor_id(); |
| 514 | |
| 515 | if (in_nmi()) |
| 516 | raw_data = rcu_dereference(trace_profile_buf_nmi); |
| 517 | else |
| 518 | raw_data = rcu_dereference(trace_profile_buf); |
| 519 | |
| 520 | if (!raw_data) |
| 521 | goto end; |
| 522 | |
| 523 | raw_data = per_cpu_ptr(raw_data, cpu); |
| 524 | |
| 525 | /* zero the dead bytes from align to not leak stack to user */ |
| 526 | *(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL; |
| 527 | |
| 528 | rec = (struct syscall_trace_exit *)raw_data; |
| 529 | |
| 530 | tracing_generic_entry_update(&rec->ent, 0, 0); |
| 531 | rec->ent.type = sys_data->exit_id; |
| 532 | rec->nr = syscall_nr; |
| 533 | rec->ret = syscall_get_return_value(current, regs); |
| 534 | |
Linus Torvalds | 43c1266 | 2009-09-21 09:15:07 -0700 | [diff] [blame] | 535 | perf_tp_event(sys_data->exit_id, 0, 1, rec, size); |
Frederic Weisbecker | 20ab442 | 2009-09-18 06:10:28 +0200 | [diff] [blame] | 536 | |
| 537 | end: |
| 538 | local_irq_restore(flags); |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 539 | } |
| 540 | |
| 541 | int reg_prof_syscall_exit(char *name) |
| 542 | { |
| 543 | int ret = 0; |
| 544 | int num; |
| 545 | |
| 546 | num = syscall_name_to_nr(name); |
Jason Baron | 57421db | 2009-08-24 17:40:22 -0400 | [diff] [blame] | 547 | if (num < 0 || num >= NR_syscalls) |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 548 | return -ENOSYS; |
| 549 | |
| 550 | mutex_lock(&syscall_trace_lock); |
| 551 | if (!sys_prof_refcount_exit) |
Josh Stone | 1c569f0 | 2009-08-24 14:43:14 -0700 | [diff] [blame] | 552 | ret = register_trace_sys_exit(prof_syscall_exit); |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 553 | if (ret) { |
| 554 | pr_info("event trace: Could not activate" |
| 555 | "syscall entry trace point"); |
| 556 | } else { |
| 557 | set_bit(num, enabled_prof_exit_syscalls); |
| 558 | sys_prof_refcount_exit++; |
| 559 | } |
| 560 | mutex_unlock(&syscall_trace_lock); |
| 561 | return ret; |
| 562 | } |
| 563 | |
| 564 | void unreg_prof_syscall_exit(char *name) |
| 565 | { |
| 566 | int num; |
| 567 | |
| 568 | num = syscall_name_to_nr(name); |
Jason Baron | 57421db | 2009-08-24 17:40:22 -0400 | [diff] [blame] | 569 | if (num < 0 || num >= NR_syscalls) |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 570 | return; |
| 571 | |
| 572 | mutex_lock(&syscall_trace_lock); |
| 573 | sys_prof_refcount_exit--; |
| 574 | clear_bit(num, enabled_prof_exit_syscalls); |
| 575 | if (!sys_prof_refcount_exit) |
Josh Stone | 1c569f0 | 2009-08-24 14:43:14 -0700 | [diff] [blame] | 576 | unregister_trace_sys_exit(prof_syscall_exit); |
Jason Baron | f4b5ffc | 2009-08-10 16:53:02 -0400 | [diff] [blame] | 577 | mutex_unlock(&syscall_trace_lock); |
| 578 | } |
| 579 | |
| 580 | #endif |
| 581 | |
| 582 | |