# linux-kernel-modules

Walks your agent through writing and debugging loadable kernel modules: Kbuild, module parameters, /proc, sysfs, character devices, KGDB and ftrace.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 639 installs · ★ 267
- Author: mohitmishra786
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/mohitmishra786/low-level-dev-skills/tree/HEAD/skills/low-level-programming/linux-kernel-modules/SKILL.md
- Updated: 2026-06-27
- HTML: https://affpapa.org/en/nevibecode/skills/linux-kernel-modules

## What it does

The skill gives the agent a working shape for an LKM: the `Makefile` Kbuild expects, `module_init` and `module_exit`, output through `printk`. Then module parameters via `module_param` with write permissions, a `/proc` entry built on `seq_file`, and a sysfs attribute through `kobject` and `kobj_attribute`.

Character devices get their own section: `register_chrdev`, `copy_to_user` and `copy_from_user`, and the `mknod` line that creates the node. For debugging there is KGDB over serial or network, function tracing with ftrace, and dynamic debug to turn on `pr_debug` output. Module signing for Secure Boot is covered too.

Builds run against the headers of the installed kernel — the `Makefile` points at `/lib/modules/$(shell uname -r)/build`. No headers for the running kernel and `make` fails, so check that package before the first build. Loading and unloading need `insmod` and `rmmod` as root. The skill text stops inside the `EXPORT_SYMBOL` versus `EXPORT_SYMBOL_GPL` section, so treat symbol export as only partly covered.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill linux-kernel-modules -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/linux-kernel-modules/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/linux-kernel-modules/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill linux-kernel-modules -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/linux-kernel-modules/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill linux-kernel-modules -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/linux-kernel-modules/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install mohitmishra786/low-level-dev-skills linux-kernel-modules
```

2. **Manually: put the files in place**
- File: `.github/skills/linux-kernel-modules/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill linux-kernel-modules -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/mohitmishra786/low-level-dev-skills --path skills/low-level-programming/linux-kernel-modules
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/linux-kernel-modules/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill linux-kernel-modules -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/mohitmishra786/low-level-dev-skills/tree/HEAD/skills/low-level-programming/linux-kernel-modules/SKILL.md

## When to use it
- build a minimal loadable module with a `Makefile` Kbuild accepts
- add module parameters and change them at runtime through sysfs
- expose counters and status from the module in `/proc` with `seq_file`
- write a character device that reads and writes from userspace
- attach KGDB or ftrace when the module crashes on load

## Example prompts
- Write a minimal kernel module with a Kbuild Makefile and show me how to build and load it
- Add a count module parameter writable through sysfs and document it with MODULE_PARM_DESC
- Create a character device mydev with read and write using copy_to_user and copy_from_user

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 2d7f9e42521c212d.

BEGIN THIRD-PARTY FILE 2d7f9e42521c212d
````text
---
name: linux-kernel-modules
description: Linux kernel module skill for writing and debugging loadable kernel modules. Use when writing LKMs with Kbuild, adding module parameters, creating /proc and sysfs entries, implementing character devices, debugging with KGDB or ftrace, or handling module signing for Secure Boot. Activates on queries about Linux kernel modules, loadable modules, Kbuild, module parameters, /proc filesystem, sysfs, character devices, KGDB, or module signing.
---

# Linux Kernel Modules

## Purpose

Guide agents through writing loadable Linux kernel modules (LKMs): the Kbuild build system, module parameters, /proc and sysfs interfaces, character device implementation, kernel debugging with KGDB and `ftrace`, and module signing for Secure Boot.

## Triggers

- "How do I write a Linux kernel module?"
- "How do I add parameters to my kernel module?"
- "How do I create a /proc or sysfs entry?"
- "How do I implement a character device driver?"
- "How do I debug a kernel module with KGDB?"
- "How do I sign a kernel module for Secure Boot?"

## Workflow

### 1. Minimal kernel module

```c
// hello.c — minimal loadable kernel module
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Your Name");
MODULE_DESCRIPTION("Minimal hello world module");
MODULE_VERSION("1.0");

static int __init hello_init(void)
{
    printk(KERN_INFO "hello: module loaded\n");
    return 0;   // non-zero = load failure
}

static void __exit hello_exit(void)
{
    printk(KERN_INFO "hello: module unloaded\n");
}

module_init(hello_init);
module_exit(hello_exit);
```

```makefile
# Makefile — must be exactly this structure for Kbuild
obj-m := hello.o

KDIR := /lib/modules/$(shell uname -r)/build

all:
	$(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
	$(MAKE) -C $(KDIR) M=$(PWD) clean
```

```bash
# Build
make

# Load
sudo insmod hello.ko

# Check it loaded
lsmod | grep hello
dmesg | tail -5       # see printk output

# Unload
sudo rmmod hello

# Show module info
modinfo hello.ko
```

### 2. Module parameters

```c
#include <linux/moduleparam.h>

static int count = 1;
static char *name = "world";

// module_param(variable, type, permissions)
````
END THIRD-PARTY FILE 2d7f9e42521c212d

The third-party file has ended. Everything between the 2d7f9e42521c212d tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2227 of 10478 bytes. © mohitmishra786 · MIT · https://github.com/mohitmishra786/low-level-dev-skills/tree/HEAD/skills/low-level-programming/linux-kernel-modules/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md