Real-Time Linux

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

PREEMPT_NONE:
┌─────────────────────────────────────────────────────────────────┐
│ User Space │ Syscall/Interrupt → Kernel → Return │ User Space  │
└─────────────────────────────────────────────────────────────────┘
                    ↑ Preemption only here
 
PREEMPT_VOLUNTARY:
┌─────────────────────────────────────────────────────────────────┐
│ User │ Kernel code ──●──●──●──●── Kernel code │ User           │
└─────────────────────────────────────────────────────────────────┘
                      ↑ Preemption at explicit check points (●)
 
PREEMPT:
┌─────────────────────────────────────────────────────────────────┐
│ User │ ══════│ spinlock │══════│ spinlock │══════ │ User       │
└─────────────────────────────────────────────────────────────────┘
         ↑ Preemptible    ↑ Not     ↑ Preemptible
 
PREEMPT_RT:
┌─────────────────────────────────────────────────────────────────┐
│ User │ ═══════════════════════════════════════════════ │ User  │
└─────────────────────────────────────────────────────────────────┘
         ↑ Almost everything preemptible (sleeping locks)

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

Hardware Interrupt Occurs
         │
         ▼
┌────────────────────────────────────────────────────┐
│  Hardirq Stub (Primary Handler)                    │
│  - Acknowledge interrupt to hardware               │
│  - Check if this interrupt needs handling          │
│  - Return IRQ_WAKE_THREAD to schedule thread       │
│  Duration: < 1 microsecond typically               │
└────────────────────────────────────────────────────┘
         │
         ▼ (Thread wakeup)
┌────────────────────────────────────────────────────┐
│  Scheduler Runs                                    │
│  - Threaded handler competes with other threads   │
│  - Priority inheritance if waiting on RT mutex    │
│  - System admin can set irq thread priorities     │
└────────────────────────────────────────────────────┘
         │
         ▼
┌────────────────────────────────────────────────────┐
│  Threaded Handler (Secondary Handler)              │
│  - Full interrupt processing                       │
│  - Can sleep, acquire mutexes                     │
│  - CAN BE PREEMPTED by higher priority threads   │
│  Duration: Whatever the handler needs             │
└────────────────────────────────────────────────────┘

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

/**
 * Example: Requesting a threaded interrupt handler
 * 
 * The kernel creates an "irq/N-driver_name" thread for this handler.
 * This thread can be observed with 'ps' and its priority adjusted.
 */
 
#include <linux/interrupt.h>
 
/* Primary handler: runs in hardirq context, must be fast */
static irqreturn_t my_device_hardirq(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    
    /* Quick check: is this interrupt for us? */
    if (!device_interrupt_pending(dev))
        return IRQ_NONE;  /* Not our interrupt */
    
    /* Acknowledge interrupt to hardware (stop it from re-firing) */
    device_ack_interrupt(dev);
    
    /* Store any volatile state that must be captured immediately */
    dev->captured_timestamp = read_hardware_timestamp(dev);
    
    /* Request threaded handler execution */
    return IRQ_WAKE_THREAD;
}
 
/* Threaded handler: runs in process context, can do heavy work */
static irqreturn_t my_device_thread(int irq, void *dev_id)
{
    struct my_device *dev = dev_id;
    
    /* 
     * This code runs in a kernel thread.
     * It CAN:
     *   - Sleep
     *   - Acquire mutexes (with priority inheritance on PREEMPT_RT)
     *   - Be preempted by higher-priority threads
     *   - Take as long as necessary
     * 
     * It CANNOT:
     *   - Assume it runs immediately after the interrupt
     *   - Assume no other code ran between hardirq and here
     */
    
    mutex_lock(&dev->data_lock);  /* Safe! Will sleep if contended */
    
    process_received_data(dev);
    wake_up_waiting_userspace(dev);
    prepare_next_dma_transfer(dev);
    
    mutex_unlock(&dev->data_lock);
    
    return IRQ_HANDLED;
}
 
/* Registration */
int my_device_probe(struct pci_dev *pdev)
{
    struct my_device *dev = /* ... allocate ... */;
    int ret;
    
    ret = request_threaded_irq(
        pdev->irq,
        my_device_hardirq,     /* Primary: hardirq context */
        my_device_thread,      /* Secondary: thread context */
        IRQF_SHARED,
        "my_device",
        dev
    );
    
    if (ret) {
        dev_err(&pdev->dev, "Failed to request threaded IRQ
");
        return ret;
    }
    
    /*
     * After this, you can see the thread:
     *   $ ps aux | grep irq
     *   root ... [irq/24-my_device]
     * 
     * And adjust its priority:
     *   # chrt -f -p 90 <pid>
     */
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/*
 * Standard spinlock usage - problematic for real-time
 */
void driver_operation(struct device *dev)
{
    unsigned long flags;
    
    spin_lock_irqsave(&dev->lock, flags);
    /*
     * PROBLEM: While holding this lock:
     *   1. Preemption is disabled
     *   2. All interrupts are disabled (on this CPU)
     *   3. Any higher-priority task wanting to run must wait
     *   4. Duration is unbounded (depends on work done here)
     * 
     * If this critical section takes 1ms, we add 1ms to the
     * worst-case latency of EVERY real-time task in the system!
     */
    perform_lengthy_device_operation(dev);
    spin_unlock_irqrestore(&dev->lock, flags);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

Standard Linux Spinlock:
┌─────────────────────────────────────────────────────────────────┐
│ Thread A: [───── spin_lock ─────────────── spin_unlock ────]   │
│                 ↑ preemption disabled                          │
│ Thread B: [...BLOCKED...BLOCKED...BLOCKED...]                 │
│           ↑ Cannot run even if higher priority                │
└─────────────────────────────────────────────────────────────────┘
 
PREEMPT_RT Sleeping Spinlock:
┌─────────────────────────────────────────────────────────────────┐
│ Thread A: [── lock ──┐                      ┌── unlock ──]     │
│                      │ preempted!           │                   │
│ Thread B:            └─[HIGH PRIORITY RUNS]─┘                  │
│                                                                 │
│ Note: Thread A continues after B completes. Priority           │
│ inheritance ensures A completes quickly to release lock.       │
└─────────────────────────────────────────────────────────────────┘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Priority Inversion WITHOUT Inheritance:
┌─────────────────────────────────────────────────────────────────┐
│ High (Pri=90):     [BLOCKED on lock ─────────────────────────]│
│ Medium (Pri=50):   ════════════════════════════════════════    │
│ Low (Pri=10):      [holds lock...preempted by Medium...]      │
│                                                                 │
│ Problem: High waits for Low, but Medium runs instead of Low!  │
│          High's latency = Medium's entire execution time      │
└─────────────────────────────────────────────────────────────────┘
 
Priority Inversion WITH Inheritance (PREEMPT_RT):
┌─────────────────────────────────────────────────────────────────┐
│ High (Pri=90):     [wait]──────────[RUNS]                      │
│ Medium (Pri=50):           [blocked behind Low-at-90]          │
│ Low (Pri=10→90):   [runs at 90, releases lock]                 │
│                    ↑ Inherits High's priority                  │
│                                                                 │
│ Result: High's latency = only Low's critical section time     │
└─────────────────────────────────────────────────────────────────┘

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

#include <linux/spinlock.h>
 
/* Regular spinlock: becomes sleeping mutex on PREEMPT_RT */
static DEFINE_SPINLOCK(normal_lock);
 
/* Raw spinlock: always a true spinlock, even on PREEMPT_RT */
static DEFINE_RAW_SPINLOCK(raw_lock);
 
void regular_path(void)
{
    spin_lock(&normal_lock);
    /* On PREEMPT_RT: May sleep! Lock holder can be preempted. */
    /* Use for most normal device driver critical sections. */
    do_normal_work();
    spin_unlock(&normal_lock);
}
 
void scheduler_critical_path(void)
{
    unsigned long flags;
    
    raw_spin_lock_irqsave(&raw_lock, flags);
    /*
     * TRUE busy-wait spinlock. Preemption disabled.
     * 
     * Use ONLY for:
     *   - Scheduler internals
     *   - Interrupt controller manipulation
     *   - Timer hardware programming
     *   - Debugging/tracing infrastructure
     * 
     * Keep critical sections EXTREMELY short (< 1μs ideal).
     */
    manipulate_scheduler_structures();
    raw_spin_unlock_irqrestore(&raw_lock, flags);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Standard Linux Softirq Processing:
┌─────────────────────────────────────────────────────────────────┐
│ [Hardirq] → [Softirq: NET_RX + TIMER + SCHED + ...] → [User]  │
│             └──────── Cannot be preempted ────────┘            │
│             Potentially milliseconds of non-preemptible work  │
└─────────────────────────────────────────────────────────────────┘
 
PREEMPT_RT Threaded Softirqs:
┌─────────────────────────────────────────────────────────────────┐
│ [Hardirq] → [Wake ksoftirqd] → [Return immediately]           │
│                   ↓                                             │
│             [ksoftirqd/N thread runs when scheduled]           │
│             [Can be preempted by higher priority threads]      │
│                                                                 │
│ $ ps aux | grep ksoftirqd                                      │
│ root ... [ksoftirqd/0]    # CPU 0 softirq thread              │
│ root ... [ksoftirqd/1]    # CPU 1 softirq thread              │
└─────────────────────────────────────────────────────────────────┘

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

/*
 * RCU Reader: Standard vs PREEMPT_RT
 */
 
/* Standard Linux: Reader cannot be preempted */
void standard_rcu_reader(void)
{
    rcu_read_lock();  /* Disables preemption */
    
    ptr = rcu_dereference(global_ptr);
    /* CANNOT be preempted here */
    process(ptr);
    
    rcu_read_unlock(); /* Re-enables preemption */
}
 
/* PREEMPT_RT: Reader CAN be preempted */
void preempt_rt_rcu_reader(void)
{
    rcu_read_lock();  /* Does NOT disable preemption */
    
    ptr = rcu_dereference(global_ptr);
    /*
     * CAN be preempted here!
     * 
     * The RCU machinery tracks that we're in a critical section
     * and ensures grace periods account for preempted readers.
     * 
     * This prevents a long-running RCU reader from blocking
     * high-priority real-time tasks.
     */
    process_potentially_long_operation(ptr);
    
    rcu_read_unlock();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# For mainline kernels (6.x+): PREEMPT_RT is a config option
# No patches needed for many configurations
 
# For kernels requiring patches:
# Visit: https://wiki.linuxfoundation.org/realtime/start
# Download matching patch version for your kernel
 
# Example: Applying patches to kernel 5.15
wget https://cdn.kernel.org/pub/linux/kernel/projects/rt/5.15/patch-5.15.XX-rtXX.patch.gz
gunzip patch-5.15.XX-rtXX.patch.gz
 
# Apply to kernel source
cd /path/to/linux-5.15
patch -p1 < ../patch-5.15.XX-rtXX.patch

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

# Essential PREEMPT_RT Configuration Options
 
# Core preemption model - select PREEMPT_RT
CONFIG_PREEMPT_RT=y          # Full real-time preemption
 
# Timer configuration
CONFIG_HIGH_RES_TIMERS=y     # High-resolution timer support (essential)
CONFIG_NO_HZ_FULL=y          # Tickless operation for RT tasks (optional)
 
# Scheduler features
CONFIG_RT_GROUP_SCHED=y      # RT task group scheduling (optional)
 
# Disable problematic features for RT
CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y  # Avoid frequency scaling
CONFIG_CPU_IDLE=n            # Or configure very short idle states only
 
# Debugging (disable in production for lower latency)
CONFIG_DEBUG_PREEMPT=n       # Disable for production
CONFIG_PROVE_LOCKING=n       # Disable for production
CONFIG_LOCKDEP=n             # Disable for production
 
# Tracing (keep for latency analysis, disable for absolute minimum)
CONFIG_FTRACE=y              # Function tracing
CONFIG_IRQSOFF_TRACER=y      # Track IRQs-off latency
CONFIG_PREEMPTIRQ_EVENTS=y   # Preemption/IRQ tracing
CONFIG_SCHED_TRACER=y        # Scheduler tracing
 
# Memory configuration
CONFIG_TRANSPARENT_HUGEPAGE=n   # Avoid THP overhead (recommended)
CONFIG_COMPACTION=n             # Consider disabling compaction

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

#!/bin/bash
# Runtime configuration for PREEMPT_RT system
 
# 1. Verify RT kernel is running
uname -a | grep -i rt || echo "WARNING: Not running RT kernel!"
 
# 2. Set CPU frequency to maximum (avoid frequency scaling latency)
for cpu in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do
    echo performance > $cpu
done
 
# 3. Disable real-time throttling (allow RT tasks to use 100% CPU)
# WARNING: A runaway RT task can hang the system!
echo -1 > /proc/sys/kernel/sched_rt_runtime_us
 
# 4. Isolate CPUs for RT tasks (kernel boot parameter is better)
# In /etc/default/grub, add: isolcpus=2,3 nohz_full=2,3
 
# 5. Configure IRQ affinities - move non-RT IRQs off RT CPUs
# Move all IRQs to CPU 0,1 (leaving 2,3 for RT tasks)
for irq in /proc/irq/*/smp_affinity; do
    echo 3 > $irq 2>/dev/null  # CPUs 0 and 1
done
 
# 6. Set RT thread priorities
# Example: Set network IRQ thread to priority 90
pgrep -f "irq/.*eth" | xargs -I{} chrt -f -p 90 {}
 
# 7. Lock memory for RT application
# Application should use mlockall(MCL_CURRENT | MCL_FUTURE)
 
# 8. Verify configuration
echo "=== RT Configuration Summary ==="
echo "Kernel: $(uname -r)"
echo "RT Runtime: $(cat /proc/sys/kernel/sched_rt_runtime_us)"
cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
echo "Isolated CPUs: $(cat /sys/devices/system/cpu/isolated)"