diff --git a/rhbz1544711.patch b/rhbz1544711.patch new file mode 100644 index 0000000..434fc53 --- /dev/null +++ b/rhbz1544711.patch @@ -0,0 +1,208 @@ +commit a8e317b60 (HEAD -> master, origin/master, origin/HEAD) +Author: Stan Cox +Date: Tue Feb 13 22:38:03 2018 -0500 + + Fixes for gcc 8 + + * includes/sys/sdt.h (__SDT_COND_SIGNED): Add CT, cast type argument + + Author: Will Cohen + + * stap-serverd.cxx (generate_mok, handleRequest, handle_connection): + Catch format overflow + + * translate.cxx (translate_pass): Use ref in catch. + +diff --git a/includes/sys/sdt.h b/includes/sys/sdt.h +index 940f74483..c0c5a492c 100644 +--- a/includes/sys/sdt.h ++++ b/includes/sys/sdt.h +@@ -119,8 +119,8 @@ struct __sdt_type + + #define __SDT_ALWAYS_SIGNED(T) \ + template<> struct __sdt_type { static const bool __sdt_signed = true; }; +-#define __SDT_COND_SIGNED(T) \ +-template<> struct __sdt_type { static const bool __sdt_signed = ((T)(-1) < 1); }; ++#define __SDT_COND_SIGNED(T,CT) \ ++template<> struct __sdt_type { static const bool __sdt_signed = ((CT)(-1) < 1); }; + __SDT_ALWAYS_SIGNED(signed char) + __SDT_ALWAYS_SIGNED(short) + __SDT_ALWAYS_SIGNED(int) +@@ -141,14 +141,14 @@ __SDT_ALWAYS_SIGNED(const volatile short) + __SDT_ALWAYS_SIGNED(const volatile int) + __SDT_ALWAYS_SIGNED(const volatile long) + __SDT_ALWAYS_SIGNED(const volatile long long) +-__SDT_COND_SIGNED(char) +-__SDT_COND_SIGNED(wchar_t) +-__SDT_COND_SIGNED(volatile char) +-__SDT_COND_SIGNED(volatile wchar_t) +-__SDT_COND_SIGNED(const char) +-__SDT_COND_SIGNED(const wchar_t) +-__SDT_COND_SIGNED(const volatile char) +-__SDT_COND_SIGNED(const volatile wchar_t) ++__SDT_COND_SIGNED(char, char) ++__SDT_COND_SIGNED(wchar_t, wchar_t) ++__SDT_COND_SIGNED(volatile char, char) ++__SDT_COND_SIGNED(volatile wchar_t, wchar_t) ++__SDT_COND_SIGNED(const char, char) ++__SDT_COND_SIGNED(const wchar_t, wchar_t) ++__SDT_COND_SIGNED(const volatile char, char) ++__SDT_COND_SIGNED(const volatile wchar_t, wchar_t) + #if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) + /* __SDT_COND_SIGNED(char16_t) */ + /* __SDT_COND_SIGNED(char32_t) */ +diff --git a/stap-serverd.cxx b/stap-serverd.cxx +index b8f70114c..063c3c587 100644 +--- a/stap-serverd.cxx ++++ b/stap-serverd.cxx +@@ -1607,6 +1607,7 @@ generate_mok(string &mok_fingerprint) + char tmpdir[PATH_MAX] = { '\0' }; + string public_cert_path, private_cert_path, destdir; + mode_t old_umask; ++ int retlen; + + mok_fingerprint.clear (); + +@@ -1631,7 +1632,14 @@ generate_mok(string &mok_fingerprint) + } + + // Make a temporary directory to store results in. +- snprintf (tmpdir, PATH_MAX, "%s/stap-server.XXXXXX", mok_path.c_str ()); ++ retlen = snprintf (tmpdir, PATH_MAX, "%s/stap-server.XXXXXX", mok_path.c_str ()); ++ if (retlen < 0 || retlen >= PATH_MAX) ++ { ++ server_error (_F("Could not create %s name", "temporary directory")); ++ tmpdir[0] = '\0'; ++ goto cleanup; ++ } ++ + if (mkdtemp (tmpdir) == NULL) + { + server_error (_F("Could not create temporary directory %s: %s", tmpdir, +@@ -1704,6 +1712,7 @@ handleRequest (const string &requestDirName, const string &responseDirName, stri + unsigned u; + unsigned i; + FILE* f; ++ int retlen; + + // Save the server version. Do this early, so the client knows what version of the server + // it is dealing with, even if the request is not fully completed. +@@ -1782,7 +1791,12 @@ handleRequest (const string &requestDirName, const string &responseDirName, stri + struct stat st; + char *arg; + +- snprintf (stapargfile, PATH_MAX, "%s/argv%d", requestDirName.c_str (), i); ++ retlen = snprintf (stapargfile, PATH_MAX, "%s/argv%d", requestDirName.c_str (), i); ++ if (retlen < 0 || retlen >= PATH_MAX) ++ { ++ server_error (_F("Error creating %s name", "path")); ++ return; ++ } + + rc = stat(stapargfile, & st); + if (rc) break; +@@ -1888,7 +1902,15 @@ handleRequest (const string &requestDirName, const string &responseDirName, stri + { + glob_t globber; + char pattern[PATH_MAX]; +- snprintf (pattern, PATH_MAX, "%s/*.ko", new_staptmpdir.c_str()); ++ int retlen; ++ ++ retlen = snprintf (pattern, PATH_MAX, "%s/*.ko", new_staptmpdir.c_str()); ++ if (retlen < 0 || retlen >= PATH_MAX) ++ { ++ server_error (_F("Error creating %s name", "pattern")); ++ return; ++ } ++ + rc = glob (pattern, GLOB_ERR, NULL, &globber); + if (rc) + server_error (_F("Unable to find a module in %s", new_staptmpdir.c_str())); +@@ -2164,6 +2186,7 @@ handle_connection (void *arg) + copy for each connection.*/ + vector argv; + PRInt32 bytesRead; ++ int retlen; + + /* Detatch to avoid a memory leak */ + if(max_threads > 0) +@@ -2213,7 +2236,13 @@ handle_connection (void *arg) + #endif + + secStatus = SECFailure; +- snprintf(tmpdir, PATH_MAX, "%s/stap-server.XXXXXX", getenv("TMPDIR") ?: "/tmp"); ++ retlen = snprintf(tmpdir, PATH_MAX, "%s/stap-server.XXXXXX", getenv("TMPDIR") ?: "/tmp"); ++ if (retlen < 0 || retlen >= PATH_MAX) ++ { ++ server_error (_F("Error creating %s name", "temporary directory")); ++ tmpdir[0]=0; /* prevent /bin/rm */ ++ goto cleanup; ++ } + rc1 = mkdtemp(tmpdir); + if (! rc1) + { +@@ -2223,9 +2252,20 @@ handle_connection (void *arg) + } + + /* Create a temporary files names and directories. */ +- snprintf (requestFileName, PATH_MAX, "%s/request.zip", tmpdir); ++ retlen = snprintf (requestFileName, PATH_MAX, "%s/request.zip", tmpdir); ++ if (retlen < 0 || retlen >= PATH_MAX) ++ { ++ server_error (_F("Error creating %s name", "request.zip path")); ++ goto cleanup; ++ } ++ ++ retlen = snprintf (requestDirName, PATH_MAX, "%s/request", tmpdir); ++ if (retlen < 0 || retlen >= PATH_MAX) ++ { ++ server_error (_F("Error creating %s name", "request directory path")); ++ goto cleanup; ++ } + +- snprintf (requestDirName, PATH_MAX, "%s/request", tmpdir); + rc = mkdir(requestDirName, 0700); + if (rc) + { +@@ -2233,7 +2273,13 @@ handle_connection (void *arg) + goto cleanup; + } + +- snprintf (responseDirName, PATH_MAX, "%s/response", tmpdir); ++ retlen = snprintf (responseDirName, PATH_MAX, "%s/response", tmpdir); ++ if (retlen < 0 || retlen >= PATH_MAX) ++ { ++ server_error (_F("Error creating %s name", "response directory path")); ++ goto cleanup; ++ } ++ + rc = mkdir(responseDirName, 0700); + if (rc) + { +@@ -2243,7 +2289,12 @@ handle_connection (void *arg) + // Set this early, since it gets used for errors to be returned to the client. + stapstderr = string(responseDirName) + "/stderr"; + +- snprintf (responseFileName, PATH_MAX, "%s/response.zip", tmpdir); ++ retlen = snprintf (responseFileName, PATH_MAX, "%s/response.zip", tmpdir); ++ if (retlen < 0 || retlen >= PATH_MAX) ++ { ++ server_error (_F("Error creating %s name", "response.zip path")); ++ goto cleanup; ++ } + + /* Read data from the socket. + * If the user is requesting/requiring authentication, authenticate +diff --git a/translate.cxx b/translate.cxx +index 1240a80ec..4ade06fdd 100644 +--- a/translate.cxx ++++ b/translate.cxx +@@ -7860,7 +7860,7 @@ translate_pass (systemtap_session& s) + if (versions.size() >= 3 && s.verbose > 1) + clog << _F("ignoring extra parts of compat version: %s", s.compatible.c_str()) << endl; + } +- catch (const runtime_error) ++ catch (const runtime_error&) + { + throw SEMANTIC_ERROR(_F("parse error in compatibility version: %s", s.compatible.c_str())); + } diff --git a/rhbz1546563.patch b/rhbz1546563.patch new file mode 100644 index 0000000..4e4030b --- /dev/null +++ b/rhbz1546563.patch @@ -0,0 +1,273 @@ +From fbb26e17a4c026f05a497fc5d584516bad3b6950 Mon Sep 17 00:00:00 2001 +From: David Smith +Date: Wed, 6 Dec 2017 14:37:42 -0600 +Subject: [PATCH] Fix PR22551 by updating the use of timers for the 4.15 + kernel. + +* runtime/linux/timer_compatibility.h: New file. +* runtime/time.c: Update timer callback function parameter type. Update + timer initialization. +* runtime/transport/relay_v2.c: Ditto. +* runtime/transport/transport.c: Ditto. +* tapset-timers.cxx (timer_derived_probe_group::emit_module_decls): + Ditto. Handle old and new timer callback interface. +* runtime/linux/runtime.h: Include timer_compatibility.h instead of timer.h. +* tapset/linux/scsi.stp: Ditto. +--- + runtime/linux/runtime.h | 2 +- + runtime/linux/timer_compatibility.h | 76 +++++++++++++++++++++++++++++++++++++ + runtime/time.c | 7 ++-- + runtime/transport/relay_v2.c | 8 ++-- + runtime/transport/transport.c | 13 +++---- + tapset-timers.cxx | 14 +++++-- + tapset/linux/scsi.stp | 2 +- + 7 files changed, 100 insertions(+), 22 deletions(-) + create mode 100644 runtime/linux/timer_compatibility.h + +diff --git a/runtime/linux/runtime.h b/runtime/linux/runtime.h +index 9c585a2..df9b74c 100644 +--- a/runtime/linux/runtime.h ++++ b/runtime/linux/runtime.h +@@ -34,7 +34,7 @@ + #include + #include + #include +-#include ++#include "timer_compatibility.h" + #include + #include + #include +diff --git a/runtime/linux/timer_compatibility.h b/runtime/linux/timer_compatibility.h +new file mode 100644 +index 0000000..ac03de9 +--- /dev/null ++++ b/runtime/linux/timer_compatibility.h +@@ -0,0 +1,76 @@ ++/* ++ * linux/timer.h compatibility defines and inlines ++ * Copyright (C) 2017 Red Hat Inc. ++ * ++ * This file is part of systemtap, and is free software. You can ++ * redistribute it and/or modify it under the terms of the GNU General ++ * Public License (GPL); either version 2, or (at your option) any ++ * later version. ++ */ ++ ++#ifndef _TIMER_COMPATIBILITY_H_ ++#define _TIMER_COMPATIBILITY_H_ ++ ++#include ++ ++/* ++ * Starting with the 4.15 kernel, the timer interface ++ * changed. Originally, you'd do something like: ++ * ++ * static void timer_func(unsigned long val); ++ * ++ * init_timer(&timer); ++ * timer.expires = jiffies + STP_RELAY_TIMER_INTERVAL; ++ * timer.function = timer_func; ++ * timer.data = 0; ++ * add_timer(&timer); ++ * ++ * The 'data' parameter would get passed to the callback ++ * function. Starting with 4.15, you'd do something like this: ++ * ++ * static void timer_func(struct timer_list *val); ++ * ++ * timer_setup(&timer, timer_func, 0); ++ * timer.expires = jiffies + STP_RELAY_TIMER_INTERVAL; ++ * add_timer(&timer); ++ * ++ * With the new code, the timer that caused the callback gets passed ++ * to the timer callback function. The 'data' field has been removed. ++ * ++ * So, we're going to use the new interface. To hide the differences ++ * between the callback function parameter type, we'll define a new ++ * type, 'stp_timer_callback_parameter_t'. ++ * ++ * If code needs to figure out the difference between the old and new ++ * interface, it should test the TIMER_TRACE_FLAGMASK define (which ++ * only exists in the new interface). ++ */ ++ ++#if defined(TIMER_TRACE_FLAGMASK) ++/* This is the >= 4.15 kernel interface. */ ++ ++typedef struct timer_list * stp_timer_callback_parameter_t; ++ ++#else ++/* This is the < 4.15 kernel interface. */ ++ ++typedef unsigned long stp_timer_callback_parameter_t; ++ ++/** ++ * timer_setup - prepare a timer for first use ++ * @timer: the timer in question ++ * @callback: the function to call when timer expires ++ * @flags: any TIMER_* flags (note that anything other than 0 is an ++ * error, since this compatibility function can't support any ++ * of the TIMER_* flags) ++ */ ++#define timer_setup(timer, callback, flags) \ ++ { \ ++ init_timer((timer)); \ ++ (timer)->function = callback; \ ++ (timer)->data = 0; \ ++ BUILD_BUG_ON_ZERO((flags) != 0); \ ++ } ++#endif ++ ++#endif /* _TIMER_COMPATIBILITY_H_ */ +diff --git a/runtime/time.c b/runtime/time.c +index 2e666d5..91ceafa 100644 +--- a/runtime/time.c ++++ b/runtime/time.c +@@ -168,10 +168,10 @@ __stp_time_smp_callback(void *val) + + /* The timer callback is in a softIRQ -- interrupts enabled. */ + static void +-__stp_time_timer_callback(unsigned long val) ++__stp_time_timer_callback(stp_timer_callback_parameter_t unused) + { + stp_time_t *time =__stp_time_local_update(); +- (void) val; ++ (void) unused; + + /* PR6481: make sure IRQs are enabled before resetting the timer + (IRQs are disabled and then reenabled in +@@ -200,9 +200,8 @@ __stp_init_time(void *info) + time->freq = __stp_get_freq(); + __stp_time_local_update(); + +- init_timer(&time->timer); ++ timer_setup(&time->timer, __stp_time_timer_callback, 0); + time->timer.expires = jiffies + STP_TIME_SYNC_INTERVAL; +- time->timer.function = __stp_time_timer_callback; + + #ifndef STAPCONF_ADD_TIMER_ON + add_timer(&time->timer); +diff --git a/runtime/transport/relay_v2.c b/runtime/transport/relay_v2.c +index f81d75d..135951a 100644 +--- a/runtime/transport/relay_v2.c ++++ b/runtime/transport/relay_v2.c +@@ -30,7 +30,7 @@ + #include + #include + #include +-#include ++#include "../linux/timer_compatibility.h" + #include "../uidgid_compatibility.h" + #include "relay_compat.h" + +@@ -120,7 +120,7 @@ static void __stp_relay_wakeup_readers(struct rchan_buf *buf) + wake_up_interruptible(&buf->read_wait); + } + +-static void __stp_relay_wakeup_timer(unsigned long val) ++static void __stp_relay_wakeup_timer(stp_timer_callback_parameter_t unused) + { + #ifdef STP_BULKMODE + int i; +@@ -151,10 +151,8 @@ static void __stp_relay_wakeup_timer(unsigned long val) + static void __stp_relay_timer_init(void) + { + atomic_set(&_stp_relay_data.wakeup, 0); +- init_timer(&_stp_relay_data.timer); ++ timer_setup(&_stp_relay_data.timer, __stp_relay_wakeup_timer, 0); + _stp_relay_data.timer.expires = jiffies + STP_RELAY_TIMER_INTERVAL; +- _stp_relay_data.timer.function = __stp_relay_wakeup_timer; +- _stp_relay_data.timer.data = 0; + add_timer(&_stp_relay_data.timer); + smp_mb(); + } +diff --git a/runtime/transport/transport.c b/runtime/transport/transport.c +index 3400f22..320fd18 100644 +--- a/runtime/transport/transport.c ++++ b/runtime/transport/transport.c +@@ -311,7 +311,7 @@ static void _stp_detach(void) + } + + +-static void _stp_ctl_work_callback(unsigned long val); ++static void _stp_ctl_work_callback(stp_timer_callback_parameter_t unused); + + /* + * Called when stapio opens the control channel. +@@ -320,13 +320,12 @@ static void _stp_attach(void) + { + dbug_trans(1, "attach\n"); + _stp_pid = current->pid; +- if (_stp_namespaces_pid < 1) +- _stp_namespaces_pid = _stp_pid; ++ if (_stp_namespaces_pid < 1) ++ _stp_namespaces_pid = _stp_pid; + _stp_transport_data_fs_overwrite(0); +- init_timer(&_stp_ctl_work_timer); ++ ++ timer_setup(&_stp_ctl_work_timer, _stp_ctl_work_callback, 0); + _stp_ctl_work_timer.expires = jiffies + STP_CTL_TIMER_INTERVAL; +- _stp_ctl_work_timer.function = _stp_ctl_work_callback; +- _stp_ctl_work_timer.data= 0; + add_timer(&_stp_ctl_work_timer); + } + +@@ -341,7 +340,7 @@ static void _stp_attach(void) + * notified. Reschedules itself if someone is still attached + * to the cmd channel. + */ +-static void _stp_ctl_work_callback(unsigned long val) ++static void _stp_ctl_work_callback(stp_timer_callback_parameter_t unused) + { + int do_io = 0; + unsigned long flags; +diff --git a/tapset-timers.cxx b/tapset-timers.cxx +index 1a40bcd..0ab4d69 100644 +--- a/tapset-timers.cxx ++++ b/tapset-timers.cxx +@@ -122,9 +122,13 @@ timer_derived_probe_group::emit_module_decls (systemtap_session& s) + s.op->newline(-1) << "};"; + s.op->newline(); + +- s.op->newline() << "static void enter_timer_probe (unsigned long val) {"; ++ s.op->newline() << "static void enter_timer_probe (stp_timer_callback_parameter_t val) {"; ++ s.op->newline() << "#if defined(TIMER_TRACE_FLAGMASK)"; ++ s.op->newline(1) << "struct stap_timer_probe* stp = container_of(val, struct stap_timer_probe, timer_list);"; ++ s.op->newline(-1) << "#else"; + s.op->newline(1) << "struct stap_timer_probe* stp = & stap_timer_probes [val];"; +- s.op->newline() << "if ((atomic_read (session_state()) == STAP_SESSION_STARTING) ||"; ++ s.op->newline(-1) << "#endif"; ++ s.op->newline(1) << "if ((atomic_read (session_state()) == STAP_SESSION_STARTING) ||"; + s.op->newline() << " (atomic_read (session_state()) == STAP_SESSION_RUNNING))"; + s.op->newline(1) << "mod_timer (& stp->timer_list, jiffies + "; + emit_interval (s.op); +@@ -148,9 +152,11 @@ timer_derived_probe_group::emit_module_init (systemtap_session& s) + s.op->newline() << "for (i=0; i<" << probes.size() << "; i++) {"; + s.op->newline(1) << "struct stap_timer_probe* stp = & stap_timer_probes [i];"; + s.op->newline() << "probe_point = stp->probe->pp;"; +- s.op->newline() << "init_timer (& stp->timer_list);"; +- s.op->newline() << "stp->timer_list.function = & enter_timer_probe;"; ++ ++ s.op->newline() << "timer_setup (& stp->timer_list, enter_timer_probe, 0);"; ++ s.op->newline() << "#if !defined(TIMER_TRACE_FLAGMASK)"; + s.op->newline() << "stp->timer_list.data = i;"; // NB: important! ++ s.op->newline() << "#endif"; + // copy timer renew calculations from above :-( + s.op->newline() << "stp->timer_list.expires = jiffies + "; + emit_interval (s.op); +diff --git a/tapset/linux/scsi.stp b/tapset/linux/scsi.stp +index 44f686c..3577942 100644 +--- a/tapset/linux/scsi.stp ++++ b/tapset/linux/scsi.stp +@@ -14,7 +14,7 @@ + #include + #include + #include +-#include ++#include "linux/timer_compatibility.h" + #include + %} + +-- +2.9.3 + diff --git a/systemtap.spec b/systemtap.spec index fd53194..0fe2999 100644 --- a/systemtap.spec +++ b/systemtap.spec @@ -72,12 +72,20 @@ %define dracutbindir %{_bindir} %endif +# To avoid testsuite/*/*.stp has shebang which doesn't start with '/' +%undefine __brp_mangle_shebangs + Name: systemtap Version: 3.2 -Release: 2%{?dist} +Release: 7%{?dist} # for version, see also configure.ac Patch10: rhbz1504009.patch +Patch11: rhbz1544711.patch + +# redhat: https://bugzilla.redhat.com/show_bug.cgi?id=1546563 +# upstream: https://sourceware.org/bugzilla/show_bug.cgi?id=22551 +Patch12: rhbz1546563.patch # Packaging abstract: # @@ -113,7 +121,6 @@ URL: http://sourceware.org/systemtap/ Source: ftp://sourceware.org/pub/systemtap/releases/systemtap-%{version}.tar.gz # Build* -BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) BuildRequires: gcc-c++ BuildRequires: gettext-devel BuildRequires: pkgconfig(nss) @@ -212,10 +219,7 @@ Group: Development/System License: GPLv2+ URL: http://sourceware.org/systemtap/ Requires: systemtap-devel = %{version}-%{release} -# On RHEL[45], /bin/mktemp comes from the 'mktemp' package. On newer -# distributions, /bin/mktemp comes from the 'coreutils' package. To -# avoid a specific RHEL[45] Requires, we'll do a file-based require. -Requires: nss /bin/mktemp +Requires: nss coreutils Requires: zip unzip Requires(pre): shadow-utils Requires(post): chkconfig @@ -481,6 +485,8 @@ cd .. %endif %patch10 -p1 +%patch11 -p1 +%patch12 -p1 %build @@ -705,9 +711,6 @@ done touch $RPM_BUILD_ROOT%{dracutstap}/params.conf %endif -%clean -rm -rf ${RPM_BUILD_ROOT} - %pre runtime getent group stapusr >/dev/null || groupadd -g 156 -r stapusr 2>/dev/null || groupadd -r stapusr getent group stapsys >/dev/null || groupadd -g 157 -r stapsys 2>/dev/null || groupadd -r stapsys @@ -1161,6 +1164,21 @@ done # PRERELEASE %changelog +* Thu Feb 22 2018 Sergey Avseyev - 3.2-7 +- rhbz1546563 (backport fix for removed timers in kernel 4.15) + +* Tue Feb 13 2018 Stan Cox - 3.2-6 +- rebuilt + +* Fri Feb 09 2018 Igor Gnatenko - 3.2-5 +- Escape macros in %%changelog + +* Wed Feb 07 2018 Igor Gnatenko - 3.2-4 +- Fix very old Requires + +* Sun Dec 10 2017 Björn Esser - 3.2-3 +- Rebuilt for libjson-c.so.3 + * Fri Oct 20 2017 Frank Ch. Eigler - 3.2-2 - rhbz1504009 (dtrace -G -o /dev/null) @@ -1186,7 +1204,7 @@ done - Upstream release. * Mon Jul 07 2014 Josh Stone -- Flip with_dyninst to an %ifarch whitelist. +- Flip with_dyninst to an %%ifarch whitelist. * Wed Apr 30 2014 Jonathan Lebon - 2.5-1 - Upstream release.