PR28618 stapregex: allow non-capturing group

configury: let python3 be python3

Our baroque heuristics for identifying python2/3 under their various
historical aliases is showing its age.  On some modern distros,
/usr/bin/python is to be positively NOT used.  Fixing configure.ac
$PYTHON3 search to only look for python3, and not even consider
$PYTHON_UNKNOWN.  At some point we'll want to simplify further, and
get rid of python2 remnants.

autoconf: version bumps for the next release-4.7

version bumps for the next release-4.7

systemtap.spec: release-4.6 w/correct date

NEWS: release-4.6

systemtap.spec: actually add the wiki link

systemtap.spec: release-4.6

PR28449: runtime/transport: bump up _stp_subbuf_size to 64K

After commit cd48874296, it was reported that the kernel-side I/O
buffers could be exhausted more easily by the some tests in the
testsuite.  This resulted in "bufhdr corrupted ..." type messages
coming from the syscall.exp test case for example.

We bump up the $subject variable, so without "stap -s XYZ", the
default kernel->user transport will consist of 256 subbufs of 64K
each, per cpu.  (When a user does supply -s XYZ, the number gets
overridden, and the subbuf size may be quite a bit larger.)  With the
new default, the syscall.exp suite runs bufhdr-clean on an 8cpu box.

PR28557: module probe insertion on modern kernels

For reasons not completely understood, kernels in the 5.* range have
stopped taking module kprobes registrations of the form the runtime
has offered them.  New code in runtime/linux/kprobes.c
(stapkp_prepare_kprobe) now tried to fully relocate addresses itself,
rather than letting the kernel try it with symbols / kallsyms.

Added more diagnostic prints in nearby symbol/kprobe code paths and a
few more error checks in transport.

pre-release-4.6: tested kernel versions

NEWS: clarify liveness analysis entry

NEWS: couple more bpf additions

pre-release-4.6: regen examples index

pre-release-4.6: regen docs

pre-release-4.6: make update-po

AUTHORS: new authors for release-4.6

Add NEWS blurb about riscv64 support.

procfs_bpf.exp PR28544: fix string handling error

This was causing a procfs_bpf.exp failure on recent RHELs
as a non-zero-padded string passed from the procfs pipe
caused buffer garbage to be passed to the stap script.

man/stap.1.in stapregex: clarify POSIX ERE features

Although stapregex was based on re2c, its current feature set implements
POSIX Extended Regular Expressions. However, a lot of POSIX ERE docs
that come up in a web search include extra stuff (e.g. the Boost doc).
Refer the user more clearly to egrep(1) for the exact list of features.

pass-2 elaborate: autocast: suppress "Potential type mismatch in reassignment"

Analysis indicates this warning is not that helpful, and extra
diagnostics just added for autocasting should help work around
polymorphism issues that this warning would have identified earlier.

Add -faligned-new to CXXFLAGS when available to compile dyninst 10.1 code

Fedora 30 and 31 have Dyninst 10.1.  The code added to dyninst
by commit a00056bec6a0265afb592944dde2ff461b525e8d makes some data
structures cache aligned (128 bytes).  The c++ compiler ends up flagging that
as an error:

  CXX      stap-analysis.o
/notnfs/smakarov/stap-checkout/analysis.cxx: In constructor ‘analysis::analysis(std::string)’:
/notnfs/smakarov/stap-checkout/analysis.cxx:59:37: error: ‘new’ of type ‘Dyninst::ParseAPI::SymtabCodeSource’ with extended alignment 128 [-Werror=aligned-new=]
   59 |  sts = new SymtabCodeSource(name_str);
      |                                     ^
/notnfs/smakarov/stap-checkout/analysis.cxx:59:37: note: uses ‘void* operator new(std::size_t)’, which does not have an alignment parameter
/notnfs/smakarov/stap-checkout/analysis.cxx:59:37: note: use ‘-faligned-new’ to enable C++17 over-aligned new support
cc1plus: all warnings being treated as errors
make[2]: *** [Makefile:1724: stap-analysis.o] Error 1

To make the compiler happy adding a -faligned-new option to the
CXXFLAGS when it is available.  This issue does not affect later
releases of dyninst as the problem code was removed from dyninst in
git commit d233ae7596cd74201d634c2f0f7d7a0e3d628e79.

dwarf type details: trace at -v level 5

Our type-detail inference (tagging some staptree nodes with DWARF DIE
pointers) in pass 2 was not very verbose about its work, making
type-mismatch warnings harder to diagnose.  Add a ::print() virtual
function to exp_type_details() and derived classes.  Call it from
resolve_details(), renamed from resolved_details().

runtime: port to kernel 5.15-rc

get_mm_exe_file got unexported.  Deal with it the usual way.

configury: fix -ltbb for DYNINST_LIBS

Some versions/builds of dyninst don't require -ltbb, and it is
unavailable on some platforms.  So look for it conditionally.

staprun/relay.c: bypass compiler warning

Newly added code did a read(2), deliberately ignoring how many bytes
were read.  Some gcc versions complain.  Phrase the same operation
differently to make gcc happier.

PR28449: fix cross-cpu message ordering

Correct unintended loss of cross-cpu message total-ordering via commit
8819e2a04596d by packetizing normal printf() traffic.  This also
restores bulk mode / stap-merge operation to same as before.  staprun
now has a builtin merge equivalent built on threads, with some
message-loss fault-tolerance.  A new "dumpalot" test produces ample
output with varying "-s BUFFER" runs.  While in the vicinity, the old
"relay_old.c" (<=rhel5) file is nuked; it was not even compiled.

systemtap.base/labels.exp: also accept 'Child process exited'

Finding more testcases which fail due to new 'Child process' status warnings.
Here the test program returns status 1 so the failure is spurious.

Add info about guru-mode checks and syscall_any tapset changes to NEWS.

Adjust analysis code to compile with older Dyninst 9

The Block getInsn method and InsnLoc constructor have different
signature in older Dyninst 9.  To hide those differences between
version of Dyninst just put the method invocation in the constructor
and let the compiler figure out which type the parameter is.

Update test_unused.exp to match current unused variable analysis output.

Tolerate dyninst10's need for -lboost_system in analysis.cxx

The analysis code uses dyninst.  As a result the new analysis code in
the translator will need to link in the boost_system library like
commit 891810c246d6de05a2df80c5b3e9f9aaa13231f7 does for stapdyn.

Make the liveness warning 32-bit agnostic

On 32-bit platforms Dwarf_Addr is long long unsigned int which doesn't
match the %lx (long unsigned int) print format to print the warning.
Cast the variable as (void *) so %p format can be used to print its
value on both 32-bit and 64-bit platforms.

Assert that anything other than 32-bit or 64-bit processors will not be seen

One last diagnostic print to remove.  In this case the mapping between
dwarf register and Dyninst register name needs to take into account
whether this is 32-bit or 64-bit code.  However, there is a default in
the switch case to catch the anything other than 4 or 8 bytes.  If the
code see something other than one of those two values, something is
very wrong.  Figured best to just have an assert stop things, so the
problem is examined.

Remove developmental diagnostic output in code.

Add caching for the liveness data structure

Dyninst already caches information to make future queries at the same
location less expensive for an executable.  Thus, it is enough for the
code to cache the LivenessAnalyzer data on a per executable basis.
This information is stored in the cachedLivenessInfo member of
LivenessAnalyzer class.

Cache the dyninst of the binaries

Reading and processing the binary with dyninst can take a lot of time
(and space).  Added caching to avoid repeated processing of the same
binary.

Add a test to check that the liveness analysis is reporting unused variables.

Use the elf_path in mod_info as that always points to the executable

For kernel probes q.dw.module_name just lists "kernel" rather than
the actual path to the binary.  The mod_info elf_path has more accurate
path to the actual executable, using that instead.

Remove the unused attribute now that the location_context is used by liveness.

Output warning message when liveness detect write to dead variable.

Eliminate unnecessary CodeRegion discovery

Documentation on findFuncs method seemed to require a CodeRegion passed in.
However, Dyninst developers said in this case can just pass in a NULL
(https://github.com/dyninst/dyninst/issues/1102).  Simplified
the code to eliminate the uneeded CodeRegion information.

Do liveness analysis after location information set and use regno info

Initially the call to the liveness analysis was being done before
the location information was setup.  Relocated the call after the
location information has been setup.

Corrected liveness analysis code to use the register number.  Also
added print out the function the liveness analysis is being run on.
Note that for probes on inlined functions this name will be different
than the probe point function name, it will be the actual function
that the code was inlined into.

Add register mappings for aarch64 and powerpc architectures

Add support to handle 32-bit x86 binaries

Dyninst liveness analysis treats the analysis of 32-bit x86 and 64-bit
x86_64 code differently.  In dyninst the register names are different.
Thus, trying to get the liveness results for rdi (the 64-bit register
name) on 32-bit analysis will fail.  The analysis also needs to treat
32-bit and 64-bit a bit differently as there are difference in the
calling ABIs.

Right now the code dummy up using edi/rdi register which is the holds
the first argument in the register.  Doing this because the
location_context cts doesn't hold information outside the variable name.

Show the liveness information at points being probed

This code is work-in-progress and to check whether the liveness
analysis is working.  Currently, the location context information for
the variable isn't being passed in and the setup of that is disabled.

Move HAVE_DYNINST setting back to original/correct place.

Update configure machinery and add files to hold Dyninst analysis

The analysis uses tooling in Dyninst to do the analysis. However,
Dyninst is not available for some architectures. Needed to make the
configuration machinery only enable the Dyninst-based analysis for
supported machines such as x86-64 and aarch64.

The analysis.cxx is not currently connected to anything and doesn't do
any analysis.  For the moment it uses a couple Dyninst functions
verify that Dyninst libraries are being linked in.  This has been
tested to compile on both architectures that support Dyninst (x86_64)
and do not support Dyninst (32-bit Arm).

Add symbolic link so syscall_any tapset works for riscv bpf backend.

Update the syscall<->number mappings for syscall_any and add bpf support

Update syscall_any number<->name maps to include syscallent-common.h entries.

Some syscalls information had been moved to syscallent-common.h in
the strace code.  Need to use the #include in the syscallent*.h files
to get those entries.

Pull in the includes to get strace syscall info from syscallent-common.h

There are now a number of syscall in strace that are described in
src/linux/generic/syscall-common.h which is pulled into a number of
different architecture syscallent*.h includes.  Don't want to miss
those additional syscalls in the mappings.

stap_run.exp: accept 'WARNING: Child process exited due to signal'

This was causing numerous spurious FAIL outcomes on RHEL[89].
The extra "WARNING: Child process exited due to signal" is not an error,
it's merely stap communicating to the user that the child
process was interrupted, which is exactly what we do.

Not sure why it's printed on some systems and not others.
XXX There may be a deeper issue in that the tiny do-nothing binary
probed by the testcase (e.g. testsuite/systemtap.base/at_register.c)
was supposed to stop on its own and didn't.
Adding a delay to the first kill -INT $mypid makes the problem
more obvious.

Support softfloat by dyninst backend.

The softfloat library has conflicting types for some types defined in
stdint.h, which -dyninst includes, so avoid by using cpp to redefine
them.  Add a float test to sdt_types.c.  Only test dyninst with
V3_uprobe.  Add x8664 float registers to register definition used by
dyninst.

BZ2012907 systemtap.spec: use sysuser.d/* for user/group management

Newer systemd systems (Fedora 32+) have an a declarative mechanism for
creation of system users/groups, instead of groupadd/useradd calls in
the %pre scripts.  Switch to this scheme for modern enough systems.

https://systemd.io/UIDS-GIDS/
https://fedoraproject.org/wiki/Changes/Adopting_sysusers.d_format

Allow stopwatch example to run with bpf backend.

Add various tapset/bpf files (and links) to support syscall_any for BPF

Update syscall_num.stp mappings between syscall number and name

Need to generate new versions of syscall_num.stp files that include
the preprocessor architecture guards so multiple syscall_num.stp
can be used by BPF code at the same time.

This is also using a more recent version of strace-code (ommit
940f7c9f71dd0514b933874c7b02230e0dd7dfd1) to include newer syscalls
in the mappings.

Allow multiple architecture syscall_num.stp files to be used by bpf backend

Systemtap's BPF still has the concept of target architecture and isn't
write once run anywhere for BPF code.  Thus, to make the syscall_any
tapset work the tapset needs to have all the different architecture
initialization code available and select the appropriate one based on
the architecture.  Thus, each syscalls_num.stp file has preprocessing
guards to make them empty unless the architecture matches.

Update dump-syscalls.sh to work with newer strace-code

There have been some changes in the strace-code:
-Header files now in strace-code/src/linux/*/syscallent.h
-mips headers use BASE_NR and file needs to be massaged to get numeric value
-corrected the name of riscv architecture name to riscv64

Add support for s390 floating point registers

Add float registers.  Add move from float register to general
register.  Allow an sdt argument to be a float register.

staprun: don't colorize the space following the warning/error tags

Brings the colorization back in line with the old behavior.

staprun: make the previous commit obey the color_errors switch again

The color_errors check inside print_color() was not preserved. Fix it.

staprun: fix warning/error/dbug eprintf() races causing garbled output

There are lots of races when printing warnings/errors/dbugs in staprun
because multiple eprintf() calls are used to print a single message and
stderr is not line-buffered. As a result, warnings/errors/dbugs race with
the relayfs reader threads printing to stdout and with other stap scripts
running concurrently in the same PTY. This causes the messages printed to
stderr and stdout to be garbled.

Fix all of this by using a single eprintf() for each warning/error/dbug
message, and by making stderr line-buffered so that we don't need to worry
about differing libc implementations potentially flushing a single message
in chunks rather than flushing the whole message in one go.

runtime: make _stp_vlog() more robust to avoid truncating log messages

Currently, _stp_vlog() very readily drops or truncates warnings, errors,
and debug messages. In the case of warnings and errors, this is quite
problematic because these messages are of high importance and, as such,
are even sent to stapio via the control channel rather than the relay
transport.

The reason why _stp_vlog() truncates and even drops these messages so
easily is twofold: the normal print buffer is used directly without any
attempt to flush it when there isn't enough space and it's used as
temporary storage for warnings and errors.

When warnings and errors are sent to the control channel, they are
copied into a new buffer, which is wasteful due to the copy operation
and the effort put into scrounging for space in the print buffer.
Instead of using a temporary buffer to construct warnings and errors,
it's more reliable and efficient to construct the message in one of the
control channel's buffers that would've been used anyway to send the
message.

In the case of debug messages, the print buffer can take appropriate
steps to ensure there's enough space via _stp_reserve_bytes(). Now, the
length of a debug message is calculated before it's generated, making it
possible to use _stp_reserve_bytes().

Altogether, this makes _stp_vlog() very resistant to losing both normal
debug messages and high-priority warning and error messages.

PR27829: Support floating point values passed through sdt.h markers

Add the type to the individual arg entries in the .notes.stapsdt section;
currently SP@A, where S is optional '-' sign, P is precision of type and A is
address.  Revised format is SPT@A where T is optional 'f' for float variables.
Add x8664 float registers xmm8 - xmm15 and aarch64 float registers v8 - v31.
Parse the type field; result is currently ignored.  asm statements are
restricted to 30 arguments; sdt probes can have up to 12 arguments.  To fit
this into a single asm statement, precision and type are encoded into a single
field: 0xSSTT where SS is the precision and TT is the type as encoded by
__builtin_classify_type.  The sign S, precision P, and type T are decoded by
_SDT_SIGN, _SDT_SIZE, and _SDT_TYPE.  Test that the revised
.notes.stapsdt section interacts correctly with eu-elfutils and gdb.

testsuite traceaio.c

Add simple test program calling io_submit() with several iocbs, testing
handling or PWRITE, PREAD, PWRITEV, and PREADV.

The test can be run manually by compiling the program, running it with
"stap -c", and inspecting the generated trace.

With more work, this can be used in "make installcheck", and verified
using expected output file.

Signed-off-by: Nir Soffer <nsoffer@redhat.com>

Fix traceaio with IO_CMD_{PREAD,PWRITE}

IOCB_CMD_PREADV was used twice, skipping logging of iovecs for
IOCB_CMD_PWRITEV.

Signed-off-by: Nir Soffer <nsoffer@redhat.com>

traceaio example: tweak @cast and IOCB_CMD_*

Make this test case operable without kernel debuginfo by using
@cast( ..., "kernel<header>") to extract iocb / iovec decls
from headers.  Rename IO_CMD_* values to IOCB_CMD_* to match
linux aio_abi.h

Fix traceaio with IO_CMD_{PREAD,PWRITE}

When using IO_CMD_{PREAD,PWRITE} aio_nbytes is the size of a single
buffer aio_buf.

Previously the script logged unrelated memory contents from userspace:

[     0 sanlock(8214):] io_submit(140589225578496, 1, 0x7fdd5fefc718)
    iocb[   0]=0x7fdd58000b70, fd=16, opcode=0, offset=0, nbytes=1048576, buf=0x7fdd5c5f6000
        iovec[   0]=0x7fdd5c5f6000, base=0x3000412212010, len=16
        iovec[   1]=0x7fdd5c5f6010, base=0x0, len=1
        iovec[   2]=0x7fdd5c5f6020, base=0x1, len=16
        ...

Now we trace iovecs only when using IO_CMD_{PREADV,PWITEV}:

[     0 sanlock(8397):] io_submit(140589225566208, 1, 0x7fdd5e6f9718)
    iocb[   0]=0x7fdd48000b70, fd=19, opcode=0, offset=0, nbytes=1048576, buf=0x7fdd5c3f2000
[     0 sanlock(8397):] io_submit(140589225566208, 1, 0x7fdd5e6f9718)
    iocb[   0]=0x7fdd48000b70, fd=19, opcode=1, offset=512, nbytes=512, buf=0x7fdd4810a000

Signed-off-by: Nir Soffer <nsoffer@redhat.com>

PR28384: convert more nfs_proc.stp server_ip to string

This tapset variable has been changed in stap version 4.3
to a string.  Finish covering all instances in various
probe aliases.

Add traceaio example

Show how to trace arguments to io_submit. This is useful to debug EINVAL
errors, for example when number of iovecs exceeds limits.

Signed-off-by: Nir Soffer <nsoffer@redhat.com>

Correct RISC-V handling of SDT markers and document their format.

Fix races in perf probe task finder callback

The task finder callback for a perf probe can run concurrently across
different tasks' workers, resulting in redundant registrations since
_stp_perf_init() and _stp_perf_del() lack synchronization. This results
in the redundant perf events never being removed and a use-after-free
scenario occurring in the kernel's core perf code after the stap module
is unloaded. Adding a mutex lock to the task finder callback fixes the
issue.

This fixes the following crash:
BUG: unable to handle page fault for address: ffffffffc045a777
#PF: supervisor instruction fetch in kernel mode
#PF: error_code(0x0010) - not-present page
PGD 2a15067 P4D 2a15067 PUD 2a17067 PMD 1c4a96067 PTE 0
Oops: 0010 [#1] SMP NOPTI
CPU: 5 PID: 78029 Comm: cat Tainted: G           OE     5.13.9 #78
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS ArchLinux 1.14.0-1 04/01/2014
RIP: 0010:0xffffffffc045a777
Code: Unable to access opcode bytes at RIP 0xffffffffc045a74d.
RSP: 0018:ffffc900001d8d80 EFLAGS: 00010046
RAX: ffffffffc045a777 RBX: ffff8881e60f2ee0 RCX: ffffc9000403fc18
RDX: ffffc9000403fc18 RSI: ffffc900001d8dc0 RDI: ffff8881e60f2ee0
RBP: ffffc900001d8db0 R08: 00000000ffffffff R09: 0000000000000000
R10: 0000000000000000 R11: ffffc900001d8ff8 R12: ffffc900001d8dc0
R13: 0000000000000000 R14: ffffc9000403fc18 R15: 0000000000000000
FS:  0000000000000000(0000) GS:ffff888237b40000(0000) knlGS:0000000000000000
CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: ffffffffc045a74d CR3: 0000000002a10005 CR4: 0000000000370ee0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
 <IRQ>
 ? __perf_event_overflow+0x60/0xd7
 ? __perf_event_overflow+0xd7/0xd7
 perf_swevent_hrtimer+0xd3/0x147
 ? nohz_balancer_kick+0x35/0x221
 ? tick_sched_do_timer+0x5a/0x5a
 ? trigger_load_balance+0x41/0x54
 ? scheduler_tick+0x132/0x153
 ? __pv_queued_spin_lock_slowpath+0x115/0x1c1
 ? timerqueue_del+0x24/0x49
 ? __remove_hrtimer+0x3c/0x6c
 __run_hrtimer+0xd3/0x166
 __hrtimer_run_queues+0x67/0x76
 hrtimer_interrupt+0xea/0x21e
 local_apic_timer_interrupt+0x2e/0x54
 __sysvec_apic_timer_interrupt+0x6e/0xb2
 sysvec_apic_timer_interrupt+0x73/0x83
 </IRQ>
 asm_sysvec_apic_timer_interrupt+0x12/0x20

The /* pc=0x... */ is no longer printed by "stap -v -L 'kernel.function("*")'

The disappeared /* pc=0x... */ resulted from the missing implementation
of the function "dwarf_derived_probe::printsig_nonest".
Which makes "p->printsig_nonest(sig)" in main.cxx end up calling
"derived_probe::printsig_nonest", and the type of "p" is

(gdb) ptype /m p
type = /* real type = dwarf_derived_probe * */

This patch added "dwarf_derived_probe::printsig_nonest" for PC value
print.

https://sourceware.org/bugzilla/show_bug.cgi?id=27940

Signed-off-by: Di Chen <dichen@redhat.com>

Use task_state tapset function to avoid task_struct changes

The Linux 5.14 kernel's task_struct changed the state field to
__state.  The task_state tapset function selects the appropriate
version.  Make the scheduler.stp tapset and schedtimes.stp example use
the task_state function rather than directly trying to access the
task_struct state field (and get it wrong for newer kernels).

tapset: start adopting kernel netif_* tracepoints in netdev.* tapset

Start with netdev.receive.

dwflpp.h: add conditional EM_RISCV define

.... for use on older elfutils

Add dwarfless register access for RISC-V

Add bactrace support for RISC-V

RISC-V dwarf register number to pt_reg mappings

Eliminate the sa_restorer field in sigaction struct for RISC-V.

Avoid generating problematic asynchronous unwind tables on RISC-V

By default SystemTap turns on the generations of asynchronous
unwind tables for all processor.  When this was enabled for RISC-V
kernel modules would be generated, but the resulting kernel modules
would fail to load because the kernel's module loader could not
handle the R_RISCV_32_PCREL relocations in the .ko files.
Disabling the asynchronous unwind tables for RISC-V is a
work around to get things functioning for RISC-V.

Add RISC-V 64-bit processor support

Add the actual RISC-V syscall-number mappings to the tapsets.

Add creation of mappings between syscall names and numbers for RISC-V

RISC-V doesn't have crash available, disable it for rpmbuilds.

Update to newer config.guess to support RISC-V

Use lex_cast instead of to_string when shortening function names.

Revert "runtime: unregister the control channel before cleaning up"

This reverts commit dbe08f1acbdf47718a5f4c2a965b246c778eaac6.

There's a circular dependency because _stp_cleanup_and_exit() may send a
message over the control channel to indicate an issue, like with
_stp_warn(). The reordering thus causes this crash:

BUG: unable to handle kernel paging request at ffff8800ffffffff
IP: [<ffffffff81436c39>] __list_del_entry+0x29/0xd0
PGD 385f067 PUD 0
Oops: 0000 [#1] SMP
CPU: 14 PID: 28496 Comm: staprun-d Kdump: loaded Tainted: GF          OE  ------------ T 3.10.0-1127.19.1.el7.x86_64.debug #1
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS ?-20180531_142017-buildhw-08.phx2.fedoraproject.org-1.fc28 04/01/2014
task: ffff88016f948000 ti: ffff880055a88000 task.ti: ffff880055a88000
RIP: 0010:[<ffffffff81436c39>]  [<ffffffff81436c39>] __list_del_entry+0x29/0xd0
RSP: 0018:ffff880055a8bd18  EFLAGS: 00010006
RAX: ffff8800ffffffff RBX: ffff8800364d8b40 RCX: dead000000000200
RDX: ffff8800364d8cc0 RSI: ffffffffc116e204 RDI: ffff8800364d8b40
RBP: ffff880055a8bd18 R08: 0000000000000002 R09: 0000000000000000
R10: 0000000000000001 R11: 0000000000000000 R12: ffff8800364d8660
R13: ffff8800364d8678 R14: 0000000000000092 R15: 0000000000000000
FS:  00007fcdb6ff7780(0000) GS:ffff880237200000(0000) knlGS:0000000000000000
CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: ffff8800ffffffff CR3: 000000015ed98000 CR4: 0000000000360fe0
DR0: ffffffffc044a0e0 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000600
Call Trace:
 [<ffffffffc116e218>] _stp_mempool_alloc+0x38/0x80 [stap_b0934ab5a589458489ec9c296ca81d66_20480]
 [<ffffffffc1173114>] _stp_ctl_send+0xc4/0x350 [stap_b0934ab5a589458489ec9c296ca81d66_20480]
 [<ffffffffc1172ef3>] _stp_vlog.constprop.133+0xf3/0x1d0 [stap_b0934ab5a589458489ec9c296ca81d66_20480]
 [<ffffffffc1173034>] _stp_warn+0x64/0x80 [stap_b0934ab5a589458489ec9c296ca81d66_20480]
 [<ffffffffc1177b87>] _stp_cleanup_and_exit+0x367/0x410 [stap_b0934ab5a589458489ec9c296ca81d66_20480]
 [<ffffffffc117ea0a>] cleanup_module+0x1a/0xe0 [stap_b0934ab5a589458489ec9c296ca81d66_20480]
 [<ffffffff8115420e>] SyS_delete_module+0x19e/0x310
 [<ffffffff81895d3e>] tracesys+0xa6/0xcc

The original bug that the reorder attempted to fix is already fixed by
166a95089 ("runtime: fix panics when polling on the control channel
while unloading"). That commit doesn't allow delete_module() to run when
there are open file descriptors to the control channel, which guarantees
that the control channel cannot be in use during module cleanup. Thus,
we can simply restore the old ordering.

runtime: fix panics when polling on the control channel while unloading

When the stapio pselect() runs while the given stap module is unloading,
there's a use-after-free opportunity in do_select(). This occurs because
the control channel's poll function, _stp_ctl_poll_cmd(), passes a
pointer to a global variable along to do_select(), which can then
dereference the pointer after the stap module is unloaded.

Normally, this wouldn't be a problem because do_select() uses get_file()
and fput(), which respectively grab and release references to the module
owner specified in `file->f_op->owner`. However, procfs doesn't provide
any interface to pass in a module owner, and instead all procfs files
use an internal `struct file_operations` declared in fs/proc/inode.c.
As a result, we cannot bolster procfs files with module reference
count protection through any normal means, so we must inject a module
owner the hard way.

A module owner is now patched into the control channel's file ops when
the file is opened by making a copy of the existing file ops and then
setting the module owner inside the copy, which then replaces the old
`file->f_op` pointer. This neatly fixes the race because procfs *does*
guarantee that none of the procfs callback functions are still running
after an entry is removed, and because _stp_ctl_poll_cmd() cannot be
reached without first passing through _stp_ctl_open_cmd().

Since delete_module() can now return EWOULDBLOCK, we must make staprun
aware that it's not a fatal error and that the module deletion should
be retried. EWOULDBLOCK simply indicates that a pselect() on the control
channel has yet to finish, so it will go away after a brief wait.

This fixes the following panic:
BUG: unable to handle kernel paging request at ffffffffc0914030
PGD 79820c067 P4D 79820c067 PUD 79820e067 PMD 3f9ee6067 PTE 0
Oops: 0002 [#1] SMP PTI
CPU: 6 PID: 1636475 Comm: stapio Kdump: loaded Tainted: G           OE     4.19.91-22.2.al7.x86_64 #1
RIP: 0010:_raw_spin_lock_irqsave+0x1e/0x40
RSP: 0018:ffffb9fb0e45f980 EFLAGS: 00010046
RAX: 0000000000000000 RBX: 0000000000000246 RCX: 0000000000000000
RDX: 0000000000000001 RSI: ffffb9fb0e45faf0 RDI: ffffffffc0914030
RBP: ffffffffc0914030 R08: 0000000000000001 R09: ffff973fa8924000
R10: 0000000000000104 R11: 0000000000000041 R12: 0000000000000000
R13: ffffb9fb0e45fab0 R14: 000000000000000f R15: 000000000000000f
FS:  00007effdcf53740(0000) GS:ffff97409fb80000(0000) knlGS:0000000000000000
CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: ffffffffc0914030 CR3: 0000000522d42003 CR4: 00000000003606e0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
 remove_wait_queue+0x14/0x60
 poll_freewait+0x37/0xa0
 do_select+0x650/0x740
 ? compat_poll_select_copy_remaining+0x110/0x110
 ? kvm_sched_clock_read+0xd/0x20
 ? sched_clock+0x5/0x10
 ? sched_clock_cpu+0xc/0xa0
 ? select_idle_sibling+0x28/0x400
 ? account_entity_enqueue+0x9c/0xd0
 ? enqueue_entity+0x71f/0xc80
 ? __switch_to_asm+0x35/0x70
 ? enqueue_task_fair+0xd2/0x9b0
 ? remove_entity_load_avg+0x27/0x70
 ? check_preempt_curr+0x6b/0x90
 ? ttwu_do_wakeup+0x19/0x150
 ? try_to_wake_up+0x219/0x580
 core_sys_select+0x1e2/0x320
 ? audit_filter_inodes+0x1f/0xf0
 ? audit_filter_syscall.constprop.11+0x8c/0xd0
 ? __audit_syscall_exit+0x1fd/0x290
 ? kvm_clock_get_cycles+0xd/0x10
 ? ktime_get_ts64+0x46/0xf0
 __se_sys_pselect6+0xf6/0x1b0
 do_syscall_64+0x5b/0x1b0
 entry_SYSCALL_64_after_hwframe+0x44/0xa9

Shorten function names that will exceed the kernel's objtool limit of 128

translate.cxx (c_unparser::emit_global_init_type,emit_function) Shorten
 (c_unparser::c_funcname)  Add funcname_shortened parm, shorten
 name if length limit exceeded

testsuite/systemtap.base/func_definition.{exp,stp}  Add shorten funcname test.

runtime/transport: add a comment blurb for ordering invariant at shutdown

runtime: unregister the control channel before cleaning up

The control channel can still be in use when clean-up occurs, resulting
in a race that's made apparent by these warnings:
------------[ cut here ]------------
double register detected
WARNING: CPU: 10 PID: 47720 at kernel/notifier.c:27 notifier_chain_register+0x35/0x50
 [last unloaded: stap_7cfd458d8a2c43a8bc8489143978f8_47593]
CPU: 10 PID: 47720 Comm: stapio Tainted: G        W  OE     5.12.13-200.fc33.x86_64 #1
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS ArchLinux 1.14.0-1 04/01/2014
RIP: 0010:notifier_chain_register+0x35/0x50
RSP: 0018:ffffc26e4316be58 EFLAGS: 00010092
RAX: 0000000000000018 RBX: 0000000000027348 RCX: ffff9fd837c985c8
RDX: 00000000ffffffd8 RSI: 0000000000000027 RDI: ffff9fd837c985c0
RBP: ffffffffae531550 R08: 0000000000000000 R09: ffffc26e4316bc88
R10: ffffc26e4316bc80 R11: ffffffffadb45f68 R12: ffffffffc08bf1c0
R13: 0000000000000286 R14: 0000000000000000 R15: 0000000000000001
FS:  00007f1414a23740(0000) GS:ffff9fd837c80000(0000) knlGS:0000000000000000
CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007f13ff4e1ef8 CR3: 000000000d92e005 CR4: 0000000000370ee0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
 atomic_notifier_chain_register+0x24/0x40
 _stp_ctl_write_cmd+0x55c/0x9b0 [stap_7cfd458d8a2c43a8bc8489143978f8_47720]
 ? proc_reg_write+0x51/0x90
 ? vfs_write+0xc3/0x270
 ? ksys_write+0x4f/0xc0
 ? do_syscall_64+0x33/0x40
 ? entry_SYSCALL_64_after_hwframe+0x44/0xae
---[ end trace 5a8ca3c0eab5e3b6 ]---

This can be easily reproduced by having a background thread quickly loop
on trying to rmmod any stap modules, resulting in the module's exit
routine running concurrently with the STP_START command from stapio.

Closing the control channel before attempting clean-up fixes this race.

bpf pr23478 :: test non-unique key/val iteration

bpf pr23478 :: test multi-key associative array iteration

rhbz1938312: un-disable bpf.exp after kernel bugfix

Some overzealous audit checking caused kernel deadlock when probing
sensitive tracepoints. The rhbz lists the problem as fixed in 5.12.10.

pr23478 WIP: fixes for existing foreach testcases

pr23478 WIP: rework bpf foreach to handle multi-key array

The major addition is a new ELF section giving details on each
foreach loop in the program, including where the sort column
is located within a composite key.

Previously all the foreach info was packed into a uint64_t
flags parameter to stapbpf's map_get_next_key userspace-only
helper function, which would not work for this nor for future
foreach work (sort_aggr, array slicing).

* bpf-internal.h (BPF_MAXKEYLEN,BPF_MAXKEYLEN_PLUS): new const.
(SORT_FLAGS etc): deprecate, but still read from old .bo files.
(globals::foreach_info): new struct with info for bpfinterp.cxx.
(globals::foreach_loop_info): vector of foreach_info structs.
(typedef interned_foreach_info): serialized foreach_info.
({intern,deintern}_loop_info): [de]serialize foreach_info.
(loop_idx): alias for index into foreach_loop_info vector.
* bpf-shared-globals.h ({intern,deintern}_loop_info): crudely
[de]serialize foreach_info by putting the fields in a vector.

* bpf-translate.cxx (bpf_unparser::visit_foreach_loop): change
to generate foreach_info, handle multi-key array iteration.
(output_foreach_info): serialize foreach_loop_info into a
new 'stapbpf_foreach_loop_info' ELF section.
(translate_bpf_pass): add 'stapbpf_foreach_loop_info' ELF section.

* stapbpf/stapbpf.cxx (foreach_loop_info): global table
of foreach loop information.
(load_bpf_file): load 'stapbpf_foreach_loop_info' ELF section.
(init_perf_transport): add foreach_loop_info to bpf_transport_context.
(main): add foreach_loop_info to bpf_transport_context.
* stapbpf/bpfinterp.h (struct bpf_transport_context): add
field for storing foreach_loop_info data.
(bpf_transport_context::bpf_transport_context): add
field for storing foreach_loop_info data.

* stapbpf/bpfinterp.cxx (struct foreach_state): represent an
in-progress foreach loop iteration including sorted values.
(foreach_info): alias for bpf::globals::foreach_info.
(foreach_state_add): new function.
(foreach_cmp_{str,int}): new functions.
(foreach_state_sort): new function.
(foreach_state_empty): new function.
(convert_key): new function.
(_foreach_state_next,foreach_state_next): new functions.
(foreach_state_cleanup): new function. Avoid C++ destructor.
(typedef foreach_stack): stack of foreach_state, used for
handling nested foreach loop iteration.
(map_get_next_key): rewrite to use foreach_info,foreach_state
and handle multi-key arrays (storing large keys in map_values).
(bpf_interpret): pass map_values to map_get_next_key, to be
used for storing composite keys in addition to values.
(struct map_keys): replaced by struct foreach_state.
(convert_{int,str}_{key,kp}): deleted functions.
(convert_{key,kp}): deleted functions.
(computed_key_size): deleted function.
(map_sort,map_next): deleted functions.

Run task_fd_lookup.exp with --compatible 4.0

Running in --compatible 4.0 mode forces @cast(0, "mount")->mnt_parent
to focus on the kernel module.