LddAgenda < Training2

---++ Agenda for Training course Embedded GNU/Linux Device Drivers

This 5-day training class uses hands-on exercises combined with instruction to illustrate the concepts of GNU/Linux kernel internals and device driver development. It is designed to bring you quickly up to speed. We describe processes, concepts and commands necessary to write GNU/Linux device drivers through a combination of theory and on-the-job training. Don’t reinvent the wheel, but learn from an experienced trainer and take home a working knowledge and the ability to use it effectively in your own embedded development project.

---++ Prerequisites
   * Basic familiarity with using a GNU/Linux system as an end user
   * Basic familiarity with a command line shell
   * Basic knowledge of user space / application development
   * Intermediate C programming knowledge
   * Should have attended Embedded GNU/Linux Systems Architecture before (strongly recommended!)

---++ Who should attend?
People with interest in or tasked with the development or evaluation of developing GNU/Linux device drivers like software engineers, field engineers, (project) managers, hardware engineers.

---+ Course Outline

---++ Introduction
   * quick history of GNU/Linux
   * licensing 
   * kernel versioning
   * release cycle
   * kernel trees
   * mainline 
   * kernel vs. user space
   * mechanism vs. policy 
   * kernel driver alternatives 
   * RTOS vs. Linux

---++ Memory Management
   * Virtual memory vs. physical memory
   * memory allocation in kernel
   * pages
   * zones
   * API
   * slab

---++ Kernel Patch
   * life cycle
   * git
   * kernel source
   * create patch
   * check patch
   * fix patch
   * ship patch
   * audited code

---++ Kernel Module
   * get kernel sources
   * configure
   * build
   * install
   * device drivers (statically linked, loaded at runtime)
   * init
   * licensing
   * EXPORT SYMBOL GPL
   * out of tree makefile
   * module-init-tools
   * module in kernel tree
   * Kconfig 
   * parameter passing
   * sparse

---++ Char Drivers
   * architecture
   * user/kernel interface
   * I/O subsystem
   * VFS
   * sysfs (devices, bus, drivers, classes)
   * kobject
   * ktype
   * kset 
   * linux kernel driver model
   * device files
   * char driver
      * initialization
      * registration
      * open, release
      * cdev, cdev add, cdev del,...
      * major/minor numbers
      * udev, udevmonitor, udevadm

---++ Advanced Character Driver Operations
   * ioctl
   * unlocked ioctl
   * compat ioctl
   * user space API
   * kernel space API
   * process lifecycle
   * sleeping/blocking 
   * sleeping/waking up 
   * wait queue
   * thundering herd
   * poll/select

---++ Kernel Debugging
   * bug
   * debugging
   * debugging the kernel
   * binary search with git
   * debug support from kernel
   * printk 
      * syslogd
      * klogd
      * loglevels
      * rate limit
      * debug levels
      * debug selective subsystems
   * debugging by querying debugfs
   * oops debugging, asserting oops
   * Magic SysRq Key
   * kgdb/kdb
   * JTAG

---++ Tracing
   * gcov
   * lcov
   * oprofile
   * ftrace
      * nop tracer
      * function tracer
      * sched switch tracer (viewer)
      * function graph tracer
      * dynamic tracer
   * LTTng

---++ Interrupts
   * interrupts vs. polling
   * interrupt
   * program sections 
   * reentrancy
   * events
   * interrupt handler
   * shared interrupt handler
   * interrupt flow
   * interrupt control

---++ Deferring Work
   * top/bottom halves
   * softirqs
   * tasklets
   * work queues

---++ Concurrency
   * critical region/section
   * atomic
   * race condition
   * synchronization
   * locking
   * locking solutions
   * deadlock
   * contention
   * what to lock?
   * what to use?
      * atomic operations
      * spin locks
      * reader-writer spin locks
      * semaphore
      * binary semaphore
      * mutex
      * reader-writer semaphore
      * completion variables
      * sequential locks
      * disable preemption
      * orderig and barriers

---++ Time
   * HZ
   * Jiffies
   * big/small delays
   * kernel timers

---++ Hardware I/O
   * I/O Ports
   * I/O Memory
   * How to deal with side effects accessing registers?

---++ User-Kernel Communication
   * put(get) user()
   * copy to(from) user() 
   * Kernel I/O
   * memory mapping
   * procfs
   * sysfs
   * debugfs
   * relayfs
   * netlink
   * ioctl

---++ Portability
   * word size
   * opaque types
   * signed/unsigned char
   * data alignment
   * integral promotion
   * code reuse
   * endianess
   * system tick
   * page size
   * instruction ordering
   * SMP/preemption/high memory