The Linux Master Package

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!

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

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

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.

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

Students should have experience in basic programming usage or have taken:

• Introduction to Programming and Coding for Everyone with JavaScript
• Fundamentals of Operating Systems

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

You need to have equivalent experience or taken the following GogoTraining courses:

• Introduction to Programming and Coding for Everyone with JavaScript
• Fundamentals of Operating Systems
• Linux V7 Essentials

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

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 www.intellimetrix.us/gogotraining.  If your laptop lacks a parallel port, a compatible docking station usually has one.
 

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

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 www.intellimetrix.us/gogotraining.