Refactor documentation for integrating and profiling in-tree kernel drivers, enhancing clarity in titles, overviews, and step instructions.

Author: madeline-underwood

content/learning-paths/embedded-and-microcontrollers/streamline-kernel-module/5_intree_kernel_driver.md

@@ -1,12 +1,12 @@
 ---
-title: Build the in-tree kernel driver
+title: Integrate a custom character device driver into the Linux kernel
 weight: 6
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Build an in-tree Linux kernel driver
+## Overview
 
 Now that you have learned how to build and profile an out-of-tree kernel module, you'll move on to building a driver statically into the Linux kernel. You will then profile it by adding the kernel’s `vmlinux` file as an image in Streamline’s capture settings, rather than the kernel object itself. This allows you to view function calls and call paths as before, and also inspect specific sections of the kernel code that might be contributing to performance issues.
 
@@ -16,7 +16,7 @@ Use the same example character driver you used earlier `mychardrv`. This time, y
 
 Go to your kernel source directory, in our case, it's located in Buildroot's output directory in `$(BUILDROOT_HOME)/output/build/linux-custom`.
 
-Copy the `mychardrv.c` file created earlier to `drivers/char` directory.
+Copy the `mychardrv.c` file created earlier to `drivers/char` directory:
 
     ```bash
     cd drivers/char

content/learning-paths/embedded-and-microcontrollers/streamline-kernel-module/6_sl_profile_intree.md

@@ -10,18 +10,18 @@ layout: learningpathall
 
 Profiling in-tree drivers follows almost the same process as profiling an out-of-tree kernel module. The steps include:
 
-1. Transferring `gator` to the target device using scp.
+- Transferring `gator` to the target device using scp
 
-2. Launching Streamline, selecting TCP view, and entering the target’s IP or hostname.
+- Launching Streamline, selecting TCP view, and entering the target’s IP or hostname
 
-3. Setting up counters and enabling Event-Based Sampling (EBS).
+- Setting up counters and enabling Event-Based Sampling (EBS)
 
 The main difference is that, instead of adding the kernel module’s object file as the capture image in Capture settings, you use the Linux ELF file (vmlinux) generated by Buildroot.
 
-![Streamline Capture settings dialog showing vmlinux selected as the capture image. The dialog displays fields for selecting the capture image, with vmlinux highlighted, and options for configuring counters and event-based sampling. The interface uses a neutral, technical design typical of profiling tools. The wider environment includes other Streamline configuration tabs and settings. Visible text includes Capture settings, Capture image, and vmlinux. alt-text#center](./images/img11_vmlinux_capture_settings.png)
+![Streamline Capture settings dialog showing vmlinux selected as the capture image. The dialog displays fields for selecting the capture image, with vmlinux highlighted, and options for configuring counters and event-based sampling. The interface uses a neutral, technical design typical of profiling tools. The wider environment includes other Streamline configuration tabs and settings. Visible text includes Capture settings, Capture image, and vmlinux. alt-text #center](./images/img11_vmlinux_capture_settings.png)
 
 After clicking Save in Capture settings dialog, you can start the capture and analyze it as you did before.
-![Streamline function tab displaying profiling data for vmlinux. The main area shows a list of kernel functions with columns for metrics such as sample count and percentage of total samples. The function names are clearly listed, and the selected function is highlighted. The interface uses a neutral, technical design typical of performance profiling tools. Visible text includes Function, Sample Count, and Percentage. The wider environment includes other Streamline tabs and configuration options, reinforcing a focused, analytical workflow. ](./images/img12_vmlinux_function_tab.png)
+![Streamline function tab displaying profiling data for vmlinux. The main area shows a list of kernel functions with columns for metrics such as sample count and percentage of total samples. The function names are clearly listed, and the selected function is highlighted. The interface uses a neutral, technical design typical of performance profiling tools. Visible text includes Function, Sample Count, and Percentage. The wider environment includes other Streamline tabs and configuration options, reinforcing a focused, analytical workflow. alt-text #center] (./images/img12_vmlinux_function_tab.png)
 
 Since you used `vmlinux` image, you can view the driver functions as well as all other kernel functions that were sampled during the capture.
 

content/learning-paths/embedded-and-microcontrollers/streamline-kernel-module/8_summary.md

@@ -7,6 +7,6 @@ layout: learningpathall
 ---
 ## Summary
 
-In this Learning Path, you learned how to build and profile Linux kernel modules one step at a time. You started with an out-of-tree character driver that had a cache performance issue. Using Arm Streamline, you found where the problem was. Then, you applied the same profiling approach to an in-tree driver and saw how it works with the full kernel. While the example was simple, you can use these methods for more complex, real-world drivers and situations.
+In this Learning path, you learned how to build and profile Linux kernel modules step-by-step. You started with an out-of-tree character driver that had a cache performance issue and then used Arm Streamline to spot where the problem was. Later, you tried the same idea with an in-tree driver and saw how profiling works with the full kernel. Although the example problem was simple, the same methods apply to complex, real-world drivers and scenarios.
 
 The key takeaway is that profiling isn’t just about making code faster.It’s about understanding how your code talks to the hardware. Streamline provides a clear picture of what’s happening inside the CPU so that you can write better, more efficient drivers. By learning to identify bottlenecks, you'll be more confident in fixing them and avoiding common mistakes in kernel programming.