1// SPDX-License-Identifier: GPL-2.0 2/* 3 * trace_export.c - export basic ftrace utilities to user space 4 * 5 * Copyright (C) 2009 Steven Rostedt <srostedt@redhat.com> 6 */ 7#include <linux/stringify.h> 8#include <linux/kallsyms.h> 9#include <linux/seq_file.h> 10#include <linux/uaccess.h> 11#include <linux/ftrace.h> 12#include <linux/module.h> 13#include <linux/init.h> 14 15#include "trace_output.h" 16 17/* Stub function for events with triggers */ 18static int ftrace_event_register(struct trace_event_call *call, 19 enum trace_reg type, void *data) 20{ 21 return 0; 22} 23 24#undef TRACE_SYSTEM 25#define TRACE_SYSTEM ftrace 26 27/* 28 * The FTRACE_ENTRY_REG macro allows ftrace entry to define register 29 * function and thus become accessible via perf. 30 */ 31#undef FTRACE_ENTRY_REG 32#define FTRACE_ENTRY_REG(name, struct_name, id, tstruct, print, regfn) \ 33 FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print)) 34 35/* not needed for this file */ 36#undef __field_struct 37#define __field_struct(type, item) 38 39#undef __field 40#define __field(type, item) type item; 41 42#undef __field_fn 43#define __field_fn(type, item) type item; 44 45#undef __field_desc 46#define __field_desc(type, container, item) type item; 47 48#undef __field_packed 49#define __field_packed(type, container, item) type item; 50 51#undef __array 52#define __array(type, item, size) type item[size]; 53 54#undef __stack_array 55#define __stack_array(type, item, size, field) __array(type, item, size) 56 57#undef __array_desc 58#define __array_desc(type, container, item, size) type item[size]; 59 60#undef __dynamic_array 61#define __dynamic_array(type, item) type item[]; 62 63#undef F_STRUCT 64#define F_STRUCT(args...) args 65 66#undef F_printk 67#define F_printk(fmt, args...) fmt, args 68 69#undef FTRACE_ENTRY 70#define FTRACE_ENTRY(name, struct_name, id, tstruct, print) \ 71struct ____ftrace_##name { \ 72 tstruct \ 73}; \ 74static void __always_unused ____ftrace_check_##name(void) \ 75{ \ 76 struct ____ftrace_##name *__entry = NULL; \ 77 \ 78 /* force compile-time check on F_printk() */ \ 79 printk(print); \ 80} 81 82#undef FTRACE_ENTRY_DUP 83#define FTRACE_ENTRY_DUP(name, struct_name, id, tstruct, print) \ 84 FTRACE_ENTRY(name, struct_name, id, PARAMS(tstruct), PARAMS(print)) 85 86#include "trace_entries.h" 87 88#undef __field_ext 89#define __field_ext(_type, _item, _filter_type) { \ 90 .type = #_type, .name = #_item, \ 91 .size = sizeof(_type), .align = __alignof__(_type), \ 92 is_signed_type(_type), .filter_type = _filter_type }, 93 94 95#undef __field_ext_packed 96#define __field_ext_packed(_type, _item, _filter_type) { \ 97 .type = #_type, .name = #_item, \ 98 .size = sizeof(_type), .align = 1, \ 99 is_signed_type(_type), .filter_type = _filter_type }, 100 101#undef __field 102#define __field(_type, _item) __field_ext(_type, _item, FILTER_OTHER) 103 104#undef __field_fn 105#define __field_fn(_type, _item) __field_ext(_type, _item, FILTER_TRACE_FN) 106 107#undef __field_desc 108#define __field_desc(_type, _container, _item) __field_ext(_type, _item, FILTER_OTHER) 109 110#undef __field_packed 111#define __field_packed(_type, _container, _item) __field_ext_packed(_type, _item, FILTER_OTHER) 112 113#undef __array 114#define __array(_type, _item, _len) { \ 115 .type = #_type"["__stringify(_len)"]", .name = #_item, \ 116 .size = sizeof(_type[_len]), .align = __alignof__(_type), \ 117 is_signed_type(_type), .filter_type = FILTER_OTHER, \ 118 .len = _len }, 119 120#undef __stack_array 121#define __stack_array(_type, _item, _len, _field) __array(_type, _item, _len) 122 123#undef __array_desc 124#define __array_desc(_type, _container, _item, _len) __array(_type, _item, _len) 125 126#undef __dynamic_array 127#define __dynamic_array(_type, _item) { \ 128 .type = #_type "[]", .name = #_item, \ 129 .size = 0, .align = __alignof__(_type), \ 130 is_signed_type(_type), .filter_type = FILTER_OTHER }, 131 132#undef FTRACE_ENTRY 133#define FTRACE_ENTRY(name, struct_name, id, tstruct, print) \ 134static struct trace_event_fields ftrace_event_fields_##name[] = { \ 135 tstruct \ 136 {} }; 137 138#include "trace_entries.h" 139 140#undef __entry 141#define __entry REC 142 143#undef __field 144#define __field(type, item) 145 146#undef __field_fn 147#define __field_fn(type, item) 148 149#undef __field_desc 150#define __field_desc(type, container, item) 151 152#undef __field_packed 153#define __field_packed(type, container, item) 154 155#undef __array 156#define __array(type, item, len) 157 158#undef __stack_array 159#define __stack_array(type, item, len, field) 160 161#undef __array_desc 162#define __array_desc(type, container, item, len) 163 164#undef __dynamic_array 165#define __dynamic_array(type, item) 166 167#undef F_printk 168#define F_printk(fmt, args...) __stringify(fmt) ", " __stringify(args) 169 170#undef FTRACE_ENTRY_REG 171#define FTRACE_ENTRY_REG(call, struct_name, etype, tstruct, print, regfn) \ 172static struct trace_event_class __refdata event_class_ftrace_##call = { \ 173 .system = __stringify(TRACE_SYSTEM), \ 174 .fields_array = ftrace_event_fields_##call, \ 175 .fields = LIST_HEAD_INIT(event_class_ftrace_##call.fields),\ 176 .reg = regfn, \ 177}; \ 178 \ 179struct trace_event_call __used event_##call = { \ 180 .class = &event_class_ftrace_##call, \ 181 { \ 182 .name = #call, \ 183 }, \ 184 .event.type = etype, \ 185 .print_fmt = print, \ 186 .flags = TRACE_EVENT_FL_IGNORE_ENABLE, \ 187}; \ 188static struct trace_event_call __used \ 189__section("_ftrace_events") *__event_##call = &event_##call; 190 191#undef FTRACE_ENTRY 192#define FTRACE_ENTRY(call, struct_name, etype, tstruct, print) \ 193 FTRACE_ENTRY_REG(call, struct_name, etype, \ 194 PARAMS(tstruct), PARAMS(print), NULL) 195 196bool ftrace_event_is_function(struct trace_event_call *call) 197{ 198 return call == &event_function; 199} 200 201#include "trace_entries.h" 202