kernel-concurrency

Kernel Concurrency

Purpose

Guide agents through synchronization in the Linux kernel: spinlocks, mutexes, semaphores, RCU, seqlocks, completions, and memory ordering rules — critical for correct drivers and subsystem patches.

When to Use

• IRQ handler shares data with process context
• Read-mostly data structures needing RCU
• Choosing lock type for probe vs ioctl paths
• Debugging deadlocks or scheduling while atomic

Workflow

1. Lock selection tree

Context can sleep?
├── No (IRQ, spinlock held, preempt disabled)
│   └── spin_lock_irqsave() / atomic_t
└── Yes
    ├── Exclusive long-held → mutex
    ├── Reader/writer → rw_semaphore or RCU (read-mostly)
    └── One-shot signal → completion

Never sleep while holding a spinlock (kmalloc(GFP_KERNEL), mutex_lock).

2. Spinlock + IRQ

spinlock_t lock;
unsigned long flags;

spin_lock_irqsave(&lock, flags);
/* critical section — no blocking */
spin_unlock_irqrestore(&lock, flags);

Use spin_lock_bh when softirq/tasklet sharing is the concern.

3. Mutex in process context

struct mutex m;
mutex_lock(&m);
/* may allocate, may sleep */
mutex_unlock(&m);

4. RCU (read-copy update)

/* Readers — no lock */
rcu_read_lock();
p = rcu_dereference(ptr);
/* use p */
rcu_read_unlock();

/* Writer */
new = kmalloc(...);
rcu_assign_pointer(ptr, new);
synchronize_rcu();
kfree(old);

RCU readers must not block indefinitely. Grace period completes after all CPUs quiescent.

5. Seqlock (jiffies, timestamps)

unsigned seq;
do {
    seq = read_seqbegin(&seqlock);
    /* read shared data */
} while (read_seqretry(&seqlock, seq));

Writer uses write_seqlock / write_sequnlock.

6. Completions

DECLARE_COMPLETION(done);
/* waiter */
wait_for_completion(&done);
/* signaller */
complete(&done);

7. Memory barriers

Kernel provides smp_mb(), smp_wmb(), smp_rmb(). Device MMIO uses readl/writel (ordered on most arches). See skills/low-level-programming/memory-model for userspace analogies.