Arm Architecture and Linux Kernel Interface - Author's Direct Lecture

1. 30% discount coupon issued when 300 people sign up

To celebrate reaching 300 students (Part 1 and 2), we are issuing a 30% discount coupon. Thank you. It is for the first 200 people.

• 30% off coupon link: https://inf.run/rjtAk

2. Roadmap Guide 🎯

This lecture is a roadmap 'Arm - advanced course for system software developers ' This lecture is included in .

If you want to learn Arm architecture (Armv8-A, Armv7-A) systematically , it is recommended to use the roadmap ( 30% discount on all lectures ). For reference, the Arm architecture roadmap (all author lectures) is Basic Course and Advanced Course It consists of two parts.

The most important thing in modern system software
Arm Architecture and the Linux Kernel

The Arm processors used in smartphones, AI SoC system semiconductors, electric vehicles (autonomous driving, infotainment), cloud servers, and MacBooks are all Armv8-A based 64-bit Cortex-A processors (Cortex-A53, Cortex-A57, Cortex-A72, etc.). The Armv8-A architecture can be seen as the most needed basic knowledge in the current system software industry.

In electric vehicles and system semiconductors
The most running operating system kernel

The Linux kernel, along with Arm processors, is used in smartphones, cloud servers, and electric vehicle systems . In addition, most system software developers in the system semiconductor industry (fabless) use the Linux kernel or Linux device drivers to program drivers that control the chips they design .

To recap, the most commonly running operating system kernel on Arm processors is the Linux kernel.

' Interface between Arm architecture and Linux kernel '
4 Reasons Why You Should Learn

1⃣ First, if you are familiar with the interface between the Arm architecture and the Linux kernel (assembly instruction analysis), you can better understand the detailed operation of the Arm architecture. This is because you can internalize what you have learned by analyzing the source code that implements what you have learned in theory.

2⃣ Second, the core functions of the Linux kernel, such as processes, interrupt handling, system calls, and memory management techniques, are implemented by utilizing the features of the CPU architecture. If you are familiar with the interface between the Arm architecture and the Linux kernel, you can deeply understand the detailed operation of the Linux kernel.

3⃣ Third, by analyzing the registers, exception handling, assembly instructions, trust zone, and memory management methods in the source code of the Linux kernel, you can learn about the Arm architecture and the Linux kernel together.

4⃣ Fourth, Arm processors and the Linux kernel are used in more than 90% of the products in the system software industry. If you understand how the Linux kernel works on the Arm processor, you can apply what you have learned.

Most system software developed recently is developed in Arm processors and Linux environments, so knowledge related to this is essential.

Based on my experience writing books and giving lectures
More in-depth and detailed than anyone else!

Developers who have attended the author's lecture on 'Arm Architecture Structure and Principles for System Software Development' may be surprised. This is because the Arm architecture lecturer suddenly talks about the Linux kernel. However, I am the author who wrote not only Arm architecture but also Linux kernel books. My main history related to the Linux kernel is as follows.

As the instructor of this course, I am confident that I can explain the 'Arm architecture and the Linux kernel interface' better than anyone else.

I recommend this to these people

After class

• Understand the detailed operating principles of the Arm architecture

• Understand how the major subsystems of the Linux kernel are implemented by leveraging the features of the Arm architecture.

• Understanding how the Linux kernel implements context scheduling

• Understanding the detailed operation of system calls and exception handlers in the Linux kernel

• Understanding how the Linux kernel implements its memory system

Learn about these things

For students who are not familiar with Linux, this course introduces the overall structure of a Linux system. It explains in detail the three major resources that are important to the Linux kernel.

Describes the core of the Linux kernel: processes (user space and kernel space, user processes, kernel threads).

Describes the data structures of a process dependent on the Arm architecture, covering in detail the operating principles, especially the registers involved in context switches.

The behavior of context switching dependent on the Arm architecture is described in detail through assembly instruction analysis.

Explains the flow of interrupt processing in a big picture. The method of handling interrupts is explained in detail through an analysis of the 'Exception Vector Table of the Armv8 Architecture'.

The flow of interrupt handling is explained based on two scenarios (interruption occurring during user application execution, interruption occurring during kernel code execution). Next, the exception handler code (assembly code) is reviewed in detail.

We review the entire execution flow of a system call and explain in detail the contents of the exception vector table related to the system call.

We analyze the SVC instruction routine that is executed when a system call is triggered in user space. Then, we describe in detail the exception handler routine that is executed in kernel space during the process of triggering a system call.

Describes the kernel core APIs that are processed when a system call is triggered (SVC instruction execution) and the system call handler is called in kernel space. It also covers the core symbol information of the system call handler in detail.

This article introduces the main functions of memory management in the Linux kernel and explains memory management-related features that should be known from the perspective of the Arm architecture.

We introduce the config for setting the range of virtual addresses in the Linux kernel. Then, we describe the interface supported for multi-level page tables in the Linux kernel.

This section details the workings of page lookups handled using interfaces supported by the Linux kernel, and the structure of the fixup macro.

Vivid course reviews left by students

<Structure and Principles of Arm Architecture for System Software Development - Part 1/2 Author's Lecture>

Things to note before taking the class