Linux Kernel Internals and Development (LFD420) Training in St. George

Enroll in or hire us to teach our Linux Kernel Internals and Development (LFD420) class in St. George, Utah by calling us @303.377.6176. Like all HSG
classes, Linux Kernel Internals and Development (LFD420) may be offered either onsite or via instructor led virtual training. Consider looking at our public training schedule to see if it
is scheduled: Public Training Classes

Provided there are enough attendees, Linux Kernel Internals and Development (LFD420) may be taught at one of our local training facilities.

Answers to Popular Questions:

Course Description

This four-day course provides experienced programmers with a solid
understanding of the Linux kernel. Upon mastering this material, you
will have a basic understanding of the Linux architecture, kernel
algorithms, scheduling, hardware and memory management, modularization
techniques and debugging, as well as how the kernel developer community
operates and how to efficiently work with it. This course includes
extensive hands-on exercises and demonstrations designed to give you the
necessary tools to develop and debug Linux kernel code. The course is
based on both the most upstream recent Linux kernel version, and
maintains compatibility with the kernel versions used by at least the
last two releases of the major Linux distributions.

Course Length: 4 Days
Course Tuition: $2600 (US)

Prerequisites

Students attending this course should be proficient in the C programming
language. Be familiar with basic Linux (UNIX) utilities such as ls, grep
and tar. Be comfortable using any of the available text editors (e.g.
emacs, vi, etc.). Experience with any major Linux distribution is
helpful but not strictly required.

Course Outline

Introduction

Objectives

Who You Are

The Linux Foundation

Linux Foundation Training

Course Registration

Preliminaries

Procedures

Things change in Linux

Linux Distributions

Kernel Versions

Kernel Sources and Use of git

Platforms

Documentation and Links

Kernel Architecture I

UNIX and Linux **

Monolithic and Micro Kernels

Object-Oriented Methods

Main Kernel Tasks

User-Space and Kernel-Space

Kernel Mode Linux **

Kernel Programming Preview

Error Numbers and Getting Kernel Output

Task Structure

Memory Allocation

Transferring Data between User and Kernel Spaces

Linked Lists

String to Number Conversions

Jiffies

Labs

Modules

What are Modules?

A Trivial Example

Compiling Modules

Modules vs Built-in

Module Utilities

Automatic Loading/Unloading of Modules

Module Usage Count

The module struct

Module Licensing

Exporting Symbols

Resolving Symbols **

Labs

Kernel Architecture II

Processes, Threads, and Tasks

Process Context

Kernel Preemption

Real Time Preemption Patch

Dynamic Kernel Patching

Run-time Alternatives **

Porting to a New Platform **

Kernel Initialization

Overview of System Initialization

System Boot

Das U-Boot for Embedded Systems**

Kernel Configuration and Compilation

Installation and Layout of the Kernel Source

Kernel Browsers

Kernel Configuration Files

Kernel Building and Makefiles

initrd and initramfs

Labs

System Calls

What are System Calls?

Available System Calls

How System Calls are Implemented

Adding a New System Call

Replacing System Calls from Modules

Labs

Kernel Style and General Considerations

Coding Style

kernel-doc **

Using Generic Kernel Routines and Methods

Making a Kernel Patch

sparse

Using likely() and unlikely()

Writing Portable Code, CPU, 32/64-bit, Endianness

Writing for SMP

Writing for High Memory Systems

Power Management

Keeping Security in Mind

Mixing User- and Kernel-Space Headers **

Labs

Race Conditions and Synchronization Methods

Concurrency and Synchronization Methods

Atomic Operations

Bit Operations

Spinlocks

Seqlocks

Disabling Preemption

Mutexes

Semaphores

Completion Functions

Read-Copy-Update (RCU)

Reference Counts

Labs

SMP and Threads

SMP Kernels and Modules

Processor Affinity

CPUSETS

SMP Algorithms - Scheduling, Locking, etc.

Per-CPU Variables **

Labs

Processes

What are Processes?

The task_struct

Creating User Processes and Threads

Creating Kernel Threads

Destroying Processes and Threads

Executing User-Space Processes From Within the Kernel

Labs

Process Limits and Capabilities **

Process Limits

Capabilities

Labs

Monitoring and Debugging

Debuginfo Packages

Tracing and Profiling

sysctl

SysRq Key

oops Messages

Kernel Debuggers

debugfs

Labs

Scheduling Basics

Main Scheduling Tasks

SMP

Scheduling Priorities

Scheduling System Calls

The 2.4 schedule() Function

O(1) Scheduler

Time Slices and Priorities

Load Balancing

Priority Inversion and Priority Inheritance **

Labs

Completely Fair Scheduler (CFS)

The CFS Scheduler

Calculating Priorities and Fair Times

Scheduling Classes

CFS Scheduler Details

Labs

Memory Addressing

Virtual Memory Management

Systems With no MMU

Memory Addresses

High and Low Memory

Memory Zones

Special Device Nodes

NUMA

Paging

Page Tables

page structure

Kernel Samepage Merging (KSM) **

Labs

Huge Pages

Huge Page Support

libhugetlbfs

Transparent Huge Pages

Labs

Memory Allocation

Requesting and Releasing Pages

Buddy System

Slabs and Cache Allocations

Memory Pools

kmalloc()

vmalloc()

Early Allocations and bootmem()

Memory Defragmentation

Labs

Process Address Space

Allocating User Memory and Address Spaces

Locking Pages

Memory Descriptors and Regions

Access Rights

Allocating and Freeing Memory Regions

Page Faults

Labs

Disk Caches and Swapping

Caches

Page Cache Basics

What is Swapping?

Swap Areas

Swapping Pages In and Out

Controlling Swappiness

The Swap Cache

Reverse Mapping **

OOM Killer

Labs

Device Drivers**

Types of Devices

Device Nodes

Character Drivers

An Example

Labs

Signals

What are Signals?

Available Signals

System Calls for Signals

Sigaction

Signals and Threads

How the Kernel Installs Signal Handlers

How the Kernel Sends Signals

How the Kernel Invokes Signal Handlers

Real Time Signals

Labs

** These sections may be considered in part or in whole as optional. They contain either background reference material, specialized topics, or advanced subjects. The instructor may choose to cover or not cover them depending on classroom experience and time constraints

Linux Unix Uses & Stats

Linux supports many efficient tools and operates them seamlessly. Because it's architecture is lightweight it runs faster than both Windows 8.1 and 10.

Security:

Because Linux is an open-source software, anyone can contribute code to help enhance the users’ experience i.e., adding features, fixing bugs, reducing security risks, and more.

Software Development:

The terminal in Linux is a *wild card*. You can do almost anything with it. This includes software installation, application and server configurations, file system management, and etc.

Large-scale:

Open-source projects benefit from having an attentive community. As a result, Linux is more secure than Windows. Instead of installing anti viruses to clean malware, you just have to stick to the recommended repositories.

Efficient:

Developers have the convenience of running servers, training machine learning models, accessing remote machines, and compiling and running scripts from the same terminal window.

Free:

Linux is free (you can put it on as many systems as you like) and you can change it to suit your needs.

Cons

Learning Curve:

Linux is not for everyone, there is a learning curve in switching to Ubuntu. To actually learn Linux efficiently would take a user one to several years.

No Tech Support:

Unlike Windows, there isn’t a dedicated tech support, so getting help for things is up to you.

Designer Compatabilty:

Linux is not as user friendly as Windows or as ‘straight out of the box design’ As an example for design choices, Adobe hasn’t released any of its products to Linux users. So it’s impossible to run them directly. The Ubuntu alternative is a free software called GIMP.

Gaming Capabilities:

Most games aren’t available in Linux. But that’s not to say you can’t make it happen, it's just not as easy.

Linux Unix Job Market

Average Salary

$85k-$105k

Job Count

n/a

Top Job Locations

New York City
Boston
San Francisco

Complimentary Skills to have along with Linux Unix

The following are types of jobs that may require Linux skills. The top 15 job titles on Dice.com that mention Linux in their postings are: