<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Souparna Chatterjee on Medium]]></title>
        <description><![CDATA[Stories by Souparna Chatterjee on Medium]]></description>
        <link>https://medium.com/@souparnachatterjee98?source=rss-9d62e2148052------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*M9qxl6wx4GPV7Vwc</url>
            <title>Stories by Souparna Chatterjee on Medium</title>
            <link>https://medium.com/@souparnachatterjee98?source=rss-9d62e2148052------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 19:38:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@souparnachatterjee98/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Day 2 of My Linux Kernel Hacking Journey: Rebuilding and Exploring the Linux Kernel on WSL2]]></title>
            <link>https://medium.com/@souparnachatterjee98/day-2-of-my-linux-kernel-hacking-journey-rebuilding-and-exploring-the-linux-kernel-on-wsl2-0ae341e38a08?source=rss-9d62e2148052------2</link>
            <guid isPermaLink="false">https://medium.com/p/0ae341e38a08</guid>
            <dc:creator><![CDATA[Souparna Chatterjee]]></dc:creator>
            <pubDate>Wed, 27 May 2026 21:47:21 GMT</pubDate>
            <atom:updated>2026-05-27T21:47:21.174Z</atom:updated>
            <content:encoded><![CDATA[<p>A few days ago, I loaded my first Linux kernel module inside WSL2.</p><p>Today, I went much deeper.</p><p>Not just writing a tiny module and printing logs — actually rebuilding the Linux kernel from source, exploring scheduler internals, reading task management code, and setting up the foundation for kernel debugging.</p><p>This was the first time the Linux kernel stopped feeling like a black box and started feeling like a very large, very organized systems codebase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RHGypRjLHz9cLB5WEQZ09w.png" /></figure><h3>Why I Started This Series</h3><p>I will soon be joing Sasken Technologies as a Software Engineer, and over time I want to move deeper into systems engineering areas like:</p><ul><li>Linux kernel</li><li>Device drivers</li><li>Embedded Linux</li><li>BSP development</li><li>Automotive Linux</li><li>Hypervisors</li><li>Android/Linux internals</li></ul><p>Instead of only studying theory or interview questions, I wanted to build real low-level systems understanding publicly and consistently.</p><p>So I started a: “30–60 Days of Linux Kernel Hacking” series</p><p>The goal is simple: <em>Learn low-level systems engineering by actually building things and reading real kernel code.</em></p><p>I’ll be documenting:</p><ul><li>kernel experiments</li><li>debugging workflows</li><li>driver development</li><li>Linux internals</li><li>scheduler exploration</li><li>embedded Linux setup</li><li>patches and small contributions</li><li>QEMU/KGDB workflows</li></ul><h3>Today’s Goal</h3><p>Today’s objective was straightforward:</p><h3>Rebuild and explore the Linux kernel itself.</h3><p>Not modules. The actual kernel.</p><h3>Environment Setup</h3><h3>Host Machine</h3><ul><li>Windows 11</li><li>WSL2</li><li>Ubuntu 24.04</li><li>Kernel: 6.6.114.1-microsoft-standard-WSL2</li></ul><h3>Step 1 — Enter WSL2</h3><p>From PowerShell:</p><pre>wsl -d Ubuntu</pre><h3>Step 2 — Install Build Dependencies</h3><p>Inside Ubuntu:</p><pre>sudo apt update</pre><pre>sudo apt install git fakeroot build-essential ncurses-dev \<br>xz-utils libssl-dev bc flex libelf-dev bison</pre><p>These packages are required for:</p><ul><li>kernel compilation</li><li>menuconfig</li><li>ELF handling</li><li>module builds</li><li>symbol generation</li></ul><h3>Step 3 — Clone the WSL2 Linux Kernel Source</h3><pre>cd ~</pre><pre>git clone <a href="https://github.com/microsoft/WSL2-Linux-Kernel.git">https://github.com/microsoft/WSL2-Linux-Kernel.git</a></pre><pre>cd WSL2-Linux-Kernel</pre><p>Since I’m working inside WSL2, using Microsoft’s kernel tree made the setup much cleaner.</p><h3>Step 4 — Reuse Current Kernel Configuration</h3><pre>cp /proc/config.gz .<br>gunzip config.gz<br>mv config .config</pre><p>This copies the currently running kernel configuration directly into the source tree.</p><p>Massive time saver.</p><h3>Step 5 — Prepare the Build</h3><pre>make olddefconfig</pre><p>This validates and updates the configuration automatically.</p><h3>Step 6 — Build the Entire Kernel</h3><p>The fun part.</p><pre>make -j$(nproc)</pre><p>Watching the kernel compile in real time was honestly surreal.</p><p>Lines like:</p><pre>CC kernel/sched/core.o<br>LD vmlinux.o<br>MODPOST Module.symvers<br>BUILD arch/x86/boot/bzImage</pre><p>suddenly make everything feel real.</p><p>You start realizing how enormous Linux actually is:</p><ul><li>scheduler</li><li>networking</li><li>memory management</li><li>filesystems</li><li>architecture code</li><li>synchronization primitives</li><li>modules</li><li>boot code</li></ul><p>all compiling together into a working operating system kernel.</p><h3>Kernel Build Success</h3><p>Eventually:</p><pre>Kernel: arch/x86/boot/bzImage is ready</pre><p>Seeing that message after a full build felt ridiculously satisfying.</p><p>For the first time, I had successfully built a Linux kernel from source.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*d-yQFj1pX4wFnxA3Mh8biA.png" /></figure><h3>Diving Into the Scheduler</h3><p>After the build, I started exploring scheduler internals.</p><p>Main files:</p><pre>kernel/sched/core.c</pre><p>and</p><pre>include/linux/sched.h</pre><p>This subsystem is basically responsible for deciding:</p><ul><li>which task runs</li><li>when it runs</li><li>CPU allocation</li><li>task switching</li><li>preemption</li><li>task states</li><li>scheduling classes</li></ul><p>Basically the core of multitasking Linux.</p><h3>Understanding Task States</h3><p>I started reading functions like:</p><pre>task_state_index()</pre><p>and:</p><pre>task_state_to_char()</pre><p>These convert internal task states into the characters shown by tools like:</p><pre>ps<br>top<br>htop</pre><p>For example:</p><p>StateMeaningRRunningSSleepingDUninterruptible SleepTStoppedZZombie</p><p>This was one of those moments where OS concepts suddenly stop being academic.</p><p>You realize: t<em>hese commands are literally showing data produced by scheduler code you can open and read yourself.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9HxJspxLeMDHdLOp9DfxZA.png" /></figure><h3>Exploring schedule()</h3><p>Then I opened:</p><pre>__sched schedule(void)</pre><p>inside:</p><pre>kernel/sched/core.c</pre><p>This is one of the most important functions in the entire Linux kernel.</p><p>Whenever Linux switches tasks, scheduling logic eventually flows through here.</p><p>Reading it for the first time felt like opening the door to how Linux actually works internally.</p><p>A lot of the code is still difficult to fully understand, but it no longer feels inaccessible.</p><p>That mental barrier disappeared today.</p><h3>Setting Up for Kernel Debugging</h3><p>I also started preparing a proper kernel debugging workflow based on IIT Delhi’s Linux kernel hacking material and kernel documentation.</p><p>This includes:</p><ul><li>QEMU/KVM</li><li>virt-manager</li><li>root filesystem setup</li><li>KGDB/KDB</li><li>serial debugging</li><li>GDB attachment</li><li>kernel symbol inspection</li></ul><p>The goal is to move beyond just reading code into:</p><ul><li>tracing execution</li><li>debugging kernel paths</li><li>inspecting scheduler behavior</li><li>understanding crashes and panics</li></ul><p>Basically learning how real low-level Linux debugging works.</p><h3>Biggest Things I Learned Today</h3><h3>1. The Linux kernel feels less “mystical” now</h3><p>It’s massive, yes.</p><p>But it’s still just structured C code.</p><p>Once you start navigating the source tree, following execution paths becomes surprisingly manageable.</p><h3>2. Scheduler internals are insanely interesting</h3><p>The scheduler feels like a giant state machine coordinating the entire OS.</p><p>Understanding:</p><ul><li>task states</li><li>context switching</li><li>preemption</li><li>scheduling flow</li></ul><p>makes Linux feel much more tangible.</p><h3>3. Building the kernel removes fear</h3><p>Before this, kernel development felt intimidating from a distance.</p><p>After rebuilding it yourself, opening scheduler code, tracing functions, and reading headers:</p><p>it starts feeling approachable.</p><p>Difficult — definitely.</p><p>But approachable.</p><h3>4. WSL2 is far more capable than I expected</h3><p>Rebuilding an entire Linux kernel from inside Windows without dual booting still feels slightly unreal.</p><p>WSL2 is honestly an amazing environment for learning systems programming.</p><h3>Commands I Used Most Today</h3><h3>Build the Kernel</h3><pre>make -j$(nproc)</pre><h3>Search Scheduler Functions</h3><pre>grep -rn &quot;schedule(&quot; kernel/</pre><h3>Open Scheduler Source</h3><pre>nano kernel/sched/core.c</pre><h3>Search Inside Nano</h3><pre>Ctrl + W</pre><h3>Open Task Headers</h3><pre>nano include/linux/sched.h</pre><h3>What’s Next</h3><p>Over the next few days, I’ll be exploring:</p><ul><li>character drivers</li><li>procfs</li><li>sysfs</li><li>ioctl</li><li>wait queues</li><li>workqueues</li><li>interrupts</li><li>spinlocks</li><li>mutexes</li><li>kernel threads</li><li>memory allocation</li><li>DMA basics</li><li>PCI/USB drivers</li><li>Netlink sockets</li><li>KGDB debugging</li><li>QEMU virtualization</li></ul><p>Eventually moving toward:</p><ul><li>real driver development</li><li>embedded Linux workflows</li><li>kernel debugging setups</li><li>upstream-style development practices</li></ul><h3>Advice to Anyone Starting Kernel Development</h3><p>Don’t try to understand the entire Linux kernel at once.</p><p>That’s impossible.</p><p>Instead:</p><ol><li>Build the kernel</li><li>Load a module</li><li>Read scheduler code</li><li>Trace a function</li><li>Print logs</li><li>Follow execution flow slowly</li></ol><p>One subsystem at a time.</p><p>That approach makes the kernel surprisingly approachable.</p><h3>Final Thoughts</h3><p>This was the first day where Linux kernel development stopped feeling theoretical.</p><p>Rebuilding the kernel, opening scheduler internals, tracing task states, and reading actual scheduling code made systems engineering feel very real.</p><p>Still at the beginning.</p><p>But finally moving beyond surface-level Linux usage and into understanding how the OS actually works underneath.</p><h3>References</h3><ul><li><a href="https://www.kernel.org/doc/html/v4.14/kernel-hacking/index.html?utm_source=chatgpt.com">Linux Kernel Hacking Documentation</a></li><li><a href="https://www.kernel.org/doc/html/v6.12/kernel-hacking/index.html?utm_source=chatgpt.com">Linux Kernel Debugging Docs</a></li><li>IIT Delhi Linux Kernel Hacking Guide by Abhishek Safui</li><li>Linux scheduler source (kernel/sched/core.c)</li><li>Linux task management headers (include/linux/sched.h)</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0ae341e38a08" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building My First Linux Kernel Module on WSL2 — From Endless Errors to “Hello, WSL Kernel!”]]></title>
            <link>https://medium.com/@souparnachatterjee98/building-my-first-linux-kernel-module-on-wsl2-from-endless-errors-to-hello-wsl-kernel-cdcbb8167057?source=rss-9d62e2148052------2</link>
            <guid isPermaLink="false">https://medium.com/p/cdcbb8167057</guid>
            <category><![CDATA[kernel]]></category>
            <category><![CDATA[linux-driver]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[linux-kernel]]></category>
            <category><![CDATA[wsl-2]]></category>
            <dc:creator><![CDATA[Souparna Chatterjee]]></dc:creator>
            <pubDate>Thu, 21 May 2026 19:31:45 GMT</pubDate>
            <atom:updated>2026-05-21T19:31:45.154Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oWiyF_5rZZM33DlZE6yUVw.png" /></figure><p>For the last few days, I wanted to properly enter Linux kernel and device driver development — not through a virtual machine black box, not through random copy-paste tutorials, but by understanding how the Linux kernel actually behaves during compilation, module linking, symbol resolution, and runtime insertion.</p><p>Instead of using VirtualBox, I decided to do something slightly unconventional:</p><p><em>Build Linux kernel modules directly on top of Microsoft’s WSL2 kernel</em></p><p>And honestly, that decision made the learning experience much deeper. This wasn’t just a “hello world” driver session.</p><p>I ended up debugging:</p><ul><li>kernel headers</li><li>missing ELF dependencies</li><li>modpost failures</li><li>symbol resolution errors</li><li>missing Module.symvers</li><li>WSL memory crashes</li><li>broken build symlinks</li><li>module insertion lifecycle</li></ul><p>By the end, I successfully:</p><ul><li>compiled my own Linux kernel module</li><li>inserted it into the running WSL2 kernel</li><li>verified it through dmesg</li><li>unloaded it cleanly</li></ul><p>This article documents the full journey.</p><h3>Why WSL2 Instead of VirtualBox?</h3><p>Most beginner Linux driver tutorials use:</p><ul><li>VirtualBox</li><li>preconfigured Ubuntu images</li><li>prebuilt headers</li><li>hidden abstractions</li></ul><p>I wanted to understand:</p><ul><li>where kernel modules actually compile</li><li>how the Linux build system works</li><li>what Module.symvers really does</li><li>how external kernel modules interact with the running kernel</li></ul><p>WSL2 was perfect because:</p><ul><li>Microsoft ships its own Linux kernel</li><li>the kernel source is publicly available</li><li>it forces you to understand the build environment</li></ul><p>And most importantly: you’re working against a <em>real running kernel</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*j9w3umGGM4WkL-_rU7ep3Q.png" /></figure><h3>Step 1 — Cloning the Microsoft WSL2 Kernel</h3><p>I first cloned Microsoft’s official WSL2 Linux kernel repository.</p><pre>git clone --depth 1 \<br>-b linux-msft-wsl-6.6.y \<br>https://github.com/microsoft/WSL2-Linux-Kernel.git</pre><p>After cloning:</p><pre>cd WSL2-Linux-Kernel</pre><p>This kernel source now matched my currently running WSL2 kernel.</p><h3>Step 2 — Copying the Running Kernel Configuration</h3><p>Linux kernel modules must be built against the correct kernel configuration.</p><p>So I copied the active kernel config directly from the running kernel:</p><pre>zcat /proc/config.gz &gt; .config</pre><p>Then verified module support:</p><pre>grep CONFIG_MODULES .config</pre><p>Output:</p><pre>CONFIG_MODULES=y</pre><p>Good sign.</p><h3>Step 3 — Preparing the Kernel Build System</h3><p>Next:</p><pre>make modules_prepare</pre><p>At this point the Linux build system started generating:</p><ul><li>headers</li><li>syscall tables</li><li>symbol helpers</li><li>build scripts</li><li>objtool infrastructure</li></ul><p>And then the first real kernel build error appeared.</p><h3>Step 4 — The First Major Error (libelf.h Missing)</h3><p>The build suddenly failed with:</p><pre>fatal error: libelf.h: No such file or directory</pre><p>A little later:</p><pre>fatal error: gelf.h: No such file or directory</pre><p>This was my first exposure to how dependent the Linux kernel build system is on external tooling.</p><p>The fix:</p><pre>sudo apt install build-essential flex bison \<br>libssl-dev libelf-dev dwarves</pre><p>After installing these dependencies, objtool compiled successfully.</p><p>This alone taught me a huge lesson: <em>Linux kernel development is as much about infrastructure as it is about code.</em></p><h3>Step 5 — Creating the Kernel Build Link</h3><p>Linux external modules expect the kernel build directory to exist at:</p><pre>/lib/modules/$(uname -r)/build</pre><p>So I manually linked my kernel source tree:</p><pre>sudo mkdir -p /lib/modules/$(uname -r)</pre><pre>sudo ln -sf ~/WSL2-Linux-Kernel \<br>/lib/modules/$(uname -r)/build</pre><p>Verification:</p><pre>ls -l /lib/modules/$(uname -r)/build</pre><p>Output:</p><pre>-&gt; /home/souparna28/WSL2-Linux-Kernel</pre><p>Now external modules could compile against the active WSL2 kernel.</p><h3>Step 6 — Writing My First Kernel Module</h3><p>I created a new directory:</p><pre>mkdir ~/my_driver<br>cd ~/my_driver</pre><p>Then wrote my first Linux kernel module:</p><pre>#include &lt;linux/module.h&gt;<br>#include &lt;linux/kernel.h&gt;<br>#include &lt;linux/init.h&gt;</pre><pre>static int __init hello_init(void)<br>{<br>    printk(KERN_INFO &quot;Hello, WSL kernel!\n&quot;);<br>    return 0;<br>}</pre><pre>static void __exit hello_exit(void)<br>{<br>    printk(KERN_INFO &quot;Goodbye, WSL Kernel\n&quot;);<br>}</pre><pre>module_init(hello_init);<br>module_exit(hello_exit);</pre><pre>MODULE_LICENSE(&quot;GPL&quot;);<br>MODULE_AUTHOR(&quot;Souparna&quot;);<br>MODULE_DESCRIPTION(&quot;My first WSL2 Linux kernel module&quot;);</pre><p>This was my first interaction with:</p><ul><li>module_init</li><li>module_exit</li><li>kernel logging</li><li>module metadata</li></ul><h3>Step 7 — Writing the Kernel Module Makefile</h3><p>Kernel modules use the Linux Kbuild system.</p><p>My Makefile:</p><pre>obj-m += hello_driver.o</pre><pre>all:<br>	make -C /lib/modules/$(shell uname -r)/build \<br>	M=$(PWD) modules</pre><pre>clean:<br>	make -C /lib/modules/$(shell uname -r)/build \<br>	M=$(PWD) clean</pre><h3>Step 8 — My First Compilation Failure</h3><p>The first build attempt failed badly.</p><p>Errors included:</p><pre>unknown type name ‘int_init’<br>unknown type name ‘void_exit’</pre><p>and:</p><pre>hello_exit undeclared</pre><p>Turns out I had typos like:</p><ul><li>int_init</li><li>void_exit</li><li>helo_exit</li></ul><p>instead of:</p><ul><li>__init</li><li>__exit</li><li>hello_exit</li></ul><p>This was a small but important reminder: <em>Kernel development is unforgiving. </em>Even tiny naming mistakes break compilation instantly.</p><h3>Step 9 — The Real Kernel Problem: Module.symvers</h3><p>After fixing syntax errors, I hit a much more serious issue:</p><pre>ERROR: modpost: &quot;_printk&quot; undefined!<br>ERROR: modpost: &quot;module_layout&quot; undefined!<br>ERROR: modpost: &quot;__fentry__&quot; undefined!</pre><p>This was confusing because:</p><ul><li>printk</li><li>module infrastructure</li><li>kernel symbols</li></ul><p>should already exist.</p><p>The real issue:</p><pre>WARNING: Module.symvers is missing.</pre><p>This was the moment I learned what Module.symvers actually does.</p><p>Module.symvers contains:</p><ul><li>exported kernel symbols</li><li>symbol versions</li><li>module linkage metadata</li></ul><p>Without it, modpost cannot resolve external kernel symbols.</p><h3>Step 10 — Building Kernel Modules to Generate Module.symvers</h3><p>To generate it:</p><pre>make modules -j$(nproc)</pre><p>Immediately another issue appeared:</p><pre>&#39;cpio&#39; could not be found</pre><p>Fix:</p><pre>sudo apt install -y cpio</pre><p>Then I tried again.</p><h3>Step 11 — WSL2 Memory Problems</h3><p>The kernel build repeatedly died during:</p><pre>LD vmlinux.o<br>Killed</pre><p>WSL simply ran out of memory.</p><p>Checking memory:</p><pre>free -h</pre><p>showed:</p><ul><li>low RAM</li><li>swap fully consumed</li></ul><p>The fix was reducing parallelism:</p><pre>make modules -j1</pre><p>instead of:</p><pre>make modules -j$(nproc)</pre><p>This stabilized the build.</p><p>This taught me another lesson: <em>Parallel kernel compilation can destroy low-memory environments.</em></p><h3>Step 12 — Successfully Generating Module.symvers</h3><p>Finally:</p><pre>ls -lh Module.symvers</pre><p>Output:</p><pre>-rw-r--r-- 1 souparna28 1.2M Module.symvers</pre><p>Huge milestone.</p><p>Now the external module build system finally had access to exported kernel symbols.</p><h3>Step 13 — Successfully Building My First Kernel Module</h3><p>Back inside my driver directory:</p><pre>make clean<br>make</pre><p>And finally:</p><pre>LD [M]  /home/souparna28/my_driver/hello_driver.ko<br>BTF [M] /home/souparna28/my_driver/hello_driver.ko</pre><p>Success.</p><p>The Linux kernel module compiled correctly.</p><p>Generated files included:</p><ul><li>hello_driver.ko</li><li>hello_driver.o</li><li>Module.symvers</li><li>modules.order</li></ul><h3>Step 14 — Learning That .ko Files Are NOT Executables</h3><p>I accidentally tried:</p><pre>hello_driver.ko</pre><p>and got:</p><pre>command not found</pre><p>Because:<br>.ko files are not executable binaries.</p><p>They are loadable kernel objects.</p><h3>Step 15 — Inserting the Module Into the Running Kernel</h3><p>Actual insertion:</p><pre>sudo insmod hello_driver.ko</pre><p>Verification:</p><pre>lsmod | grep hello_driver</pre><p>Output:</p><pre>hello_driver 12288 0</pre><p>The module was officially loaded into the running WSL2 kernel.</p><h3>Step 16 — Verifying Kernel Logs</h3><p>Finally:</p><pre>dmesg | tail -n 20</pre><p>Output:</p><pre>Hello, WSL kernel!</pre><p>That single line felt incredible.</p><p>A custom kernel module I wrote was now executing inside the Linux kernel.</p><h3>Step 17 — Unloading the Module</h3><p>Removing it:</p><pre>sudo rmmod hello_driver</pre><p>Then checking logs again:</p><pre>dmesg | tail -n 10</pre><p>Output:</p><pre>Goodbye, WSL Kernel</pre><p>The full kernel module lifecycle worked successfully.</p><h3>What I Learned</h3><p>This journey taught me much more than: <em>“How to print from a kernel module.”</em></p><p>I learned:</p><ul><li>Linux kernel build internals</li><li>external module compilation</li><li>Kbuild workflow</li><li>symbol resolution</li><li>Module.symvers</li><li>kernel infrastructure dependencies</li><li>WSL2 kernel architecture</li><li>low-level debugging</li><li>module lifecycle</li><li>Linux memory limitations during builds</li></ul><p>Most importantly: <em>Linux kernel development is not about memorizing APIs.</em>It’s about understanding systems deeply enough to debug them.And honestly, that’s what makes it fun.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cdcbb8167057" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>