From e90c0946e51940934277634f882b56890974774a Mon Sep 17 00:00:00 2001 From: eabdullin Date: Thu, 21 Sep 2023 20:36:51 +0000 Subject: [PATCH] import CS trace-cmd-2.9.2-10.el9 --- ...-last-elements-of-local-libtracefs-a.patch | 1012 +++++++++++++++++ SPECS/trace-cmd.spec | 6 +- 2 files changed, 1017 insertions(+), 1 deletion(-) create mode 100644 SOURCES/trace-cmd-Remove-last-elements-of-local-libtracefs-a.patch diff --git a/SOURCES/trace-cmd-Remove-last-elements-of-local-libtracefs-a.patch b/SOURCES/trace-cmd-Remove-last-elements-of-local-libtracefs-a.patch new file mode 100644 index 0000000..ab14b05 --- /dev/null +++ b/SOURCES/trace-cmd-Remove-last-elements-of-local-libtracefs-a.patch @@ -0,0 +1,1012 @@ +From f1962337ff1cc89ded2782bccbabba0b609a06c2 Mon Sep 17 00:00:00 2001 +From: "Steven Rostedt (VMware)" +Date: Fri, 9 Apr 2021 15:47:30 -0400 +Subject: [PATCH] trace-cmd: Remove last elements of local libtracefs and + libtraceevent + +Even though trace-cmd no longer holds the libraries libtracefs and +libtraceevent, there were some header files still lingering and worse, +still being used! + +Link: https://lore.kernel.org/linux-trace-devel/20210409154730.2c24e7d1@gandalf.local.home + +Signed-off-by: Steven Rostedt (VMware) +--- + include/traceevent/event-parse.h | 750 ------------------------------- + include/traceevent/kbuffer.h | 68 --- + include/traceevent/trace-seq.h | 55 --- + include/tracefs/tracefs.h | 61 --- + python/Makefile | 2 +- + python/ctracecmd.i | 4 +- + 6 files changed, 3 insertions(+), 937 deletions(-) + delete mode 100644 include/traceevent/event-parse.h + delete mode 100644 include/traceevent/kbuffer.h + delete mode 100644 include/traceevent/trace-seq.h + delete mode 100644 include/tracefs/tracefs.h + +diff --git a/include/traceevent/event-parse.h b/include/traceevent/event-parse.h +deleted file mode 100644 +index 7cdbda24..00000000 +--- a/include/traceevent/event-parse.h ++++ /dev/null +@@ -1,750 +0,0 @@ +-/* SPDX-License-Identifier: LGPL-2.1 */ +-/* +- * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt +- * +- */ +-#ifndef _PARSE_EVENTS_H +-#define _PARSE_EVENTS_H +- +-#include +-#include +-#include +-#include +-#include +-#include +- +-#include "traceevent/trace-seq.h" +- +-#ifndef __maybe_unused +-#define __maybe_unused __attribute__((unused)) +-#endif +- +-#ifndef DEBUG_RECORD +-#define DEBUG_RECORD 0 +-#endif +- +-struct tep_record { +- unsigned long long ts; +- unsigned long long offset; +- long long missed_events; /* buffer dropped events before */ +- int record_size; /* size of binary record */ +- int size; /* size of data */ +- void *data; +- int cpu; +- int ref_count; +- int locked; /* Do not free, even if ref_count is zero */ +- void *priv; +-#if DEBUG_RECORD +- struct tep_record *prev; +- struct tep_record *next; +- long alloc_addr; +-#endif +-}; +- +-/* ----------------------- tep ----------------------- */ +- +-struct tep_handle; +-struct tep_event; +- +-typedef int (*tep_event_handler_func)(struct trace_seq *s, +- struct tep_record *record, +- struct tep_event *event, +- void *context); +- +-typedef int (*tep_plugin_load_func)(struct tep_handle *tep); +-typedef int (*tep_plugin_unload_func)(struct tep_handle *tep); +- +-struct tep_plugin_option { +- struct tep_plugin_option *next; +- void *handle; +- char *file; +- char *name; +- char *plugin_alias; +- char *description; +- const char *value; +- void *priv; +- int set; +-}; +- +-/* +- * Plugin hooks that can be called: +- * +- * TEP_PLUGIN_LOADER: (required) +- * The function name to initialized the plugin. +- * +- * int TEP_PLUGIN_LOADER(struct tep_handle *tep) +- * +- * TEP_PLUGIN_UNLOADER: (optional) +- * The function called just before unloading +- * +- * int TEP_PLUGIN_UNLOADER(struct tep_handle *tep) +- * +- * TEP_PLUGIN_OPTIONS: (optional) +- * Plugin options that can be set before loading +- * +- * struct tep_plugin_option TEP_PLUGIN_OPTIONS[] = { +- * { +- * .name = "option-name", +- * .plugin_alias = "override-file-name", (optional) +- * .description = "description of option to show users", +- * }, +- * { +- * .name = NULL, +- * }, +- * }; +- * +- * Array must end with .name = NULL; +- * +- * +- * .plugin_alias is used to give a shorter name to access +- * the vairable. Useful if a plugin handles more than one event. +- * +- * If .value is not set, then it is considered a boolean and only +- * .set will be processed. If .value is defined, then it is considered +- * a string option and .set will be ignored. +- * +- * TEP_PLUGIN_ALIAS: (optional) +- * The name to use for finding options (uses filename if not defined) +- */ +-#define TEP_PLUGIN_LOADER tep_plugin_loader +-#define TEP_PLUGIN_UNLOADER tep_plugin_unloader +-#define TEP_PLUGIN_OPTIONS tep_plugin_options +-#define TEP_PLUGIN_ALIAS tep_plugin_alias +-#define _MAKE_STR(x) #x +-#define MAKE_STR(x) _MAKE_STR(x) +-#define TEP_PLUGIN_LOADER_NAME MAKE_STR(TEP_PLUGIN_LOADER) +-#define TEP_PLUGIN_UNLOADER_NAME MAKE_STR(TEP_PLUGIN_UNLOADER) +-#define TEP_PLUGIN_OPTIONS_NAME MAKE_STR(TEP_PLUGIN_OPTIONS) +-#define TEP_PLUGIN_ALIAS_NAME MAKE_STR(TEP_PLUGIN_ALIAS) +- +-enum tep_format_flags { +- TEP_FIELD_IS_ARRAY = 1, +- TEP_FIELD_IS_POINTER = 2, +- TEP_FIELD_IS_SIGNED = 4, +- TEP_FIELD_IS_STRING = 8, +- TEP_FIELD_IS_DYNAMIC = 16, +- TEP_FIELD_IS_LONG = 32, +- TEP_FIELD_IS_FLAG = 64, +- TEP_FIELD_IS_SYMBOLIC = 128, +-}; +- +-struct tep_format_field { +- struct tep_format_field *next; +- struct tep_event *event; +- char *type; +- char *name; +- char *alias; +- int offset; +- int size; +- unsigned int arraylen; +- unsigned int elementsize; +- unsigned long flags; +-}; +- +-struct tep_format { +- int nr_common; +- int nr_fields; +- struct tep_format_field *common_fields; +- struct tep_format_field *fields; +-}; +- +-struct tep_print_arg_atom { +- char *atom; +-}; +- +-struct tep_print_arg_string { +- char *string; +- int offset; +-}; +- +-struct tep_print_arg_bitmask { +- char *bitmask; +- int offset; +-}; +- +-struct tep_print_arg_field { +- char *name; +- struct tep_format_field *field; +-}; +- +-struct tep_print_flag_sym { +- struct tep_print_flag_sym *next; +- char *value; +- char *str; +-}; +- +-struct tep_print_arg_typecast { +- char *type; +- struct tep_print_arg *item; +-}; +- +-struct tep_print_arg_flags { +- struct tep_print_arg *field; +- char *delim; +- struct tep_print_flag_sym *flags; +-}; +- +-struct tep_print_arg_symbol { +- struct tep_print_arg *field; +- struct tep_print_flag_sym *symbols; +-}; +- +-struct tep_print_arg_hex { +- struct tep_print_arg *field; +- struct tep_print_arg *size; +-}; +- +-struct tep_print_arg_int_array { +- struct tep_print_arg *field; +- struct tep_print_arg *count; +- struct tep_print_arg *el_size; +-}; +- +-struct tep_print_arg_dynarray { +- struct tep_format_field *field; +- struct tep_print_arg *index; +-}; +- +-struct tep_print_arg; +- +-struct tep_print_arg_op { +- char *op; +- int prio; +- struct tep_print_arg *left; +- struct tep_print_arg *right; +-}; +- +-struct tep_function_handler; +- +-struct tep_print_arg_func { +- struct tep_function_handler *func; +- struct tep_print_arg *args; +-}; +- +-enum tep_print_arg_type { +- TEP_PRINT_NULL, +- TEP_PRINT_ATOM, +- TEP_PRINT_FIELD, +- TEP_PRINT_FLAGS, +- TEP_PRINT_SYMBOL, +- TEP_PRINT_HEX, +- TEP_PRINT_INT_ARRAY, +- TEP_PRINT_TYPE, +- TEP_PRINT_STRING, +- TEP_PRINT_BSTRING, +- TEP_PRINT_DYNAMIC_ARRAY, +- TEP_PRINT_OP, +- TEP_PRINT_FUNC, +- TEP_PRINT_BITMASK, +- TEP_PRINT_DYNAMIC_ARRAY_LEN, +- TEP_PRINT_HEX_STR, +-}; +- +-struct tep_print_arg { +- struct tep_print_arg *next; +- enum tep_print_arg_type type; +- union { +- struct tep_print_arg_atom atom; +- struct tep_print_arg_field field; +- struct tep_print_arg_typecast typecast; +- struct tep_print_arg_flags flags; +- struct tep_print_arg_symbol symbol; +- struct tep_print_arg_hex hex; +- struct tep_print_arg_int_array int_array; +- struct tep_print_arg_func func; +- struct tep_print_arg_string string; +- struct tep_print_arg_bitmask bitmask; +- struct tep_print_arg_op op; +- struct tep_print_arg_dynarray dynarray; +- }; +-}; +- +-struct tep_print_parse; +- +-struct tep_print_fmt { +- char *format; +- struct tep_print_arg *args; +- struct tep_print_parse *print_cache; +-}; +- +-struct tep_event { +- struct tep_handle *tep; +- char *name; +- int id; +- int flags; +- struct tep_format format; +- struct tep_print_fmt print_fmt; +- char *system; +- tep_event_handler_func handler; +- void *context; +-}; +- +-enum { +- TEP_EVENT_FL_ISFTRACE = 0x01, +- TEP_EVENT_FL_ISPRINT = 0x02, +- TEP_EVENT_FL_ISBPRINT = 0x04, +- TEP_EVENT_FL_ISFUNCENT = 0x10, +- TEP_EVENT_FL_ISFUNCRET = 0x20, +- TEP_EVENT_FL_NOHANDLE = 0x40, +- TEP_EVENT_FL_PRINTRAW = 0x80, +- +- TEP_EVENT_FL_FAILED = 0x80000000 +-}; +- +-enum tep_event_sort_type { +- TEP_EVENT_SORT_ID, +- TEP_EVENT_SORT_NAME, +- TEP_EVENT_SORT_SYSTEM, +-}; +- +-enum tep_event_type { +- TEP_EVENT_ERROR, +- TEP_EVENT_NONE, +- TEP_EVENT_SPACE, +- TEP_EVENT_NEWLINE, +- TEP_EVENT_OP, +- TEP_EVENT_DELIM, +- TEP_EVENT_ITEM, +- TEP_EVENT_DQUOTE, +- TEP_EVENT_SQUOTE, +-}; +- +-typedef unsigned long long (*tep_func_handler)(struct trace_seq *s, +- unsigned long long *args); +- +-enum tep_func_arg_type { +- TEP_FUNC_ARG_VOID, +- TEP_FUNC_ARG_INT, +- TEP_FUNC_ARG_LONG, +- TEP_FUNC_ARG_STRING, +- TEP_FUNC_ARG_PTR, +- TEP_FUNC_ARG_MAX_TYPES +-}; +- +-enum tep_flag { +- TEP_NSEC_OUTPUT = 1, /* output in NSECS */ +- TEP_DISABLE_SYS_PLUGINS = 1 << 1, +- TEP_DISABLE_PLUGINS = 1 << 2, +-}; +- +-#define TEP_ERRORS \ +- _PE(MEM_ALLOC_FAILED, "failed to allocate memory"), \ +- _PE(PARSE_EVENT_FAILED, "failed to parse event"), \ +- _PE(READ_ID_FAILED, "failed to read event id"), \ +- _PE(READ_FORMAT_FAILED, "failed to read event format"), \ +- _PE(READ_PRINT_FAILED, "failed to read event print fmt"), \ +- _PE(OLD_FTRACE_ARG_FAILED,"failed to allocate field name for ftrace"),\ +- _PE(INVALID_ARG_TYPE, "invalid argument type"), \ +- _PE(INVALID_EXP_TYPE, "invalid expression type"), \ +- _PE(INVALID_OP_TYPE, "invalid operator type"), \ +- _PE(INVALID_EVENT_NAME, "invalid event name"), \ +- _PE(EVENT_NOT_FOUND, "no event found"), \ +- _PE(SYNTAX_ERROR, "syntax error"), \ +- _PE(ILLEGAL_RVALUE, "illegal rvalue"), \ +- _PE(ILLEGAL_LVALUE, "illegal lvalue for string comparison"), \ +- _PE(INVALID_REGEX, "regex did not compute"), \ +- _PE(ILLEGAL_STRING_CMP, "illegal comparison for string"), \ +- _PE(ILLEGAL_INTEGER_CMP,"illegal comparison for integer"), \ +- _PE(REPARENT_NOT_OP, "cannot reparent other than OP"), \ +- _PE(REPARENT_FAILED, "failed to reparent filter OP"), \ +- _PE(BAD_FILTER_ARG, "bad arg in filter tree"), \ +- _PE(UNEXPECTED_TYPE, "unexpected type (not a value)"), \ +- _PE(ILLEGAL_TOKEN, "illegal token"), \ +- _PE(INVALID_PAREN, "open parenthesis cannot come here"), \ +- _PE(UNBALANCED_PAREN, "unbalanced number of parenthesis"), \ +- _PE(UNKNOWN_TOKEN, "unknown token"), \ +- _PE(FILTER_NOT_FOUND, "no filter found"), \ +- _PE(NOT_A_NUMBER, "must have number field"), \ +- _PE(NO_FILTER, "no filters exists"), \ +- _PE(FILTER_MISS, "record does not match to filter") +- +-#undef _PE +-#define _PE(__code, __str) TEP_ERRNO__ ## __code +-enum tep_errno { +- TEP_ERRNO__SUCCESS = 0, +- TEP_ERRNO__FILTER_MATCH = TEP_ERRNO__SUCCESS, +- +- /* +- * Choose an arbitrary negative big number not to clash with standard +- * errno since SUS requires the errno has distinct positive values. +- * See 'Issue 6' in the link below. +- * +- * http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/errno.h.html +- */ +- __TEP_ERRNO__START = -100000, +- +- TEP_ERRORS, +- +- __TEP_ERRNO__END, +-}; +-#undef _PE +- +-struct tep_plugin_list; +- +-#define INVALID_PLUGIN_LIST_OPTION ((char **)((unsigned long)-1)) +- +-enum tep_plugin_load_priority { +- TEP_PLUGIN_FIRST, +- TEP_PLUGIN_LAST, +-}; +- +-int tep_add_plugin_path(struct tep_handle *tep, char *path, +- enum tep_plugin_load_priority prio); +-struct tep_plugin_list *tep_load_plugins(struct tep_handle *tep); +-void tep_unload_plugins(struct tep_plugin_list *plugin_list, +- struct tep_handle *tep); +-void tep_load_plugins_hook(struct tep_handle *tep, const char *suffix, +- void (*load_plugin)(struct tep_handle *tep, +- const char *path, +- const char *name, +- void *data), +- void *data); +-char **tep_plugin_list_options(void); +-void tep_plugin_free_options_list(char **list); +-int tep_plugin_add_options(const char *name, +- struct tep_plugin_option *options); +-int tep_plugin_add_option(const char *name, const char *val); +-void tep_plugin_remove_options(struct tep_plugin_option *options); +-void tep_plugin_print_options(struct trace_seq *s); +-void tep_print_plugins(struct trace_seq *s, +- const char *prefix, const char *suffix, +- const struct tep_plugin_list *list); +- +-/* tep_handle */ +-typedef char *(tep_func_resolver_t)(void *priv, +- unsigned long long *addrp, char **modp); +-void tep_set_flag(struct tep_handle *tep, int flag); +-void tep_clear_flag(struct tep_handle *tep, enum tep_flag flag); +-bool tep_test_flag(struct tep_handle *tep, enum tep_flag flags); +- +-static inline int tep_is_bigendian(void) +-{ +- unsigned char str[] = { 0x1, 0x2, 0x3, 0x4 }; +- unsigned int val; +- +- memcpy(&val, str, 4); +- return val == 0x01020304; +-} +- +-/* taken from kernel/trace/trace.h */ +-enum trace_flag_type { +- TRACE_FLAG_IRQS_OFF = 0x01, +- TRACE_FLAG_IRQS_NOSUPPORT = 0x02, +- TRACE_FLAG_NEED_RESCHED = 0x04, +- TRACE_FLAG_HARDIRQ = 0x08, +- TRACE_FLAG_SOFTIRQ = 0x10, +-}; +- +-int tep_set_function_resolver(struct tep_handle *tep, +- tep_func_resolver_t *func, void *priv); +-void tep_reset_function_resolver(struct tep_handle *tep); +-int tep_register_comm(struct tep_handle *tep, const char *comm, int pid); +-int tep_override_comm(struct tep_handle *tep, const char *comm, int pid); +-int tep_register_function(struct tep_handle *tep, char *name, +- unsigned long long addr, char *mod); +-int tep_register_print_string(struct tep_handle *tep, const char *fmt, +- unsigned long long addr); +-bool tep_is_pid_registered(struct tep_handle *tep, int pid); +- +-#define TEP_PRINT_INFO "INFO" +-#define TEP_PRINT_INFO_RAW "INFO_RAW" +-#define TEP_PRINT_COMM "COMM" +-#define TEP_PRINT_LATENCY "LATENCY" +-#define TEP_PRINT_NAME "NAME" +-#define TEP_PRINT_PID 1U +-#define TEP_PRINT_TIME 2U +-#define TEP_PRINT_CPU 3U +- +-void tep_print_event(struct tep_handle *tep, struct trace_seq *s, +- struct tep_record *record, const char *fmt, ...) +- __attribute__ ((format (printf, 4, 5))); +- +-int tep_parse_header_page(struct tep_handle *tep, char *buf, unsigned long size, +- int long_size); +- +-enum tep_errno tep_parse_event(struct tep_handle *tep, const char *buf, +- unsigned long size, const char *sys); +-enum tep_errno tep_parse_format(struct tep_handle *tep, +- struct tep_event **eventp, +- const char *buf, +- unsigned long size, const char *sys); +- +-void *tep_get_field_raw(struct trace_seq *s, struct tep_event *event, +- const char *name, struct tep_record *record, +- int *len, int err); +- +-int tep_get_field_val(struct trace_seq *s, struct tep_event *event, +- const char *name, struct tep_record *record, +- unsigned long long *val, int err); +-int tep_get_common_field_val(struct trace_seq *s, struct tep_event *event, +- const char *name, struct tep_record *record, +- unsigned long long *val, int err); +-int tep_get_any_field_val(struct trace_seq *s, struct tep_event *event, +- const char *name, struct tep_record *record, +- unsigned long long *val, int err); +- +-int tep_print_num_field(struct trace_seq *s, const char *fmt, +- struct tep_event *event, const char *name, +- struct tep_record *record, int err); +- +-int tep_print_func_field(struct trace_seq *s, const char *fmt, +- struct tep_event *event, const char *name, +- struct tep_record *record, int err); +- +-enum tep_reg_handler { +- TEP_REGISTER_SUCCESS = 0, +- TEP_REGISTER_SUCCESS_OVERWRITE, +-}; +- +-int tep_register_event_handler(struct tep_handle *tep, int id, +- const char *sys_name, const char *event_name, +- tep_event_handler_func func, void *context); +-int tep_unregister_event_handler(struct tep_handle *tep, int id, +- const char *sys_name, const char *event_name, +- tep_event_handler_func func, void *context); +-int tep_register_print_function(struct tep_handle *tep, +- tep_func_handler func, +- enum tep_func_arg_type ret_type, +- char *name, ...); +-int tep_unregister_print_function(struct tep_handle *tep, +- tep_func_handler func, char *name); +- +-struct tep_format_field *tep_find_common_field(struct tep_event *event, const char *name); +-struct tep_format_field *tep_find_field(struct tep_event *event, const char *name); +-struct tep_format_field *tep_find_any_field(struct tep_event *event, const char *name); +- +-const char *tep_find_function(struct tep_handle *tep, unsigned long long addr); +-unsigned long long +-tep_find_function_address(struct tep_handle *tep, unsigned long long addr); +-unsigned long long tep_read_number(struct tep_handle *tep, const void *ptr, int size); +-int tep_read_number_field(struct tep_format_field *field, const void *data, +- unsigned long long *value); +- +-struct tep_event *tep_get_first_event(struct tep_handle *tep); +-struct tep_event *tep_get_event(struct tep_handle *tep, int index); +-int tep_get_events_count(struct tep_handle *tep); +-struct tep_event *tep_find_event(struct tep_handle *tep, int id); +- +-struct tep_event * +-tep_find_event_by_name(struct tep_handle *tep, const char *sys, const char *name); +-struct tep_event * +-tep_find_event_by_record(struct tep_handle *tep, struct tep_record *record); +- +-int tep_data_type(struct tep_handle *tep, struct tep_record *rec); +-int tep_data_pid(struct tep_handle *tep, struct tep_record *rec); +-int tep_data_preempt_count(struct tep_handle *tep, struct tep_record *rec); +-int tep_data_flags(struct tep_handle *tep, struct tep_record *rec); +-const char *tep_data_comm_from_pid(struct tep_handle *tep, int pid); +-struct tep_cmdline; +-struct tep_cmdline *tep_data_pid_from_comm(struct tep_handle *tep, const char *comm, +- struct tep_cmdline *next); +-int tep_cmdline_pid(struct tep_handle *tep, struct tep_cmdline *cmdline); +- +-void tep_print_field(struct trace_seq *s, void *data, +- struct tep_format_field *field); +-void tep_print_fields(struct trace_seq *s, void *data, +- int size __maybe_unused, struct tep_event *event); +-int tep_strerror(struct tep_handle *tep, enum tep_errno errnum, +- char *buf, size_t buflen); +- +-struct tep_event **tep_list_events(struct tep_handle *tep, +- enum tep_event_sort_type); +-struct tep_event **tep_list_events_copy(struct tep_handle *tep, +- enum tep_event_sort_type); +-struct tep_format_field **tep_event_common_fields(struct tep_event *event); +-struct tep_format_field **tep_event_fields(struct tep_event *event); +- +-enum tep_endian { +- TEP_LITTLE_ENDIAN = 0, +- TEP_BIG_ENDIAN +-}; +-int tep_get_cpus(struct tep_handle *tep); +-void tep_set_cpus(struct tep_handle *tep, int cpus); +-int tep_get_long_size(struct tep_handle *tep); +-void tep_set_long_size(struct tep_handle *tep, int long_size); +-int tep_get_page_size(struct tep_handle *tep); +-void tep_set_page_size(struct tep_handle *tep, int _page_size); +-bool tep_is_file_bigendian(struct tep_handle *tep); +-void tep_set_file_bigendian(struct tep_handle *tep, enum tep_endian endian); +-bool tep_is_local_bigendian(struct tep_handle *tep); +-void tep_set_local_bigendian(struct tep_handle *tep, enum tep_endian endian); +-int tep_get_header_page_size(struct tep_handle *tep); +-int tep_get_header_timestamp_size(struct tep_handle *tep); +-bool tep_is_old_format(struct tep_handle *tep); +-void tep_set_test_filters(struct tep_handle *tep, int test_filters); +- +-struct tep_handle *tep_alloc(void); +-void tep_free(struct tep_handle *tep); +-void tep_ref(struct tep_handle *tep); +-void tep_unref(struct tep_handle *tep); +-int tep_get_ref(struct tep_handle *tep); +- +-/* for debugging */ +-void tep_print_funcs(struct tep_handle *tep); +-void tep_print_printk(struct tep_handle *tep); +- +-/* ----------------------- filtering ----------------------- */ +- +-enum tep_filter_boolean_type { +- TEP_FILTER_FALSE, +- TEP_FILTER_TRUE, +-}; +- +-enum tep_filter_op_type { +- TEP_FILTER_OP_AND = 1, +- TEP_FILTER_OP_OR, +- TEP_FILTER_OP_NOT, +-}; +- +-enum tep_filter_cmp_type { +- TEP_FILTER_CMP_NONE, +- TEP_FILTER_CMP_EQ, +- TEP_FILTER_CMP_NE, +- TEP_FILTER_CMP_GT, +- TEP_FILTER_CMP_LT, +- TEP_FILTER_CMP_GE, +- TEP_FILTER_CMP_LE, +- TEP_FILTER_CMP_MATCH, +- TEP_FILTER_CMP_NOT_MATCH, +- TEP_FILTER_CMP_REGEX, +- TEP_FILTER_CMP_NOT_REGEX, +-}; +- +-enum tep_filter_exp_type { +- TEP_FILTER_EXP_NONE, +- TEP_FILTER_EXP_ADD, +- TEP_FILTER_EXP_SUB, +- TEP_FILTER_EXP_MUL, +- TEP_FILTER_EXP_DIV, +- TEP_FILTER_EXP_MOD, +- TEP_FILTER_EXP_RSHIFT, +- TEP_FILTER_EXP_LSHIFT, +- TEP_FILTER_EXP_AND, +- TEP_FILTER_EXP_OR, +- TEP_FILTER_EXP_XOR, +- TEP_FILTER_EXP_NOT, +-}; +- +-enum tep_filter_arg_type { +- TEP_FILTER_ARG_NONE, +- TEP_FILTER_ARG_BOOLEAN, +- TEP_FILTER_ARG_VALUE, +- TEP_FILTER_ARG_FIELD, +- TEP_FILTER_ARG_EXP, +- TEP_FILTER_ARG_OP, +- TEP_FILTER_ARG_NUM, +- TEP_FILTER_ARG_STR, +-}; +- +-enum tep_filter_value_type { +- TEP_FILTER_NUMBER, +- TEP_FILTER_STRING, +- TEP_FILTER_CHAR +-}; +- +-struct tep_filter_arg; +- +-struct tep_filter_arg_boolean { +- enum tep_filter_boolean_type value; +-}; +- +-struct tep_filter_arg_field { +- struct tep_format_field *field; +-}; +- +-struct tep_filter_arg_value { +- enum tep_filter_value_type type; +- union { +- char *str; +- unsigned long long val; +- }; +-}; +- +-struct tep_filter_arg_op { +- enum tep_filter_op_type type; +- struct tep_filter_arg *left; +- struct tep_filter_arg *right; +-}; +- +-struct tep_filter_arg_exp { +- enum tep_filter_exp_type type; +- struct tep_filter_arg *left; +- struct tep_filter_arg *right; +-}; +- +-struct tep_filter_arg_num { +- enum tep_filter_cmp_type type; +- struct tep_filter_arg *left; +- struct tep_filter_arg *right; +-}; +- +-struct tep_filter_arg_str { +- enum tep_filter_cmp_type type; +- struct tep_format_field *field; +- char *val; +- char *buffer; +- regex_t reg; +-}; +- +-struct tep_filter_arg { +- enum tep_filter_arg_type type; +- union { +- struct tep_filter_arg_boolean boolean; +- struct tep_filter_arg_field field; +- struct tep_filter_arg_value value; +- struct tep_filter_arg_op op; +- struct tep_filter_arg_exp exp; +- struct tep_filter_arg_num num; +- struct tep_filter_arg_str str; +- }; +-}; +- +-struct tep_filter_type { +- int event_id; +- struct tep_event *event; +- struct tep_filter_arg *filter; +-}; +- +-#define TEP_FILTER_ERROR_BUFSZ 1024 +- +-struct tep_event_filter { +- struct tep_handle *tep; +- int filters; +- struct tep_filter_type *event_filters; +- char error_buffer[TEP_FILTER_ERROR_BUFSZ]; +-}; +- +-struct tep_event_filter *tep_filter_alloc(struct tep_handle *tep); +- +-/* for backward compatibility */ +-#define FILTER_NONE TEP_ERRNO__NO_FILTER +-#define FILTER_NOEXIST TEP_ERRNO__FILTER_NOT_FOUND +-#define FILTER_MISS TEP_ERRNO__FILTER_MISS +-#define FILTER_MATCH TEP_ERRNO__FILTER_MATCH +- +-enum tep_errno tep_filter_add_filter_str(struct tep_event_filter *filter, +- const char *filter_str); +- +-enum tep_errno tep_filter_match(struct tep_event_filter *filter, +- struct tep_record *record); +- +-int tep_filter_strerror(struct tep_event_filter *filter, enum tep_errno err, +- char *buf, size_t buflen); +- +-int tep_event_filtered(struct tep_event_filter *filter, +- int event_id); +- +-void tep_filter_reset(struct tep_event_filter *filter); +- +-void tep_filter_free(struct tep_event_filter *filter); +- +-char *tep_filter_make_string(struct tep_event_filter *filter, int event_id); +- +-int tep_filter_remove_event(struct tep_event_filter *filter, +- int event_id); +- +-int tep_filter_copy(struct tep_event_filter *dest, struct tep_event_filter *source); +- +-int tep_filter_compare(struct tep_event_filter *filter1, struct tep_event_filter *filter2); +- +-#endif /* _PARSE_EVENTS_H */ +diff --git a/include/traceevent/kbuffer.h b/include/traceevent/kbuffer.h +deleted file mode 100644 +index a2b52209..00000000 +--- a/include/traceevent/kbuffer.h ++++ /dev/null +@@ -1,68 +0,0 @@ +-/* SPDX-License-Identifier: LGPL-2.1 */ +-/* +- * Copyright (C) 2012 Red Hat Inc, Steven Rostedt +- * +- */ +-#ifndef _KBUFFER_H +-#define _KBUFFER_H +- +-#ifndef TS_SHIFT +-#define TS_SHIFT 27 +-#endif +- +-enum kbuffer_endian { +- KBUFFER_ENDIAN_BIG, +- KBUFFER_ENDIAN_LITTLE, +-}; +- +-enum kbuffer_long_size { +- KBUFFER_LSIZE_4, +- KBUFFER_LSIZE_8, +-}; +- +-enum { +- KBUFFER_TYPE_PADDING = 29, +- KBUFFER_TYPE_TIME_EXTEND = 30, +- KBUFFER_TYPE_TIME_STAMP = 31, +-}; +- +-struct kbuffer; +- +-struct kbuffer *kbuffer_alloc(enum kbuffer_long_size size, enum kbuffer_endian endian); +-void kbuffer_free(struct kbuffer *kbuf); +-int kbuffer_load_subbuffer(struct kbuffer *kbuf, void *subbuffer); +-void *kbuffer_read_event(struct kbuffer *kbuf, unsigned long long *ts); +-void *kbuffer_next_event(struct kbuffer *kbuf, unsigned long long *ts); +-unsigned long long kbuffer_timestamp(struct kbuffer *kbuf); +-unsigned long long kbuffer_subbuf_timestamp(struct kbuffer *kbuf, void *subbuf); +-unsigned int kbuffer_ptr_delta(struct kbuffer *kbuf, void *ptr); +- +-void *kbuffer_translate_data(int swap, void *data, unsigned int *size); +- +-void *kbuffer_read_at_offset(struct kbuffer *kbuf, int offset, unsigned long long *ts); +- +-int kbuffer_curr_index(struct kbuffer *kbuf); +- +-int kbuffer_curr_offset(struct kbuffer *kbuf); +-int kbuffer_curr_size(struct kbuffer *kbuf); +-int kbuffer_event_size(struct kbuffer *kbuf); +-int kbuffer_missed_events(struct kbuffer *kbuf); +-int kbuffer_subbuffer_size(struct kbuffer *kbuf); +- +-void kbuffer_set_old_format(struct kbuffer *kbuf); +-int kbuffer_start_of_data(struct kbuffer *kbuf); +- +-/* Debugging */ +- +-struct kbuffer_raw_info { +- int type; +- int length; +- unsigned long long delta; +- void *next; +-}; +- +-/* Read raw data */ +-struct kbuffer_raw_info *kbuffer_raw_get(struct kbuffer *kbuf, void *subbuf, +- struct kbuffer_raw_info *info); +- +-#endif /* _K_BUFFER_H */ +diff --git a/include/traceevent/trace-seq.h b/include/traceevent/trace-seq.h +deleted file mode 100644 +index d68ec69f..00000000 +--- a/include/traceevent/trace-seq.h ++++ /dev/null +@@ -1,55 +0,0 @@ +-// SPDX-License-Identifier: LGPL-2.1 +-/* +- * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt +- * +- */ +- +-#ifndef _TRACE_SEQ_H +-#define _TRACE_SEQ_H +- +-#include +-#include +- +-/* ----------------------- trace_seq ----------------------- */ +- +-#ifndef TRACE_SEQ_BUF_SIZE +-#define TRACE_SEQ_BUF_SIZE 4096 +-#endif +- +-enum trace_seq_fail { +- TRACE_SEQ__GOOD, +- TRACE_SEQ__BUFFER_POISONED, +- TRACE_SEQ__MEM_ALLOC_FAILED, +-}; +- +-/* +- * Trace sequences are used to allow a function to call several other functions +- * to create a string of data to use (up to a max of PAGE_SIZE). +- */ +- +-struct trace_seq { +- char *buffer; +- unsigned int buffer_size; +- unsigned int len; +- unsigned int readpos; +- enum trace_seq_fail state; +-}; +- +-void trace_seq_init(struct trace_seq *s); +-void trace_seq_reset(struct trace_seq *s); +-void trace_seq_destroy(struct trace_seq *s); +- +-extern int trace_seq_printf(struct trace_seq *s, const char *fmt, ...) +- __attribute__ ((format (printf, 2, 3))); +-extern int trace_seq_vprintf(struct trace_seq *s, const char *fmt, va_list args) +- __attribute__ ((format (printf, 2, 0))); +- +-extern int trace_seq_puts(struct trace_seq *s, const char *str); +-extern int trace_seq_putc(struct trace_seq *s, unsigned char c); +- +-extern void trace_seq_terminate(struct trace_seq *s); +- +-extern int trace_seq_do_fprintf(struct trace_seq *s, FILE *fp); +-extern int trace_seq_do_printf(struct trace_seq *s); +- +-#endif /* _TRACE_SEQ_H */ +diff --git a/include/tracefs/tracefs.h b/include/tracefs/tracefs.h +deleted file mode 100644 +index 9a99ad6c..00000000 +--- a/include/tracefs/tracefs.h ++++ /dev/null +@@ -1,61 +0,0 @@ +-/* SPDX-License-Identifier: LGPL-2.1 */ +-/* +- * Copyright (C) 2019, VMware, Tzvetomir Stoyanov +- * +- */ +-#ifndef _TRACE_FS_H +-#define _TRACE_FS_H +- +-#include +-#include "traceevent/event-parse.h" +- +-char *tracefs_get_tracing_file(const char *name); +-void tracefs_put_tracing_file(char *name); +- +-/* The returned string must *not* be freed */ +-const char *tracefs_tracing_dir(void); +- +-/* ftarce instances */ +-struct tracefs_instance; +- +-void tracefs_instance_free(struct tracefs_instance *instance); +-struct tracefs_instance *tracefs_instance_create(const char *name); +-int tracefs_instance_destroy(struct tracefs_instance *instance); +-bool tracefs_instance_is_new(struct tracefs_instance *instance); +-const char *tracefs_instance_get_name(struct tracefs_instance *instance); +-char * +-tracefs_instance_get_file(struct tracefs_instance *instance, const char *file); +-char *tracefs_instance_get_dir(struct tracefs_instance *instance); +-int tracefs_instance_file_write(struct tracefs_instance *instance, +- const char *file, const char *str); +-char *tracefs_instance_file_read(struct tracefs_instance *instance, +- char *file, int *psize); +-int tracefs_instances_walk(int (*callback)(const char *, void *), void *context); +- +-bool tracefs_instance_exists(const char *name); +-bool tracefs_file_exists(struct tracefs_instance *instance, char *name); +-bool tracefs_dir_exists(struct tracefs_instance *instance, char *name); +- +-/* events */ +-void tracefs_list_free(char **list); +-char **tracefs_event_systems(const char *tracing_dir); +-char **tracefs_system_events(const char *tracing_dir, const char *system); +-int tracefs_iterate_raw_events(struct tep_handle *tep, +- struct tracefs_instance *instance, +- cpu_set_t *cpus, int cpu_size, +- int (*callback)(struct tep_event *, +- struct tep_record *, +- int, void *), +- void *callback_context); +- +-char **tracefs_tracers(const char *tracing_dir); +- +-struct tep_handle *tracefs_local_events(const char *tracing_dir); +-struct tep_handle *tracefs_local_events_system(const char *tracing_dir, +- const char * const *sys_names); +-int tracefs_fill_local_events(const char *tracing_dir, +- struct tep_handle *tep, int *parsing_failures); +- +-char *tracefs_get_clock(struct tracefs_instance *instance); +- +-#endif /* _TRACE_FS_H */ +diff --git a/python/Makefile b/python/Makefile +index d2906c4f..acd67e91 100644 +--- a/python/Makefile ++++ b/python/Makefile +@@ -9,7 +9,7 @@ PYTHON_PY_LIBS := tracecmd.install + endif + + ctracecmd.so: ctracecmd.i $(LIBTRACECMD_STATIC) +- swig -Wall -python -noproxy -I$(src)/include/traceevent -I$(src)/include/trace-cmd ctracecmd.i ++ swig -Wall -python -noproxy -I$(src)/include/traceevent -I$(src)/include/trace-cmd $(LIBTRACEEVENT_CFLAGS) ctracecmd.i + $(CC) -fpic -c $(CPPFLAGS) $(CFLAGS) $(PYTHON_INCLUDES) ctracecmd_wrap.c + $(CC) --shared $(LIBTRACECMD_STATIC) $(LDFLAGS) ctracecmd_wrap.o -o ctracecmd.so $(TRACE_LIBS) + +diff --git a/python/ctracecmd.i b/python/ctracecmd.i +index 5f7181c7..d161abd1 100644 +--- a/python/ctracecmd.i ++++ b/python/ctracecmd.i +@@ -257,5 +257,5 @@ static int python_callback(struct trace_seq *s, + #define __thread + + %include "trace-cmd.h" +-%include "trace-seq.h" +-%include "event-parse.h" ++%include ++%include +-- +2.41.0 + diff --git a/SPECS/trace-cmd.spec b/SPECS/trace-cmd.spec index 9d29f13..ec9b8c0 100644 --- a/SPECS/trace-cmd.spec +++ b/SPECS/trace-cmd.spec @@ -6,7 +6,7 @@ Name: trace-cmd Version: %{srcversion} -Release: 9%{?dist} +Release: 10%{?dist} License: GPLv2 and LGPLv2 Summary: A user interface to Ftrace Requires: libtracecmd @@ -24,6 +24,7 @@ Source2: trace-cmd.service Source3: 98-trace-cmd.rules Patch0: trace-cmd-Fix-broken-profile-command.patch Patch1: trace-cmd-utils.mk-don-t-ignore-LDFLAGS-when-linking-the-share.patch +Patch2: trace-cmd-Remove-last-elements-of-local-libtracefs-a.patch BuildRequires: make BuildRequires: gcc @@ -137,6 +138,9 @@ install -p -m 644 98-trace-cmd.rules %{buildroot}/%{_udevrulesdir}/ %{_includedir}/trace-cmd %changelog +* Fri Jul 21 2023 Jerome Marchand - 2.9.2-10 +- Remove remaining trace of libtracefs and libtraceevent + * Thu Mar 31 2022 Jerome Marchand - 2.9.2-9 - Add flight recorder service