writing-char-drivers — Claude Code skill: Linux /dev drivers
writing-char-drivers — a skill for writing Linux character drivers: cdev registration, file_operations implementation, safe userspace copies, ioctl and mmap.
MIT 378 installs ★ 298 updated 2026-06-27
npx skills add mohitmishra786/low-level-dev-skills --skill writing-char-drivers -a claude-codeWhat writing-char-drivers does
Teaches the agent to create Linux character devices with full lifecycle: allocate major/minor via alloc_chrdev_region, initialize cdev, populate file_operations structure with open, read, write, unlocked_ioctl methods. Shows safe data transfer between kernel and userspace using copy_to_user and copy_from_user, defines ioctl commands with _IO, _IOW, _IOWR macros and a fixed magic number, maps device physical memory into process address space via remap_pfn_range with pgprot_noncached.
Includes a table of typical errors: -EFAULT on invalid userspace pointer, ENOTTY on magic mismatch in ioctl, static major conflict, SIGSEGV in mmap due to cached mapping of MMIO regions. Activates on mentions of cdev, file_operations, copy_from_user, ioctl, kernel mmap. Code requires kernel headers (<linux/fs.h>, <linux/cdev.h>, <linux/uaccess.h>) to compile.
What it helps with
- register a character device with dynamic major allocation
- implement
readandwritewith safe userspace copies - add
unlocked_ioctlwith commands via_IOWand_IOWR - map device MMIO region to userspace via
mmap - handle
-EFAULTandENOTTYin a driver
Example prompts for the agent
- Add SET_SPEED
unlocked_ioctlto the existing platform driver - Register
cdevwith dynamic major and create/dev/mydev - Implement
my_readwithcopy_to_userand offset check
How to install writing-char-drivers
1Skills CLI (Vercel)
npx skills add mohitmishra786/low-level-dev-skills --skill writing-char-drivers -a claude-code2Manually: put the files in place
~/.claude/skills/writing-char-drivers/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/writing-char-drivers/
1Skills CLI (Vercel)
npx skills add mohitmishra786/low-level-dev-skills --skill writing-char-drivers -a codex2Manually: put the files in place
.agents/skills/writing-char-drivers/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add mohitmishra786/low-level-dev-skills --skill writing-char-drivers -a cursor2Manually: put the files in place
.cursor/skills/writing-char-drivers/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install mohitmishra786/low-level-dev-skills skills/kernel-dev/writing-char-drivers2Manually: put the files in place
.github/skills/writing-char-drivers/SKILL.md1Skills CLI (Vercel)
npx skills add mohitmishra786/low-level-dev-skills --skill writing-char-drivers -a gemini-cli2Platform CLI
gemini skills install https://github.com/mohitmishra786/low-level-dev-skills --path skills/kernel-dev/writing-char-driversManually: put the files in place
.devin/skills/writing-char-drivers/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add mohitmishra786/low-level-dev-skills --skill writing-char-drivers -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about writing-char-drivers
How to install writing-char-drivers in Claude Code?
Run npx skills add mohitmishra786/low-level-dev-skills --skill writing-char-drivers -a claude-code. The skill will appear in ~/.claude/skills/writing-char-drivers/SKILL.md.
What does writing-char-drivers do?
The skill teaches the agent to write Linux character drivers: register cdev, populate file_operations, transfer data via copy_to_user and copy_from_user, create ioctl commands and map device memory to userspace.
What does writing-char-drivers require?
Linux kernel headers (<linux/fs.h>, <linux/cdev.h>, <linux/uaccess.h>) and a kernel module build environment. Code will not compile without them.
Source text
SKILL.md · MIT
---
name: writing-char-drivers
description: Character driver skill for Linux kernel char devices. Use when implementing file_operations, cdev, copy_to_user, ioctl, or mmap for userspace interfaces. Activates on queries about char device, cdev, file_operations, copy_from_user, ioctl, or kernel mmap.
---
# Writing Character Drivers
## Purpose
Guide agents through Linux character device implementation: `struct file_operations`, `cdev` registration, safe userspace copies, `ioctl` design, and basic `mmap` — focused depth beyond `skills/kernel/device-drivers`.
## When to Use
- Exposing hardware to `/dev/mydev`
- Implementing `read`/`write`/`poll` from kernel
- Defining `ioctl` commands with type-safe macros
- Mapping device MMIO to userspace (carefully)
## Workflow
### 1. Char device registration
```c
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/uaccess.h>
#define MY_MAJOR 0 /* 0 = dynamic alloc */
#define MY_MINOR 0
static dev_t devno;
static struct cdev my_cdev;
static struct class *class;
static const struct file_operations my_fops = {
.owner = THIS_MODULE,
.open = my_open,
.release = my_release,
.read = my_read,
.write = my_write,
.unlocked_ioctl = my_ioctl,
.llseek = no_llseek,
};
static int __init my_init(void)
{
int ret = alloc_chrdev_region(&devno, MY_MINOR, 1, "mydev");
if (ret)
return ret;
cdev_init(&my_cdev, &my_fops);
ret = cdev_add(&my_cdev, devno, 1);
if (ret)
goto err_cdev;
class = class_create("mydev");
device_create(class, NULL, devno, NULL, "mydev");
return 0;
err_cdev:
unregister_chrdev_region(devno, 1);
return ret;
}
```
Modern drivers often use `devm_*` variants inside `probe`.
### 2. Safe userspace I/O
```c
static ssize_t my_read(struct file *filp, char __user *buf,
size_t count, loff_t *ppos)
{
char kbuf[128];
ssize_t len;
if (*ppos >= sizeof(kbuf))
return 0;
len = min(count, sizeof(kbuf) - *ppos);
memcpy(kbuf, "data", 4);
if (copy_to_user(buf, kbuf + *ppos, len))
return -EFAULT;
*ppos += len;
return len;
}
```
Never dereference `__user` pointers directly.
### 3. ioctl pattern
```c
#include <linux/ioctl.h>
#define MY_IOC_MAGIC 'k'
#define MY_IOC_RESET _IO(MY_IOC_MAGIC, 0)
#define MY_IOC_SET _IOW(MY_IOC_MAGIC, 1, int)
static long my_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
switch (cmd) {
case MY_IOC_RESET:
return 0;
case MY_IOC_SET: {
int val;
if (copy_from_user(&val, (void __user *)arg, sizeof(val)))
return -EFAULT;
return 0;
}
default:
return -ENOTTY;
}
}
```
Use `_IOWR` with fixed-size structs; prefer `compat_ioctl` on bi-arch.
### 4. mmap (device memory)
```c
static int my_mmap(struct file *filp, struct vm_area_struct *vma)
{
unsigned long size = vma->vm_end - vma->vm_start;
phys_addr_t phys = device_phys_base;
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
return remap_pfn_range(vma, vma->vm_start, phys >> PAGE_SHIFT,
size, vma->vm_page_prot);
}
```
Prefer `mmap` of DMA buffers only with explicit size limits and permission checks.
### 5. poll / async I/O
Implement `poll` + `wake_up_interruptible` for blocking reads; use `fasync_helper` for SIGIO.
### 6. Agent usage
```
/writing-char-drivers Add unlocked_ioctl SET_SPEED to existing platform driver
```
## Common Problems
| Symptom | Cause | Fix |
|---------|-------|-----|
| `-EFAULT` | Bad user pointer | Validate `access_ok` (older) / rely on `copy_*` |
| `ENOTTY` | Wrong ioctl magic | Match userspace `ioctl.h` |
| Major conflict | Static major taken | Use `alloc_chrdev_region` |
| mmap SIGSEGV | Cached mapping to device | `pgprot_noncached` |
| Sleep in ioctl | Holding spinlock | Drop lock before blocking |
## Related Skills
- `skills/kernel-dev/platform-device-model` — probe context
- `skills/kernel/device-drivers` — full driver lifecycle
- `skills/kernel/kernel-concurrency` — locking in file ops
- `skills/kernel-dev/kernel-debugging-advanced` — trace ioctl path
- `skills/low-level-programming/linux-kernel-modules` — module boilerplate
© mohitmishra786 · MIT · mohitmishra786/low-level-dev-skills