LINUX Kernel Internals and device drivers
Computer
Training
Provided by Microsys Technologies and Solutions Pvt. Ltd.,
Module 1 : A Brief History
Module 2: LINUX System Programming Fundamentals
Module 3 : Kernel Architecture and the Process Descriptor
Module 4 : Process Creation and the Scheduler
Module 5 : Open File kernel data structures
Module 6 : Linux Memory Management
Module 7 : Building a fresh LINUX Kernel
Module 8 : System Call Implementation and LKMs
Module 9 : The /proc filesystem
Module 10: LINUX Device Drivers
Module 11: I/O Port Drivers
Module 12 : LINUX Device Drivers - Advanced Aspects
Module 13 : LINUX Device Drivers - Interrupt Handling
Module 14 : Kernel Synchronization
Module 15 : Linux kernel debugging with kgdb
|
|
||||||||||
LINUX Kernel Internals and device drivers
Course Prerequisites:
Participants should have:
Mandatory:
A firm understanding of user- level UNIX or LINUX and some experience
using the OS (includes vi editor and various user- level tools such as find, du,
cut, redirection, awk, grep, etc.)
Strong 'C' programming skills
Application development exposure on UNIX/Linux platform using 'C'
Preferable, not mandatory:
In- depth application development experience and usage of system calls on any
UNIX or LINUX platform using 'C'
Duration : 6 days
Format:
Morning Session: Theory
Afternoon/Evening Session: Laboratory hands- on (participants will design &
implement programs and/or case studies covered in the Theory session)
Requirements:
LCD display projector (daily)
White board
Marker pens and white- board eraser
For lab: Suggested man:machine ratio: 1:1 is optimal, 2:1 is viable.
System H/W Requirements:
Intel- based PCs (Pentium4, 256MB RAM or more preferable) running LINUX as the O.S.
System S/W Requirements:
LINUX O.S. - preferably RedHat Linux 7.3 with kernel version 2.4.18
The Linux O.S. should be installed as a "Development System" - must include
-the 'C' development system (C complier & linker with std C library)
-vi / other editors
-kernel sources (the kernel source RPM should be installed subsequently)
-kernel source for 2.4.20 vanilla kernel
Preferable:
X Window System installed (for ease of use)
Debugger (gdb)
Important:
Every participant (or at max 2 participants) should have a separate independent LINUX
desktop system to use for this course. This is as a particular participant's system can crash;
having them completely stand- alone prevents this from affecting others (if a single LINUX
server system is shared via network access, one participant crashing the kernel will force all
others to lose data and stop work).
The systems to be used for lab sessions should be "test" systems - this is as during kernellevel
development they could crash and even suffer data loss.
DAY-WISE COVERAGE
Day 1
Module 1 : A Brief History
Introduction to Linux
Linux Variants
The Birth of Linux: Linus Torvalds' historic post
OSDLs Linux Timeline
The GNU project
GNU [L]GPL
Module 2: LINUX System Programming Fundamentals
A brief mention on Process Privileges-
Process Credentials
SUID, SGID executables
Process execution
executing a process
the exec family of system calls
Process creation with the fork system call
Waiting for a Child Process
Orphans and Zombies
Signals and signalling with POSIX sigaction
Signals in Linux
POSIX: The sigaction() system call
Signal Flags for special behaviour
Executing critical code: Blocking signal(s) from delivery to a
process when required
Lab Session: Implement the:
The assignments provided by the instructor
The remaining programs reviewed during the session.
Day 2
Module 2: LINUX System Programming Fundamentals (contd.)
Real- time signal handling support
Using the SA_NODEFER flag
Sending signals to other processes
Piping: Using the pipe, fork, dup and exec API in one stroke
Tracing a process with strace
A Conceptual Introduction to POSIX Threading on Linux
The multithreading concept
Pthreads on Linux
Module 3 : Kernel Architecture and the Process Descriptor
Layout of the kernel source tree
Architecture
Process descriptor- the task_struct structure
Module 4 : Process Creation and the Scheduler
Process Creation
The INIT_TASK macro
Process Creation the __clone() function and flags
fork() kernel implementation
The Linux kernel scheduler
Internal working of the kernel scheduler
Brief Note on the 2.5/2.6 kernel scheduler
Module 5 : Open File kernel data structures
The Open Files Table - the files_struct structure
The File Table - the file structure
The File Operations pointer - the file_operations structure
Lab Session: Implement the:
The assignments provided by the instructor
The remaining programs (if any) reviewed during the session.
Day 3
Module 6 : Linux Memory Management
Hardware Segmentation
Paging
Paging on the x86
Process Page Tables
Linux Memory Zones
Zone allocator
Buddy System
Memory Map - page structure
Swapping and the Page Cache
VM LRU Page Lists
Page Reclamation
Page Life Cycle
Process VM Mapping
Kernel Threads
Memory Regions - VMAs
VM Management Policy
Kernel data structures- overall relationships
Module 7 : Building a fresh LINUX Kernel
Overview of the process
Download and extraction
Configuration
Compile and build
Boot option setting
Case Study: Building a kernel with the Magic SysRq key enabled
and other specific features
Lab Session:
Kernel build
Day 4
Module 8 : System Call Implementation and LKMs
System Calls
LINUX x86 System Call Implementation
The syscall[n] macros
The sys_call_table
Loadable Kernel Modules (LKMs)
Intercepting a system call using LKMs
Additional Notes
Compiling Modules
Loading and Unloading
Symbol exporting
The nm utility
Memory allocation API in the kernel
Case Study on LKMs
Module 9 : The /proc filesystem
What is the /proc filesystem
Exploring the /proc filesystem
A first quick session on /proc
Kernel data in /proc
Session 2 on /proc : kernel data
Using the sysctl facility
Sysctl - the kernel branch
Sysctl - the fs branch
Sysctl - the vm branch
Real-world case- study of user- level procfs usage
Lab Session:
Implement the exit() trapping module
Case study/Project I: the exec module (details will be provided).
Day 5
Module 10: LINUX Device Drivers
What is a device driver
User- space and kernel- space
Writing a device driver - the basics
Block and character device files
The VFS layer and driver registration
Writing a character device driver for Linux - the framework
registering with the kernel
the major-wide open and fop setup
minor- specific open
Default processing on null fop entries
Writing our own character driver: the cz and cnul memory devices
Using the proc filesystem within a kernel module/driver
for reading
for writing
Case Studies
Case # 1: the cz driver
Lab Session:
Implement the cz and cnul device driver
Implement the above using the procfs interfaces as well
Module 11: I/O Port Drivers
Linux Hardware I/O Management
Memory Barriers
Port I/O operations
Portability issues
The x86 parallel port specification
Case Study #3: Build a Linux device driver to drive an actual
parallel port hardware device (device will be provided by the
instructor during the session for testing the driver)
Day 6
Module 12 : LINUX Device Drivers - Advanced Aspects
Blocking I/O and Wait Queues
Kernel implementation of sleep_on_* and wait_event_*
routines
Simple blocking I/O implementation: the sleepy driver
Additional tests (slpy2)
Handling Blocking and Non- blocking I/O
Using semaphores for mutual exclusion control
Blocking I/O - for read()/write() operations in device
drivers
Module 13 : LINUX Device Drivers - Interrupt Handling
Control of Interrupts
Interrupt Handlers
Installing an Interrupt Handler
Tasklets and Bottom Halves
The ppd driver features tour-
Module parameter passing
IRQ request
Procfs entries
Blocking I/O mode
Interrupt handling with tasklet
Task Queues
Module 14 : Kernel Synchronization
The need for synchronization in the kernel
Linux's synchronization techniques
Using spinlocks
Module 15 : Linux kernel debugging with kgdb
Using the kernel debugger kgdb
Hardware and Software requirements
Hardware and Software setup
Initiating a debugging session on the target system
Lab Session:
Implement the cz and cnul device driver
Case study/Project II: the vcp module (details will be
provided by the instructor)
Implement Case study/project III
Case 4: Enhance Case 3 project, by adding on an interrupt
handler. Have a tasklet service it.
Appendices
Appendix A : LINUX Resources
Appendix B : Bibliography
Appendix C : Misc. Useful Topics
Kernel Initialization
Dynamic Kernel Timers
Using the GNU debugger gdb
Tracing processes with strace
About The Training Provider: Microsys Technologies and Solutions Pvt. Ltd.,
Microsys Technologies and Solutions Pvt. Ltd., - Microsys Technologies & Solutions Pvt. Ltd is a proactive organization headquartered in Pune with its branches across Mumbai & Bangalore. In the last few years of our existence we have successfully offered value propositions to our clientele across the country and overseas.
Customized Software Development
Corporate Training & IT Education
leadership and management skill programs
...
There are no comments. Be the first to add one!