SAFE public projects git trees. - safe/jmp/linux-2.6/blob - kernel/trace/trace_syscalls.c

   1 #include <trace/syscall.h>
   2 #include <linux/kernel.h>
   3 #include <linux/ftrace.h>
   4 #include <linux/perf_counter.h>
   5 #include <asm/syscall.h>
   6
   7 #include "trace_output.h"
   8 #include "trace.h"
   9
  10 static DEFINE_MUTEX(syscall_trace_lock);
  11 static int sys_refcount_enter;
  12 static int sys_refcount_exit;
  13 static DECLARE_BITMAP(enabled_enter_syscalls, FTRACE_SYSCALL_MAX);
  14 static DECLARE_BITMAP(enabled_exit_syscalls, FTRACE_SYSCALL_MAX);
  15
  16 enum print_line_t
  17 print_syscall_enter(struct trace_iterator *iter, int flags)
  18 {
  19         struct trace_seq *s = &iter->seq;
  20         struct trace_entry *ent = iter->ent;
  21         struct syscall_trace_enter *trace;
  22         struct syscall_metadata *entry;
  23         int i, ret, syscall;
  24
  25         trace = (typeof(trace))ent;
  26         syscall = trace->nr;
  27         entry = syscall_nr_to_meta(syscall);
  28
  29         if (!entry)
  30                 goto end;
  31
  32         if (entry->enter_id != ent->type) {
  33                 WARN_ON_ONCE(1);
  34                 goto end;
  35         }
  36
  37         ret = trace_seq_printf(s, "%s(", entry->name);
  38         if (!ret)
  39                 return TRACE_TYPE_PARTIAL_LINE;
  40
  41         for (i = 0; i < entry->nb_args; i++) {
  42                 /* parameter types */
  43                 if (trace_flags & TRACE_ITER_VERBOSE) {
  44                         ret = trace_seq_printf(s, "%s ", entry->types[i]);
  45                         if (!ret)
  46                                 return TRACE_TYPE_PARTIAL_LINE;
  47                 }
  48                 /* 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                 if (!ret)
  53                         return TRACE_TYPE_PARTIAL_LINE;
  54         }
  55
  56 end:
  57         trace_seq_printf(s, "\n");
  58         return TRACE_TYPE_HANDLED;
  59 }
  60
  61 enum print_line_t
  62 print_syscall_exit(struct trace_iterator *iter, int flags)
  63 {
  64         struct trace_seq *s = &iter->seq;
  65         struct trace_entry *ent = iter->ent;
  66         struct syscall_trace_exit *trace;
  67         int syscall;
  68         struct syscall_metadata *entry;
  69         int ret;
  70
  71         trace = (typeof(trace))ent;
  72         syscall = trace->nr;
  73         entry = syscall_nr_to_meta(syscall);
  74
  75         if (!entry) {
  76                 trace_seq_printf(s, "\n");
  77                 return TRACE_TYPE_HANDLED;
  78         }
  79
  80         if (entry->exit_id != ent->type) {
  81                 WARN_ON_ONCE(1);
  82                 return TRACE_TYPE_UNHANDLED;
  83         }
  84
  85         ret = trace_seq_printf(s, "%s -> 0x%lx\n", entry->name,
  86                                 trace->ret);
  87         if (!ret)
  88                 return TRACE_TYPE_PARTIAL_LINE;
  89
  90         return TRACE_TYPE_HANDLED;
  91 }
  92
  93 extern char *__bad_type_size(void);
  94
  95 #define SYSCALL_FIELD(type, name)                                       \
  96         sizeof(type) != sizeof(trace.name) ?                            \
  97                 __bad_type_size() :                                     \
  98                 #type, #name, offsetof(typeof(trace), name), sizeof(trace.name)
  99
 100 int ftrace_format_syscall(struct ftrace_event_call *call, struct trace_seq *s)
 101 {
 102         int i;
 103         int nr;
 104         int ret;
 105         struct syscall_metadata *entry;
 106         struct syscall_trace_enter trace;
 107         int offset = offsetof(struct syscall_trace_enter, args);
 108
 109         nr = syscall_name_to_nr(call->data);
 110         entry = syscall_nr_to_meta(nr);
 111
 112         if (!entry)
 113                 return 0;
 114
 115         ret = trace_seq_printf(s, "\tfield:%s %s;\toffset:%zu;\tsize:%zu;\n",
 116                                SYSCALL_FIELD(int, nr));
 117         if (!ret)
 118                 return 0;
 119
 120         for (i = 0; i < entry->nb_args; i++) {
 121                 ret = trace_seq_printf(s, "\tfield:%s %s;", entry->types[i],
 122                                         entry->args[i]);
 123                 if (!ret)
 124                         return 0;
 125                 ret = trace_seq_printf(s, "\toffset:%d;\tsize:%zu;\n", offset,
 126                                        sizeof(unsigned long));
 127                 if (!ret)
 128                         return 0;
 129                 offset += sizeof(unsigned long);
 130         }
 131
 132         trace_seq_printf(s, "\nprint fmt: \"");
 133         for (i = 0; i < entry->nb_args; i++) {
 134                 ret = trace_seq_printf(s, "%s: 0x%%0%zulx%s", entry->args[i],
 135                                         sizeof(unsigned long),
 136                                         i == entry->nb_args - 1 ? "\", " : ", ");
 137                 if (!ret)
 138                         return 0;
 139         }
 140
 141         for (i = 0; i < entry->nb_args; i++) {
 142                 ret = trace_seq_printf(s, "((unsigned long)(REC->%s))%s",
 143                                         entry->args[i],
 144                                         i == entry->nb_args - 1 ? "\n" : ", ");
 145                 if (!ret)
 146                         return 0;
 147         }
 148
 149         return ret;
 150 }
 151
 152 void ftrace_syscall_enter(struct pt_regs *regs, long id)
 153 {
 154         struct syscall_trace_enter *entry;
 155         struct syscall_metadata *sys_data;
 156         struct ring_buffer_event *event;
 157         int size;
 158         int syscall_nr;
 159
 160         syscall_nr = syscall_get_nr(current, regs);
 161         if (!test_bit(syscall_nr, enabled_enter_syscalls))
 162                 return;
 163
 164         sys_data = syscall_nr_to_meta(syscall_nr);
 165         if (!sys_data)
 166                 return;
 167
 168         size = sizeof(*entry) + sizeof(unsigned long) * sys_data->nb_args;
 169
 170         event = trace_current_buffer_lock_reserve(sys_data->enter_id, size,
 171                                                         0, 0);
 172         if (!event)
 173                 return;
 174
 175         entry = ring_buffer_event_data(event);
 176         entry->nr = syscall_nr;
 177         syscall_get_arguments(current, regs, 0, sys_data->nb_args, entry->args);
 178
 179         trace_current_buffer_unlock_commit(event, 0, 0);
 180         trace_wake_up();
 181 }
 182
 183 void ftrace_syscall_exit(struct pt_regs *regs, long ret)
 184 {
 185         struct syscall_trace_exit *entry;
 186         struct syscall_metadata *sys_data;
 187         struct ring_buffer_event *event;
 188         int syscall_nr;
 189
 190         syscall_nr = syscall_get_nr(current, regs);
 191         if (!test_bit(syscall_nr, enabled_exit_syscalls))
 192                 return;
 193
 194         sys_data = syscall_nr_to_meta(syscall_nr);
 195         if (!sys_data)
 196                 return;
 197
 198         event = trace_current_buffer_lock_reserve(sys_data->exit_id,
 199                                 sizeof(*entry), 0, 0);
 200         if (!event)
 201                 return;
 202
 203         entry = ring_buffer_event_data(event);
 204         entry->nr = syscall_nr;
 205         entry->ret = syscall_get_return_value(current, regs);
 206
 207         trace_current_buffer_unlock_commit(event, 0, 0);
 208         trace_wake_up();
 209 }
 210
 211 int reg_event_syscall_enter(void *ptr)
 212 {
 213         int ret = 0;
 214         int num;
 215         char *name;
 216
 217         name = (char *)ptr;
 218         num = syscall_name_to_nr(name);
 219         if (num < 0 || num >= FTRACE_SYSCALL_MAX)
 220                 return -ENOSYS;
 221         mutex_lock(&syscall_trace_lock);
 222         if (!sys_refcount_enter)
 223                 ret = register_trace_syscall_enter(ftrace_syscall_enter);
 224         if (ret) {
 225                 pr_info("event trace: Could not activate"
 226                                 "syscall entry trace point");
 227         } else {
 228                 set_bit(num, enabled_enter_syscalls);
 229                 sys_refcount_enter++;
 230         }
 231         mutex_unlock(&syscall_trace_lock);
 232         return ret;
 233 }
 234
 235 void unreg_event_syscall_enter(void *ptr)
 236 {
 237         int num;
 238         char *name;
 239
 240         name = (char *)ptr;
 241         num = syscall_name_to_nr(name);
 242         if (num < 0 || num >= FTRACE_SYSCALL_MAX)
 243                 return;
 244         mutex_lock(&syscall_trace_lock);
 245         sys_refcount_enter--;
 246         clear_bit(num, enabled_enter_syscalls);
 247         if (!sys_refcount_enter)
 248                 unregister_trace_syscall_enter(ftrace_syscall_enter);
 249         mutex_unlock(&syscall_trace_lock);
 250 }
 251
 252 int reg_event_syscall_exit(void *ptr)
 253 {
 254         int ret = 0;
 255         int num;
 256         char *name;
 257
 258         name = (char *)ptr;
 259         num = syscall_name_to_nr(name);
 260         if (num < 0 || num >= FTRACE_SYSCALL_MAX)
 261                 return -ENOSYS;
 262         mutex_lock(&syscall_trace_lock);
 263         if (!sys_refcount_exit)
 264                 ret = register_trace_syscall_exit(ftrace_syscall_exit);
 265         if (ret) {
 266                 pr_info("event trace: Could not activate"
 267                                 "syscall exit trace point");
 268         } else {
 269                 set_bit(num, enabled_exit_syscalls);
 270                 sys_refcount_exit++;
 271         }
 272         mutex_unlock(&syscall_trace_lock);
 273         return ret;
 274 }
 275
 276 void unreg_event_syscall_exit(void *ptr)
 277 {
 278         int num;
 279         char *name;
 280
 281         name = (char *)ptr;
 282         num = syscall_name_to_nr(name);
 283         if (num < 0 || num >= FTRACE_SYSCALL_MAX)
 284                 return;
 285         mutex_lock(&syscall_trace_lock);
 286         sys_refcount_exit--;
 287         clear_bit(num, enabled_exit_syscalls);
 288         if (!sys_refcount_exit)
 289                 unregister_trace_syscall_exit(ftrace_syscall_exit);
 290         mutex_unlock(&syscall_trace_lock);
 291 }
 292
 293 struct trace_event event_syscall_enter = {
 294         .trace                  = print_syscall_enter,
 295 };
 296
 297 struct trace_event event_syscall_exit = {
 298         .trace                  = print_syscall_exit,
 299 };
 300
 301 #ifdef CONFIG_EVENT_PROFILE
 302
 303 static DECLARE_BITMAP(enabled_prof_enter_syscalls, FTRACE_SYSCALL_MAX);
 304 static DECLARE_BITMAP(enabled_prof_exit_syscalls, FTRACE_SYSCALL_MAX);
 305 static int sys_prof_refcount_enter;
 306 static int sys_prof_refcount_exit;
 307
 308 static void prof_syscall_enter(struct pt_regs *regs, long id)
 309 {
 310         struct syscall_trace_enter *rec;
 311         struct syscall_metadata *sys_data;
 312         int syscall_nr;
 313         int size;
 314
 315         syscall_nr = syscall_get_nr(current, regs);
 316         if (!test_bit(syscall_nr, enabled_prof_enter_syscalls))
 317                 return;
 318
 319         sys_data = syscall_nr_to_meta(syscall_nr);
 320         if (!sys_data)
 321                 return;
 322
 323         /* get the size after alignment with the u32 buffer size field */
 324         size = sizeof(unsigned long) * sys_data->nb_args + sizeof(*rec);
 325         size = ALIGN(size + sizeof(u32), sizeof(u64));
 326         size -= sizeof(u32);
 327
 328         do {
 329                 char raw_data[size];
 330
 331                 /* zero the dead bytes from align to not leak stack to user */
 332                 *(u64 *)(&raw_data[size - sizeof(u64)]) = 0ULL;
 333
 334                 rec = (struct syscall_trace_enter *) raw_data;
 335                 tracing_generic_entry_update(&rec->ent, 0, 0);
 336                 rec->ent.type = sys_data->enter_id;
 337                 rec->nr = syscall_nr;
 338                 syscall_get_arguments(current, regs, 0, sys_data->nb_args,
 339                                        (unsigned long *)&rec->args);
 340                 perf_tpcounter_event(sys_data->enter_id, 0, 1, rec, size);
 341         } while(0);
 342 }
 343
 344 int reg_prof_syscall_enter(char *name)
 345 {
 346         int ret = 0;
 347         int num;
 348
 349         num = syscall_name_to_nr(name);
 350         if (num < 0 || num >= FTRACE_SYSCALL_MAX)
 351                 return -ENOSYS;
 352
 353         mutex_lock(&syscall_trace_lock);
 354         if (!sys_prof_refcount_enter)
 355                 ret = register_trace_syscall_enter(prof_syscall_enter);
 356         if (ret) {
 357                 pr_info("event trace: Could not activate"
 358                                 "syscall entry trace point");
 359         } else {
 360                 set_bit(num, enabled_prof_enter_syscalls);
 361                 sys_prof_refcount_enter++;
 362         }
 363         mutex_unlock(&syscall_trace_lock);
 364         return ret;
 365 }
 366
 367 void unreg_prof_syscall_enter(char *name)
 368 {
 369         int num;
 370
 371         num = syscall_name_to_nr(name);
 372         if (num < 0 || num >= FTRACE_SYSCALL_MAX)
 373                 return;
 374
 375         mutex_lock(&syscall_trace_lock);
 376         sys_prof_refcount_enter--;
 377         clear_bit(num, enabled_prof_enter_syscalls);
 378         if (!sys_prof_refcount_enter)
 379                 unregister_trace_syscall_enter(prof_syscall_enter);
 380         mutex_unlock(&syscall_trace_lock);
 381 }
 382
 383 static void prof_syscall_exit(struct pt_regs *regs, long ret)
 384 {
 385         struct syscall_metadata *sys_data;
 386         struct syscall_trace_exit rec;
 387         int syscall_nr;
 388
 389         syscall_nr = syscall_get_nr(current, regs);
 390         if (!test_bit(syscall_nr, enabled_prof_exit_syscalls))
 391                 return;
 392
 393         sys_data = syscall_nr_to_meta(syscall_nr);
 394         if (!sys_data)
 395                 return;
 396
 397         tracing_generic_entry_update(&rec.ent, 0, 0);
 398         rec.ent.type = sys_data->exit_id;
 399         rec.nr = syscall_nr;
 400         rec.ret = syscall_get_return_value(current, regs);
 401
 402         perf_tpcounter_event(sys_data->exit_id, 0, 1, &rec, sizeof(rec));
 403 }
 404
 405 int reg_prof_syscall_exit(char *name)
 406 {
 407         int ret = 0;
 408         int num;
 409
 410         num = syscall_name_to_nr(name);
 411         if (num < 0 || num >= FTRACE_SYSCALL_MAX)
 412                 return -ENOSYS;
 413
 414         mutex_lock(&syscall_trace_lock);
 415         if (!sys_prof_refcount_exit)
 416                 ret = register_trace_syscall_exit(prof_syscall_exit);
 417         if (ret) {
 418                 pr_info("event trace: Could not activate"
 419                                 "syscall entry trace point");
 420         } else {
 421                 set_bit(num, enabled_prof_exit_syscalls);
 422                 sys_prof_refcount_exit++;
 423         }
 424         mutex_unlock(&syscall_trace_lock);
 425         return ret;
 426 }
 427
 428 void unreg_prof_syscall_exit(char *name)
 429 {
 430         int num;
 431
 432         num = syscall_name_to_nr(name);
 433         if (num < 0 || num >= FTRACE_SYSCALL_MAX)
 434                 return;
 435
 436         mutex_lock(&syscall_trace_lock);
 437         sys_prof_refcount_exit--;
 438         clear_bit(num, enabled_prof_exit_syscalls);
 439         if (!sys_prof_refcount_exit)
 440                 unregister_trace_syscall_exit(prof_syscall_exit);
 441         mutex_unlock(&syscall_trace_lock);
 442 }
 443
 444 #endif
 445
 446