translator: in -u (unoptimized) mode, don't merge identical probe handler bodies

Normal optimized mode can make it difficult to see which stap probe
was being invoked for which C probe handler body, as identical probe
handlers are reused.  This is inconvenient if one just has a kernel
crash backtrace to start from from.

* translate.cxx (emit_common_header, emit_probe): In -u mode,
  eschew duplicate probe handler body elision.

Fix PR17275 by fixing testcase problems on s390x.

* testsuite/buildok/memory-all-probes.stp: Tweak test to avoid overly
  broad wildcards, which can cause the test to fail on systems without
  uprobes (like s390x).
* testsuite/buildok/tcp-all-probes.stp: Ditto.

PR16716 partial fix: Fix types in 'syscall.{mmap[2],[p]poll}'.

* tapset/linux/syscalls.stp (syscall.mmap2): Fixed type.
* tapset/linux/nd_syscalls.stp (nd_syscall.mmap2): Ditto.
* tapset/linux/syscalls2.stp: Fixed types in syscall.poll, syscall.ppoll,
  and syscall.compat_ppoll.
* tapset/linux/nd_syscalls2.stp: Ditto.
* tapset/linux/aux_syscalls.stp (_mremap_flags): Updated and improved.
  (get_mmap_args): Fixed type.
* tapset/linux/i386/syscalls.stp: Fixed types in syscall.mmap2.
* tapset/linux/i386/nd_syscalls.stp: Ditto.

* tapset/linux/ia64/syscalls.stp: Fixed types in syscall.mmap and
  syscall.mmap2.
* tapset/linux/ia64/nd_syscalls.stp: Ditto.
* tapset/linux/powerpc/syscalls.stp: Ditto.
* tapset/linux/powerpc/nd_syscalls.stp: Ditto.
* tapset/linux/x86_64/syscalls.stp: Ditto.
* tapset/linux/x86_64/nd_syscalls.stp: Ditto.
* tapset/linux/s390/syscalls.stp: Ditto.
* tapset/linux/s390/nd_syscalls.stp (get_32mmap_args): Updated and fixed
  types.
* testsuite/buildok/syscalls2-detailed.stp: Made syscall.uselib tests
  optional, since rawhide kernels have dropped the syscall.
* testsuite/buildok/nd_syscalls2-detailed.stp: Ditto.
* testsuite/systemtap.syscall/mmap.c: Added more tests.
* testsuite/systemtap.syscall/poll.c: Ditto.
* testsuite/systemtap.syscall/recv.c: Ignore error code.

stap_run.exp: avoid propagating PR17274

hrtimer/kprobes_onthefly.exp: use process.function only if supported

We should test for uprobes support before testing with the
process("echo").function probe.

Improve on-the-fly initialization code.

* translate.cxx (c_unparser::emit_probe_condition_initialize): Only output
  'cond_enabled' field initialization if the probe isn't always enabled.
  (translate_pass): Always initialize 'cond_enabled' to 1. This can get
  overridden by the output of
  c_unparser::emit_probe_condition_initialize().

PR17242 extra: Remove _stp_register_regs() from x86_gs test

PR17242 extra: Change dangling _stp_register_regs() function to init probes.

* tapset/i386/registers.stp: Convert the _stp_register_regs() function to
  an init probe.
* tapset/powerpc/registers.stp: Ditto.

Add perf.return functionality to ltrace.stp.

* ltrace.stp (filter_p, arg, report, begin, end):  New
(process.plt, process.plt.return): Handle return value.
(end): Display summary statistics.

* perf.sh (poly): Add guard for negative and too large values.

runtime: plea with the gods for a lockless stp_print_flush

PR17260: Use get_context to guard stp_print_flush's lock

Holding a context ensures that any probes triggered in the interim will
be considered reentrant and skipped, since such a nested probe might
have recursed on that spinlock.  We faced a similar situation before
with _stp_ctl_send and all the locks it touches.

Reverts "PR17260: make stp_print_flush use spin_trylock instead of
spin_lock", commit 80c97a2fab46b9d6213d93d63e18d6fd2cbd88f1.

translator: fix function-call actioncount optimization regression

commit #765e6976 accidentally emitted actioncount-tracking code in the
wrong place in the function-call sequence.

* translate.cxx (visit_functioncall): Move it up a wee little bit.

PR17260: make stp_print_flush use spin_trylock instead of spin_lock

This risks "WARNING: NNNN transport failures..." messages at stap
shutdown, but appears to work around this particular reentrancy
problem.

testsuite: switch from kernel.function("copy_flags") -> "copy_signal"

The former was retired in kernel commit #514ddb446c; the latter
exists as far back as RHEL4.

PR10995: stapprobes.3stap: armability corrections from jlebon

PR10995: extend man pages re. arming/disarming

statement.nearest probes followup: some docs, samples, tweakage

* NEWS: Mention it.
* man/stapprobes.3stap: Document it.
* testsuite/systemtap.examples/*: Use it.
* testsuite/systemtap.*/: Baby test it.
* dwflpp.cxx: Drop debugging statement and make a speech.

dwflpp: register statement.nearest suffix

If a line number is given in 'statement', line records in dwarf may not
be found for a given line number.
In this case, alternative line numbers were suggested and exited.

With statement.nearest suffix, a kprobe is inserted into the nearest
line number that is available in dwarf line record.

 * dwflpp.cxx(dwflpp.cxx::insert_alternative_linenos): Add a new method,
       Add an arg "has_nearest" in dwflpp::iterate_over_srcfile_lines
 * dwflpp.h(dwflpp.cxx::insert_alternative_linenos): Ditto.
 * tapsets.cxx: Add a new suffix statement.nearest

Signed-off-by: Honggyu Kim <hong.gyu.kim@lge.com>

Merge branch 'jlebon/onthefly' (PR10995)

This branch adds support for on-the-fly probes as described in PR10995.
It also includes various minor fixes as well as a new file
runtime/linux/kprobes.c which hosts kprobes-related code (rather than
being dynamically emitted from tapsets.cxx).

NEWS: add blurb for on-the-fly

pr13306.exp: adapt to new timing report

on-the-fly: don't use background timer if hrtimers missing

On older systems (< 2.6.17), hrtimers are not supported. Guard code
related to the background timer with this check so that we can at least
still compile code on these older platforms.

on-the-fly: only start background timer if needed

Rather than always starting the background timer, only start it when it
is needed. That is, start the background timer when a probe which has an
effect on the conditions of probes which support on-the-fly operations
isn't a safe context for calling schedule_work() (determined by
otf_safe_context()).

make schedule_work() call depend on otf_safe_context()

Now that each probe group directly describes whether their context is
safe for workqueue manipulations, we can directly emit in the probe
epilogue a call to schedule_work() if the probe is safe, rather than
doing it on a case-by-case basis.

on-the-fly: make support a property of group rather than probe

Support for on-the-fly operations is more a property of the
derived_probe_group (which does the actual emitting), rather than
derived_probe.

For example, not because a dwarf_derived_probe supports on-the-fly
operations does it mean that a uprobe_derived_probe (which inherits from
dwarf_derived_probe) does. Similarly, a uprobe_derived_probe's support
for on-the-fly operations depends on the actual code emitted by the
group, which will emit different things depending on whether we're using
utrace or inode-uprobes for example.

To do this, we introduce a 'group' attribute which remembers to which
group a derived_probe has been added. This is then used during
translation time to check if the probe group supports on-the-fly
operations.

This patch also introduces otf_safe_context(), which determines whether
the context of the probe type is safe enough for direct workqueue
manipulations. This then allows us to only use the background timer if
the probe doing the toggling does not support workqueue manipulations.

implement STP_ON_THE_FLY_INTERVAL

split linux/timer.c into .c and .h

For the background timer, it is useful to have some of the definitions
currently sitting in linux/timer.c. Split it into a header file and
include the header.

on-the-fly: use a background timer to schedule work

Calling schedule_work() is not always safe from some contexts (e.g. when
tracing/probing the internals of workqueues themselves).

We remove the code which previously called schedule_work() in the common
epilogue of all probe types. We will need to vet on a case-by-case basis
which probe types are safe.

Meanwhile, we implement a background timer which simply checks if
schedule_work() needs to be called.

affection.exp: also check probe globals locking

In light of the locking issue mentioned in the previous commit, this
commit now updates affection.exp so that locking is also checked to
ensure probes lock the right vars for the right access.

on-the-fly: read-lock visited globals

If we have the following situation

   probe X if (a || b) {...}
   probe Y {a = ...}
   probe Z {b = ...}

then we will have Y write-locking a and Z write-locking b, but because
these variables affect X's condition, the cond_enabled of X will be
re-evaluated in the out: path of both Y and Z. This means that it could
happen that Y tries to read b at the same time as Z updates it, and
vice-versa.

This patch ensures that Y and Z also read-lock b and a, respectively. It
does this by making the varuse collector also visit the conditions of
probes who we can affect.

on-the-fly: use atomic_t for need_module_refresh

The need_module_refresh global can get written to in two different
locations at the same time. To avoid getting a messed up value, use
atomic_t operations.

Concurrency-wise, in the worse case, we get work scheduled twice rather
than once only.

uprobes_onthefly.exp: new testcase

kprobes_onthefly.exp: new testcase

hrtimer_onthefly.exp: new testcase

onthefly_common.tcl: new file for on-the-fly testing

This Tcl file contains a library of common procs for on-the-fly testing.
Other testcases will source it.

affection.exp: new testcase

kprobes.c: add DEBUG_KPROBES to monitor kprobe [un]registration

This re-implements the functionality added by the the initially reverted
commit 9108b75 (revert commit fd777b5).

kprobes.c: link stap_dwarf_probe to stap_dwarf_kprobe

Prior to PR5673, the stap_dwarf_kprobe struct was embedded in the
stap_dwarf_probe struct. It was then moved out due to issues mentioned
in PR5673.

In this patch we simply add back a pointer member in stap_dwarf_probe to
its own stap_dwarf_kprobe so that they may never be mistakenly shared.
This also greatly simplifies many of the function signatures which
previously took in the stap_dwarf_probe and the stap_dwarf_kprobe as
separate parameters.

kprobes.c: memset also after batch unregistration

We should not only clear the kprobe struct after a single
unregistration, but also when batch unregistration is used. (Even though
batch unregistration is normally only done when exiting, but better safe
than sorry!).

kprobes.c: add misses before resetting struct

If we memset before, then all the missed counts will be reset as well.

kprobes.c: remove enabled_p from stap_dwarf_probe

Using the kernel function kprobe_disabled(), we can directly query
whether a kprobe is enabled or not. This makes the enabled_p field
redundant. We replace its use with a stapkp_enabled() function which
simply call kprobe_disabled().

runtime: remove STP_ON_THE_FLY

This patch removes the use of the STP_ON_THE_FLY macro so that
on-the-fly related code is always emitted/executed. When no probes use
conditions, the overhead is quite small: the cond_enabled field of each
stap_probe is set to 1 at start-up.

In general, blocks that were previously incompatible with dyninst and
were behind an STP_ON_THE_FLY guard are now emitted only if !usermode.

The tests were adjusted to not test STP_ON_THE_FLY_DISABLED, which no
longer exists.

on-the-fly: handle non-0/1 probe condition expressions

It is necessary to evaluate a given if(FOO) expression with a !!
prefix in order to turn it into a 0/1 boolean for probe.cond_enabled
matching purposes.  With that done, a 1-bit field for cond_enabled is
sufficient.

kprobes.c: check for kernel version

Support for kprobes enabling/disabling was added in v2.6.30 (kernel
commit de5bd88d). Guard arming related code with this check as well.

bla

kprobes.c: register as disabled instead of post disabling

The register_kprobe() function supports settings the kprobe struct
flags member to KPROBE_FLAG_DISABLED to indicate that we want it
registered but disabled (see also Documentation/kprobes.txt).

This patch takes advantage of this by setting the flags member
accordingly during registration, rather than calling disable_kprobe()
after a successful registration.

PR16861: reset kprobe struct and improve refresh

We need to ensure that the stap_dwarf_kprobe struct is completely
zero'ed out after each unregistration so as not to affect future
registrations which will use the same struct.

We also modify the signature of systemtap_module_refresh so that the
name of the module is passed. This allows us to only update the kprobes
related to that module, rather than checking all of them.

Finally, we also set the priority of the module notifier to 0 to
indicate we don't care in which order we are called (i.e. it shouldn't
matter whether we're called before or after the kprobes callback).

kprobes.c: split stapkp_refresh_probe()

We break down stapkp_refresh_probe() into stapkp_enable_probe() and
stapkp_disable_probe(). We also introduce predicate functions
stapkp_should_enable_probe() and stapkp_should_disable_probe() to
improve clarity.

kprobes.c: refactor stapkp_register_probe()

Here, we split the general stapkp_register_probe into a kprobe and
kretprobe variant, and then further split the work into preparing the
kprobe for registration and actually registering it.

kprobes.c: factor out stapkp_refresh_probe()

We take out everything from stapkp_refresh() related to actual
enable/disable and move it to stapkp_refresh_probe().

kprobes.c: factor out stapkp_unregister_probes()

In this commit, we do a few things:
1. We separate the kprobe nmissed accounting from actual unregistration.
   The stapkp_add_missed() function now solely takes care of this.
2. We abstract away support for bulk unregistration behind one main
   stapkp_unregister_probes() function. This function uses the bulk
   method if supported, falling back on manual one-by-one unregistration
   if not.

kprobes.c: factor out stapkp_unregister_probe()

Factor out the unregistration part of the code in stapkp_refresh() into
the new function stapkp_unregister_probe().

kprobes.c: factor out stapkp_register_probe() [2/2]

This commit and the previous were split in two to make the diff more
legible.

In this commit, we actually replace the code we factored out in
stapkp_init() and stapkp_refresh() by a simple call to
stapkp_register_probe().

kprobes.c: factor out stapkp_register_probe() [1/2]

This commit and the next were split in two to make the diff more
legible.

In this commit, we add a stapkp_register_probe() function which is
directly taken from stapkp_init() (also found in stapkp_refresh()).

kprobes.c: add stapkp_exit()

We move off everything from emit_module_exit() and into a new
stapkp_exit() function.

kprobes.c: add stapkp_refresh()

We move off everything from emit_module_refresh() and into a new
stapkp_refresh() function.

kprobes.c: add stapkp_init()

We move off everything from emit_module_init() and into a new
stapkp_init() function.

kprobes.c: new file for dwarf kprobes handling

This is the first in a series of patches to move off as much of the
static code previously emitted by dwarf_derived_probe_group into a new
runtime/linux/kprobes.c file. This should greatly help legibility and
maintainability. No refactoring will be performed until everything has
been moved over.

In this first patch, we simply move off as much as possible from
emit_module_decls() into kprobes.c.

The one tricky bit is whether the 'module' and 'section' members of the
stap_dwarf_probe struct is a char* or a char[]. This is determined
dynamically, but we use macros to allow us to still declare the struct
in kprobes.c.

uprobes-inode: add stapiu_consumer_[un]register()

To ensure the 'registered' member of the stapiu_consumer struct is
always valid, only make assignments to it in stapiu_[un]register() which
does the actual uprobe_[un]register() call.

uprobes-inode: support on-the-fly [dis]arming

We add support for uprobes arming/disarming:

- Upon finding new target processes, we skip uprobe registration if the
  associated probe handler's condition is not enabled.
- We add new functions stapiu_refresh() and stapiu_target_refresh(),
  which check if any of the uprobes need to be registered or
  unregistered according to the probe handler condition.
- We add the infrastructure needed for the stapiu_refresh() call to be
  emitted if using inode uprobes.

runtime: add spaces in generated source

uprobes-inode: override on_the_fly_supported()

As the first step towards adding on-the-fly support to uprobes, we
override the on_the_fly_supported() method to determine if inode-uprobes
is supported. This requires us to change the signature of the method to
also pass the systemtap_session object.

uprobes-inode.c: only mark as registered if successful

After calling stapiu_register(), we would mark the consumer as
registered even if stapiu_register() failed.

Note that this isn't that dangerous since trying to unregister a
non-registered uprobe does nothing.

runtime: print refresh report when -t given

In addition to printing probe timings, when the -t option is given, info
about systemtap_module_refresh is also given if STP_ON_THE_FLY was
enabled. This gives an idea of the number of times refresh was called,
and the min/avg/max time it took to perform the refresh.

kprobes: support on-the-fly [dis]arming

Using the newly added on-the-fly infrastructure, we turn on support for
kprobes. This entails the following steps:

1. Override derived_probe::on_the_fly_supported() to return true to
   signal that on-the-lfy arming/disarming is supported.
2. Add an enabled_p field to the stap_dwarf_probe struct.
3. Inside systemtap_module_init(), after registering the k[ret]probe,
   disable it right away if the probe handler condition is not met.
4. Inside systemtap_module_refresh():
   - If a new module was inserted, then after registering the
     k[ret]probe, disable it right away if the probe handler condition
     is not met.
   - If the module was removed, then unset the enabled_p field.
   - If the kprobe is currently disabled, but the probe handler
     condition is now true, enable it.
   - If the kprobe is currently enabled, but the probe handler condition
     is now false, disable it.

dwarf_derived_probe_group: improve formatting

No modifications, only formatting of the code for better legibility.

hrtimer probes: support on-the-fly [dis]arming

This patch adds support for on-the-fly arming/disarming of hrtimer
probes. Although it is only supported for non-usermode, there were a few
changes required in dyninst/timer.c so that the same interface is
exposed for both usermode and kernel mode.

runtime/dyninst/timer.c

   - Decouple timer creation from timer starting by factoring out
     _stp_hrtimer_start() from _stp_hrtimer_create().
   - Make _stp_hrtimer_cancel() actually just cancel the timer, and not
     completely delete it.
   - Add new _stp_hrtimer_delete() to delete the timer.

runtime/linux/timer.c

   - Similarly, factor out _stp_hrtimer_start() from
     _stp_hrtimer_create().
   - Add new _stp_hrtimer_delete(), which also does a cancel.

tapset-timers.cxx

   - Declare hrtimer_derived_probe as a probe that supports on-the-fly
     operations.
   - In emit_module_init(): unconditionally create the timer, but if in
     STP_ON_THE_FLY mode, only bother to start it if its condition is
     met.
   - In emit_module_refresh(): check for which timers to start/cancel.

runtime: lock module_refresh with mutex

If STP_ON_THE_FLY is enabled, then we need to ensure that
systemtap_module_refresh() is never run concurrently. Since we use a
workqueue, no concurrency can occur from arm/disarm refreshes alone.
However, the module notifier could fire at any time.

runtime: use workqueue to schedule systemtap_module_refresh()

In this patch, we check in the probe handler common epilogue whether a
module refresh is needed as determined by the probe handlers. If so, we
schedule_work() so that systemtap_module_refresh() is eventually called
to update the necessary probes.

runtime: add DEBUG_STP_ON_THE_FLY and dbug_otf()

translate.cxx: evaluate conditions in module_init and handlers

This patch ensures that the stap_probes[] cond_enabled field is updated
as required: once during systemtap_module_init(), and as needed in probe
handlers that may affect the result of condition evaluation (using the
derived_probe::affected_probe set populated in
semantic_pass_conditions()).

If the new evaluated value of the condition is different from its
previous value, then need_module_refresh is set (if this type of probe
supports on-the-fly arming/disarming), which will be acted upon in a
future patch.

derived_probe: add on_the_fly_supported()

We add a new function derived_probe::on_the_fly_supported(), which
defaults to false. As we add on-the-fly arming/disarming to various
probe types, we simply need to override this function to notify the
runtime that the operation is supported (and thus e.g. to refresh the
module when necessary).

In semantic_pass_conditions(), we now only turn on STP_ON_THE_FLY if one
of the probes with a condition supports it.

runtime: split stap_probe struct definition from stap_probes

Because probe handlers will need to refer to the stap_probes[]
cond_enabled field, we need to define the stap_probe struct prior to the
probe handlers.

This patch achieves this by moving probe emitting in between the
stap_probe struct definition and the actual stap_probes[] array
declaration.

stap_probe struct: add cond_enabled field

The new cond_enabled field represents whether the condition of the
associated probe handler currently evaluates to true or false. This
field will be re-evaluated in probe handlers. This is why we also need
to unconst the stap_probes[] array.

semantic_pass_conditions(): collect affected probes

In anticipation for on-the-fly probe arming/disarming, we change
semantic_pass_conditions() to not only inline the probe condition into
its body, but also to collect, for each probe, the set of probes whose
conditions may change after the probe's handler is run. That set is
stored in the new derived_probe::probes_with_affected_conditions.

These sets will be used by the translator to emit code that will check
whether affected probes should be armed/disarmed after a handler is run.

We also introduce the STP_ON_THE_FLY define which will gate all
on-the-fly related code and will be emitted only if required. Finally,
we have STP_ON_THE_FLY_DISABLED which can be used to disable all
on-the-fly arming/disarming.

emit_module_refresh: print newline in error msg

man/stapprobes.3stap: fix "an an" typo

java probes: remove probe group

Java probes decay to SDT marker probes. There is no Java-specific code
that needs to be emitted during C unparsing and thus no
java_derived_probe_group needed. We remove forward decls to a
non-existent java_derived_probe_group struct and the
java_derived_probes reference in systemtap_session.

Revert "tapsets.cxx: add -DDEBUG_KPROBES tracing option for k*probe [un]registration"

This reverts commit 9108b75e1dcaf8f6b4aa3b961cfabeda4d1d1948.

This functionality will be added back very shortly.

Remove a stowaway debug statement

translate.cxx: use function in place of comparison

translate.cxx: reduce actionremaining after function calls

testsuite: assuage worries of MCE/memory-failure dmesg during syscall tests

PR17249: tolerate early module notifier calls with null mod->sect_attrs

In the case of MODULE_STATE_COMING, we may encounter NULL sect_attrs,
and we must not crash.  Sadly, that case can mean the loss of ability
to probe module-init functions - i.e., breaking the bz6503 test case.

* runtime/transport/symbols.c (_stp_module_notifier): Don't assume
  that mod->sect_attrs is valid.  Treat COMING|LIVE notifications
  similarly, except LIVE should assume init.* gone gone gone,
  she been gone so long, she been gone gone gone so long.

PR17232 take #3: mutex the control messages

As per jistone's advice, simplify control message control by imposing
a mutex over the whole receive-side handling of a ctl message.  That
precludes concurrent or reentrant messages (independent of /ctl
open-time limits or threading assumptions).  It lets the start and
exit handling functions keep track with fewer state variables.

In a way, this elaborates upon a reversion of commit #262f7598.

* runtime/transport/control.c (_stp_ctl_write_cmd): Use a new static
  cmd_mutex for ctl message handling.  Don't bother with counters and
  flags for startedness etc; let the lower level functions handle
  that.  Handle error exits via goto out instead of return to assure
  mutex unlocks.
* runtime/transport/transport.c (_stp_handle_start,
  _stp_cleanup_and_exit): Drop the stp_transport_mutex control,
  explain why unnecessary.  Be more paranoid during module-notifier
  cleanup.

PR17232 variant #2: in runtime, let STP_EXIT nest within STP_START

Uncommitted variant #1 consisted of using module refcounts in the
generated systemtap_module_init/exit function pair to ensure that an
uncleaned module cannot be unloaded.  That precluded cleanup via
rmmod(8), so a robust but inconvenient solution.

This variant #2 consists of a surgical fix, wherein an STP_EXIT
message comes in during an STP_START is used to set an atomic flag for
deferred _stp_cleanup_and_exit() handling.

A variant #3 is coming soon, using a protocol-wide command-message
mutex, like we did back before commit #262f7598.

tapsets.cxx: add -DDEBUG_KPROBES tracing option for k*probe [un]registration

runtime: let _stp_print_flush() talk less on -DDEBUG_TRANS

A 0-length call is very common and uninformative.

regenerate examples index

tapset: explicitly mark probing_32bit_app() long

PR17242: Initialize tapset global arrays early on

Some of the tapset arrays were lazy-initialized on their function's
first call, but that requires the caller to always take a write lock,
and also makes those functions impure.

Now there is a "probe init" alias for the earliest possible begin probe,
and all of these arrays use that alias to initialize their contents.
None of these are big enough to expect noticeable overhead from having
to always initialize them.

Keep perf counters in a vector instead of an unordered map.

* session.h (perf_counters): Use a vector instead of unordered map so
  iteration is in a predictable order.
* tapsets.cxx (visit_perf_op): Use it.
  (dwarf_derived_probe): Likewise
  (emit_probe_local_init): Likewise
  (emit_module_utrace_decls): Likewise
  (emit_module_inode_decls): Likewise
* tapset-perfmon.cxx (perf_builder::build): Likewise
* elaborate.h (perf_counter_refs): Make a set of strings.
* perf.sh:  New test.
* perf.exp: Use it.

stap.1: mention sysrq-x secureboot-disabling keystroke on some kernels

Add Secure Boot blurb to man/stap.1.

PR16716 partial fix: Fix types in 'syscall.{ftruncate,[l]lseek,truncate}'.

* tapset/linux/syscalls.stp: Fix syscall.ftruncate[64], syscall.llseek,
  and syscall.lseek types and nesting.
* tapset/linux/syscalls2.stp: Fix syscall.truncate types, nesting, and
  formatting.
* tapset/linux/nd_syscalls2.stp: Ditto.
* tapset/linux/nd_syscalls.stp: Fix nd_syscall.ftruncate nesting and
  formatting.
* tapset/linux/aux_syscalls.stp (_seek_whence_str): Update.
* runtime/linux/compat_unistd.h: Add '__NR_[gs]etsockopt' defines.
* testsuite/systemtap.syscall/readwrite.c: Add more tests.
* testsuite/systemtap.syscall/trunc.c: Ditto.

NEWS: retroactively add secureboot wiki link

Keep list of perf counters in an unordered list.

* session.h (perf_counters):  Use unordered_map instead of map.
* tapsets.cxx:  Likewise for all perf_counters iterators.

Add scripts to test systemtap probes on a set of kernel functions.

* scripts/kprobes_test/stap_probes_test.py: New script. While debugging
  PR17140, I needed a script to bisect a list of kernel functions to put
  systemtap probes on.
* scripts/kprobes_test/stap_gen_code.py: Ditto.
* scripts/kprobes_test/stap_run_module.py: Ditto.
* scripts/kprobes_test/README: Update with better instructions.
* scripts/kprobes_test/config_opts.py: Update comments.
* scripts/kprobes_test/monitor_system.py: Add beaker system monitoring
  instructions.

Remove dtrace --types sdt_misc test.

* (sdt_misc.exp, sdt_misc_.d):  Remove test for dtrace --types.
* listing_mode.exp: Fix typo.

systemtap.exp: add timer probe to testsuite rc file

Add plt.return probes.

* tapsets.cxx (query_one_plt):  iterate_over_modules instead of
  derive_probes to reduce plt.statement visibility.
  (register_plt_variants): Remove plt.statement  Add plt.return
* plt.exp:  Add test for plt.return
* plt.stp:  Likewise
* list.exp (test_plt_list):  Likewise.
* listing_mode.exp: Remove plt.statement tests  Add plt.return tests
* unprivileged_myproc.exp Likewise.
* unprivileged_probes.exp Likewise.