The article explains how batching cache‑sync operations for dma_map_sg, dma_unmap_sg and dma_sync_sg on arm64 can cut their execution time by up to three‑fold, details the kernel patches introduced, and presents benchmark results on Dimensity 9500 and RK3588 platforms.
This article explains the fundamentals of Linux arm64 memory management, covering virtual and physical memory concepts, MMU operation, page table structures, address translation steps, page fault handling, and practical C++ examples for allocation, mapping, and performance optimization using huge pages and pre‑paging techniques.
Redis on ARM64 platforms may abort startup with a warning about a kernel COW bug when Transparent Huge Pages are enabled, risking RDB corruption; this guide explains the underlying issue, when it’s safe to ignore the warning, and provides two solutions—disabling THP or configuring ignore‑warnings—to ensure safe operation.
This article walks through the registration of the KVM misc device in the Linux 5.9 kernel for arm64, explains how /dev/kvm is created via misc_register, and demonstrates a user‑space program that opens the device and uses an ioctl to retrieve the KVM API version, with detailed code analysis.
This article walks through the step‑by‑step initialization of KVM's hyp mode memory mapping on ARM64, covering EL2 register setup, identity mapping, page‑table allocation, stack preparation, and code section mappings required for a functional hypervisor environment.
The article provides a detailed technical analysis of Linux 5.9 on arm64 KVM, explaining how Host and Guest OSes are distinguished at EL1, how HCR_EL2 flags control mode switching, and how the EL2 exception vector and related registers are initialized during Linux boot to enable KVM virtualization.
The article explains how Type‑1 and Type‑2 hypervisors differ in their use of ARM64 exception levels, outlines their shared responsibilities such as resource, scheduling, and device management, and compares their architectures and performance through a serial‑port example, highlighting the trade‑offs of each approach.
The article explains why backtracing with eBPF fentry on arm64 is harder than on x86, details the stack layout differences, shows how recent commits changed register saving, and provides a practical detection routine to locate the frame pointer and retrieve the tracee's instruction pointer.
This guide walks developers with C and assembly experience through building a simple bare‑metal operating system that runs directly on ARM64 hardware without any existing OS or bootloader, offering a hands‑on introduction to low‑level system concepts for students, embedded engineers, and computer‑system enthusiasts.
This article traces the evolution from real‑mode segmentation to modern paging, explains segment and page‑table structures on x86 and ARM, dissects kernel macros such as PGDIR_SHIFT and PUD_SHIFT, and demonstrates a kernel module that translates a process's virtual address to its physical address.
The openEuler 24.03 LTS release introduces a dynamic composite page (large folio) that retains 4 KB base‑page compatibility while enabling 64 KB page performance gains, reducing TLB misses and memory overhead, and delivering double‑digit benchmark improvements for big‑data, Kafka, MySQL, I/O and memory‑allocation workloads.
This article explains the background, purpose, and detailed implementation of the Linux kernel cgroup freezer subsystem, including its data structures, command‑line usage, signal‑based freeze workflow, and a practical experiment that demonstrates process suspension and power savings on ARM64.
Linus Torvalds, the creator of Linux and Git, has upgraded from an AMD Ryzen Threadripper workstation to a powerful Ampere AArch64 system, boosting his ARM64 kernel testing to match x86‑64 builds and signaling a shift in hardware strategy for upcoming Linux 6.10 merges.
This guide explains why Intel‑based macOS libraries need architecture conversion for Apple Silicon simulators, compares XCFramework and Rosetta solutions, and provides a step‑by‑step method using lipo, ar, and custom Swift code to replace load commands and rebuild arm64 binaries for simulator use.
The article explains Linux kernel read‑write semaphores, detailing the classic rw_semaphore’s optimistic‑spinning and hand‑off mechanisms, then introduces the per‑CPU rwsem for ARM64, which replaces global counters with per‑CPU data and an RCU fast‑path to cut cache‑coherency traffic at the cost of losing optimistic spinning.
This tutorial details how to set up a cross‑compilation toolchain on Ubuntu 20.04, install QEMU, build a BusyBox‑based root filesystem, compile and configure the ARM64 Linux kernel, create a simulated disk, share files between host and guest, and perform kernel debugging using GDB and Eclipse.
The 18th China Linux Kernel Developer Conference (CLK 2023) will be held in Shenzhen on October 28, 2023, hosted by OPPO, and invites Linux kernel developers to submit technical papers (open call from September 22, deadline October 10) on topics such as architecture, scheduling, memory, storage, networking, virtualization, performance, testing and kernel use in IoT, mobile, automotive, cloud and AI, with required author bio, title and abstract.
This article, based on ByteDance STE’s 2022 Linux Kernel Developer Conference talk, explains the HVO (HugeTLB vmemmap Optimization) feature that dramatically reduces struct page memory for huge pages, details its latest enhancements, cross‑architecture support, usage steps, performance trade‑offs, and future plans.
Microsoft announced the official release of .NET 7 on November 9, highlighting major enhancements such as improved Base Class Library, native ARM64 support, expanded Linux and IBM Power compatibility, integrated .NET MAUI and Blazor updates, and streamlined container and Azure cloud‑native capabilities.
Microsoft’s .NET Framework 4.8.1 update, bundled with Visual Studio 2022 17.3, introduces native Arm64 support and official Arm64EC compatibility, enabling legacy .NET apps to run directly on Arm64 hardware without emulation, while dropping support for older Windows versions and providing new download links.
The article details how Linux’s function‑graph ftrace tracer works on ARM64, explaining required kernel configs, how -pg inserts _mcount calls, the runtime patching of ftrace_graph_caller, register usage for argument passing, and return handling, and why shadow‑call‑stack must be disabled to enable precise call‑graph and timing analysis.
Linus Torvalds announced the stable Linux 5.19 kernel, built on an Apple M2‑based ARM64 MacBook with Asahi Linux support, highlighting new features such as LoongArch support, FAT32 timestamps, AMD BRS sampling, RISC‑V 32‑bit compatibility, Zstd firmware compression, and a substantial increase in graphics driver code.
This article explains the technical details of Linux kernel preemption, covering the difference between preemptible and non‑preemptible kernels, the role of the reschedule flag and preempt count, scheduling checkpoints and preempt points, low‑latency handling in non‑preemptible kernels, and the voluntary preemption model.
KVM turns the Linux kernel into a hypervisor that, together with QEMU, provides hardware‑assisted CPU and memory virtualization on ARM64 platforms, using EL2‑based Stage‑2 address translation, while offering multiple I/O virtualization methods such as emulation, virtio, device passthrough, and shared assignment for flexible guest performance and isolation.
The QQ Music/Karaoke team migrated their Android app from 32‑bit to Arm64‑v8a by reconfiguring Gradle builds, recompiling or replacing over 120 native libraries, extending the dynamic‑resource loader for ABI selection, implementing ABI‑aware update channels, and fixing issues such as library path limits, I/O reliability, camera latency, and WebView cache corruption, completing the transition in early 2021.
This article explains how to write and integrate ARM64 inline assembly in iOS applications to implement anti‑debugging checks, discusses the syntax, constraints, calling conventions, common pitfalls, and provides complete assembly‑only solutions for secure runtime detection.
The article explains Linux kernel virtual memory management on 64‑bit ARM64 Android systems, detailing user‑ and kernel‑space address layout, physical vs. linear addresses, allocation mechanisms such as brk and mmap, common allocators, key structures like mm_struct and vm_area_struct, and the functions that control mmap layout and unmapped‑area selection.
This article explains the principles and challenges of migrating software from x86 to Huawei's Kunpeng ARM64 platform, covering instruction‑set differences, dependency analysis, compilation adjustments, performance testing, and the suite of tools Huawei provides to streamline the migration process.
This guide walks you through using an automated script to download dependencies, build QEMU 4.1.1, compile the Linux 4.19.1 kernel and BusyBox for ARM64, and install openEuler 1.0 in a virtual machine, including optional GDB debugging and snapshot tips.
This guide shares practical experience and step‑by‑step solutions for migrating C/C++ and other language projects from x86 servers to ARM64 TaiShan platforms, covering compilation differences, code adjustments, compiler options, and performance tuning to achieve stable and efficient execution.
This article investigates a crash caused by calling IMP pointers on ARM64 iOS devices, explains how variadic function argument passing differs from the standard ABI, demonstrates the issue with test code and assembly analysis, and provides a solution by explicitly casting IMP to the correct function type.
