Merge tag 'trace-ringbuffer-v6.15-2' of git://git.kernel.org/pub/scm/linux/kernel...

Pull ring-buffer updates from Steven Rostedt:

 - 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 acknowledgement 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.

* tag 'trace-ringbuffer-v6.15-2' of git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace:
  tracing: Use _text and the kernel offset in last_boot_info
  tracing: Show last module text symbols in the stacktrace
  ring-buffer: Remove the unused variable bmeta
  tracing: Skip update_last_data() if cleared and remove active check for save_mod()
  tracing: Initialize scratch_size to zero to prevent UB
  tracing: Fix a compilation error without CONFIG_MODULES
  tracing: Freeable reserved ring buffer
  mm/memblock: Add reserved memory release function
  tracing: Update modules to persistent instances when loaded
  tracing: Show module names and addresses of last boot
  tracing: Have persistent trace instances save module addresses
  module: Add module_for_each_mod() function
  tracing: Have persistent trace instances save KASLR offset
  ring-buffer: Add ring_buffer_meta_scratch()
  ring-buffer: Add buffer meta data for persistent ring buffer
  ring-buffer: Use kaslr address instead of text delta
  ring-buffer: Fix bytes_dropped calculation issue

diff --cc include/linux/mm.h
Simple merge

diff --cc include/linux/module.h
index d9a5183a9fe711062dc8b3241d54583e1f296808,9a71dd2cb11fdcec6960589dadbc3aada4e3eb31..d94b196d5a34e104d81308df4b150452eb96cdc9
--- 1/include/linux/module.h
--- 2/include/linux/module.h
+++ b/include/linux/module.h
@@@ -771,6 -772,18 +771,8 @@@ static inline bool is_livepatch_module(
  
  void set_module_sig_enforced(void);
  
 -void *__module_writable_address(struct module *mod, void *loc);
 -
 -static inline void *module_writable_address(struct module *mod, void *loc)
 -{
 -      if (!IS_ENABLED(CONFIG_ARCH_HAS_EXECMEM_ROX) || !mod ||
 -          mod->state != MODULE_STATE_UNFORMED)
 -              return loc;
 -      return __module_writable_address(mod, loc);
 -}
 -
+ void module_for_each_mod(int(*func)(struct module *mod, void *data), void *data);
+ 
  #else /* !CONFIG_MODULES... */
  
  static inline struct module *__module_address(unsigned long addr)
@@@ -878,6 -891,15 +880,10 @@@ static inline bool module_is_coming(str
  {
        return false;
  }
 -static inline void *module_writable_address(struct module *mod, void *loc)
 -{
 -      return loc;
 -}
 -
+ 
+ static inline void module_for_each_mod(int(*func)(struct module *mod, void *data), void *data)
+ {
+ }
  #endif /* CONFIG_MODULES */
  
  #ifdef CONFIG_SYSFS

diff --cc kernel/module/main.c
index debeb0eb15d7ea6dcf9bea308c17e5c180a48922,927a2e0ffd5fb54f041b04bf2b8587e9d0a86a72..a2859dc3eea66ec19991e7e4afb5bbcae2c2d167
--- 1/kernel/module/main.c
--- 2/kernel/module/main.c
+++ b/kernel/module/main.c
@@@ -3740,10 -3800,28 +3740,23 @@@ lookup
   */
  bool is_module_text_address(unsigned long addr)
  {
 -      bool ret;
 -
 -      preempt_disable();
 -      ret = __module_text_address(addr) != NULL;
 -      preempt_enable();
 -
 -      return ret;
 +      guard(rcu)();
 +      return __module_text_address(addr) != NULL;
  }
  
+ void module_for_each_mod(int(*func)(struct module *mod, void *data), void *data)
+ {
+       struct module *mod;
+ 
+       guard(rcu)();
+       list_for_each_entry_rcu(mod, &modules, list) {
+               if (mod->state == MODULE_STATE_UNFORMED)
+                       continue;
+               if (func(mod, data))
+                       break;
+       }
+ }
+ 
  /**
   * __module_text_address() - get the module whose code contains an address.
   * @addr: the address.

diff --cc kernel/trace/ring_buffer.c
Simple merge

diff --cc kernel/trace/trace.c
Simple merge

diff --cc kernel/trace/trace.h
Simple merge

diff --cc kernel/trace/trace_events.c
Simple merge

diff --cc kernel/trace/trace_output.c
Simple merge