The Linux Master Package Career Path Courses:

Learning to program is both fun and easy by taking this brand new and exciting Introduction to Programming for Non-Programmers course! Not only will you learn the foundations of how to program, but you’ll also gain a solid foundation in the world’s most popular computer language: JavaScript.  Without having to install any special software, and using only your web browser and your text editor, you’ll journey into the exacting world of programming. Using an easy to learn training style, you’ll learn about the JavaScript language, functions, variables, making decisions, looping, and more. At the end of the course, you’ll be in a great position to take other introductory programming language course.

View all course details
Video Title
01: Introduction to Programming
16 min
02: Introduction to JavaScript
15 min
Quiz: Introduction to Programming and JavaScript
04: Functions Part 2
17 min
Quiz: Functions
05: Variables
24 min
Quiz: Variables
06: Making Decisions
22 min
Quiz: Making Decisions
07: Repeating Steps
24 min
Quiz: Repeating Steps
08: Course Summary
20 min
09: Capstone Exercise
15 min
Course Survey
View all course details

Module 00: Course Introduction


Module 01: Introduction to Programming

  • What is a computer language?
  • Why should you learn a computer language?
  • What computer language should you learn first?
  • Demo: Let's Make our First Statement in JavaScript!
  • Lab Exercise: hello.html

Module 02: Introduction to JavaScript 

  • JavaScript Advantages
  • Web Browser and JavaScript
  • .html File Extension
  • Editing hello.html
  • // and /* … */
  • Demo: Hello World
  • Lab Exercise: Hello World

Module 03: Functions Part 1  

  • About Functions
  • alert() w/o input parameter
  • Semicolon
  • alert() w/Input parameter
  • Strings

Module 04: Functions Part 2 

  • Defining Functions without inputs
  • Defining Functions with inputs
  • Returning values from Functions
  • Demo: Using the Alert Function
  • Lab Exercise: Using the Alert Function

Module 05: Variables 

  • JavaScript Variables
  • var keyword
  • String variables
  • Number variables
  • Operators: +, -, *, /
  • Confirm Function
  • true, false
  • prompt() Function
  • Demo: Using Variables
  • Lab Exercise: Using Variables

Module 06: Making Decisions 

  • if statement
  • if else statement
  • confirm() with if statement
  • confirm() with if-else statement
  • Compare Operators: ==, <. >, <=, >=
  • if-else-if…
  • Demo: Making Decisions
  • Lab Exercise: Making Decisions

Module 07: Repeating Steps 

  • Repeating fixed number of times
  • Repeating variable number of times
  • while statement
  • while statement with prompt()
  • Checking for null
  • Demo: Repeating Steps
  • Lab Exercise: Repeating Steps 

Module 08: Course Summary

  • Put All Skills Together To Write a Javascript App
  • Review the key concepts
  • Write a temperature conversion script!


View all course details

The only prerequisite is a basic familiarity with computers, along with an eagerness to learn programming. You do not need any programming experience.

View all course details

This course provides a fundamental understanding of the functions within any modern operating system. Most users of computers, like Windows 10 or Redhat V8, only deal with the GUI (graphical user interface). This course explores the functions used by those GUIs and provides an understanding of what is really happening. Used either stand-alone to gain a basic understanding of operating system concepts or with a companion textbook, Modern Operating Systems by Andrew S. Tanenbaum, while viewing the course or as a resource for later reference, this course provides a solid foundation that would enhance understanding for other courses, such as USB 2.0 Architecture Part 1, Oracle 12c Real Application Clusters Part 2: Performance Tuning, Administration and Backup, PCI Express (PCIe) Overview, Cloud Computing Foundation, and any programming course.  This course is a pre-requisite for the Linux V7 Essentials course.

View all course details
Video Title
01: Introduction to Operating Systems
25 min
02: Operating Systems and Hardware
25 min
03: Operating System Concepts
26 min
04: Operating System Structure
22 min
05: Processes and Threads
24 min
06: Interprocess Communication
22 min
08: Deadlocks
23 min
09: Memory Management
28 min
10: Input/Output
27 min
11: Files Systems
25 min
12: Multimedia Operating Systems
25 min
13: Multiple Processor Systems
27 min
14: Operating System Security
25 min
15: Examples of Operating System Architectures
24 min
16: Course Summary
6 min
Course Survey
View all course details

Module 00: Course Introduction - Fundamentals of Operating Systems


Module 01:  Introduction to Operating Systems

  • What is an operating system?
  • History of Operating Systems
  • Types of Operating Systems

Module 02: Operating Systems and Hardware

  • Operating Systems Concepts
  • Processor and Processor Features
  • Processor Pipeline and Execution
  • Operating Systems and Processors
  • Memory Overview
  • I/O Devices Overview
  • Operating Systems and Hardware Quiz

Module 03: Operating System Concepts

  • Types of Operating Systems
  • Services Provided by Operating Systems
  • Invoking Operating System Services
  • Operating System Concepts Quiz

Module 04: Operating System Structure

  • Monolithic Systems
  • Layered Systems
  • Virtual Machines
  • Other Structures 
  • Operating System Structure Quiz

Module 05: Processes and Threads

  • The Process Model
  • The Thread Model
  • Implementation Techniques
  • Trade-offs 
  • Processes and Threads Quiz

Module 06:  Interprocess Communication 

  • Types of Interprocess Communication
  • Operating System Implementations
  • Add-on Implementations
  • Interprocess Communication Quiz

Module 07:  Scheduling

  • Introduction to Operating System Scheduling
  • Types of Schedulers
  • Policy Versus Mechanism
  • Thread Scheduling
  • Scheduling Quiz

Module 08:  Deadlocks

  • What are deadlocks?
  • Detection and Recovery
  • Avoidance
  • Prevention
  • Other Issues 
  • Deadlocks Quiz

Module 09:  Memory Management

  • Basics of Memory Management
  • Swapping
  • Paging for Memory Management
  • Paging for Virtual Memory
  • Implementation Issues 
  • Memory Management Quiz

Module 10:  Input/Output

  • Principles of I/O Hardware
  • Principles of I/O Software
  • I/O Software Layers
  • Types of I/O Devices
  • Power Management
  • Input/Output Quiz

Module 11:  Files Systems

  • File Systems Basics 
  • Files
  • Directories
  • Implementation
  • Examples 
  • File Systems Quiz

Module 12:  Multimedia Operating Systems

  • Introduction to Multimedia Operating Systems
  • Multimedia Files
  • Multimedia Process Scheduling
  • Multimedia File Systems
  • Caching
  • Disk Scheduling
  • Multimedia Operating Systems Quiz

Module 13:  Multiple Processor Systems

  • Types of Multiple Processors
  • Multiple Processor Hardware  
  • Multiple Processor Operating Systems
  • Multiple Processor Scheduling
  • Multiple Computers
  • Multiple Processor Systems Quiz 

Module 14:  Operating System Security

  • The Security Environment
  • Basics of Cryptography
  • User Authentication 
  • Security Attacks 
  • Protection Mechanisms
  • Security Quiz

Module 15: Examples of Operating System Architectures

  • Unix and Linux
  • Windows 
  • Others
  • Operating System Architectures Quiz

Module 16: Course Summary

View all course details

Course attendees should have a general understanding of computer use, including starting and using applications, creating and using files, and a basic exposure to using computers connected to some form of network. Some knowledge of programming, computer hardware and application design will be helpful but is not required.  If you do not have this experience, we recommend the following GogoTraining course, C Programming Bootcamp Part 1.

View all course details

This hands-on class will teach you the basics of Linux V7 using Red Hat Linux, a powerful open-source operating system.  You will learn how to install, work with users and groups, and program using bash shell and the vi editor. This class, in addition to Linux V7 System Administration, prepares you to sit for the  Certified System Administrator exam given by Red Hat. This course also provides the necessary foundation for any version of Linux.

View all course details
Video Title
01: Introduction to Linux
17 min
02: Installation
14 min
03: Linux Usage Basics
15 min
04: Running Linux Commands
23 min
05: Exploring the Filesystem Part 1
18 min
06: Exploring the Filesystem Part 2
16 min
07: Introduction to the bash Shell
18 min
08: Standard Input/Output and Pipes
17 min
09: Introduction to Users and Groups
12 min
10: Text Processing Part 1
14 min
11: Text Processing Part 2
19 min
12: Basic System Configuration
13 min
13: The vi Editor Part 1
15 min
14: The vi Editor Part 2
13 min
16: Shell Programming Part 1
11 min
17: Shell Programming Part 2
17 min
18: Shell Programming Part 3
19 min
19: Network Applications Part 1
13 min
20: Network Applications Part 2
11 min
21: Advanced Users and Groups Part 1
13 min
22: Advanced Users and Groups Part 2
18 min
23: Finding Things
17 min
24: Linux Processes Part 1
11 min
25: Linux Processes Part 2
20 min
26: Advanced File System Part 1
16 min
27: Advanced File System Part 2
11 min
28: The Next Steps
4 min
Course Survey
View all course details

Module 00: Course Introduction - Red Hat Linux V7 Essentials 

Module 01: Introduction to Linux

  • Linux history
  • Advantages of Linux and Open-source
  • Linux distributions
  • Three basic parts of Linux

Module 02: V7 Installation

  • Hardware compatibility
  • Installer Features
  • Install boot process
  • First boot
  • Lab Exercise: Installing Linux

Module 03: Linux Usage Basics 

  • Logging in
  • Accessing the command line
  • Changing your password
  • The root user
  • Elevating privileges
  • Editing text files
  • Lab Exercise: Working with root user

Module 04: Running Linux Commands 

  • Running commands
  • Getting help
  • The whatis command
  • The --help option
  • man and info
  • Demo: Running Linux Command
  • Lab Exercise: Trying date, man and info command

Module 05: Exploring the Filesystem Part 1

  • Overview of the filesystem hierarchy
  • pwd, pathname, ls and cd
  • Demo: Commands to Explore the Filesystem

Module 06: Exploring the Filesystem Part 2 

  • Copying and removing files
  • Creating and removing directories
  • Nautilus
  • Determining file content, viewing files, file permissions
  • Demo: Using Nautilus
  • Lab Exercise: Using shell Commands

Module 07: Introduction to the bash Shell 

  • Command line shortcuts and history tricks
  • Command line expansion
  • Command editing tricks
  • gnome-terminal
  • Demo: Bash and the Gnome Terminal
  • Lab Exercise: Working with bash shell

Module 08: Standard Input/Output and Pipes

  • Standard input, output and error
  • Redirecting standard input and output
  • Redirecting standard error
  • Redirecting both standard input and standard error
  • Using pipes
  • Demo: Input and Output Redirection
  • Lab Exercise: Redirecting Input and Output

Module 09: Introduction to Users and Groups 

  • Linux security model
  • Users and Groups
  • Permission types
  • Examining and changing permissions
  • Lab Exercise: Using Permissions

Module 10: Text Processing Part 1

  • Regex Patterns
  • Sed
  • Exercise: Word match with Regexes

Module 11: Text Processing Part 2

  • Extracting and manipulating text with sed, awk and Perl
  • Demo: sed and awk Examples
  • Perl
  • Lab Exercise: Write a sed Command

Module 12: Basic System Configuration 

  • Configuring date and time
  • Configuring printers
  • Network configuration
  • System logs
  • Demo: - Configuring a Printer
  • Lab Exercise: Configuring a Basic System

Module 13: The vi Editor Part 1

  • Using vi
  • Command vs. insert mode
  • Demo: vi First Steps

Module 14: The vi Editor Part 2

  • Changing, pasting, deleting, copying and importing text
  • Joining, searching and replacing text
  • Splitting screen
  • Configuring vi
  • Lab Exercise: Using vi Editor

Module 15: Configuring the bash Shell 

  • bash variables
  • Environment variables
  • Aliases
  • Startup and exit scripts
  • Intro to shell scripting
  • Lab Exercise: Configuring the bash Shell

Module 16: Shell Programming Part 1

  • Create a simple shell program
  • Execute a simple shell program
  • Demo: Creating and Executing Shell Programs
  • Lab Exercises

Module 17: Shell Programming Part 2

  • Using variables
  • read and expr, || and &&
  • Demo: Variables, read and expr
  • Lab Exercises

Module 18: Shell Programming Part 3

  • The test command
  • if, while, until, for, case
  • Lab Exercises

Module 19: Network Applications Part 1 

  • Firefox and other web browsers
  • Evolution and other email clients
  • Email, encryption and digital signatures
  • The empathy messaging system

Module 20: Network Applications Part 2

  • telnet and the “r” services
  • ssh, scp
  • FTP clients
  • Connecting to Windows disk shares
  • File transfer with Nautilus
  • Lab Exercise: Using Network Application Tools

Module 21: Advanced Users and Groups Part 1

  • User and group ID numbers
  • /etc/passwd, /etc/group and /etc/shadow
  • System users and groups
  • Changing your identity

Module 22: Advanced Users and Groups Part 2

  • Default permissions
  • SUID, SGID and sticky bits
  • Demo: SUID, SGID and sticky bits
  • Lab Exercise: Using umask

Module 23: Finding Things

  • which
  • whatis
  • man –k (aka. apropos)
  • find
  • locate
  • The Gnome search tool
  • Demo: Examples of Finding Files
  • Lab Exercise: Finding Programs, Files, Pages

Module 24: Linux Processes Part 1 

  • Intro to processes
  • Viewing processes, process states

Module 25: Linux Processes Part 2 

  • Sending signals and terminating processes
  • Process management tools
  • Running a process in the background
  • Suspending a process
  • cron and anacron
  • Demo: Process Management
  • Lab Exercise: Experiment with ps, top and kill

Module 26: Advanced File System Part 1

  • Partitions and filesystems
  • Inode numbers
  • Checking free space

Module 27: Advanced File System Part 2

  • Working with archive files
  • Compression utilities
  • Demo: Archiving Files
  • Lab Exercise: Using labfile

Module 28: The Next Steps

  • Next steps in Linux
  • Other Linux training classes
  • The Linux community
View all course details

This hands-on class will teach you the how to administer a Linux V7 system. You’ll learn how to install Linux V7, handle system initialization, work with disk partitions, and manage packages, users and groups. Additionally, the course will cover networking, using utilities to find things, discuss the Linux Kernel, the X Windows system and learn to troubleshoot. This course was written using Red Hat Linux and provides the necessary foundation for administering any version of Linux.

This class, in addition to Linux V7 Essentials, prepares you to sit for the Certified System Administrator exam. 

View all course details
Video Title
01: Linux Review
10 min
02: Linux V7 Installation
28 min
03: Virtual Machines
10 min
04: System Initialization Part 1
16 min
05: System Initialization Part 2
28 min
06: File System Management Part 1
17 min
07: File System Management Part 2
20 min
08: More File Systems
22 min
09: Package Management
22 min
10: Managing Users and Groups
19 min
12: User Administration Part 2
22 min
13: ACL, PAM and Remote Authentication
18 min
14: Quotas and LUKS
17 min
15: Networking and IP
12 min
16: More on Network Interfaces
10 min
17: More on Networking
13 min
18: Finding Things
10 min
19: Linux Processes
8 min
20: Kernel Services
12 min
21: More on the Kernel
9 min
22: Software RAID
13 min
23: X Window System
17 min
24: Troubleshooting
12 min
Course Survey
View all course details

Module 00: Course Introduction - Linux V7 System Administration

Module 01: Linux Review

  • Select best distribution
  • Demos: Review Command Line Tools to Work with Files
  • Lab Exercises: Experiment with the Essential Commands

Module 02: Linux V7 Installation

  • Hardware compatibility
  • Network information
  • Installation, disk partitioning
  • Install boot process
  • Demos
  • Lab Exercise: Install Linux V7

Module 03: Virtual Machines

  • What is Virtualization?
  • KVM
  • Creating a Virtual Machine

Module 04: System Initialization Part 1

  • Linux boot process
  • GRUB
  • The Kernels

Module 05: System Initialization Part 2

  • init process
  • Runlevels
  • Start/Stop Scripts
  • Demo: chkconfig
  • Shutdown and Reboot
  • Demo: Shutdown and Reboot
  • Lab Exercise: System Initialization

Module 06: File System Management Part 1

  • Mount Points
  • System Directories
  • Filesystem Types
  • Journaling
  • mount Command
  • umount Command
  • Demos: File System Directories, Umount, Mount

Module 07: File System Management Part 2

  • Adding a new disk partition
  • fdisk
  • Checking a disk with fsck
  • Swap space
  • LVMs
  • Demo: Creating LVMs
  • Lab Exercise: Complete Creating LVMs

Module 08: More File Systems 

  • File System Attributes
  • SELinux
  • Recovering from a Crash
  • Demo: Recover from a Crash
  • Lab Exercise: Work with ACLs and SELinux

Module 09: Package Management

  • software "packages"
  • rpm
  • yum
  • RedHat Network
  • Demos: Demonstrate rpm, Demonstrate yum
  • Lab Exercise: Working with Packages

Module 10: Managing Users and Groups

  • /etc/passwd
  • File Ownership
  • Creating a User
  • Modifying and Deleting a User
  • Creating and Deleting a Group

Module 11: User Administration Part 1

  • Login Scripts and More Account Utilities
  • Switching Accounts
  • Demos: Show order of login scripts by added echoes, Change the shell

Module 12: User Administration Part 2 

  • SUID and SGID Executables
  • The Sticky Bit
  • Default File Permissions
  • Demos: Perl program, SGID directories, sticky bit, and umask
  • Lab Exercise: Working with Users and Groups

Module 13: ACL, PAM and Remote Authentication 

  • ACL-Access Control Lists
  • PAM
  • Remote Authentication
  • Demo: Remote Login

Module 14: Quotas and LUKS

  • What is a Quota?
  • Turning on Quotas
  • Setting and Testing Quotas
  • LUKS
  • Demo: Quota Examples, LUKS
  • Lab Exercise: Working with Quotas

Module 15: Networking and IP 

  • Networking Basics
  • Networking Interfaces
  • IPv4
  • IPv6

Module 16: More on Network Interfaces

  • Starting and Stopping an Interface
  • ifconfig
  • ip
  • Demo: ifconfig and ip

Module 17: More on Networking 

  • Network config files
  • Name resolution
  • Network Diagnostics
  • IPv6 tools
  • cron and anacron
  • Lab Exercise: Experimenting with Networking

Module 18: Finding Things 

  • which
  • whatis
  • find
  • Locate
  • Lab Exercise: Experiment with the find command

Module 19: Linux Processes 

  • Managing system logs
  • System monitoring
  • Killing processes
  • Lab Exercise: Linux Processes

Module 20: Kernel Services 

  • Introduction to the kernel
  • Kernel modules
  • The initramfs image

Module 21: More on the Kernel 

  • Kernel configuration with sysctl
  • Installing a new kernel
  • /proc filesytem
  • Lab Exercise: Exploring the Kernel

Module 22: Software RAID

  • Software RAID
  • Creating a RAID
  • RAID Info
  • Removing a RAID
  • Demo: Creating a RAID
  • Lab Exercise: Creating a RAID

Module 23: X Window System 

  • X server
  • Configuring X
  • Exporting display
  • Demo: Using X Host +
  • Lab Exercise: Using X Host +

Module 24: Troubleshooting 

  • Plan for a failure
  • Troubleshooting X windows
  • Troubleshooting the network
  • Machine won't boot
  • Fixing the MBR
  • Demo: Rescue the Machine
  • Lab Exercise: Troubleshooting
View all course details

Welcome to Linux Device Drivers: Programming at the Kernel Level with Doug Abbott.  If you are ready to learn with the experts, then this course is for you.  Doug has over 20 years’ experience working on the operating system and device driver level with emphasis on embedded Linux applications and is here to answer your questions.

Working with Doug you will become a master Linux programmer at the Device Driver level and be able to:

  • Understand how device drivers interact with the Linux kernel 
  • Work with the rich set of kernel APIs that provide a multitude of services to driver programmers.  
  • See how Linux handles asynchronous I/O in a way that is totally transparent to applications.  
  • Examine the unique problems of debugging in Kernel space.  
  • Understand how much of a device driver involves interactions with the kernel that have nothing to do with accessing physical hardware. 

While taking this course you will have access to Doug’s video lectures, demos and hands on exercises where you will have ample opportunity to practice what you’ve learned. Most of the lab exercises run on a standard PC. Nevertheless, the code is easily ported to other architectures supported by Linux. 

The hands-on exercises can be done using any version of the Linux Kernel.  Because the Linux Kernel changes frequently we are here to support any questions you may have on the course exercises and solutions while you take the course.

Some of the exercise are hardware dependent and require either a parallel printer port, if your computer has one, or you can purchase a single board computer to use to do the exercises – see purchase options section below.

View all course details
Video Title
01: So what’s a Device Driver?
21 min
02: Kernel Loadable Modules
17 min
03: Basic Character Driver
18 min
04: Debugging Kernel Code
21 min
05: Blocking I/O Part 1
15 min
06: Blocking I/O Part 2
10 min
07: Accessing Hardware Part 1
14 min
08: Accessing Hardware Part 2
16 min
09: Handling Interrupts Part 1
17 min
11: Memory allocation
15 min
12: Managing Time
19 min
13: Synchronization
10 min
14: Block Drivers
19 min
15: Network Drivers
22 min
16: PCI Drivers
23 min
17: USB Drivers
23 min
18: Linux Driver Model
14 min
19: Integrating a Driver with the Kernel Source Tree
30 min
View all course details

Module 00: Linux Device Drivers 2013: Programming at the Kernel Level - Course Introduction

Module 01: So what’s a Device Driver?

  • Why device drivers
  • User space I/O APIs
  • Three types of devices
  • The /dev directory
  • Demo: The /dev directory
  • Exercise: Examine the /dev directory

Module 02: Kernel Loadable Modules

  • What is a kernel loadable module?
  • Module utilities
  • Modules are kernel version specific
  • Demo: A module example
  • Kernel modules and the GPL
  • Exercise:  Loading a module

Module 03: Basic Character Driver

  • Registering and initializing a Driver
  • The file operations table, fops
  • Demo:  The Driver Example
  • Exercise:  Running a Basic Character Driver
  • Mutual Exclusion, the mutex
  • Demo:  The mutex code

Module 04: Debugging Kernel Code

  • printk()
  • strace
  • The /proc file system
  • Demo: proc file review
  • Exercise: List the proc file
  • ioctl()
  • Demo: ioctl Code Review
  • Exercise: Execute ioctl commands
  • Kgdb

Module 05: Blocking I/O Part 1

  • The wait queue
  • Putting a process to sleep
  • The device model and sysfs
  • Demo: Blocking example
  • Build and Run Blocking
  • Exercise: Run a blocking device driver
  • Exercise: Find the Bug

Module 06: Blocking I/O Part 2

  • The seq file interface
  • Demo: The seq file system
  • Exercise: List a proc file
  • Poll and select
  • Demo: the poll method
  • Asynchronous notification
  • Demo: Code review
  • Exercise: Using asynchronous notification

Module 07: Accessing Hardware Part 1

  • Side effects and compiler optimization
  • I/O APIs
  • The hardware
  • Demo: Code review of hardware access on an single board computer
  • Exercise: Flash the LEDs

Module 08: Accessing Hardware Part 2

  • Hardware and BIOS
  • Demo: Code review of hardware access on a parallel printer port 
  • Exercise: Flash the LEDs
  • Advanced Exercise: Shell Script for Alternating 2 LEDs
  • Barriers
  • Accessing hardware from User Space
  • Demo: Code Review of accessing hardware from UserSpace
  • Exercise: Accessing hardware from UserSpace

Module 09: Handling Interrupts Part 1

  • Interrupt context
  • Registering an interrupt handler, the IRQ flags
  • Demo: interrupt example
  • Exercise: Execute Interrupt driver
  • Probing for the interrupt source
  • Exercise: Interrupt probing

Module 10: Handling Interrupts Part 2

  • Deferred Interrupt – tasklets and workqueues
  • Demo: Deferred Interrupt
  • Exercise:  Deferred interrupt processing
  • Simple_int with Bottom Half
  • Advanced Exercise: Using simple_int

Module 11: Memory allocation

  • kmalloc() and kfree()
  • kmalloc() flags
  • The slab allocator
  • Demo: Slab allocator tools
  • Exercise: Slab allocator tools
  • get_free_pages()
  • The buddy algorithm
  • Demo: The buddy info proc file
  • Exercise: The buddy info proc file
  • vmalloc()

Module 12: Managing Time

  • jiffies
  • Current time
  • Demo: Implementing time delays
  • Exercise: Implementing time delays
  • The timer callback
  • Demo: Using timer callbacks
  • Exercise: Using timer callbacks

Module 13: Synchronization

  • Semaphores
  • Spinlocks
  • Mutexes

Module 14: Block Drivers

  • The block subsystem
  • I/O schedulers
  • Device registration
  • The request queue and function
  • Demo: Block driver example
  • Exercise: Build and Try a Block Driver

Module 15: Network Drivers

  • Device registration
  • The socket buffer
  • Demo: Driver example – “snull”
  • Exercise: A network driver
  • NAPI – the “new” API
  • Demo:  NAPI
  • Exercise: A NAPI network driver

Module 16: PCI Drivers

  • PCI addressing and bridging
  • Demo: PCI tools
  • Exercise: Using PCI tools
  • Accessing configuration space
  • PCI data structures and macros
  • modules.pcimap
  • Demo: Sample PCI driver

Module 17: USB Drivers

  • USB structure and characteristics (put after slide 3)
  • Demo: USB Tools
  • Exercise: Using USB tools
  • Device classes
  • USB data structures and macros
  • USB Request Block, URB
  • Demo: Sample USB driver

Module 18: Linux Driver Model

  • Overview, motivation
  • kobject
  • sysfs
  • Demo: Using sysfs
  • Exercise: Using sysfs
  • Module parameters in sysfs
  • Demo: Module parameters in sysfs
  • Exercise: Module parameters in sysfs

Module 19: Integrating a Driver with the Kernel Source Tree

  • Configuring and building the kernel
  • The Kernel source tree
  • Demo: Review of kernel source tree
  • Exercise: Examine directories of kernel source code
  • Xconfig
  • Demo: Using xconfig
  • Exercise: Using xconfig
  • The .config file
  • Source code mods
  • Kconfig files
  • Demo: Kconfig files
  • Exercise: Examine Kconfig files
View all course details

To successfully complete this course you will need to be proficient in C programming and Linux Essentials or have taken C Programming Bootcamp Part 1, C Programming Bootcamp Part 2 and Linux Essentials

You will need a PC running a fairly recent Linux distribution such as CentOS 7.  To complete the hardware-based exercises in modules 7 to 10 you will need either a standard 25-pin parallel port or a small single board computer with general purpose I/O ports. You can purchase a single board computer with your course below or directly from the instructor at  If your laptop lacks a parallel port, a compatible docking station usually has one.

View all course details

This course is your Go To source for mastering how to apply Linux to embedded computing devices.  You will learn how to install a cross-development environment, how to use the Eclipse IDE, how to run and debug applications on an embedded target, how to configure and build the Linux kernel, how to boot the target, and how to work with network applications.  You will also have many opportunities to watch demonstrations and do exercises to practice what you’ve learned. The exercises and demos have been built and tested using kernel v3.5.3, Eclipse, Juno and Fedora 17.

If you’re not familiar with Linux, we suggest taking the Red Hat Linux Essentials course. You’ll need a background in C, and the Introduction to C Programming Part 1 and Part 2 will enable you to meet that requirement.

View all course details
Video Title
01: Introducing Linux
21 min
02: KDE Graphical Desktop and the Command Shell Part 1
13 min
03: KDE Graphical Desktop and the Command Shell Part 2
18 min
04: The Eclipse Development Environment Part 1
22 min
05: The Eclipse Development Environment Part 2
14 min
06: Configuring the Workstation
14 min
07: Building and Running Target Applications
22 min
08: Debugging Applications: On the Target and on the Workstation
27 min
09: Multi-threading
24 min
10: Networking Part 1
21 min
11: Networking Part 2
20 min
12: Graphics Device Driver
20 min
13: Configuring the Linux Kernel
32 min
15: Busybox and U-boot
19 min
16: Booting the Application, Getting Ready to Ship
19 min
17: Wrapping Up
7 min
Course Survey
View all course details

Module 00: Introduction to Embedded Linux 2013 - Course Introduction

Module 01: Introducing Linux

  • What is Open Source?
  • Exercise: Installing Linux
  • Linux features
  • Tour of the file system

Module 02:  KDE Graphical Desktop and the Command Shell Part 1

  • Elements of KDE
  • Demo: Exploring the desktop
  • File Manager
  • Demo: File Manager
  • Exercise: Using the File Manager
  • K Menu
  • Demo: K Menu

Module 03:  KDE Graphical Desktop and the Command Shell Part 2

  • The Shell
  • Demo: The Shell
  • Exercise: Using the Shell
  • Demo: Graphical Help
  • Exercise: Installing course software

Module 04: The Eclipse Development Environment Part 1

  • Introduction and background
  • Workbench elements
  • Demo: The Eclipse Workbench
  • Exercise: Creating a Project
  • Eclipse menus

Module 05: The Eclipse Development Environment Part 2

  • Creating a project – the C/C++ perspective
  • Debugging with Eclipse
  • Demo: Debugging with Eclipse
  • Exercise: Debugging with Eclipse
  • Configuring Eclipse
  • Demo: Eclipse Configuration

Module 06:  Configuring the Workstation

  • Review installed software
  • Configure workstation – minicom
  • Exercise: Configure workstation-minicom
  • Configure workstation –networking
  • Exercise: Configure workstation-networking
  • Connect and power up target
  • Exercise:  Connect and power up target
  • The U-boot environment
  • Exercise: Examining the U-boot environment

Module 07: Building and Running Target Applications

  • Flash memory and file systems
  • The target file system
  • Exercise: Examining the target file system
  • Exercise: Write the first program
  • Accessing peripherals from User space
  • Demo: Accessing peripherals from User space
  • Data acquisition example
  • Demo: Creating a makefile project
  • Exercise: Create a makefile projecft
  • Demo: Code review
  • Demo: Building and running the measure program
  • Exercise:  Build and run the measure program

Module 08: Debugging Applications: On the Target and on the Workstation

  • Debugging on the target
  • Demo: Target Debug Configuration
  • Exercise: Target Debug Configuration
  • Building a high-level simulation
  • Exercise: Write thermostat.c
  • Debugging on the workstation
  • Demo: Host debugging
  • Exercise: Host debugging
  • Exercise: Run thermostat on target

Module 09: Multi-threading

  • The fork() function
  • Posix threads
  • Thermostat with threads
  • Demo: the Posix project
  • Exercise: Create the Posix project
  • Exercise: Modify thermostat.c
  • Demo: Debugging multi-threaded programs
  • Exercise: Debugging multi-threaded programs
  • Accessing hardware from device drivers

Module 10: Networking Part 1

  • The “sockets” model
  • Demo: Simple client/server example
  • Exercise: Build the client/server and run them
  • Networked thermostat
  • Exercise: Modify monitor.c
  • Demo: Running the network thermostat
  • Exercise: Run the network thermostat

Module 11: Networking Part 2

  • Multiple client connections
  • Exercise: Create multimon.c
  • Demo:  Testing multiple clients
  • Exercise: Testing multiple clients
  • Embedded web server
  • Demo: Code Review, Running the web server
  • Exercise: Build and run a simple web server
  • Exercise: Enable boa web server

Module 12: Graphics Device Driver

  •  What’s a device driver?
  • Exercise: the /dev directory
  • Demo:  the /proc directory
  • ANSI escape sequences
  • The console driver
  • The framebuffer driver
  • Demo: Display example
  • Exercise:  Using ANSI escape sequences
  • Exercise: Create an LCD thermostat

Module 13: Configuring the Linux Kernel

  • The kernel source tree
  • Demo: Review kernel source tree
  • Patching software
  • Exercise: Building the kernel: First steps
  • Configuring the kernel - xconfig
  • Demo: Configuring the kernel
  • Exercise: Configure the kernel

Module 14: Building the Linux Kernel

  • The .config file
  • Demo: The .config file
  • Kconfig files
  • Demo: a Kconfig file
  • Building the kernel
  • Exercise: Build the kernel Part 1
  • Exercise: Set up the TFTP server
  • Exercise: Build the kernel Part 2
  • Booting the new kernel over TFTP
  • Exercise: Booting the new kernel over TFTP

Module 15: Busybox and U-boot

  • The target/bin directory
  • Demo: The target/bin directory
  • Configuring and Building Busybox
  • Demo:  Configuring and Building Busybox
  • Exercise: Configuring and Building Busybox
  • Configuring U-boot
  • Demo: Configuring U-boot

Module 16: Booting the Application, Getting Ready to Ship

  • How Linux boots up
  • The init process and inittab file
  • Demo: Editing the inittab
  • Exercise: Editing the inittab
  • Exercise: Create YAFFS file system
  • Loading the root file system to NAND flash
  • Demo: loading the root file system to NAND flash
  • Exercise: loading the root file system to NAND flash
  • Loading the kernel to NAND flash
  • Demo: Loading the kernel to NAND flash
  • Exercise: Loading the kernel to NAND flash

Module 17: Wrapping Up

  • Install and get familiar with Linux
    • What’s this Open Source stuff all about?
  • Eclipse
  • Set up target board
  • Install class software – cross tool chain
  • Configure host networking and minicom
  • Target’s root file system is on host
View all course details

To successfully complete this course you should be proficient in C programming or have taken Introduction to C Programming Part 1 and Introduction to C Programming Part 2, and have taken Red Hat Linux Essentials or have some familiarity with Linux.

As this is very much a hands-on class, you’ll get more out of the class if you have the target hardware on which the examples are run.  The Embedded Linux Learning Kit from Intellimetrix is offered at a reduced price to GogoTraining members. This kit includes all of the required software on CD.  Go to

View all course details

Get Started Learning

The Linux Master Package Today!

Norman McEntire

Norman McEntire founded Servin Corporation in 1995 to focus on “Software Technology Training for Software Technology Professionals(tm). Since that time, Norman has used his unique  training style to train thousands of software developers in nearly every major technology company, including Avaya, Broadcom, Cubic, Dell, Fidelity, HP, IBM, Intel, Intuit, Motorola, NCR, Qualcomm, Wells Fargo, and many more. With degrees in Computer Engineering, Norman has designed and built everything from low-level chips, boards, and complete computer systems, to software at all levels, including device drivers, systems software, and end-user software for the desktop, web, and mobile.

Tim R. Norton

Dr. Norton has worked with a variety of computer systems of all sizes and many operating systems, including MVS, Windows and Unix/Linux. He has experience with applications design, support, and systems programming. He has done Technology Planning, Capacity Planning and Capacity Modeling for over 20 years at a variety of large companies. He co-foundered and was the Chief Scientist of a start-up company to provide web based capacity planning services for web applications. He has been a full-time Professor at a local university and continues to teach at universities in Colorado Springs. He is active in CMG (Computer Measurement Group), the leading computer performance analysis organization, and has been the Subject Area Chair for every year since 2000. He has participated in Colorado Governor Owens' Technology Summit. He has served on the Academic Advisory Boards for Computer Science at Colorado Technical University and at DeVry University of Colorado. He founded Simalytic Solutions, LLC in 1995 to provide capacity planning and application modeling services using the Simalytic® Modeling Technique and the Response Time Pipe™ that he developed as a result of his doctorial research.

James Lee

James Lee is a hacker and open-source advocate based in Illinois. He holds a master's degree from Northwestern University, and he can often be seen rooting for the Wildcats during football season. As founder of Onsight, Lee has worked as a programmer, trainer, manager, writer, and open-source advocate. Lee authored Beginning Perl, Second Edition published by Apress and coauthored Hacking Linux Exposed, Second Edition, as well as Open Source Web Development with LAMP. He enjoys hacking in Perl and Python and has written programming articles for the Linux Journal. Lee also enjoys developing software for the Web, reading, traveling and, most of all, snowboarding with his kids who are old enough now to understand why dad's favorite animals are penguins and camels and why dad laughs at Monty Python's Flying Circus.

Doug Abbott

Doug Abbott is a consultant, author, and trainer with over thirty years experience in the computing field. He has done both hardware and software design primarily in the area of data acquisition and instrumentation. As a software engineer, his focus has been on the operating system and device driver level with a particular emphasis on embedded applications of Linux.

As an instructor, Mr. Abbott has developed and taught several courses--both in-person and on-line--for UC Berkeley Extension and UC San Diego Extension. These classes have also been presented on-site to a number of well-known institutions including NASA Houston, Wind River Systems, Jet Propulsion Laboratory, and TRW among others.

Doug is the author of three books:

     Embedded Linux Development using Eclipse

     Linux for Embedded and Real-time Applications, 4th Ed.

     PCI Bus Demystified, 2nd Ed.

Doug has both a bachelor's and master's degree in electrical engineering from UC Berkeley.



This course comes with a Transcript that tracks your progress. You can use your transcript to view and monitor your progress and when you complete the course, you can print or email the transcript, or print a course completion certificate.

Letter of Course Attendance

When you complete this course you will receive a Letter of Course Attendance Download Link so you can print and/or email your Letter of Course Attendance.

Sample of Letter of Course Attendance

QA Forum

When you purchase this course you will be able to use the QA Forum and have direct access to the instructor.