====== Technical details of the real-time preemption ======

The main aim of the real-time preemption is to //minimize the amount of kernel code that is non-preemptible// ((Paul McKenney, A realtime preemption overview [[https://lwn.net/Articles/146861/]])). 
Therefore different mechanisms are implemented. Those mechanisms are partially available in mainline Linux.
The PREEMPT_RT patch has been partially merged into the mainline Linux kernel, starting from version 5.15 ((Realtime preemption locking core merged [[https://lwn.net/Articles/867919/]]))
and enabled with ''CONFIG_PREEMPT_RT''

----

<WRAP half column>
===== High resolution timers =====

The high resolution timers allows precise timed scheduling and removes the dependency of timers on the periodic scheduler tick (jiffies). 

<WRAP rightalign>[[realtime:documentation:technical_details:hr_timers|Read more about High Resolution Timers]]</WRAP>

===== Threaded interrupt handler =====

The PREEMPT_RT patch forces the mechanism of threaded interrupt handlers. Due to this all interrupt handlers run in a threaded context except they are marked with the IRQF_NO_THREAD flag. This mechanism can be forced also in Linux mainline kernel without PREEMPT_RT patch by the kernel command line option ''threadirqs''. But there is a small difference in the resulted behavior.

<WRAP rightalign>[[realtime:documentation:technical_details:threadirq|Read more about threaded interrupt handlers]]</WRAP>

===== RCU =====

RCU mechanisms in mainline Linux are only preemptible if CONFIG_PREEMPT is set (Preemption model: "Low-Latency Desktop"). The PREEMPT_RT preemption models both use preemptible RCU mechanisms. Additionally the PREEMPT_RT patch eliminates RCU handling from all intermediate states and processes it only in its own thread.

<WRAP rightalign>[[realtime:documentation:technical_details:rcu|Read more about RCU]]</WRAP>

</WRAP>

<WRAP half column>

===== rt_mutex =====

[[https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/include/linux/mutex.h|Mutexes]] are implemented with
[[https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/include/linux/rtmutex.h|rt mutexes]]. A rt_mutex implements priority inheritance (see ''rt_mutex_adjust_prio_chain'') to avoid priority inversion. This also applies to sleeping spinlocks and rwlocks. However, the holder of a semaphore can be preempted but does not participate in priority inheritance.

<WRAP rightalign>[[https://docs.kernel.org/locking/rt-mutex-design.html|Read more about rt_mutex]]</WRAP>

===== Sleeping spinlocks =====

In a non-PREEMPT-RT preemption model [[https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/include/linux/spinlock_types.h|spinlocks]]
are mapped onto
[[https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/include/linux/spinlock_types_raw.h|raw spinlocks]].
A task waiting for a spinlock held by another task spins until the task holding the spinlock releases it. Preemption is disabled in raw spinlock context. In PREEMPT_RT spinlocks are mapped onto [[https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/include/linux/rtmutex.h|rt_mutex_base]]
and became "sleeping spinlocks", and raw spinlocks retain their behavior. A task waiting for a sleeping spinlock goes to sleep and is woken up when the spinlock is released. In the sleeping spinlock context preemption is not disabled.

<WRAP rightalign>[[realtime:documentation:technical_details:sleeping_spinlocks|Read more about sleeping spinlocks]]</WRAP>

===== local_lock =====

local_lock maps to a per CPU spinlock, which protects the critical section while staying preemptible. See [[https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/include/linux/local_lock_internal.h#n104|local_lock_internal.h]]

<WRAP rightalign>[[https://docs.kernel.org/locking/locktypes.html#local-lock-and-preempt-rt|Read more about local_lock and PREEMPT_RT]]</WRAP>

</WRAP>