plano

   1 intro
   2         linux
   3                 version history/evolution DO?
   4                 modules
   5                 constant change, book is already outdated
   6                 current versioning/development model
   7                 build dependencies
   8                 running new/bleeding-edge kernels
   9         kernel/user space
  10         libc/system calls
  11
  12 concepts
  13         operating system functions
  14                 process management
  15                         concurrency
  16                         communication/IPC, scheduling
  17                 memory management
  18                         address space
  19                         virtual memory
  20                 filesystems
  21                 networking
  22                 device, I/O
  23         robustness/security
  24                 error checking
  25                 kernel space code
  26                 programming errors and bugs
  27                 restrict some operations to privileged users
  28                 do not send unzeored data (information leak)
  29                 do not trust received data (malformed data) (exploit)
  30
  31 basics
  32         Makefile
  33         Kconfig DO?
  34         build
  35         init/exit
  36         module macros
  37         module parameters
  38         config/build time options/parameters
  39         sysfs interface for modules DO?
  40         printk
  41
  42 VFS
  43         center/hub/interface
  44         char/block/procfs/sysfs: all go through VFS to device
  45         fops is the main structure in linux
  46         FS on top of block devices
  47                 block layer
  48                 exception: some on top of MTD devices
  49
  50 device driver subsystem
  51         buses
  52         device classes
  53         interfaces
  54                 dev file
  55                 sysfs
  56                 procfs
  57                 sysctl DO?
  58                 netlink DO?
  59
  60 char device
  61 procfs
  62 sysfs
  63 block device DO? STUDY
  64 network device DO? STUDY
  65 terminal/serial device DO? STUDY
  66
  67 debugging techniques
  68         printk/procfs
  69         debugfs DO? STUDY
  70         kgdb DO?
  71         trace DO?
  72         kprobe DO?
  73
  74 C basics
  75         container_of (struct embedding)
  76         fops/*ops (function pointers)
  77         IS_ERR (pointers and error values)
  78
  79 data structures
  80         list_head
  81         bitmap
  82         trees DO? STUDY rbtree
  83         idr DO?
  84         any hash implementation DO? STUDY
  85
  86 contexts
  87         user context (current, copy_from_user, schedule) STUDY schedule
  88         interrupt context
  89         workqueue is user context
  90         sleep == schedule
  91
  92 concurrency
  93         SMP systems
  94         locking
  95         spinlock: disable scheduler
  96         semaphore/mutex sleeps
  97         per-cpu variables STUDY
  98         atomic
  99         RCU DO?
 100
 101 memory allocation
 102         kobject refcount MENTION
 103         slab STUDY
 104                 multiple implementations
 105                 space efficient (tables for different object sizes)
 106                 concurrency efficient (per-cpu tables)
 107         kmalloc
 108                 uses slab STUDY
 109         vmalloc
 110                 linux memory layout
 111
 112 scheduling/timing
 113         schedule{,_timeout}
 114         timer
 115         workqueue
 116         completion/wait_head
 117         tasklets DO? STUDY
 118
 119 portability
 120         readl/writel/etc
 121         be16_to_cpu/etc
 122
 123 interrupt
 124         {request,free}_irq
 125         interrupt context
 126         tasklet/workqueue/postpone
 127
 128 buses
 129         PCI bus DO?
 130         USB bus DO?
 131         some bus: SPI, I2C, parport DO?
 132
 133 device classes
 134         some class: cdrom, backlight, input, misc DO?
 135
 136 kobject DO? advanced
 137         refcounting
 138
 139 STUDY:
 140         module owner, concurrency, reference counting