Merge tag 'perf-core-for-mingo-4.20-20181008' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Pull perf/core improvements and fixes from Arnaldo Carvalho de Melo:

 - Fix building the python bindings with python3, which fixes some
   problems with building with clang on Clear Linux (Eduardo Habkost)

 - Fix coverity warnings, fixing up some error paths and plugging
   some temporary small buffer leaks (Sanskriti Sharma)

 - Adopt a wrapper for strerror_r() for the same reasons as recently
   for libbpf (Steven Rostedt)

 - S390 does not support watchpoints in perf test 22', check if
   that test is supported by the arch. (Thomas Richter)

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>

20 files changed, 539 insertions, 259 deletions

diff --git a/tools/include/linux/bitops.h b/tools/include/linux/bitops.h
index acc704bd3998..0b0ef3abc966 100644
--- a/tools/include/linux/bitops.h
+++ b/tools/include/linux/bitops.h
@@ -3,8 +3,6 @@
 #define _TOOLS_LINUX_BITOPS_H_
 
 #include <asm/types.h>
-#include <linux/compiler.h>
-
 #ifndef __WORDSIZE
 #define __WORDSIZE (__SIZEOF_LONG__ * 8)
 #endif
@@ -12,10 +10,9 @@
 #ifndef BITS_PER_LONG
 # define BITS_PER_LONG __WORDSIZE
 #endif
+#include <linux/bits.h>
+#include <linux/compiler.h>
 
-#define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
-#define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
-#define BITS_PER_BYTE           8
 #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
 #define BITS_TO_U64(nr)         DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u64))
 #define BITS_TO_U32(nr)         DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(u32))
diff --git a/tools/include/linux/bits.h b/tools/include/linux/bits.h
new file mode 100644
index 000000000000..2b7b532c1d51
--- /dev/null
+++ b/tools/include/linux/bits.h
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef __LINUX_BITS_H
+#define __LINUX_BITS_H
+#include <asm/bitsperlong.h>
+
+#define BIT(nr)                 (1UL << (nr))
+#define BIT_ULL(nr)             (1ULL << (nr))
+#define BIT_MASK(nr)            (1UL << ((nr) % BITS_PER_LONG))
+#define BIT_WORD(nr)            ((nr) / BITS_PER_LONG)
+#define BIT_ULL_MASK(nr)        (1ULL << ((nr) % BITS_PER_LONG_LONG))
+#define BIT_ULL_WORD(nr)        ((nr) / BITS_PER_LONG_LONG)
+#define BITS_PER_BYTE           8
+
+/*
+ * Create a contiguous bitmask starting at bit position @l and ending at
+ * position @h. For example
+ * GENMASK_ULL(39, 21) gives us the 64bit vector 0x000000ffffe00000.
+ */
+#define GENMASK(h, l) \
+        (((~0UL) - (1UL << (l)) + 1) & (~0UL >> (BITS_PER_LONG - 1 - (h))))
+
+#define GENMASK_ULL(h, l) \
+        (((~0ULL) - (1ULL << (l)) + 1) & \
+         (~0ULL >> (BITS_PER_LONG_LONG - 1 - (h))))
+
+#endif  /* __LINUX_BITS_H */
diff --git a/tools/lib/traceevent/Build b/tools/lib/traceevent/Build
index c681d0575d16..ba54bfce0b0b 100644
--- a/tools/lib/traceevent/Build
+++ b/tools/lib/traceevent/Build
@@ -4,6 +4,8 @@ libtraceevent-y += trace-seq.o
 libtraceevent-y += parse-filter.o
 libtraceevent-y += parse-utils.o
 libtraceevent-y += kbuffer-parse.o
+libtraceevent-y += tep_strerror.o
+libtraceevent-y += event-parse-api.o
 
 plugin_jbd2-y         += plugin_jbd2.o
 plugin_hrtimer-y      += plugin_hrtimer.o
diff --git a/tools/lib/traceevent/event-parse-api.c b/tools/lib/traceevent/event-parse-api.c
new file mode 100644
index 000000000000..61f7149085ee
--- /dev/null
+++ b/tools/lib/traceevent/event-parse-api.c
@@ -0,0 +1,275 @@
+// SPDX-License-Identifier: LGPL-2.1
+/*
+ * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+
+#include "event-parse.h"
+#include "event-parse-local.h"
+#include "event-utils.h"
+
+/**
+ * tep_get_first_event - returns the first event in the events array
+ * @tep: a handle to the tep_handle
+ *
+ * This returns pointer to the first element of the events array
+ * If @tep is NULL, NULL is returned.
+ */
+struct tep_event_format *tep_get_first_event(struct tep_handle *tep)
+{
+        if (tep && tep->events)
+                return tep->events[0];
+
+        return NULL;
+}
+
+/**
+ * tep_get_events_count - get the number of defined events
+ * @tep: a handle to the tep_handle
+ *
+ * This returns number of elements in event array
+ * If @tep is NULL, 0 is returned.
+ */
+int tep_get_events_count(struct tep_handle *tep)
+{
+        if(tep)
+                return tep->nr_events;
+        return 0;
+}
+
+/**
+ * tep_set_flag - set event parser flag
+ * @tep: a handle to the tep_handle
+ * @flag: flag, or combination of flags to be set
+ * can be any combination from enum tep_flag
+ *
+ * This sets a flag or mbination of flags  from enum tep_flag
+  */
+void tep_set_flag(struct tep_handle *tep, int flag)
+{
+        if(tep)
+                tep->flags |= flag;
+}
+
+unsigned short __tep_data2host2(struct tep_handle *pevent, unsigned short data)
+{
+        unsigned short swap;
+
+        if (!pevent || pevent->host_bigendian == pevent->file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 8) |
+                ((data & (0xffULL << 8)) >> 8);
+
+        return swap;
+}
+
+unsigned int __tep_data2host4(struct tep_handle *pevent, unsigned int data)
+{
+        unsigned int swap;
+
+        if (!pevent || pevent->host_bigendian == pevent->file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 24) |
+                ((data & (0xffULL << 8)) << 8) |
+                ((data & (0xffULL << 16)) >> 8) |
+                ((data & (0xffULL << 24)) >> 24);
+
+        return swap;
+}
+
+unsigned long long
+__tep_data2host8(struct tep_handle *pevent, unsigned long long data)
+{
+        unsigned long long swap;
+
+        if (!pevent || pevent->host_bigendian == pevent->file_bigendian)
+                return data;
+
+        swap = ((data & 0xffULL) << 56) |
+                ((data & (0xffULL << 8)) << 40) |
+                ((data & (0xffULL << 16)) << 24) |
+                ((data & (0xffULL << 24)) << 8) |
+                ((data & (0xffULL << 32)) >> 8) |
+                ((data & (0xffULL << 40)) >> 24) |
+                ((data & (0xffULL << 48)) >> 40) |
+                ((data & (0xffULL << 56)) >> 56);
+
+        return swap;
+}
+
+/**
+ * tep_get_header_page_size - get size of the header page
+ * @pevent: a handle to the tep_handle
+ *
+ * This returns size of the header page
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_get_header_page_size(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->header_page_size_size;
+        return 0;
+}
+
+/**
+ * tep_get_cpus - get the number of CPUs
+ * @pevent: a handle to the tep_handle
+ *
+ * This returns the number of CPUs
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_get_cpus(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->cpus;
+        return 0;
+}
+
+/**
+ * tep_set_cpus - set the number of CPUs
+ * @pevent: a handle to the tep_handle
+ *
+ * This sets the number of CPUs
+ */
+void tep_set_cpus(struct tep_handle *pevent, int cpus)
+{
+        if(pevent)
+                pevent->cpus = cpus;
+}
+
+/**
+ * tep_get_long_size - get the size of a long integer on the current machine
+ * @pevent: a handle to the tep_handle
+ *
+ * This returns the size of a long integer on the current machine
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_get_long_size(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->long_size;
+        return 0;
+}
+
+/**
+ * tep_set_long_size - set the size of a long integer on the current machine
+ * @pevent: a handle to the tep_handle
+ * @size: size, in bytes, of a long integer
+ *
+ * This sets the size of a long integer on the current machine
+ */
+void tep_set_long_size(struct tep_handle *pevent, int long_size)
+{
+        if(pevent)
+                pevent->long_size = long_size;
+}
+
+/**
+ * tep_get_page_size - get the size of a memory page on the current machine
+ * @pevent: a handle to the tep_handle
+ *
+ * This returns the size of a memory page on the current machine
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_get_page_size(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->page_size;
+        return 0;
+}
+
+/**
+ * tep_set_page_size - set the size of a memory page on the current machine
+ * @pevent: a handle to the tep_handle
+ * @_page_size: size of a memory page, in bytes
+ *
+ * This sets the size of a memory page on the current machine
+ */
+void tep_set_page_size(struct tep_handle *pevent, int _page_size)
+{
+        if(pevent)
+                pevent->page_size = _page_size;
+}
+
+/**
+ * tep_is_file_bigendian - get if the file is in big endian order
+ * @pevent: a handle to the tep_handle
+ *
+ * This returns if the file is in big endian order
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_is_file_bigendian(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->file_bigendian;
+        return 0;
+}
+
+/**
+ * tep_set_file_bigendian - set if the file is in big endian order
+ * @pevent: a handle to the tep_handle
+ * @endian: non zero, if the file is in big endian order
+ *
+ * This sets if the file is in big endian order
+ */
+void tep_set_file_bigendian(struct tep_handle *pevent, enum tep_endian endian)
+{
+        if(pevent)
+                pevent->file_bigendian = endian;
+}
+
+/**
+ * tep_is_host_bigendian - get if the order of the current host is big endian
+ * @pevent: a handle to the tep_handle
+ *
+ * This gets if the order of the current host is big endian
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_is_host_bigendian(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->host_bigendian;
+        return 0;
+}
+
+/**
+ * tep_set_host_bigendian - set the order of the local host
+ * @pevent: a handle to the tep_handle
+ * @endian: non zero, if the local host has big endian order
+ *
+ * This sets the order of the local host
+ */
+void tep_set_host_bigendian(struct tep_handle *pevent, enum tep_endian endian)
+{
+        if(pevent)
+                pevent->host_bigendian = endian;
+}
+
+/**
+ * tep_is_latency_format - get if the latency output format is configured
+ * @pevent: a handle to the tep_handle
+ *
+ * This gets if the latency output format is configured
+ * If @pevent is NULL, 0 is returned.
+ */
+int tep_is_latency_format(struct tep_handle *pevent)
+{
+        if(pevent)
+                return pevent->latency_format;
+        return 0;
+}
+
+/**
+ * tep_set_latency_format - set the latency output format
+ * @pevent: a handle to the tep_handle
+ * @lat: non zero for latency output format
+ *
+ * This sets the latency output format
+  */
+void tep_set_latency_format(struct tep_handle *pevent, int lat)
+{
+        if(pevent)
+                pevent->latency_format = lat;
+}
diff --git a/tools/lib/traceevent/event-parse-local.h b/tools/lib/traceevent/event-parse-local.h
new file mode 100644
index 000000000000..b9bddde577f8
--- /dev/null
+++ b/tools/lib/traceevent/event-parse-local.h
@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: LGPL-2.1
+/*
+ * Copyright (C) 2009, 2010 Red Hat Inc, Steven Rostedt <srostedt@redhat.com>
+ *
+ */
+
+#ifndef _PARSE_EVENTS_INT_H
+#define _PARSE_EVENTS_INT_H
+
+struct cmdline;
+struct cmdline_list;
+struct func_map;
+struct func_list;
+struct event_handler;
+struct func_resolver;
+
+struct tep_handle {
+        int ref_count;
+
+        int header_page_ts_offset;
+        int header_page_ts_size;
+        int header_page_size_offset;
+        int header_page_size_size;
+        int header_page_data_offset;
+        int header_page_data_size;
+        int header_page_overwrite;
+
+        enum tep_endian file_bigendian;
+        enum tep_endian host_bigendian;
+
+        int latency_format;
+
+        int old_format;
+
+        int cpus;
+        int long_size;
+        int page_size;
+
+        struct cmdline *cmdlines;
+        struct cmdline_list *cmdlist;
+        int cmdline_count;
+
+        struct func_map *func_map;
+        struct func_resolver *func_resolver;
+        struct func_list *funclist;
+        unsigned int func_count;
+
+        struct printk_map *printk_map;
+        struct printk_list *printklist;
+        unsigned int printk_count;
+
+
+        struct tep_event_format **events;
+        int nr_events;
+        struct tep_event_format **sort_events;
+        enum tep_event_sort_type last_type;
+
+        int type_offset;
+        int type_size;
+
+        int pid_offset;
+        int pid_size;
+
+        int pc_offset;
+        int pc_size;
+
+        int flags_offset;
+        int flags_size;
+
+        int ld_offset;
+        int ld_size;
+
+        int print_raw;
+
+        int test_filters;
+
+        int flags;
+
+        struct tep_format_field *bprint_ip_field;
+        struct tep_format_field *bprint_fmt_field;
+        struct tep_format_field *bprint_buf_field;
+
+        struct event_handler *handlers;
+        struct tep_function_handler *func_handlers;
+
+        /* cache */
+        struct tep_event_format *last_event;
+
+        char *trace_clock;
+};
+
+#endif /* _PARSE_EVENTS_INT_H */
diff --git a/tools/lib/traceevent/event-parse.c b/tools/lib/traceevent/event-parse.c
index 7980fc6c3bac..3692f29fee46 100644
--- a/tools/lib/traceevent/event-parse.c
+++ b/tools/lib/traceevent/event-parse.c
@@ -18,11 +18,12 @@
 #include <errno.h>
 #include <stdint.h>
 #include <limits.h>
-#include <linux/string.h>
 #include <linux/time64.h>
 
 #include <netinet/in.h>
 #include "event-parse.h"
+
+#include "event-parse-local.h"
 #include "event-utils.h"
 #include "trace-seq.h"
 
@@ -6201,35 +6202,6 @@ enum tep_errno tep_parse_event(struct tep_handle *pevent, const char *buf,
         return __parse_event(pevent, &event, buf, size, sys);
 }
 
-#undef _PE
-#define _PE(code, str) str
-static const char * const tep_error_str[] = {
-        TEP_ERRORS
-};
-#undef _PE
-
-int tep_strerror(struct tep_handle *pevent __maybe_unused,
-                 enum tep_errno errnum, char *buf, size_t buflen)
-{
-        int idx;
-        const char *msg;
-
-        if (errnum >= 0) {
-                str_error_r(errnum, buf, buflen);
-                return 0;
-        }
-
-        if (errnum <= __TEP_ERRNO__START ||
-            errnum >= __TEP_ERRNO__END)
-                return -1;
-
-        idx = errnum - __TEP_ERRNO__START - 1;
-        msg = tep_error_str[idx];
-        snprintf(buf, buflen, "%s", msg);
-
-        return 0;
-}
-
 int get_field_val(struct trace_seq *s, struct tep_format_field *field,
                   const char *name, struct tep_record *record,
                   unsigned long long *val, int err)
diff --git a/tools/lib/traceevent/event-parse.h b/tools/lib/traceevent/event-parse.h
index 9c29a5f7aa39..16bf4c890b6f 100644
--- a/tools/lib/traceevent/event-parse.h
+++ b/tools/lib/traceevent/event-parse.h
@@ -405,149 +405,18 @@ void tep_print_plugins(struct trace_seq *s,
                         const char *prefix, const char *suffix,
                         const struct tep_plugin_list *list);
 
-struct cmdline;
-struct cmdline_list;
-struct func_map;
-struct func_list;
-struct event_handler;
-struct func_resolver;
-
+/* 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);
+unsigned short __tep_data2host2(struct tep_handle *pevent, unsigned short data);
+unsigned int __tep_data2host4(struct tep_handle *pevent, unsigned int data);
+unsigned long long
+__tep_data2host8(struct tep_handle *pevent, unsigned long long data);
 
-struct tep_handle {
-        int ref_count;
-
-        int header_page_ts_offset;
-        int header_page_ts_size;
-        int header_page_size_offset;
-        int header_page_size_size;
-        int header_page_data_offset;
-        int header_page_data_size;
-        int header_page_overwrite;
-
-        int file_bigendian;
-        int host_bigendian;
-
-        int latency_format;
-
-        int old_format;
-
-        int cpus;
-        int long_size;
-        int page_size;
-
-        struct cmdline *cmdlines;
-        struct cmdline_list *cmdlist;
-        int cmdline_count;
-
-        struct func_map *func_map;
-        struct func_resolver *func_resolver;
-        struct func_list *funclist;
-        unsigned int func_count;
-
-        struct printk_map *printk_map;
-        struct printk_list *printklist;
-        unsigned int printk_count;
-
-
-        struct tep_event_format **events;
-        int nr_events;
-        struct tep_event_format **sort_events;
-        enum tep_event_sort_type last_type;
-
-        int type_offset;
-        int type_size;
-
-        int pid_offset;
-        int pid_size;
-
-        int pc_offset;
-        int pc_size;
-
-        int flags_offset;
-        int flags_size;
-
-        int ld_offset;
-        int ld_size;
-
-        int print_raw;
-
-        int test_filters;
-
-        int flags;
-
-        struct tep_format_field *bprint_ip_field;
-        struct tep_format_field *bprint_fmt_field;
-        struct tep_format_field *bprint_buf_field;
-
-        struct event_handler *handlers;
-        struct tep_function_handler *func_handlers;
-
-        /* cache */
-        struct tep_event_format *last_event;
-
-        char *trace_clock;
-};
-
-static inline void tep_set_flag(struct tep_handle *pevent, int flag)
-{
-        pevent->flags |= flag;
-}
-
-static inline unsigned short
-__tep_data2host2(struct tep_handle *pevent, unsigned short data)
-{
-        unsigned short swap;
-
-        if (pevent->host_bigendian == pevent->file_bigendian)
-                return data;
-
-        swap = ((data & 0xffULL) << 8) |
-                ((data & (0xffULL << 8)) >> 8);
-
-        return swap;
-}
-
-static inline unsigned int
-__tep_data2host4(struct tep_handle *pevent, unsigned int data)
-{
-        unsigned int swap;
-
-        if (pevent->host_bigendian == pevent->file_bigendian)
-                return data;
-
-        swap = ((data & 0xffULL) << 24) |
-                ((data & (0xffULL << 8)) << 8) |
-                ((data & (0xffULL << 16)) >> 8) |
-                ((data & (0xffULL << 24)) >> 24);
-
-        return swap;
-}
-
-static inline unsigned long long
-__tep_data2host8(struct tep_handle *pevent, unsigned long long data)
-{
-        unsigned long long swap;
-
-        if (pevent->host_bigendian == pevent->file_bigendian)
-                return data;
-
-        swap = ((data & 0xffULL) << 56) |
-                ((data & (0xffULL << 8)) << 40) |
-                ((data & (0xffULL << 16)) << 24) |
-                ((data & (0xffULL << 24)) << 8) |
-                ((data & (0xffULL << 32)) >> 8) |
-                ((data & (0xffULL << 40)) >> 24) |
-                ((data & (0xffULL << 48)) >> 40) |
-                ((data & (0xffULL << 56)) >> 56);
-
-        return swap;
-}
-
-#define tep_data2host2(pevent, ptr)             __tep_data2host2(pevent, *(unsigned short *)(ptr))
-#define tep_data2host4(pevent, ptr)             __tep_data2host4(pevent, *(unsigned int *)(ptr))
-#define tep_data2host8(pevent, ptr)                                     \
+#define tep_data2host2(pevent, ptr)     __tep_data2host2(pevent, *(unsigned short *)(ptr))
+#define tep_data2host4(pevent, ptr)     __tep_data2host4(pevent, *(unsigned int *)(ptr))
+#define tep_data2host8(pevent, ptr)     \
 ({                                                              \
         unsigned long long __val;                               \
                                                                 \
@@ -655,11 +524,12 @@ unsigned long long tep_read_number(struct tep_handle *pevent, const void *ptr, i
 int tep_read_number_field(struct tep_format_field *field, const void *data,
                           unsigned long long *value);
 
+struct tep_event_format *tep_get_first_event(struct tep_handle *tep);
+int tep_get_events_count(struct tep_handle *tep);
 struct tep_event_format *tep_find_event(struct tep_handle *pevent, int id);
 
 struct tep_event_format *
 tep_find_event_by_name(struct tep_handle *pevent, const char *sys, const char *name);
-
 struct tep_event_format *
 tep_find_event_by_record(struct tep_handle *pevent, struct tep_record *record);
 
@@ -689,65 +559,23 @@ struct tep_event_format **tep_list_events(struct tep_handle *pevent, enum tep_ev
 struct tep_format_field **tep_event_common_fields(struct tep_event_format *event);
 struct tep_format_field **tep_event_fields(struct tep_event_format *event);
 
-static inline int tep_get_cpus(struct tep_handle *pevent)
-{
-        return pevent->cpus;
-}
-
-static inline void tep_set_cpus(struct tep_handle *pevent, int cpus)
-{
-        pevent->cpus = cpus;
-}
-
-static inline int tep_get_long_size(struct tep_handle *pevent)
-{
-        return pevent->long_size;
-}
-
-static inline void tep_set_long_size(struct tep_handle *pevent, int long_size)
-{
-        pevent->long_size = long_size;
-}
-
-static inline int tep_get_page_size(struct tep_handle *pevent)
-{
-        return pevent->page_size;
-}
-
-static inline void tep_set_page_size(struct tep_handle *pevent, int _page_size)
-{
-        pevent->page_size = _page_size;
-}
-
-static inline int tep_is_file_bigendian(struct tep_handle *pevent)
-{
-        return pevent->file_bigendian;
-}
-
-static inline void tep_set_file_bigendian(struct tep_handle *pevent, int endian)
-{
-        pevent->file_bigendian = endian;
-}
-
-static inline int tep_is_host_bigendian(struct tep_handle *pevent)
-{
-        return pevent->host_bigendian;
-}
-
-static inline void tep_set_host_bigendian(struct tep_handle *pevent, int endian)
-{
-        pevent->host_bigendian = endian;
-}
-
-static inline int tep_is_latency_format(struct tep_handle *pevent)
-{
-        return pevent->latency_format;
-}
-
-static inline void tep_set_latency_format(struct tep_handle *pevent, int lat)
-{
-        pevent->latency_format = lat;
-}
+enum tep_endian {
+        TEP_LITTLE_ENDIAN = 0,
+        TEP_BIG_ENDIAN
+};
+int tep_get_cpus(struct tep_handle *pevent);
+void tep_set_cpus(struct tep_handle *pevent, int cpus);
+int tep_get_long_size(struct tep_handle *pevent);
+void tep_set_long_size(struct tep_handle *pevent, int long_size);
+int tep_get_page_size(struct tep_handle *pevent);
+void tep_set_page_size(struct tep_handle *pevent, int _page_size);
+int tep_is_file_bigendian(struct tep_handle *pevent);
+void tep_set_file_bigendian(struct tep_handle *pevent, enum tep_endian endian);
+int tep_is_host_bigendian(struct tep_handle *pevent);
+void tep_set_host_bigendian(struct tep_handle *pevent, enum tep_endian endian);
+int tep_is_latency_format(struct tep_handle *pevent);
+void tep_set_latency_format(struct tep_handle *pevent, int lat);
+int tep_get_header_page_size(struct tep_handle *pevent);
 
 struct tep_handle *tep_alloc(void);
 void tep_free(struct tep_handle *pevent);
diff --git a/tools/lib/traceevent/event-plugin.c b/tools/lib/traceevent/event-plugin.c
index 46eb64eb0c2e..e74f16c88398 100644
--- a/tools/lib/traceevent/event-plugin.c
+++ b/tools/lib/traceevent/event-plugin.c
@@ -14,6 +14,7 @@
 #include <unistd.h>
 #include <dirent.h>
 #include "event-parse.h"
+#include "event-parse-local.h"
 #include "event-utils.h"
 #include "trace-seq.h"
 
diff --git a/tools/lib/traceevent/parse-filter.c b/tools/lib/traceevent/parse-filter.c
index d64b6128fa7d..ed87cb56713d 100644
--- a/tools/lib/traceevent/parse-filter.c
+++ b/tools/lib/traceevent/parse-filter.c
@@ -11,6 +11,7 @@
 #include <sys/types.h>
 
 #include "event-parse.h"
+#include "event-parse-local.h"
 #include "event-utils.h"
 
 #define COMM "COMM"
diff --git a/tools/lib/traceevent/tep_strerror.c b/tools/lib/traceevent/tep_strerror.c
new file mode 100644
index 000000000000..4ac26445b2f6
--- /dev/null
+++ b/tools/lib/traceevent/tep_strerror.c
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: LGPL-2.1
+#undef _GNU_SOURCE
+#include <string.h>
+#include <stdio.h>
+
+#include "event-parse.h"
+
+#undef _PE
+#define _PE(code, str) str
+static const char * const tep_error_str[] = {
+        TEP_ERRORS
+};
+#undef _PE
+
+/*
+ * The tools so far have been using the strerror_r() GNU variant, that returns
+ * a string, be it the buffer passed or something else.
+ *
+ * But that, besides being tricky in cases where we expect that the function
+ * using strerror_r() returns the error formatted in a provided buffer (we have
+ * to check if it returned something else and copy that instead), breaks the
+ * build on systems not using glibc, like Alpine Linux, where musl libc is
+ * used.
+ *
+ * So, introduce yet another wrapper, str_error_r(), that has the GNU
+ * interface, but uses the portable XSI variant of strerror_r(), so that users
+ * rest asured that the provided buffer is used and it is what is returned.
+ */
+int tep_strerror(struct tep_handle *tep __maybe_unused,
+                 enum tep_errno errnum, char *buf, size_t buflen)
+{
+        const char *msg;
+        int idx;
+
+        if (!buflen)
+                return 0;
+
+        if (errnum >= 0) {
+                int err = strerror_r(errnum, buf, buflen);
+                buf[buflen - 1] = 0;
+                return err;
+        }
+
+        if (errnum <= __TEP_ERRNO__START ||
+            errnum >= __TEP_ERRNO__END)
+                return -1;
+
+        idx = errnum - __TEP_ERRNO__START - 1;
+        msg = tep_error_str[idx];
+        snprintf(buf, buflen, "%s", msg);
+
+        return 0;
+}
diff --git a/tools/perf/check-headers.sh b/tools/perf/check-headers.sh
index 466540ee8ea7..c72cc73a6b09 100755
--- a/tools/perf/check-headers.sh
+++ b/tools/perf/check-headers.sh
@@ -14,6 +14,7 @@ include/uapi/linux/sched.h
 include/uapi/linux/stat.h
 include/uapi/linux/vhost.h
 include/uapi/sound/asound.h
+include/linux/bits.h
 include/linux/hash.h
 include/uapi/linux/hw_breakpoint.h
 arch/x86/include/asm/disabled-features.h
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 54ca7d87236f..12c09e0ece71 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -123,6 +123,7 @@ static struct test generic_tests[] = {
         {
                 .desc = "Watchpoint",
                 .func = test__wp,
+                .is_supported = test__wp_is_supported,
                 .subtest = {
                         .skip_if_fail   = false,
                         .get_nr         = test__wp_subtest_get_nr,
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index 8e26a4148f30..b82f55fcc294 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -109,6 +109,7 @@ int test__unit_number__scnprint(struct test *test, int subtest);
 int test__mem2node(struct test *t, int subtest);
 
 bool test__bp_signal_is_supported(void);
+bool test__wp_is_supported(void);
 
 #if defined(__arm__) || defined(__aarch64__)
 #ifdef HAVE_DWARF_UNWIND_SUPPORT
diff --git a/tools/perf/tests/wp.c b/tools/perf/tests/wp.c
index 017a99317f94..f89e6806557b 100644
--- a/tools/perf/tests/wp.c
+++ b/tools/perf/tests/wp.c
@@ -227,3 +227,15 @@ int test__wp(struct test *test __maybe_unused, int i)
 
         return !wp_testcase_table[i].target_func() ? TEST_OK : TEST_FAIL;
 }
+
+/* The s390 so far does not have support for
+ * instruction breakpoint using the perf_event_open() system call.
+ */
+bool test__wp_is_supported(void)
+{
+#if defined(__s390x__)
+        return false;
+#else
+        return true;
+#endif
+}
diff --git a/tools/perf/util/auxtrace.h b/tools/perf/util/auxtrace.h
index 0a6ce9c4fc11..d88f6e9eb461 100644
--- a/tools/perf/util/auxtrace.h
+++ b/tools/perf/util/auxtrace.h
@@ -23,6 +23,7 @@
 #include <linux/list.h>
 #include <linux/perf_event.h>
 #include <linux/types.h>
+#include <asm/bitsperlong.h>
 
 #include "../perf.h"
 #include "event.h"
diff --git a/tools/perf/util/setup.py b/tools/perf/util/setup.py
index 1942f6dd24f6..63f758c655d5 100644
--- a/tools/perf/util/setup.py
+++ b/tools/perf/util/setup.py
@@ -5,16 +5,18 @@ from subprocess import Popen, PIPE
 from re import sub
 
 def clang_has_option(option):
-    return [o for o in Popen(['clang', option], stderr=PIPE).stderr.readlines() if "unknown argument" in o] == [ ]
+    return [o for o in Popen(['clang', option], stderr=PIPE).stderr.readlines() if b"unknown argument" in o] == [ ]
 
 cc = getenv("CC")
 if cc == "clang":
-    from _sysconfigdata import build_time_vars
-    build_time_vars["CFLAGS"] = sub("-specs=[^ ]+", "", build_time_vars["CFLAGS"])
-    if not clang_has_option("-mcet"):
-        build_time_vars["CFLAGS"] = sub("-mcet", "", build_time_vars["CFLAGS"])
-    if not clang_has_option("-fcf-protection"):
-        build_time_vars["CFLAGS"] = sub("-fcf-protection", "", build_time_vars["CFLAGS"])
+    from distutils.sysconfig import get_config_vars
+    vars = get_config_vars()
+    for var in ('CFLAGS', 'OPT'):
+        vars[var] = sub("-specs=[^ ]+", "", vars[var])
+        if not clang_has_option("-mcet"):
+            vars[var] = sub("-mcet", "", vars[var])
+        if not clang_has_option("-fcf-protection"):
+            vars[var] = sub("-fcf-protection", "", vars[var])
 
 from distutils.core import setup, Extension
 
diff --git a/tools/perf/util/strbuf.c b/tools/perf/util/strbuf.c
index 3d1cf5bf7f18..9005fbe0780e 100644
--- a/tools/perf/util/strbuf.c
+++ b/tools/perf/util/strbuf.c
@@ -98,19 +98,25 @@ static int strbuf_addv(struct strbuf *sb, const char *fmt, va_list ap)
 
         va_copy(ap_saved, ap);
         len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
-        if (len < 0)
+        if (len < 0) {
+                va_end(ap_saved);
                 return len;
+        }
         if (len > strbuf_avail(sb)) {
                 ret = strbuf_grow(sb, len);
-                if (ret)
+                if (ret) {
+                        va_end(ap_saved);
                         return ret;
+                }
                 len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap_saved);
                 va_end(ap_saved);
                 if (len > strbuf_avail(sb)) {
                         pr_debug("this should not happen, your vsnprintf is broken");
+                        va_end(ap_saved);
                         return -EINVAL;
                 }
         }
+        va_end(ap_saved);
         return strbuf_setlen(sb, sb->len + len);
 }
 
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index 7b0ca7cbb7de..8ad8e755127b 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -531,12 +531,14 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
                          "/tmp/perf-XXXXXX");
                 if (!mkstemp(tdata->temp_file)) {
                         pr_debug("Can't make temp file");
+                        free(tdata);
                         return NULL;
                 }
 
                 temp_fd = open(tdata->temp_file, O_RDWR);
                 if (temp_fd < 0) {
                         pr_debug("Can't read '%s'", tdata->temp_file);
+                        free(tdata);
                         return NULL;
                 }
 
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index a4d7de1c96d1..32e558a65af3 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -37,10 +37,11 @@ static int get_common_field(struct scripting_context *context,
         struct tep_format_field *field;
 
         if (!*size) {
-                if (!pevent->events)
+
+                event = tep_get_first_event(pevent);
+                if (!event)
                         return 0;
 
-                event = pevent->events[0];
                 field = tep_find_common_field(event, type);
                 if (!field)
                         return 0;
@@ -158,6 +159,7 @@ void parse_ftrace_printk(struct tep_handle *pevent,
                 printk = strdup(fmt+1);
                 line = strtok_r(NULL, "\n", &next);
                 tep_register_print_string(pevent, printk, addr);
+                free(printk);
         }
 }
 
@@ -192,25 +194,29 @@ struct tep_event_format *trace_find_next_event(struct tep_handle *pevent,
                                                struct tep_event_format *event)
 {
         static int idx;
+        int events_count;
+        struct tep_event_format *all_events;
 
-        if (!pevent || !pevent->events)
+        all_events = tep_get_first_event(pevent);
+        events_count = tep_get_events_count(pevent);
+        if (!pevent || !all_events || events_count < 1)
                 return NULL;
 
         if (!event) {
                 idx = 0;
-                return pevent->events[0];
+                return all_events;
         }
 
-        if (idx < pevent->nr_events && event == pevent->events[idx]) {
+        if (idx < events_count && event == (all_events + idx)) {
                 idx++;
-                if (idx == pevent->nr_events)
+                if (idx == events_count)
                         return NULL;
-                return pevent->events[idx];
+                return (all_events + idx);
         }
 
-        for (idx = 1; idx < pevent->nr_events; idx++) {
-                if (event == pevent->events[idx - 1])
-                        return pevent->events[idx];
+        for (idx = 1; idx < events_count; idx++) {
+                if (event == (all_events + (idx - 1)))
+                        return (all_events + idx);
         }
         return NULL;
 }
diff --git a/tools/perf/util/trace-event-read.c b/tools/perf/util/trace-event-read.c
index b98ee2a2eb44..76f12c705ef9 100644
--- a/tools/perf/util/trace-event-read.c
+++ b/tools/perf/util/trace-event-read.c
@@ -241,7 +241,7 @@ static int read_header_files(struct tep_handle *pevent)
                  * The commit field in the page is of type long,
                  * use that instead, since it represents the kernel.
                  */
-                tep_set_long_size(pevent, pevent->header_page_size_size);
+                tep_set_long_size(pevent, tep_get_header_page_size(pevent));
         }
         free(header_page);
 
@@ -297,10 +297,8 @@ static int read_event_file(struct tep_handle *pevent, char *sys,
         }
 
         ret = do_read(buf, size);
-        if (ret < 0) {
-                free(buf);
+        if (ret < 0)
                 goto out;
-        }
 
         ret = parse_event_file(pevent, buf, size, sys);
         if (ret < 0)
@@ -349,9 +347,12 @@ static int read_event_files(struct tep_handle *pevent)
                 for (x=0; x < count; x++) {
                         size = read8(pevent);
                         ret = read_event_file(pevent, sys, size);
-                        if (ret)
+                        if (ret) {
+                                free(sys);
                                 return ret;
+                        }
                 }
+                free(sys);
         }
         return 0;
 }