Linux 7.3 on Apple Silicon: Thunderbolt, P3S, and GPL

The Asahi Linux 7.3 progress report brings M3 GA support, upstream macaudio and AVD drivers, M5 Exclave hypervisor reverse engineering, P3S 4 KiB page translation for gaming, custom Thunderbolt, and GPLv2+ re-licensing.

TL;DR

  • Upstream Driver Submissions: Linux 7.3 patchsets introduce the 3,100-line macaudio driver and the 13,000-line AVD video driver to LKML, alongside barebones Devicetrees for M4 Pro, M4 Max, and M5 SoCs.
  • Apple M3 General Availability: M3 hardware drops the EXPERT installer flag, enabling Display Controller Protocol (DCP) for hardware sleep, power optimizations, and notch area display handling.
  • M5 Exclave Hypervisor Support: The m1n1 hypervisor now orchestrates three concurrent EL1 virtual machines to handle macOS, Secure Page Table Monitor (SPTM), and Secure Kernel Exclaves over Tightbeam IPC.
  • Custom Thunderbolt Driver: Upstream driver brings support for Apple’s Cortex-M3/RTKit Thunderbolt controllers, enabling USB3, XDomain, and host-to-host networking.
  • Page Size Parity with P3S: Google’s Per Process Page Size (P3S) patchset modifies ARM64 Translation Control Registers (TCR) to run 4 KiB processes natively on 16 KiB hosts without hypervisor virtualization overhead.
  • Strategic Governance Shift: Asahi Linux is transitioning codebases from MIT to GPLv2+ to prevent uncredited commercial code extraction and LLM-assisted origin obfuscation.

The release of Linux 7.3 brings structural subsystem integrations to the ARM64 desktop and server architecture. Kernel developer patchsets submitted to the Linux Kernel Mailing List (LKML) include multi-thousand-line drivers for complex audio subsystems and hardware video decoding, alongside preliminary Devicetree support for recent Apple Silicon generations. These milestones signal a transition from downstream hardware enablement to upstream-first kernel integration for custom ARM64 SoCs.

Engineering efforts on linux 7.3 apple silicon have focused on low-level memory management friction, proprietary co-processor management, and hypervisor architecture. High-performance computing workloads and binary translation layers on ARM64 have historically suffered performance degradation due to page size mismatches between 16 KiB host kernels and 4 KiB legacy software dependencies. Innovations such as Per Process Page Size (P3S) address this memory translation overhead at the hardware register level, while custom hypervisor tooling expands to handle Apple’s hardware-isolated Secure Kernel environments.

Beyond low-level technical challenges, the project faces operational shifts in software maintenance. To counter uncredited commercial derivative works and automated source code obfuscation, maintainers are shifting repository licensing models from permissive terms to strong copyleft. This decision reflects growing tensions between open-source project sustainability and aggressive corporate extraction of platform enablement code.

Upstreaming Milestones in Linux 7.3: macaudio and AVD Drivers

Subsystem upstreaming for Apple Silicon reached a critical point during the Linux 7.3 release cycle, characterized by two major driver submissions to LKML: macaudio and avd. Submitting macaudio required extensive groundwork across the Advanced Linux Sound Architecture (ALSA) core to accommodate Apple’s non-standard routing topologies and digital signal processing requirements. Representing approximately 3,100 lines of code across driver logic and Devicetree definitions, the patchset introduces support for customized hardware configurations, including modified variants of speaker and headset amplifiers that previously lacked upstream representation.

The audio patchset required modifications to existing upstream amplifier drivers to ensure proper signal path initialization, impedance matching, and thermal protection. Standard ALSA primitives assumed rigid hardware signal routing, forcing developers to implement core changes before the platform-specific audio driver could be posted for peer review. This structural work paves the way for clean, production-grade audio support across multiple MacBook variants without downstream out-of-tree kernel modules.

In contrast to the multi-year development cycle of the audio stack, the AVD (Apple Video Decoder) driver achieved rapid upstream submission. The driver spent approximately three months in the downstream repository before being submitted to LKML as a ~13,000-line patchset. This short turnaround time demonstrates an maturing internal engineering pipeline, allowing complex media acceleration blocks to transition from initial reverse engineering to formal upstream review in months rather than years.

# Example: Checking video decoder driver registration in kernel dmesg
dmesg | grep -i -E "(avd|macaudio|alsa)"
# Verify registered ALSA sound cards and PCM nodes
aplay -l

Alongside driver submissions, contributor Yureka submitted barebones Devicetrees for the Apple M4 Pro, M4 Max, and M5 SoCs. These initial Devicetree files contain the minimum register configurations, interrupt maps, and memory regions required to boot the kernel to a serial or text-based TTY console. While missing peripheral initialization for graphics, audio, and high-speed I/O, these initial trees establish the baseline hardware definitions upon which future platform support will be built within the mainline tree.

General Availability for Apple M3: DCP, Sleep, and Power Delivery

Support for the Apple M3 SoC has transitioned from an experimental phase to General Availability (GA) status. Prior releases required users to explicitly pass the EXPERT flag within the Asahi Linux installer to deploy kernel images to M3-based hardware. Following feedback and stability reports from early adopters, maintainers removed the installer flag, marking M3 devices as fully supported for general installation.

The technical driver behind this GA transition is the stable enablement of the Display Controller Protocol (DCP). Apple’s hardware architecture offloads display management to a dedicated co-processor running proprietary firmware, communicating with the primary OS via DCP. Integrating DCP support on M3 hardware addresses several critical platform requirements:

  • System Sleep and Power States: DCP interaction allows the SoC to enter low-power S2idle sleep states during inactivity, eliminating power drain while idle.
  • Battery Management: Dynamic display clock scaling and hardware-managed backlighting reduce overall CPU package power draw.
  • Display Notch Usability: The display driver properly parses screen geometry, allowing desktop environments like KDE Plasma and GNOME to render around the physical camera notch without obscuring user interface elements.

With DCP operational, M3-based MacBooks achieve feature parity with M1 and M2 systems regarding core platform functionality, power management, and thermal control. The remaining delta between generation features lies primarily in the complex hardware architecture of the M3 graphics processing unit.

Hypervisor Architecture: Virtualising M5 Exclaves and Tightbeam IPC

As Apple updates its system architecture, hardware-enforced security boundaries present increasing operational friction for third-party operating systems. In M4 and M5 series chips, Apple expanded the deployment of the Secure Page Table Monitor (SPTM) and introduced an isolated userland model known as Exclaves. Exclaves operate inside a Secure Kernel environment, isolated from the main XNU kernel at Exception Level 1 (EL1) or Exception Level 2 (EL2).

Exclaves Operational Role

In Apple macOS builds for M5 SoCs, Exclaves perform security-critical system tasks, such as rendering the hardware camera indicator directly to the display pipeline. The primary XNU kernel communicates with these isolated applications over SPTM using a specialized Inter-Process Communication (IPC) protocol named Tightbeam. If XNU detects missing or unresponsive Exclaves during boot, the kernel triggers an unrecoverable panic.

To reverse engineer and boot Linux on M5 hardware without triggering security panics, developer Sven extended the m1n1 stage-1 hypervisor. The hypervisor was adapted to instantiate and manage three distinct virtual machines simultaneously within EL1 execution space:

  1. VM 1 (macOS / XNU): Executes the primary target operating system kernel.
  2. VM 2 (SPTM): Hosts the Secure Page Table Monitor to satisfy memory access hypervisor queries.
  3. VM 3 (Secure Kernel & Exclaves): Manages the isolated Exclave execution environment and handles incoming Tightbeam IPC requests.
+-------------------------------------------------------------------+
|                        m1n1 Hypervisor (EL2)                      |
+-------------------------------------------------------------------+
       |                            |                           |
       v                            v                           v
+--------------+           +------------------+       +-------------------+
| VM 1: XNU    |  Tightbeam| VM 2: SPTM       |       | VM 3: Secure      |
| Main Kernel  |<=========>| Memory Monitor   |       | Kernel & Exclaves |
| (EL1)        |    IPC    | (EL1)            |       | (EL1)             |
+--------------+           +------------------+       +-------------------+

By virtualising all three execution contexts under m1n1, developers can trace Tightbeam IPC messages, inspect register state transitions, and observe how the Secure Kernel interacts with underlying hardware peripherals. This tri-VM topology provides the visibility required to construct native Linux drivers for M4 and M5 hardware generations.

Deconstructing Apple’s Custom Cortex-M3 Thunderbolt Controller

Thunderbolt support on custom ARM64 architectures has historically been complicated by proprietary hardware choices. In standard x86 and ARM server designs, Thunderbolt host controllers are built to Intel specifications with predictable register maps, DMA descriptors, and memory-mapped I/O (MMIO) topologies. Mainline Linux’s Thunderbolt driver (located under drivers/thunderbolt) was developed entirely around these Intel-centric hardware assumptions.

Apple departed from standard implementation models by designing a custom, per-port Thunderbolt/USB4 controller block. Each physical Thunderbolt port on an Apple Silicon Mac features a dedicated controller driven by an embedded ARM Cortex-M3 co-processor running Apple’s RTKit real-time operating system, paired with a custom USB4/Thunderbolt router core.

Hardware Attribute Standard Intel Thunderbolt Apple Silicon Custom Thunderbolt
Co-processor ISA Proprietary / Integrated x86 host logic ARM Cortex-M3 core per port
Firmware OS Vendor Monolithic Firmware RTKit Real-Time Operating System
Reset Logic Dedicated PCIe/ACPI Power State Registers Bits embedded in Power Management (PMGR) MMIO
Host Subsystem Mainline drivers/thunderbolt assumptions Custom IPC layer over shared memory structures
Linux 7.3 Status Full (PCIe, DP, USB3, Networking) USB3, XDomain, TB Networking (PCIe/DP missing)

A primary obstacle during reverse engineering was identifying how the host kernel asserts reset lines on the controller. Reverse engineering revealed that reset lines for the Cortex-M3 cores are directly coupled to Apple’s Power Management (PMGR) hardware block. Resetting a port controller requires asserting and deasserting bitfields positioned inside the middle of PMGR’s main MMIO address space—an architecture distinct from standard PCIe power state switches.

Developer Sven authored a bespoke upstream driver that translates Linux kernel Thunderbolt interactions into RTKit IPC messages. The driver shipped in Linux 7.3 implements a targeted feature set:

  • USB3 Pass-Through: High-speed USB3 data transfer across physical Type-C connectors.
  • XDomain Protocol: Peer-to-peer communication between two connected Thunderbolt hosts.
  • Thunderbolt Networking: Host-to-host IP networking over Type-C cables at high throughput.

Driver Functional Limitations

The Thunderbolt driver shipped in Linux 7.3 does not currently support PCIe tunneling or DisplayPort tunneling. Thunderbolt docks requiring PCIe encapsulation for extended display outputs, external GPUs, or legacy expansion cards will not function for those specific sub-protocols. The exact timeline for PCIe and DisplayPort tunnelling implementation in the custom Apple Silicon Thunderbolt driver has not been disclosed by maintainers.

Overcoming Page Size Friction: P3S and ARM64 TCR Switching

Memory page granularity remains a persistent issue when running legacy binary stacks on non-x86 hardware. Apple Silicon hardware is optimized for a native 16 KiB memory page size (`CONFIG_ARM64_16K=y`). Conversely, the vast majority of x86 and amd64 Linux software, Windows binaries, and game engines rely on an assumed 4 KiB page size structure (`CONFIG_PAGE_SIZE_4KB=y`).

Historically, execution of 4 KiB x86 software on Asahi Linux required running binaries inside a lightweight virtual machine via muvm, utilizing DRM Native Context for GPU pass-through. While functional, this virtualization model incurs significant trade-offs:

  • Performance Overhead: Virtualization boundaries cause an approximate 20% execution penalty depending on memory access patterns.
  • Display Server Limits: muvm cannot natively interface with Wayland compositors directly.
  • I/O Bottlenecks: Storage I/O throughput drops significantly due to virtio-fs translation layers.
  • Peripheral Handling: Complex input devices and game controllers suffer latency or routing failures across the VM boundary.

While macOS solves this in its Rosetta 2 translation layer by allowing the XNU kernel to set arbitrary page sizes on a per-process basis via custom ARM64 register extensions, the mainline Linux memory management subsystem requires all userspace processes to share the page size of the running host kernel.

To solve an identical issue in the Android ecosystem—where 16 KiB ARM64 host kernels must execute legacy 4 KiB Android application binaries—Google engineers Kalesh Singh and Frederick Mayle designed Per Process Page Size (P3S). P3S leverages ARM64 hardware capabilities by modifying the Translation Control Register (TCR) during process context switching.

   Process Context Switch (Kernel Scheduler)
                     |
                     v
      +------------------------------+
      |  Inspect Target Task Struct  |
      +------------------------------+
                     |
         +-----------+-----------+
         |                       |
         v                       v
[ Task Page Size: 16 KiB ]   [ Task Page Size: 4 KiB ]
         |                       |
         v                       v
+------------------------+  +------------------------+
| Write TCR_EL1 for 16K  |  | Write TCR_EL1 for 4K   |
| (No-op if unchanged)   |  | (Update TG0 bitfields) |
+------------------------+  +------------------------+
         |                       |
         +-----------+-----------+
                     |
                     v
       Execute Userspace Code at EL0

On ARM64 architectures, the `TCR_EL1` register controls page table translation parameters, including the page granule size for user address space (`TG0`). P3S tracks the required page granularity of each task structure. When the scheduler switches to a process designated for 4 KiB operation, the kernel writes the updated bit configuration to `TCR_EL1`. Because updating a control register is a single instruction, execution overhead is negligible compared to full VM initialization.

Applying the P3S patchset to the Asahi Linux tree permits complex 32-bit and 64-bit Windows software to run natively on a 16 KiB host kernel via FEX-Emu and WINE, bypassing muvm entirely:

# Diagnostic checking of P3S environment capability (Test in staging)
# Verify if running under a 16 KiB kernel configuration
getconf PAGESIZE
# Output should return 16384 on default Apple Silicon kernels

# Executing legacy binaries using a P3S userspace wrapper shim
p3s-shim -- /usr/bin/fex-emu -- ./GTAIV.exe

Performance testing demonstrates native-level execution across legacy applications using P3S without hypervisor layers:

  • Star Wars Battlefront (2004): 32-bit Direct3D 9 application executing cleanly under WineD3D.
  • Wolfenstein: The New Order (2014): 64-bit native Vulkan title utilizing ARM64EC WINE pathways, achieving 144+ FPS on an Apple M2 Max host.
  • Grand Theft Auto IV (2008): 32-bit workload leveraging DXVK over Vulkan, exhibiting higher frame rates than under muvm.
  • Fallout: New Vegas (2010): 32-bit engine running with DXVK translation.

Despite these performance gains, architectural challenges prevent immediate upstream integration into mainline Linux. P3S is hardcoded for 16 KiB host kernels managing 4 KiB guest processes, designed specifically for Google’s internal deployment scope. Core Linux memory management maintainers generally reject page-size-specific hacks in core `mm` code.

Additionally, P3S requires binary inspection or explicit userspace instruction to trigger page switching. Modern ARM64 binaries specify 64 KiB section alignment in ELF metadata to ensure cross-platform execution. Consequently, P3S misidentifies modern binaries as 64 KiB-compatible, necessitating a userspace shim to explicitly force 4 KiB page table layout for target binary trees. Whether Google plans to submit generalized P3S patches to mainline Linux memory management maintainers has not been publicly confirmed.

Graphics Acceleration Progress and DSP SIMD Optimisations

Graphics drivers for M3 generation hardware have progressed past early reverse engineering milestones. The M3 GPU microarchitecture represents a significant departure from M1 and M2 pipelines, requiring dedicated architectural analysis. At the X Developer Conference (XDC), developers Alyssa Millburn, Anna Maniscalco, and TellowKrinkle outlined the structural differences present in M3 graphics hardware.

The team successfully achieved initial hardware initialization within the m1n1 environment, issuing commands directly to the GPU context to render a basic test triangle. While basic rendering validates hardware initialization routines and command queue structures, integrating these changes into the upstream Mesa AGX driver stack requires redesigning compiler backends and memory allocation paths within Mesa.

Parallel to GPU work, audio engineering teams optimized userland digital signal processing (DSP) components. The internal microphone array on MacBook hardware uses a custom beamforming pipeline named Triforce, written in Rust. The initial implementation relied on an FFT-based analytic transform that was subsequently replaced with Infinite Impulse Response (IIR) filtering to reduce baseline mathematical complexity.

However, automatic vectorization in `rustc` failed on the new IIR loop implementations. Contributors Linkmauve and Frédéric Bour authored hand-coded SIMD assembly routines targeting both `arm64` NEON instructions and `amd64` AVX/SSE extensions. These SIMD routines doubled DSP execution speed while lowering overall host CPU utilization during active audio recording.

Distribution Synchronisation: Fedora Asahi Remix 45

Platform distribution mechanics achieved operational parity with main-line release cycles on 3 November 2026, with the synchronous launch of Fedora Asahi Remix 45 alongside upstream Fedora Linux 45. This marks the first instance where the downstream ARM64 distribution achieved day-and-date release alignment with its upstream parent distribution.

# Upgrading an existing Fedora Asahi Remix system via dnf
sudo dnf system-upgrade download --releasever=45
sudo dnf system-upgrade reboot

Delivery mechanics rely on standard RPM package repositories, serving tailored kernel builds, modified `mesa` hardware acceleration drivers, updated `m1n1` bootloader stage binaries, and DSP configurations directly to userland endpoints without custom deployment scripts.

Open Source Governance: The Strategic Migration from MIT to GPLv2+

The maintenance strategy of the Asahi Linux project has undergone a fundamental shift regarding license governance. Historically, the project licensed its userland utilities, hypervisor code, and hardware enablement libraries under permissive open-source terms (primarily the MIT license) to permit cross-pollination with BSD distributions and alternative operating system kernels.

This permissive licensing model has proven vulnerable to commercial extraction. Maintainers reported multiple incidents where commercial actors harvested in-development feature code directly from maintainers’ personal git repositories. This code was incorporated into proprietary, monetized platform forks without attribution. In some cases, commercial entities utilized Large Language Models (LLMs) to perform automated code transformation and structural obfuscation, stripping original copyright headers while retaining functional driver logic.

Licensing Policy Shift

To defend against commercial exploitation and automated source obfuscation, Asahi Linux is relicensing its repository ecosystem to the GNU General Public License version 2 or later (GPLv2+). permissive MIT licensing provides no legal recourse against uncredited code reuse or origin obfuscation, forcing a transition to copyleft governance models.

This strategic pivot mirrors historical open-source licensing transitions. In 2002, the WINE project abandoned its permissive MIT licensing model in favor of the LGPL (and later GPL) to prevent proprietary vendors from extracting core compatibility code into closed commercial products without contributing upstream fixes. The specific identities of commercial entities attempting to fork Asahi code under MIT licensing have not been disclosed by project maintainers.

Under GPLv2+, any commercial entity, hardware vendor, or AI model training operator distributing binaries or derivative works based on Asahi repositories must make the complete corresponding source code available under identical copyleft terms, securing open development trees against closed extraction.

Practical Implementation and Architecture Considerations

Engineers deploying ARM64 Linux nodes on Apple Silicon hardware or managing non-standard page size configurations in cloud infrastructure must evaluate several operational constraints:

1. Memory Page Size Configuration in Containerized Workloads

Running containerized application stacks on 16 KiB ARM64 host kernels requires verifying binary toolchain assumptions. Allocators such as `jemalloc`, embedded database engines (e.g., LMDB, RocksDB), and JIT runtimes (e.g., V8, Node.js) often contain hardcoded assumptions regarding 4 KiB page alignment. Engineers should test image builds on native 16 KiB environments to prevent memory allocation faults or unexpected resident set size (RSS) bloat.

# Diagnostic check: Verify page size assumptions in container runtimes
docker run --rm alpine getconf PAGESIZE

2. Managing Hypervisor Firmware and Boot Stages

Deployments must maintain strict alignment between `m1n1` stage-1 hypervisor releases, system Devicetrees, and running kernel versions. When updating Linux 7.3 kernel trees on M3 or M4 hardware, administrators must ensure the ESP (EFI System Partition) bootloader payloads are updated concurrently to prevent devicetree structure mismatches during early boot.

3. Assessing Copyleft Governance in Embedded Hardware Enablement

Systems integrators designing hardware products around Asahi enablement libraries must account for the shift to GPLv2+. Internal modification of board support packages (BSPs), driver layers, or low-level hypervisor tools will require full source distribution to end users if the hardware platforms are commercially deployed.

Key Engineering Takeaways

The Linux 7.3 development cycle demonstrates significant technical progress across ARM64 platform bringup, driver integration, and ecosystem governance. Key engineering takeaways include:

  • Upstreaming Speed: Subsystem integration velocity is increasing, highlighted by the submission of the 13,000-line AVD video decoding driver and core ALSA audio driver patchsets to LKML.
  • Hardware Hypervisor Virtualization: Modern ARM64 hardware features such as Apple’s M5 Exclaves require multi-VM hypervisor architectures (e.g., m1n1 running three concurrent EL1 targets) to virtualise hardware IPC layers like Tightbeam.
  • Register-Level Page Switching: Hardware register manipulation via ARM64 TCR (P3S) eliminates hypervisor overhead when executing 4 KiB guest software on 16 KiB host kernels, opening up performance optimizations for binary translation layers.
  • Copyleft License Protection: Strong copyleft licensing (GPLv2+) remains a critical legal barrier for open-source projects defending against unauthorized commercial extraction and LLM-assisted source code obfuscation.

Frequently asked questions

Why does Asahi Linux require custom handling for 4 KiB page sizes?

Apple Silicon hardware operates natively with a 16 KiB memory page size for optimized kernel performance. However, legacy x86/amd64 software, Windows API translation layers (WINE), and game engines hardcode an assumed 4 KiB page size alignment. Running this software directly on a native 16 KiB kernel leads to memory allocation failures or requires virtual machine abstractions.

How does the P3S patchset switch page table granularities without severe performance overhead?

Per Process Page Size (P3S) operates by tracking the required page table granularity within each process task structure. During a context switch, the kernel writes the appropriate page granule parameters to the ARM64 Translation Control Register (`TCR_EL1`). Because updating a hardware register is a single instruction operation, execution overhead is negligible compared to running full virtual machines.

What features are currently functional on Apple Silicon Thunderbolt ports under Linux 7.3?

The Linux 7.3 custom Thunderbolt driver supports USB3 data transport, XDomain peer-to-peer protocols, and host-to-host Thunderbolt Networking. DisplayPort video tunnelling and PCIe encapsulation are currently unsupported. The exact timeline for PCIe and DisplayPort tunnelling implementation has not been publicly disclosed.

Why is Asahi Linux transitioning its codebase from the MIT licence to GPLv2+?

Maintainers identified multiple instances where commercial entities extracted in-development feature code from maintainer repositories without attribution, using LLMs to obfuscate the source origin. Because permissive MIT licensing provides no copyleft protections against derivative commercial exploitation, the project adopted GPLv2+ to mandate that all downstream modifications remain open source.

Sources and further reading

This article was drafted with AI assistance from the publicly cited sources and passed automated checks for structure and sourcing. Verify critical details against the vendor advisories linked above before acting.