Project: Write a Minimal Init System (PID 1)

A minimal init system is a great way to understand Unix-like process management, signal handling, and what happens when a Linux system boots. In this project, you’ll write your own tiny init process and run it as PID 1.

What Is an Init System?

The init system is the first user-space process launched by the Linux kernel. It always has PID 1 and is responsible for:

Starting other user-space programs (like shells or daemons)
Reaping zombie processes (crucial)
Handling shutdown or reboot requests

We’re not building systemd — just a minimal educational version.

Prerequisites

You’ll need:

Intermediate knowledge of C programming
Familiarity with Linux system calls
Access to a VM, container, or custom boot environment

Goals

Your init program will:

Run as PID 1
Spawn a shell (like /bin/sh)
Reap child processes (zombies)
Handle basic signals like SIGTERM or SIGINT

Step-by-Step

1. Write the Minimal `init.c`

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52


// init.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>

void sigchld_handler(int sig) {
    // Reap zombie processes
    while (waitpid(-1, NULL, WNOHANG) > 0);
}

int main() {
    signal(SIGCHLD, sigchld_handler);

    // Mount essential pseudo-filesystems
    if (mount("proc", "/proc", "proc", 0, NULL) != 0) {
        perror("mount /proc failed");
    }

    if (mount("sysfs", "/sys", "sysfs", 0, NULL) != 0) {
        perror("mount /sys failed");
    }

    // Redirect stdio to /dev/console
    int fd = open("/dev/console", O_RDWR);
    if (fd >= 0) {
        dup2(fd, 0);
        dup2(fd, 1);
        dup2(fd, 2);
        if (fd > 2) close(fd);
    } else {
        perror("failed to open /dev/console");
    }

    pid_t pid = fork();
    if (pid == 0) {
        // Child process — launch a shell
        execl("/bin/sh", "/bin/sh", NULL);
        perror("execl failed");
        exit(1);
    }

    // Parent (PID 1)
    printf("Init started. Child PID: %d\n", pid);

    while (1) {
        pause();  // Sleep until signal
    }

    return 0;
}

2. Compile the Program

Use static linking to ensure it works in a minimal root filesystem:

1

gcc -static -o init init.c

3. Run It in a Minimal Environment

Option A: Using Docker

1

docker run -it --rm --init --name testinit -v $(pwd)/init:/init busybox /init

This version won’t run as PID 1 (when you run ps). If you run ps in the new shell, it will look something like:

1
2
3
4
5


PID   USER     TIME  COMMAND
  1   root      0:00  /sbin/docker-init -- /init      ← Docker’s tini-style init
  7   root      0:00  /init                           ← Your compiled init.c
  8   root      0:00  /bin/sh                         ← The shell your init spawned
  9   root      0:00  ps                              ← The `ps` command you ran

What’s Going On?

PID 1 is not your init — it’s Docker’s /sbin/docker-init
Docker injects its own init process (usually tini) to reap zombies and forward signals correctly.
Your custom init is actually running as PID 7 — so it’s not truly PID 1.

But Your Code Still Works

Even though it’s PID 7, your minimal init:

Spawned a /bin/sh shell (PID 8)
Stayed alive
Can still handle SIGCHLD, etc.

So your code is fine — it’s just not running as PID 1 due to Docker’s isolation behavior.

Option B: Want to Truly Run as PID 1? QEMU + Custom Initramfs

Here we will:

Build a minimal Linux kernel
Bundle your init in an initramfs
Boot it with qemu:

✅ What You Need

i. A Kernel Image: `bzImage`

Option A: Build It Yourself

1
2
3
4


git clone https://github.com/torvalds/linux.git
cd linux
make defconfig
make -j$(nproc) bzImage

After compilation, copy the result:

1

cp arch/x86/boot/bzImage /path/to/your/qemu/project/

Option B: Download Prebuilt Kernel (Lazy option 🤣)

You can download a bzImage from sources like TinyCore or GitHub projects, but compiling is best for full control and for the exploratory stuff we are doing here.

1

wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.1.tar.xz

Or search for “prebuilt bzImage”.

ii. A Minimal Initramfs: `initramfs.cpio.gz`

initramfs (short for initial RAM filesystem) is a temporary root filesystem that is loaded into memory and used by the Linux kernel very early in the boot process, before the real root filesystem is mounted.

It must include:

/init (your compiled static init program)
/bin/sh (e.g., via BusyBox)
/dev/console (required for proper boot output)

A. Download and Build BusyBox (If you don’t have it already)

1
2
3
4
5


wget https://busybox.net/downloads/busybox-1.36.1.tar.bz2
tar -xjf busybox-*.tar.bz2
cd busybox-*
make defconfig
make -j$(nproc) CONFIG_STATIC=y

This gives you a statically linked busybox binary in ./busybox.

B. Create Root Filesystem Layout

1
2


mkdir -p rootfs/{bin,sbin,etc,proc,sys,usr/bin,usr/sbin,dev}
cp busybox rootfs/bin/

C. Create Symbolic Links for BusyBox Linux commands

1
2
3


for app in $(./busybox --list); do
  ln -s /bin/busybox rootfs/bin/$app
done

D. Create /dev/console device node:

1

sudo mknod -m 622 rootfs/dev/console c 5 1

E. Install Your Custom `init`

Make sure your compiled init binary (from earlier) is copied into the root filesystem as /init.

1
2


cp init rootfs/init
chmod +x rootfs/init

This will now be PID 1 when QEMU boots.

Make it executable:

1

chmod +x rootfs/init

F. Build the Initramfs

1
2
3


cd rootfs
find . -print0 | cpio --null -ov --format=newc | gzip -9 > ../initramfs.cpio.gz
cd ..

iii. Boot It With QEMU (Once You Have the Files)

Make sure you’re in the directory with:

1
2


ls
bzImage  initramfs.cpio.gz

Then run:

1
2
3
4
5


qemu-system-x86_64 \
  -kernel bzImage \
  -initrd initramfs.cpio.gz \
  -append "console=ttyS0 init=/init" \
  -nographic

You should see:

1
2
3
4


BusyBox v1.36.1 built-in shell (ash)
Enter 'help' for a list of built-in commands.
/bin/sh: can't access tty; job control turned off
~ #

This is expected — job control is unavailable without a full controlling terminal, but your shell works perfectly without it.

iv. Confirm It Works

Run ps in the shell. You should see this, plus many other kernel threads:

1
2
3
4


PID   USER     COMMAND
  1   0        /init
 53   0        /bin/sh
 54   0        ps

✔️ Your init is PID 1
✔️ Your shell launched
✔️ ps shows all processes
✔️ Kernel threads like [kworker/…] are visible

✅ You are now officially running your own custom Linux init system from scratch inside QEMU!

4. Stretch Goals

Add extra functionality to your init:

Handle SIGTERM, SIGINT for clean shutdown
Spawn multiple child processes (like daemons)
Log messages to a file or pseudo-terminal
Implement shutdown: call sync() and reboot(RB_POWER_OFF)
Parse a config file (like a mini /etc/inittab)

References

Next Steps

Coming soon:

Test zombie reaping with background processes
Send it signals and confirm it handles them
Add shutdown/reboot signal support
Launch other system services from your init

Project: Write a Minimal Init System (PID 1)#

What Is an Init System?#

Prerequisites#

Goals#

Step-by-Step#

1. Write the Minimal init.c#

2. Compile the Program#

3. Run It in a Minimal Environment#

Option A: Using Docker#

What’s Going On?#

But Your Code Still Works#

Option B: Want to Truly Run as PID 1? QEMU + Custom Initramfs#

✅ What You Need#

i. A Kernel Image: bzImage#

Option A: Build It Yourself#

Option B: Download Prebuilt Kernel (Lazy option 🤣)#

ii. A Minimal Initramfs: initramfs.cpio.gz#

A. Download and Build BusyBox (If you don’t have it already)#

B. Create Root Filesystem Layout#

C. Create Symbolic Links for BusyBox Linux commands#

D. Create /dev/console device node:#

E. Install Your Custom init#

F. Build the Initramfs#

iii. Boot It With QEMU (Once You Have the Files)#

iv. Confirm It Works#

4. Stretch Goals#

References#

Next Steps#