[GIT PULL v2] ring-buffer: Updates for v6.15

[Steven Rostedt]

Linus,

I removed the commit that you had issues with (along with a fix for that
commit). This is the rest of that pull request as none of this code had any
dependencies on that work. That code was fixing the persistent buffer to be
memory mapped to user space. That is still disabled with these changes.

After removing those commits, I ran this through my test suite.

ring-buffer updates for v6.15

- Restructure the persistent memory to have a "scratch" area

  Instead of hard coding the KASLR offset in the persistent memory
  by the ring buffer, push that work up to the callers of the persistent
  memory as they are the ones that need this information. The offsets
  and such is not important to the ring buffer logic and it should
  not be part of that.

  A scratch pad is now created when the caller allocates a ring buffer
  from persistent memory by stating how much memory it needs to save.

- Allow where modules are loaded to be saved in the new scratch pad

  Save the addresses of modules when they are loaded into the persistent
  memory scratch pad.

- A new module_for_each_mod() helper function was created

  With the acknowledgment of the module maintainers a new module helper
  function was created to iterate over all the currently loaded modules.
  This has a callback to be called for each module. This is needed for
  when tracing is started in the persistent buffer and the currently loaded
  modules need to be saved in the scratch area.

- Expose the last boot information where the kernel and modules were loaded

  The last_boot_info file is updated to print out the addresses of where
  the kernel "_text" location was loaded from a previous boot, as well
  as where the modules are loaded. If the buffer is recording the current
  boot, it only prints "# Current" so that it does not expose the KASLR
  offset of the currently running kernel.

- Allow the persistent ring buffer to be released (freed)

  To have this in production environments, where the kernel command line can
  not be changed easily, the ring buffer needs to be freed when it is not
  going to be used. The memory for the buffer will always be allocated at
  boot up, but if the system isn't going to enable tracing, the memory needs
  to be freed. Allow it to be freed and added back to the kernel memory
  pool.

- Allow stack traces to print the function names in the persistent buffer

  Now that the modules are saved in the persistent ring buffer, if the same
  modules are loaded, the printing of the function names will examine the
  saved modules. If the module is found in the scratch area and is also
  loaded, then it will do the offset shift and use kallsyms to display the
  function name. If the address is not found, it simply displays the address
  from the previous boot in hex.


Please pull the latest trace-ringbuffer-v6.15-2 tree, which can be found at:


  git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace.git
trace-ringbuffer-v6.15-2

Tag SHA1: 506231bd8ae8677d720f64f7afe438f21d94147e
Head SHA1: 028a58ec154257e618c27fb0eba8d9e30379bc3d


Feng Yang (1):
      ring-buffer: Fix bytes_dropped calculation issue

Jiapeng Chong (1):
      ring-buffer: Remove the unused variable bmeta

Masami Hiramatsu (Google) (5):
      mm/memblock: Add reserved memory release function
      tracing: Freeable reserved ring buffer
      tracing: Fix a compilation error without CONFIG_MODULES
      tracing: Skip update_last_data() if cleared and remove active check for save_mod()
      tracing: Show last module text symbols in the stacktrace

Steven Rostedt (10):
      ring-buffer: Use kaslr address instead of text delta
      ring-buffer: Add buffer meta data for persistent ring buffer
      ring-buffer: Add ring_buffer_meta_scratch()
      tracing: Have persistent trace instances save KASLR offset
      module: Add module_for_each_mod() function
      tracing: Have persistent trace instances save module addresses
      tracing: Show module names and addresses of last boot
      tracing: Update modules to persistent instances when loaded
      tracing: Initialize scratch_size to zero to prevent UB
      tracing: Use _text and the kernel offset in last_boot_info

----
 include/linux/mm.h          |   1 +
 include/linux/module.h      |   6 +
 include/linux/ring_buffer.h |   8 +-
 kernel/module/main.c        |  13 ++
 kernel/trace/ring_buffer.c  | 247 ++++++++++++++++------------
 kernel/trace/trace.c        | 389 +++++++++++++++++++++++++++++++++++++++++---
 kernel/trace/trace.h        |  24 ++-
 kernel/trace/trace_events.c |  40 +++--
 kernel/trace/trace_output.c |   4 +-
 mm/memblock.c               |  66 ++++++--
 10 files changed, 639 insertions(+), 159 deletions(-)
---------------------------