Embisyslabs Embedded Linux Training Institutes in bangalore courses offered on Embedded Linux, Kernel Porting. Embedded Linux is a type of Linux operating system/kernel that is designed to be installed and used within embedded devices and appliances.Embedded Linux, though utilizing the same Linux kernel, is quite different from the standard Linux OS. Embedded Linux is specifically customized for embedded systems. Therefore it is has a much smaller size, requires less processing power and has minimal features. Based on the requirements of the underlying embedded system, the Linux kernel is modified and optimized as an embedded Linux version. Such an instance of Linux can only run device-specific purpose-built applications. Embedded Linux is the system of choice for many embedded systems such as smartphones, tablets, PDAs, set-top boxes, and personal media players.
MODULE 1: UNIX and LINUX SYSTEM PROGRAMING
CH1. INTRODUCTION TO UNIX/LINUXHistoty of Unix/Linux
Linux Layered Architecture
Type of Kernels Micro and Monolithic kernel
Different types of kernel structure
Linux Bootup Sequence
CH2. FILE SYSTEM MANAGEMENTSFile Systems Types - Extended file system (ext4)
File Systems – VFS & File Systems Layouts
Boot block, Super Block, Inode Block, Data block
Inode block Structure
Types of File - Hard link, Soft link and Regular file
File descriptor and File descriptortable
System calls Sequence
System calls Vs Function Calls
File related System Calls
CH3. FILE LOCKING PROGRAMMINGFile Control Operations
Types of File Locking
Advisory and Mandatory File locking
fcntl() and flock()calls
CH4. PROCESS MANAGEMENTSProgram and Process
Process Control Block (PCB)
States Of Process
Mode of Execution User mode and Kernel mode
Scheduling & Priority
CH5. PROCESS RELATED PROGRAMMINGProcess Creation by fork() amd vfork()
Why fork() not vfork()
Creation and Destroying Zombie Process
Creation of Orphan Process
wait() and waitpid() calls
exit() and exec() ,sleep() calls
Creating , synchronizing and performing multiprocessing concepts
Setting and changing nice value and Prority no.
CH6:MEMORY MANAGEMENTS AND MMUMemory Policy and Hirarchy
Memory allocation Technique
Physical memory &Virtual Memory
Paging & Demand paging
Memory Mapping using TLB
Swap in & Swap out
Internal & External Fragmentation
MODULE 2: LINUX INTERNALS AND INTERPROCEES COMMUNICATION
CH1. THREADS AND MULTI-THREAD CONCEPTSThreads on different O.S
Why Threads in Linux
Threads Vs Process
Creation of Multithreading
Performig Multiple operation using multi-threading
CH2. SIGNALS VS. INTERRUPTSSources of Signals
Diffrents type of Signals
Actions of Signals
Receiving a Signal
Handling a Signal
Signal and Sigaction System Calls
CH3. USER AND DAEMON PROCESSCreating a Daemon Process
Characteristics of a Daemon
Writing and Running Daemon
CH4 . PRIMITIVE INTERPROCESS COMM (IPCS)PIPES
Creation of Half and Full-duplex pipe
Half and Full-duplex communication
CH5 . SYSTEMS V IPCsShared Memory
CH6 . NETWORK AND SOCKET PROGRAMMINGDescription of ISO/OSI Model
Types of IP Classes (A,B,C,D and E)
Configuring IP address on Systems
Network addresses and Host addresses
Types of Socket UDP Connectionless Oriented Socket
TCP/IP Connection Oriented Socket
Iterative Server-Client Programming
Concurrent Server- Client Programming
One Server and Many client Programming
MODULE 3: LINUX KERNEL PORTING AND DRIVER PORTING ON BEAGLEBONE BLACK
CH1: Genesis of Linux project : : IntroductionElement 1:Tool chain (Air)
Element 2:Boot loader (Earth)
Element 3:Kernel (Fire)
Element 4:User space (Water)
CH2: Toolchain Setup : :Introduction to ToolchainWhat is Toolchain
Build Systems for Toolchain
Toolchain Setup Environment
Toolchain compilation and usage
CH3: Bootloader Compilation : : Introduction to BootloaderWhat is Loader
What is Bootloader
1st and 2nd Stage Bootloader
U-Boot Bootloader Porting on New
U-Boot Commands Lists
Downloading on Target board
Bootloader commands and usage,
Bootloader code customization, U-Boot
U-Boot Image for Target Board
CH4: Kernel Configuration : : Linux kernel Cross CompilationDownload the kernel source code linux-xx.yy.zz.tar.bz2
untar it with 'tar -jxvf linux-xx.yy.zz.tar.bz2
Copy the new config as .config in kernel top level directory
Update the the config file using make ARCH=arm menuconfig
Compile the kernel with make ARCH=arm CROSS_COMPILE=
Generating Kernel Image uImage or zImage, dtb
Transfer this is to the Target Board and reboot to boot with new kernel image using tftp or nfs
Application development and Cross Compilation
CH5: Porting Linux kernel,U-boot images on Target boardSd Card partitioning and Formatting
Wrtting uImage,U-boot.bin into Sd cards
Extract and copy rootfs in SD-Card rootfs partition
Configuring NFS and using rootfs over NFS
Building the Embedded Board Using NFS
CH6: Building the Device driver as a part of Kernel(in kernel tree)We will add a Device driver to the kernel
Copy the file driver.c to linux-xx.yy.zz/drivers/char/
Edit the Kconfig file in drivers/char/
Edit the makefile and add obj-$(CONFIG_MY_DRIVER) += driver.o
Configure the kernel with make ARCH=arm menuconfig
Now, compile the kernel with make ARCH=arm CROSS_COMPILE=
Test the driver, with application Program
CH7: BUILDING AND RUNNING MODULES ON BEAGLEBONE BLACKKernel Architecture or Model
Role of the Device Drivers
Writing Your first kernel module
Module Related Commands
Kernel Module vs Applications
Loading and Unloading Modules
MODULE 4: LINUX KERNEL PROGRAMMING & CHARACTER DEVICE DRIVERCH1: AN INTRODUCTION TO DEVICE DRIVERS Role and Definition of the Device Drivers
Splitting the kernel into its functionalities
Drivers have two parts -Device specific and OS specific
Kernel Architecture or Model
CH2: BUILDING AND RUNNING MODULESTypes of Modules in the kernel
Writing Your first kernel module
Module Related Commands
Kernel Module vs Applications
Loading and Unloading Modules
Modules and Exporting Symbols
Hands-On AssignmentsLab1: Simple Hello Linux Kernel Module.
Lab2: Write a module that can take an integer parameter when it is loaded, It should have a default value when none is specified.
Lab3: Write a pair of modules where the second one calls a function in the first one
CH3: CHARACTER DEVICE DRIVERAllocating and Registering a Character Device
Concept behind Major and Minor Number
The Internal Representation of Device Numbers
Allocating and Freeing Device Numbers
Exchanging data between user space and kernel space
File Operations Data structure
Driver methods and Function Pointers
Filling the file operations structure
The Cdev Structure, inode Structure, file Structure
Manual Creation of Device Files using mknod()
Automatic Creation of Device Files using devive and class create
Hands-On AssignmentsLab1: Print the major and minor numbers when Registering by Static or Dynamic method.
Lab2: Implement a open,write,read and close entry point.
Lab3: Print the major and minor numbers when the device is Opened and keep track of the number of times it has been opened since loading, and print out the counter every time the device is opened.
Lab4: Modify the previous driver so that each opening of the device allocates its own data area, which is freed upon release. Thus data will not be persistent across multiple opens.
Lab5 : Implement a lseek entry point and Keeping track of file position.
Lab6: Dynamical Node Creation,Adapt the previous dynamic registration driver to use udev to create the device node on the fly.
CH4: KERNEL MEMORY ALLOCATION TECHNIQUE
System Memory Layout - Kernel space and User space
Concept of LOW and HIGH Memory
Kmalloc family allocator
The Flags Argument
vmalloc and Friends
Hands-On AssignmentsLab1:Testing Maximum Memory Allocation ,using kmalloc()
Lab2:Testing Maximum Memory Allocation ,using __get_free_pages().
Lab3: Testing Memory Allocation,using vmalloc().
Lab4 :Memory caches Extend your chararcter driver to allocate the driver's internal buffer by using your own memory cache.Make sure you free any slabs you create.
CH5: ADVANCED CHARACTER DRIVER OPERATIONSInpout/Output Control Device (ioctl)
User space, the ioctl system call
The ioctl driver method
Generating ioctl command
Choosing the ioctl Commands
Using the ioctl Argum
Hands-On AssignmentsLab1 : Implement a ioctl entry point along with read and write entry point.
Lab2 : Implement read and write entry point using ioctl command.
Lab3 : Write a character driver that has three ioctl commands: a)Set the process ID to which signals should be sent. b)Set the signal which should be sent. c)Send the signal.
CH6: KERNEL LOCKING MECHANISM CONCURRENCY AND RACE CONDITIONConcurrency and its Managements
Semaphores versus Mutexes
Spinlock versus Mutexes
Linux Semaphore Implementation
Introduction to the Semaphore API
Introduction to the Spinlock API
Spinlocks and Atomic Context
Hands-On AssignmentsLab1: Mutex Contention -Write three simple modules where the second and third one use a variable exported from the first one.The second (third) module should attempt to lock the mutex and if it is locked, either fail to load or hang until the mutex is available.
Lab2: Sempahore Contention -Now do the same thing using semaphores .
CH7: INTERRUPT AND INTERRUPT HANDLINGThe Definition and Role of Interrupt
Installing an Interrupt Handler
The /proc Interface
Implementing a Handler
Handler Arguments and Return Value
Installing a Shared Handler
Hands-On AssignmentsLab1: Write a module that shares its IRQ with your network card. You can generate some network interrupts either by browsing or pinging.
Lab2: Extend the previous solution to construct a character driver that shares every possible interrupt with already installed handlers.
Lab3: Mutex Unlocking from an Interrupt. Modify the simple interrupt sharing lab to have a mutex taken out and then released in the interrupt handler.
CH8: TIME, DELAY AND DEFERRED WORKTop and Bottom Halves
Tasklets and Workqueues Mechanisms
Measuring Time Lapses
Using the jiffies Counter
The Timer API
Hands-On AssignmentsLab1: Program based on Kernel Timer API
Lab2: Program based on Jiffies and HZ
Lab3: Program based on Taklet API
Lab4: Prgram based on Workqueue API
Lab5: Write a driver that puts launches a kernel timer whenever a write to the device takes place. Pass some data to the driver and have it print out. Have it print out the current->pid field when the timer function is scheduled, and then again when the function is executed.
Lab6: Write a module that launches a periodic kernel timer function; i.e., it should re-install itself.
Weekend and Weekdays Training Courses on Embedded Linux
- Why choose Linux for embedded linux development projects? .
- Embedded Linux has limited memory and disc space and no external network. We have only two user interfaces LEDs and serial ports.
- Platform Independent. (compiled on one platform and can be executed on any other platforms).
- It allows unlimited modifications in the source code. i.e we can re use components multiple times.
- Software is of free cost. Only budget considered for Hardware
- CH1. INTRODUCTION TO UNIX/LINUX
- CH2. FILE SYSTEM MANAGEMENTS
- CH3. FILE LOCKING PROGRAMMING
- CH4. PROCESS MANAGEMENTS
- CH5. PROCESS RELATED PROGRAMMING
- CH6:MEMORY MANAGEMENTS AND MMU
- CH1. THREADS AND MULTI-THREAD CONCEPTS
- CH2. SIGNALS VS. INTERRUPTS
- CH3. USER AND DAEMON PROCESS
- CH4 . PRIMITIVE INTERPROCESS COMM (IPCS)
- CH5 . SYSTEMS V IPCs
- CH6 . NETWORK AND SOCKET PROGRAMMING
- CH1: Genesis of Linux project : : Introduction
- CH2: Toolchain Setup : :Introduction to Toolchain
- CH3: Bootloader Compilation : : Introduction to Bootloader
- CH4: Kernel Configuration : : Linux kernel Cross Compilation
- CH5: Porting Linux kernel,U-boot images on Target board
- CH6: Building the Device driver as a part of Kernel(in kernel tree)
- CH7: BUILDING AND RUNNING MODULES ON BEAGLEBONE BLACK
- CH1: AN INTRODUCTION TO DEVICE DRIVERS
- CH2: BUILDING AND RUNNING MODULES
- CH3: CHARACTER DEVICE DRIVER
- CH4: KERNEL MEMORY ALLOCATION TECHNIQUE
- CH5: ADVANCED CHARACTER DRIVER OPERATIONS
- CH6: KERNEL LOCKING MECHANISM CONCURRENCY AND RACE CONDITION
- CH7: INTERRUPT AND INTERRUPT HANDLING
- CH8: TIME, DELAY AND DEFERRED WORK