Course Introduction:      

This course consists of five full days of training on Linux Kernel Internal Programming which covers the 2.4.x and introduction to 2.6 kernel. The course starts with a session on the Linux environment, which review the kernel architecture and covers the various features and programming environment

However knowledge of Linux Administration and related command line functioned are not covered in this course. On Linux Device Driver Programming section, various aspects of Device Driver programming in Linux OS is covered. This session starts on Device driver module and related kernel programming, also cover Memory management, Character Device Driver, Block Device Driver, Serial, Network Device Driver Programming.

Prerequisites:

Experienced C programmers with UNIX or Linux workstation power user skills, who want to begin developing device drivers ,modules and applications on Linux. Knowledge in Linux System Programming or Realtime programming concept is important. Our course on Embedded C and Real-time Programming can be a good back ground course for this course.

Target Audience

This course is for programmers who are new to the Linux Kernel programming and want to learn about the kernel level features of the operating system. This course also helps programmers who are further intending to learn embedded and real time programming on Linux.

COURSE CONTENTS

Day 1
Introduction to Linux
History and open source
Features
Modular and monolithic vs. micro
Kernel design goals
Understanding the Linux kernel
Kernel structure
Kernel components and organization
Modes of operation
User library different from kernel

Linux Booting and kernel initialization
Booting Basics
System Ups and Down under Linux
Boot-loaders (Various target specific boot loaders)
Understanding Linux start_kernel in brief

Building your own kernel
Building the Image
Entering the image path to the GRUB loader’s script
Rebooting the system with your image
Lab-session:
After the concept’s presentation trainee will work on
Building your Own kernel
Booting the own kernel image

Day 2
System calls
Understanding the Layer for Communication
Basics
Common system calls
How is it implemented in Linux?
Implementing a system call directly
Linux implemented methods

Programming with specific system calls
Process Related system calls
Low Level I/O and File related system calls
Inter process communication based system calls
Signals related system calls
Networking related calls (socket etc…)
Lab-session:
After the concept’s presentation trainee will work on
Implementing a system call interface directly using assembler
Programming with the various system calls as mentioned above

Day 3

POSIX Threads
Introduction to the same
Creating the thread
Working with all the related system calls

Memory Management
Introduction to X86 platform
Hardware support for memory management
Segmentation in hardware
Paging in Hardware
Linux implementation on hardware
Using Segmentation in Linux
Using Paging in Linux
A brief on Architectural independent implementation
Memory Map: Kernel/User Address spaces
Linux used algorithm for memory management
Understanding File systems in Linux
The virtual file system/switch: Overview
The /proc file system: kernel’s FS
The default FS ext2
Overview of ext3
Other FS supports on Linux
Lab-session:
After the concept’s presentation trainee will work on
Programming with POSIX
Navigating with the /proc structure
Visualizing the FS specific data structures

Day 4
Understanding Linux kernel components
Scheduler, and Policies (Brief on Algorithms)
The other queues (wait/run etc)
The related internal data structures
Interrupts and exception in linux
Kernel Synchronization

Introduction to Device Drivers: brief

Introduction to LKMS
Introduction to Linux Loadable Kernel Modules
Terminology
History of Loadable Kernel Modules
The Case For Loadable Kernel Modules
What LKMs Can't Do
What LKMs Are Used For
Making Loadable Kernel Modules
LKM Utilities
How To Insert And Remove LKMs
Unresolved Symbols
About Module Parameters
Writing Your Own Loadable Kernel Module
Lab-session:
After the concept’s presentation trainee will work on
Module Programming
Parameters passing
Stacked module

Day 5
Introduction to Linux Device Drivers
Types of drivers (Other OS based discussion)
Character and Block Device Drivers
Major and Minor numbers
Dynamic Allocation of Major Numbers
Registering your driver
Removing a Driver from the system
dev_t and kdev_t
File Operations
The file Structure
Open, release, read, and write
Copy to/from user
A sample Device Driver: simple_char

Debugging Techniques
Debugging by Printing
Debugging by Querying
Debugging by Watching
Debugging System Faults
Debuggers and Related Tools

Network device driver
Introduction to Important data structure

Net

device structure
Private and available methods
Setting up the /etc/network
Configuration network eth0/1 interfaces
Lab-session:
After the concept’s presentation trainee will work on
Write drivers programs and implement a test driver
Check applications on the same
Major Debugging Techniques
Configuring KDB based patch when needed