linux/kernel/trace/trace_export.c
<<
>>
Prefs
   1/*
   2 * trace_export.c - export basic ftrace utilities to user space
   3 *
   4 * Copyright (C) 2009 Steven Rostedt <srostedt@redhat.com>
   5 */
   6#include <linux/stringify.h>
   7#include <linux/kallsyms.h>
   8#include <linux/seq_file.h>
   9#include <linux/debugfs.h>
  10#include <linux/uaccess.h>
  11#include <linux/ftrace.h>
  12#include <linux/module.h>
  13#include <linux/init.h>
  14#include <linux/fs.h>
  15
  16#include "trace_output.h"
  17
  18#undef TRACE_SYSTEM
  19#define TRACE_SYSTEM    ftrace
  20
  21/*
  22 * The FTRACE_ENTRY_REG macro allows ftrace entry to define register
  23 * function and thus become accesible via perf.
  24 */
  25#undef FTRACE_ENTRY_REG
  26#define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print, \
  27                         filter, regfn) \
  28        FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
  29                     filter)
  30
  31/* not needed for this file */
  32#undef __field_struct
  33#define __field_struct(type, item)
  34
  35#undef __field
  36#define __field(type, item)                             type item;
  37
  38#undef __field_desc
  39#define __field_desc(type, container, item)             type item;
  40
  41#undef __array
  42#define __array(type, item, size)                       type item[size];
  43
  44#undef __array_desc
  45#define __array_desc(type, container, item, size)       type item[size];
  46
  47#undef __dynamic_array
  48#define __dynamic_array(type, item)                     type item[];
  49
  50#undef F_STRUCT
  51#define F_STRUCT(args...)                               args
  52
  53#undef F_printk
  54#define F_printk(fmt, args...) fmt, args
  55
  56#undef FTRACE_ENTRY
  57#define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter)     \
  58struct ____ftrace_##name {                                              \
  59        tstruct                                                         \
  60};                                                                      \
  61static void __always_unused ____ftrace_check_##name(void)               \
  62{                                                                       \
  63        struct ____ftrace_##name *__entry = NULL;                       \
  64                                                                        \
  65        /* force compile-time check on F_printk() */                    \
  66        printk(print);                                                  \
  67}
  68
  69#undef FTRACE_ENTRY_DUP
  70#define FTRACE_ENTRY_DUP(name, struct_name, id, tstruct, print, filter) \
  71        FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print), \
  72                     filter)
  73
  74#include "trace_entries.h"
  75
  76#undef __field
  77#define __field(type, item)                                             \
  78        ret = trace_define_field(event_call, #type, #item,              \
  79                                 offsetof(typeof(field), item),         \
  80                                 sizeof(field.item),                    \
  81                                 is_signed_type(type), filter_type);    \
  82        if (ret)                                                        \
  83                return ret;
  84
  85#undef __field_desc
  86#define __field_desc(type, container, item)     \
  87        ret = trace_define_field(event_call, #type, #item,              \
  88                                 offsetof(typeof(field),                \
  89                                          container.item),              \
  90                                 sizeof(field.container.item),          \
  91                                 is_signed_type(type), filter_type);    \
  92        if (ret)                                                        \
  93                return ret;
  94
  95#undef __array
  96#define __array(type, item, len)                                        \
  97        do {                                                            \
  98                BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);                 \
  99                mutex_lock(&event_storage_mutex);                       \
 100                snprintf(event_storage, sizeof(event_storage),          \
 101                         "%s[%d]", #type, len);                         \
 102                ret = trace_define_field(event_call, event_storage, #item, \
 103                                 offsetof(typeof(field), item),         \
 104                                 sizeof(field.item),                    \
 105                                 is_signed_type(type), filter_type);    \
 106                mutex_unlock(&event_storage_mutex);                     \
 107                if (ret)                                                \
 108                        return ret;                                     \
 109        } while (0);
 110
 111#undef __array_desc
 112#define __array_desc(type, container, item, len)                        \
 113        BUILD_BUG_ON(len > MAX_FILTER_STR_VAL);                         \
 114        ret = trace_define_field(event_call, #type "[" #len "]", #item, \
 115                                 offsetof(typeof(field),                \
 116                                          container.item),              \
 117                                 sizeof(field.container.item),          \
 118                                 is_signed_type(type), filter_type);    \
 119        if (ret)                                                        \
 120                return ret;
 121
 122#undef __dynamic_array
 123#define __dynamic_array(type, item)                                     \
 124        ret = trace_define_field(event_call, #type, #item,              \
 125                                 offsetof(typeof(field), item),         \
 126                                 0, is_signed_type(type), filter_type);\
 127        if (ret)                                                        \
 128                return ret;
 129
 130#undef FTRACE_ENTRY
 131#define FTRACE_ENTRY(name, struct_name, id, tstruct, print, filter)     \
 132int                                                                     \
 133ftrace_define_fields_##name(struct ftrace_event_call *event_call)       \
 134{                                                                       \
 135        struct struct_name field;                                       \
 136        int ret;                                                        \
 137        int filter_type = filter;                                       \
 138                                                                        \
 139        tstruct;                                                        \
 140                                                                        \
 141        return ret;                                                     \
 142}
 143
 144#include "trace_entries.h"
 145
 146#undef __entry
 147#define __entry REC
 148
 149#undef __field
 150#define __field(type, item)
 151
 152#undef __field_desc
 153#define __field_desc(type, container, item)
 154
 155#undef __array
 156#define __array(type, item, len)
 157
 158#undef __array_desc
 159#define __array_desc(type, container, item, len)
 160
 161#undef __dynamic_array
 162#define __dynamic_array(type, item)
 163
 164#undef F_printk
 165#define F_printk(fmt, args...) __stringify(fmt) ", "  __stringify(args)
 166
 167#undef FTRACE_ENTRY_REG
 168#define FTRACE_ENTRY_REG(call, struct_name, etype, tstruct, print, filter,\
 169                         regfn)                                         \
 170                                                                        \
 171struct ftrace_event_class event_class_ftrace_##call = {                 \
 172        .system                 = __stringify(TRACE_SYSTEM),            \
 173        .define_fields          = ftrace_define_fields_##call,          \
 174        .fields                 = LIST_HEAD_INIT(event_class_ftrace_##call.fields),\
 175        .reg                    = regfn,                                \
 176};                                                                      \
 177                                                                        \
 178struct ftrace_event_call __used event_##call = {                        \
 179        .name                   = #call,                                \
 180        .event.type             = etype,                                \
 181        .class                  = &event_class_ftrace_##call,           \
 182        .print_fmt              = print,                                \
 183        .flags                  = TRACE_EVENT_FL_IGNORE_ENABLE,         \
 184};                                                                      \
 185struct ftrace_event_call __used                                         \
 186__attribute__((section("_ftrace_events"))) *__event_##call = &event_##call;
 187
 188#undef FTRACE_ENTRY
 189#define FTRACE_ENTRY(call, struct_name, etype, tstruct, print, filter)  \
 190        FTRACE_ENTRY_REG(call, struct_name, etype,                      \
 191                         PARAMS(tstruct), PARAMS(print), filter, NULL)
 192
 193int ftrace_event_is_function(struct ftrace_event_call *call)
 194{
 195        return call == &event_function;
 196}
 197
 198#include "trace_entries.h"
 199
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.