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

1. 30% Discount Coupon Issued for Breaking 300 Students

To commemorate reaching 300 students (Parts 1 & 2), we are issuing a 30% discount coupon. Thank you. Limited to the first 200 people.

• 30% discount coupon link: https://inf.run/EwJWs

2. Roadmap Guide 🎯

This lectureRoad Map'Arm for System Software Developers - Advanced Course'is included in the course.

For those who want to learn Arm architecture (Armv8-A, Armv7-A) systematically, it would be good to utilize the roadmap (30% discount on all courses). For reference, the Arm architecture roadmap (all courses taught directly by the author) isBasic Course andAdvanced CourseIt consists of 2 components.

The most important in modern system software
Arm architecture and Linux kernel

Not only smartphones but also AI SoC system semiconductors, electric vehicle Automotive (autonomous driving, infotainment), and Arm processors used in cloud servers and MacBooks are all Armv8-A based 64-bit Cortex-A processors (Cortex-A53, Cortex-A57, Cortex-A72, etc...). Currently, the content that requires the most needed foundational knowledge in the system software industry can be considered the Armv8-A architecture.

In electric vehicles and system semiconductors
The most widely executed operating system kernel

Along with Arm processors, the Linux kernel is used in smartphones, cloud servers, and electric vehicle systems. Additionally, most system software developers in the system semiconductor industry (fabless) do driver programming to control the chips they design using the Linux kernel or Linux device drivers.

To summarize once again! The kernel of the operating system that runs most frequently on Arm processors is the Linux kernel.

'Arm Architecture and Linux Kernel Interface'
4 Reasons Why You Should Learn It

1⃣ First, if you have a good understanding of the interface between Arm architecture and the Linux kernel (assembly instruction analysis), you can better understand the detailed operational mechanisms of Arm architecture. This is because analyzing source code that implements theoretically learned content allows you to internalize what you've learned.

2⃣ Second, the core functions that make up the Linux kernel—processes, interrupt handling, system calls, and memory management techniques—are implemented by leveraging CPU architecture features. Understanding the interface between Arm architecture and the Linux kernel well allows you to gain deep insight into the detailed operations of the Linux kernel.

3⃣ Third, by analyzing registers, exception handling, assembly instructions, TrustZone, and memory management methods through source code that exists in the Linux kernel, you can learn both the components that make up the Arm architecture and the Linux kernel together.

4⃣ Fourth, Arm processors and the Linux kernel are used in over 90% of system software industry products. Understanding how the Linux kernel operates on Arm processors will help you effectively utilize what you've learned.

Since most system software developed recently is created in Arm processor and Linux environments, knowledge related to this is essential.

Based on book writing/lecture experience
Deeper and more detailed than anyone else!

Developers who have taken the direct lecture on 'Structure and Principles of Arm Architecture for System Software Development' might find this puzzling. This is because the Arm architecture instructor is suddenly talking about the Linux kernel. However, I am an author who has written not only about Arm architecture but also about the Linux kernel. My major background related to the Linux kernel is as follows:

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

I recommend this for people like this

After taking the course

• Understanding the detailed operating principles of Arm architecture

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

• Understanding the Implementation of Context Scheduling in the Linux Kernel

• Understanding the Detailed Operation of System Calls and Exception Handlers in the Linux Kernel

• Understanding the Implementation of Linux Kernel Memory System

You'll learn this kind of content

This introduces the overall structure of the Linux system for students who are not familiar with Linux. It provides detailed explanations of the three major resources that are importantly handled by the Linux kernel.

This explains processes, which are the core of the Linux kernel (user space and kernel space, user processes, kernel threads).

This explains the data structures of processes dependent on Arm architecture. It covers the operating principles in detail, focusing on registers related to context switching.

Explains in detail the operation of context switching dependent on Arm architecture through assembly instruction analysis.

This explains the flow of interrupt processing from a big picture perspective. It provides a detailed explanation of the interrupt processing method through analysis of the 'Armv8 architecture exception vector table'.

This explains the interrupt processing flow based on two scenarios (interrupt occurring during user application execution, interrupt occurring during kernel code execution). It then provides a detailed review of the exception handler code (assembly code).

Review the overall execution flow of system calls and provide a detailed explanation of the contents of the exception vector table related to system calls.

We analyze the SVC instruction routine that executes when a system call is triggered from user space. We then provide a detailed explanation of the exception handler routine that runs in kernel space during the system call invocation process.

This explains the core kernel APIs that are processed during the process of calling system call handlers in kernel space after a system call is triggered (SVC instruction execution). It also covers the core symbol information of system call handlers in detail.

Introduces the main functions that constitute memory management in the Linux kernel and explains memory management-related features that should be understood from an Arm architecture perspective.

This introduces the configuration for setting the range of virtual addresses in the Linux kernel. It then explains the interfaces that the Linux kernel supports for multi-level page tables.

This provides a detailed explanation of the operating principles of page lookup processing using interfaces supported by the Linux kernel and the structure of fixup macros.

Authentic reviews from learners

Pre-enrollment Reference Information