Embedded Linux: Systems and Software
Jon Sevy Geometric and Intelligent Computing Lab Drexel University May 2008
Copyright 2008, Jonathan Sevy
Table of Contents
Embedded Linux Systems Overview Creating, Configuring and Building Embedded Linux Software Systems Linux Boot Process Linux Board Port Linux Device Driver and Kernel Programming Embedded Linux Application Development Open-Source Software Licenses Tools and Resources
Page 2
Embedded Linux Systems Overview
Embedded Linux Systems Overview
Components Kernel Libraries Applications System initialization and scripts Root filesystem Runtime Linux System Kernel space vs user space Virtual/physical memory Development system requirements
Activities Resources
Page 4
Embedded Linux
Any small system running Linux Headless (no display wireless router, set-top box, e.g.) User-interactive (PDA, cellphone, etc.) More than just kernel! Applications provide system-specific functionality Shared libraries support applications Kernel manages running applications, hardware drivers Think of as stripped-down desktop system Unneeded features removed Embedded-specific features added
Page 5
Linux Software System Components
Kernel Manages tasks, drivers Drivers Manage hardware resources Root filesystem Libraries Applications (including GUI) Scripts User data
RootFilesystem Applications
Libraries
LinuxKernel Drivers, processorspecifickernelmods
Hardware
Page 6
Kernel
Current Linux kernel: 2.6 series Fully supports ARM processors (including ARM926) Complete networking, filesystem, other support Configurable Build in only those features needed Multiple possible execution modes Execute-in-place (XIP) Compressed/loadable
RootFilesystem Applications
Libraries
LinuxKernel
Drivers, processorspecifickernelmods
Hardware
Page 7
Drivers
Manage hardware resources (peripherals) Exist for many standard peripherals Built-in to kernel or loadable at run-time Well-documented process for creating custom drivers (see references)
RootFilesystem Applications
Libraries
LinuxKernel
Drivers
Hardware
Page 8
Root Filesystem
Directory tree containing needed libraries, scripts, applications Organization usually follows standard Unix filesystem conventions (/bin, /sbin, /etc, etc.) Stored as standard Linux filesystem type Typically cramfs or jffs2 compressed filesystem when in Flash Ext2/3 for disk
Page 9
Libraries
C library Standard utility functions, interface to kernel functionality Several variants:
Others as needed Pthreads ALSA GUI support
Glibc: big and full-featured uClibc: small, configurable, targeted for embedded systems (usual choice)
RootFilesystem Applications
Libraries
LinuxKernel Drivers, processorspecifickernelmods
Hardware
Page 10
Applications
Created as standard Posix/Unix applications Stored in filesystem, loaded to RAM for execution Standard applications Busybox
Standard Unix utilities in single package Configurable feature support
RootFilesystem
Custom applications GUI applications Anything system-specific (background network applications, etc.)
Applications
Libraries
LinuxKernel Drivers, processorspecifickernelmods
Hardware
Page 11
Scripts
Used to initalize/shut down system Others for access control, configuration Stored in /etc directory of root filesystem
Page 12
GUI
Provide desktop environment Window environment for GUI application creation and management Many standard apps available (productivity, multimedia, etc.) Qtopia Phone Edition Commercial, royalty-based Complete suite of applications Used in existing handset designs
Motorola A760, A780 Philips Nexperia Cellular System Solution 9000 reference platform
Page 13
Runtime Linux System
Serial console Apps started at system initialization Daemons (always running services) Kernel threads (e.g., JFFS2 garbage collection)
Page 14
Memory Considerations
Kernel space vs user space MMU enforces protection Requires copy or MMU map (mmap) to exchange data Virtual memory addresses Application address space (0x0) Kernel address space (0xC000 0000) I/O address space (0xF000 0000) /dev/mem, /dev/kmem, devmem2
Driver interface to inspect memory, used by devmem2/peek-poke
Page 15
Activity and Resources
Activity Skulk around an embedded Linux system Use devmem2 to inspect memory Use ps, top to see running system info cat some /proc files to get kernel info Resources Building Embedded Linux Systems, Karim Yaghmour, O'Reilly Embedded Linux: Hardware, Software and Interfacing, Craig Hollabaugh, Addison Wesley
Page 16
Creating, Configuring and Building Embedded Linux Software Systems
Creating, Configuring and Building Embedded Linux Systems
Kernel Libraries Applications System initialization and scripts Root filesystem Loading on target
Activities Resources
Page 18
Kernel - Configuration
Acquiring source http://www.kernel.org full ARM support standard Configuring with menuconfig make menuconfig ARCH=arm built-in vs loadable modules: y vs m .config/config.h and defconfig files command line: root=/dev/mtdblock2 rootfstype=jffs2 console=ttyS0,115200 init=/linuxrc asm -> asm-arm and arch -> arch-vx115 after configuration
Page 19
Kernel - Building
CROSS_COMPILE environment variable in top-level Makefile Set to prefix of toolchain; arm-none-linux-gnueabi- for CodeSourcery toolchain Can set on command line or as environment variable make ARCH=arm CROSS_COMPILE=arm-none-linux-gnueabi zImage: in arch/arm/boot
Self-extracting compressed kernel
loadable modules: in .tmp_versions
can install into root filesystem with correct subdirectory structure with modules_install and INSTALL_MOD_PATH:
make modules_install INSTALL_MOD_PATH=../rootfs/rootfs
Page 20
C library: uClibc or glibc
uClibc configuring with menuconfig:
make menuconfig need to set cross-compilation setting
building
make
glibc can use binary from toolchain can configure and build with configure and make (see next)
Page 21
Other Libraries
Typical library (e.g., ALSA) configuring with configure:
./configure <options> sets up files for building (may create Makefiles, configuration headers)
finding/setting options
./configure help target:
target=arm-none-linux
cross-compiler
CC=arm-none-linux-gnueabi-gcc as configure option, or export CC=arm-none-linux-gnueabi-gcc; ./configure <other-options>
saving command for later (in config.log) config.cache (may need to delete between reconfiguration)
Page 22
Applications
Busybox bundles most needed Unix apps configuring with make menuconfig building with make Other (e.g., ALSA utils) configuring with configure
may need to add CFLAGS, LDFLAGS variables with paths to needed headers and libraries (e.g., ALSA lib)
building with make
Page 23
Scripts and Initializations
linuxrc
first user code run by kernel; specified in kernel command line (init=linuxrc) does some basic filesystem mounting, etc.
init.d and rc2.d directories and links
shell scripts to start/stop services in init.d arg to each will be start, stop, restart links to scripts in rc2.d, executed by init
init
runs scripts in /etc/rc2.d directory for system service startup and shutdown scripts starting with 'S' run at startup with argument start scripts starting with 'K' run at shutdown with argument stop scripts run in lexical order (hence numbers in names)
Page 24
Root Filesystem
Create tree on development host
create required directories as part of build process
Populate with apps, libraries and scripts
/dev: use mknod to create device nodes links to RAM disk for /tmp, /var for Flash-based systems
Package as filesystem for loading on target
use mkfs variants to create binary filesystem object (e.g., mkfs.jffs2)
Loading on target
Create srecs using objcopy, load to Flash
Page 25
Activity and Resources
Activity
Configure kernel, uClibc, Busybox Configure and add an open-source library to distribution Configure and add an open-source application to distribution
Resources
Building Embedded Linux Systems, Karim Yaghmour, O'Reilly. Embedded Linux: Hardware, Software and Interfacing, Craig Hollabaugh, Addison Wesley. Busybox: http://www.busybox.net uClibc: http://www.uclibc.org/
Page 26
ARM Linux Boot Process
Linux Boot Process
Bootloader requirements zImage decompression Kernel code System initialization
Activities Resources
Page 28
Bootloader Requirements
Virtually none if use head-<mach>.S to set machine/arch numbers Can pass tag structures to kernel for configuration Can use bootloader (uboot, blob, ...) to read kernel zImage from filesystem if desired
Page 29
zImage Decompression
arch/arm/boot/compressed/head.S include arch-specific code
arch/arm/boot/compressed/head-<mach>.S
decompress kernel to RAM jump to start of kernel in RAM (zreladdr)
zreladdr = ZRELADDR = zreladdr-y zreladdr-y specified in arch/arm/mach-<mach>/Makefile.boot
arch/arm/boot/compressed/head-<mach>.S added to build in arch/arm/boot/compressed/Makefile linked into head.S by linker section declaration: .section start flush cache, turn off cache and MMU, set machine and arch number
Page 30
Kernel Code
arch/arm/kernel/head.S: stext look up machine and arch structures set up initial kernel page tables, init MMU copy data segment, zero BSS jump to start_kernel init/main.c: start_kernel initialize subsystems and built-in drivers start init process
Page 31
Resources
Linux Kernel Cross-Reference hypertext-linked browsable kernel source http://lxr.linux.no/
Page 32
Linux Board Port
Linux Board Port
Machine and processor ID Memory configuration Flash configuration Kconfig and Makefile modifications Platform includes: include/asm-arm/arch-xxx Platform source files: arch/arm/mach-xxx Interrupts Serial/console driver
Activities Resources Note: Use port to an ARM-based processor vx115 and platform vx115_vep development board as example
Page 34
Machine and Processor ID
Machine and processor ID arch/arm/tools/mach-types
define machine and arch numbers and macros arch/arm/Makefile machine-$(CONFIG_ARCH_VX115) := vx115
Boot files arch/arm/boot/compressed/head-vx115.S, Makefile
flush cache, turn off cache and MMU set up machine and arch numbers
Page 35
Memory Configuration
include/asm-arm/arch-vx115/memory.h
#define PHYS_OFFSET 0x24200000 physical address of kernel code base #define PAGE_OFFSET (0xc4200000UL) virtual address of kernel code base #define MEM_SIZE 0x01e00000 used in virtual-physical memory translation functions replaced by defines in discontiguous memory file if needed
arch/arm/Makefile
textaddr-$(CONFIG_ARCH_VX115) := 0xc4208000 kernel entry point (virtual); address of stext in link map (vmlinux.lds)
arch/arm/mach-vx115/Makefile.boot
zreladdr-y := 0x24208000 physical address where decompression routine jumps when done
arch/arm/mach-vx115/vx115_vep.c
.phys_ram = 0x24200000 in MACHINE_DESC struct start of RAM for use by kernel
Page 36
Platform-Specific Directories
include/asm-arm/arch-vx115 contains platform-specific header files
hardware.h, others
configuration process generates symbolic links
include/asm -> /include/asm-arm include/asm/arch -> /include/asm-arm/arch-vx115
arch/arm/mach-vx115 contains platform-specific source files
main board files (vx115_vep.c) interrupt, DMA, other SoC-related files
Page 37
Platform Includes: include/asm-arm/arch-vx115
Required headers hardware.h
platform hardware register defines
included into arm generic hardware.h (include/asmarm/hardware.h)
note use of virtual register addresses
system.h dma.h io.h
define arch_idle, arch_reset functions to indicate behavior when idle or on reset define MAX_DMA_ADDRESS to indicate all of memory is DMA-able define IO_SPACE_LIMIT to mark all memory as possible I/O space define CLOCK_TICK_RATE, used in jiffies.h for system timing params define HZ to set kernel tick rate different from 100/sec if desired
Page 38
timex.h
param.h
Platform Includes: include/asm-arm/arch-vx115
Required headers (cont.) serial.h system.h
used to put in standard (8250) serial port defines if using these define arch_idle, arch_reset functions to indicate behavior when idle or on reset some memory allocation defines moved to common kernel code in 2.6.18 since same in all platforms output routines for zImage decompression stage very low-level interrupt handling (described below)
vmalloc.h
uncompress.h
entry-macro.S
Other headers anything hardware-ish
Page 39
Platform Source Files: arch/arm/mach-vx115
vx115_vep.c main board-specific initialization file I/O mapping Interrupt initialization Device specification
define I/O virtual-physical map in map_desc struct array define map_io function for MACHINE_DESC struct define board-specific irq_init funtion for MACHINE_DESC struct define platform_device and amba_device structs for use in driver configuration vx115_init_machine Register devices; will be matched with appropriate drivers for driver configuration
Machine initialization function
Page 40
Platform Source Files: arch/arm/mach-vx115
vx115_vep.c (cont.) Fixup function
set memory bank info pointers to platform functions defined above, and system timer linked into list of supported machines; retrieved during boot
MACHINE_DESC struct for platform
Page 41
Platform Source Files: arch/arm/mach-vx115
irq.c define functions to ack, mask, unmask irqs define irqchip struct
function pointers for irq ack, mask, unmask
define irq initialization function
initialize controller, handlers to use specified irqchip
Page 42
Platform Source Files: arch/arm/mach-vx115
time.c System timer: define platform timer tick function
just manages hardware timer, calls system timer_tick function
define initialization function, sys_timer struct for use in MACHINE_DESC macro
Page 43
Platform Source Files: arch/arm/mach-vx115
Others other board-specific source files gpio.c
gpio interface
dma.c ssp.c
dma controller driver ssp driver; probably belongs in drivers/char
Page 44
Kconfig and Makefile Modifications
Have Kconfig and Makefile in each subdir Kconfig add selectors for defines in code and Makefiles defines generated into .config (also config.h for code header) Makefiles add to lists of files to be compiled and linked into that subdir's objects obj-y: built-in code file list obj-m: loadable module file list
Page 45
Interrupts
include/asm/arch/entry-macro.S defines assembly routine get_irqnr_and_base returns the IRQ number from controller arch/arm/mach-vx115/irq.c defines irq mask/ack routines (discussed above) common kernel routines arch/arm/kernel/entry-armv.S
low-level assembly vector handling calls machine-specific get_irqnr_and_base and common asm_do_IRQ asm_do_IRQ: (eventually) calls IRQ-specific handler
arch/arm/kernel/irq.c
Page 46
Flash Configuration
drivers/mtd/maps/vx115_flash.c define map_info struct indicating parameters for Flash devices (base addr, bank width) define mtd_partition struct for each bank giving logical partitions define init_vx115_vep_flash function
register flash map and partition info module_init macro places function pointer in init section so will be called during system initialization
Page 47
Serial Console Driver
provide serial driver for kernel control complex structure; routines for input/output and control through ioctl's specify console on kernel command line console=/dev/ttyS0
Page 48
Extracting Changes: Diff and Patch
Pull out changes so can be applied to vanilla kernel can deliver just changes rather than whole kernel Use diff and patch diff: find all differences patch: apply differences to fresh kernel Creating patch need both unmodified source tree and modified source tree directories diff -Nur (unmodified-source-dir) (modified-source-dir) > mods.patch extra args to adjust diff process
--exclude=CVS -I '.*$Id:.*' -I '.*$Id$.*' -I '.*$Revision:.*' -I '.*$Source:.*' -I'.*$Date:.*' -I '.*$Header:.*' -I '.*$Author:.*'
Applying patch from within top-level directory of vanilla source tree patch -p1 < mods.patch
Page 49
Activity and Resources
Activity work with diff and patch Resources Porting the Linux Kernel to a New ARM Platform (2.4-series kernel): http://linux7110.sourceforge.net/howtos/netbook_new/porting2arm_ale ph.pdf Linux Porting Guide (uses MIPS as example): http://www.embedded.com/shared/printableArticle.jhtml?arti cleID=9900048
Page 50
Linux Device Driver and Kernel Programming
Linux Device Driver and Kernel Programming
Device and Driver Model Loadable vs built-in drivers Kernel space vs user space Kernel memory allocation Synchronization DMA Interrupt handlers Resource (I/O space) request Hardware access functions (read/write) Proc and sysfs filesystems Debugging Driver types Netfilter architecture
Page 52
Common Driver Interface
init and exit declared with module_init and module_exit macros
called at system initialization/shutdown time for loadable modules, called when module inserted or removed from kernel
struct device_driver vx1xx_driver = { .name = "vx1xx-uart", .bus = &platform_bus_type, .probe = vx1xx_probe, .remove = vx1xx_remove, .suspend = vx1xx_suspend, .resume = vx1xx_resume, };
register/unregister device_driver struct:
bus: used in device-driver matching (see next slide) probe and remove
suspend and resume
called when device registered/unregistered during system initialization for pluggable devices, called when device insertion or removal detected called by power management subsystem to inform device to power down/up
Page 53
Device and Driver Model
Goal: separate mechanism (driver) from config info (device) Device specification Provided in platform-specific code (vx115_vep.c) Device hierarchy (parents) Registration platform_add_devices, amba_device_register in board setup function driver_register in driver init function; bus type in device_driver struct Device and driver matching and configuration registering devices and drivers causes match to occur
driver's probe function called to configure driver with handle to device data
often text-based match (ex. platform devices)
Page 54
Loadable vs Built-in Drivers
Virtually all drivers support both modes module_init macro built-in driver: places function pointer in init section so will be called during system initialization loadable module: just aliases function to init_module; called by module loader __init function qualifier: places function in init section so memory can be reclaimed after boot lsmod, insmod, rmmod and modprobe applications lsmod: list currently loaded modules insmod: loads specified module (need complete path) modprobe: loads specified module and all modules it depends on
looks in /lib/modules for named module uses modules.dep file generated by depmod to resolve module dependencies if you add a new module, need to add new modules.dep to use modprobe
Page 55
Kernel Space vs User Space
Each user application uses same virtual address space (usually 0-based) MMU maps each app's virtual addresses to its personal physical pages; map changes on context switch if give kernel pointer to userspace buffer and get context switch, what happens to buffer reference? :-( copy_from_user, copy_to_user transfer between user process buffer and kernel buffer make sure pages aren't swapped out (not an issue in most embedded systems) mmap and remap_pfn_range map a kernel buffer so it can be directly accessed from user application mmap function provided as part of driver interface (see below) kernel function remap_pfn_range does actual mapping
Page 56
Kernel Memory Allocation
kmalloc, kfree: allocate and free memory in kernel space allocates virtually and physically contiguous buffer, returns virtual address flag specifies whether can sleep or not during allocation vmalloc allocates virtually contiguous buffer , returns virtual addresses can allocate larger buffers, but less efficient
Page 57
Lists
Use built-in Linux list functions gives doubly-linked list struct list_head list_add, list_add_tail, list_splice, list_del, list_empty list_entry(entry, type, member); container_of macro get structure containing specified field
specified field need not be first field
container_of(ptr, type, member) list_entry just #defined to container_of
Page 58
Synchronization: Semaphores and Spinlocks
semaphores and mutexes usual semaphore semantics down_interruptible, down_trylock, up applicable to thread context only (suspends) spinlocks just disable/reenable interrupts in uniprocessor (non-SMP) system spin_lock_irqsave, spin_unlock_irqrestore protects against threads and ISRs
Page 59
Synchronization: Completions
wait until signalled that some operation is complete use completion struct and functions struct completion c; init_completion(&c); wait_for_completion(&c); // wait until completion signalled complete(&c); // to wake up a process waiting for completion wait applicable in thread context only (suspends); completion signalled from thread or ISR context
Page 60
Synchronization: Wait Queues
sleep until awakened and specified condition true wait_event_interruptible(wait_queue, condition); wait on queue until awakened and condition true wake_up_interruptible(wait_queue); awaken waiting task(s) wait applicable in thread context only (suspends); wake_up can be signalled from thread or ISR context Notes oddly, can't assume condition true when awakened
might be awakened due to signal might have been out-raced by another task guard against race conditions
should protect condition test with semaphore/spinlock
Page 61
DMA
buffer allocation dma_map_single/dma_unmap_single with kmalloc/kfree
kmalloc/kfree handle allocation map functions handle cache coherency
transfer ownership of buffer to/from DMA controller extra direction argument makes cache sync more efficient
also have dma_map_sg, dma_unmap_sg for mapping scattergather lists
dma_alloc_coherent, dma_free_coherent allocates non-cacheable buffer; less efficient kernel DMA interface request_dma, free_dma: request/free a DMA channel set_dma_addr, set_dma_count, set_dma_mode, set_dma_sg: configure DMA channel
Note that set only single address; assumes DMA target dedicated for each channel
enable_dma, disable_dma: start or end DMA transfer
Page 62
Interrupt Handling
Interrupt registration (low-level ISR) request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, char *name, void *context); Interrupt handler (low-level) irqreturn_t irq_handler(int irq, void *context, struct pt_regs *regs); return IRQ_HANDLED, IRQ_NONE (not handled) Synchronization Use spinlocks to protect against low-level IRQ handler Bottom halves Defer interrupt processing - high-level interrupt handlers Use tasklets and work queues to carry out processing
Page 63
Interrupt Handling: Tasklets
Context run in interrupt context (with interrupts enabled), so can't suspend done as a softirq: run after all hardware interrupts processed
kernel calls do_softirq at end of low-level interrupt processing
runs once when scheduled Use struct tasklet_struct tasklet; void tasklet_handler(unsigned long data); tasklet_init(&tasklet, tasklet_handler, data); tasklet_schedule(&tasklet); // schedule handler to be executed Synchronization Use spinlocks to protect against tasklet
Page 64
Interrupt Handling: Work Queues
Context run in process context, so can suspend run as kernel thread, so higher priority than user threads runs once when scheduled Use struct work_struct work; void work_handler(void *context); INIT_WORK(&work, work_handler, context); schedule_work(&work); Note: changed in 2.6.20; context replaced with pointer to work struct... Synchronization Use semaphore to protect against work queue
Page 65
Resource Requests
Request access to hardware region (registers, etc.) request_region, release_region: I/O space request request_mem_region, release_mem_region: memory region requests
Page 66
Resource Requests and Hardware Access
Resource (I/O space) request Request access to hardware region (registers, etc.) during driver initialization request_region, release_region: I/O space request request_mem_region, release_mem_region: memory region requests Hardware access functions (read/write) readb, readw, readl, writeb, writew, writel read/write 8/16/32-bit quantity from specified (virtual) address Preferable for memory access over direct pointer references
intends to make drivers portable to systems with separate I/O space Less relevant with embedded system
Page 67
Proc Filesystem
Virtual directory created and maintained by kernel appear as entries under /proc Provides control and statistics interface from userspace into drivers just read like would with normal files (can use cat, e.g.) Functions implemented by drivers which wish to expose an interface Use #include <linux/proc_fs.h> create_proc_entry, remove_proc_entry
request kernel to create entry for driver (usually during driver init) specify parent directory within /proc, functions for read and write just return info about driver (often text) use supplied info to control the driver
proc read function
proc write function
Page 68
Debugging
JTAG best for kernel code and built-in drivers not so useful for loadable modules or app code printk Usual method of kernel and driver debugging: print messages to system log and console procfs Can read out driver statistics/state objdump Inspecting binaries (symbol info, disassembly, etc.) ksymoops Decode kernel stack dumps into readable messages
Page 69
Driver Types
Driver interface depends on type Character stream- or character-oriented devices (UARTS, GPIOs, Block Block-oriented devices (disks, etc.) Network Drivers for network devices (Ethernet, Wifi, etc.) Higher-level frameworks Driver provides interface required by higher-level framework USB MTD SD/MMC ...
Page 70
Character Drivers
Interface: file operations (fops) struct
struct file_operations { struct module *owner; int (*open) (struct inode *, struct file *); int (*release) (struct inode *, struct file *); ssize_t (*read) (struct file *, char __user *, size_t, loff_t *); ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *); int (*mmap) (struct file *, struct vm_area_struct *); loff_t (*llseek) (struct file *, loff_t, int); unsigned int (*poll) (struct file *, struct poll_table_struct *); int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long); int (*flush) (struct file *); int (*fsync) (struct file *, struct dentry *, int datasync); ... (many more fields note order changed!) };
Implement functions for open, close, read, write, seek, etc.
Can leave many null if don't care about operation
Page 71
Character Driver Registration
major/minor number reservation major/minor used to map /dev node to driver register_chrdev_region(dev_t from, unsigned count, const char *name)
reserve range of major/minor numbers for device
driver registration have driver data structure
contains fields for whatever driver needs to do its work (buffers, lists, ...) has embedded cdev struct
use cdev_init(cdev, fops) to initialize embedded cdev struct with file ops use cdev_add(cdev, device_number, range) to register embedded cdev struct with kernel
Page 72
Driver Struct, Inodes and Files
Issue: how to get driver data structure for use in fops functions can use static struct, but limits number of devices supported by driver better: allocate struct for each device, stash so passed in as function arg Approach: stash device struct pointer in file structure open function passes inode and file pointers
inode has pointer to driver's cdev
was initialized when cdev_init called
extract pointer to driver struct which contains cdev struct with container_of set file->private_data field so can retrieve driver struct when get other calls
other file_operations functions pass just file struct, not inode
Page 73
Activity and Resources
Activity use objdump and ksymoops Create simple character driver
File ops interface Proc interface See example driver source code
Can build on x86 platform; has device module that registers device that matches with driver
Resources Linux Device Drivers, 3rd edition, Alessandro Rubini, O'Reilly
online version at http://lwn.net/Kernel/LDD3/ (pdf) 2nd edition in HTML: http://www.xml.com/ldd/chapter/book/
Linux Kernel Development, Robert Love, Sams
Page 74
Embedded Linux Application Development Overview
Embedded Linux Application Development
C development Posix development Makefiles Driver interface Library linking Debugging C++ Shell script development
Activities Resources
Page 76
C Application Development
Just regular Unix Posix development processes: fork, exec, wait threads: pthreads and attributes synchronization: condition variables, semaphores and mutexes communication: pipes, queues, shared memory file I/O: open, close, read, write signals sockets for networking
Page 77
C Application Development (cont.)
Driver interface file nodes and standard file operations Libraries Toolchain provides standard C libs Specify paths to custom libs and headers C++ standard C++ development Use libstdc++
Page 78
Debugging
Debugging with printf Send messages to console or system log Debugging with gdbserver Build gdbserver for platform Build app with debugging symbols (-g when compiling) Start app to be debugged with gdbserver
gdbserver <serial-device> <app-to-debug> gdbserver /dev/ttyS1 /bin/ls gdb, Insight, etc.
Connect to gdbserver over serial with gdb-capable debugger
Page 79
Shell Script Development
Use standard apps in shell script Pipes, redirection if, case Environment variables Notes Different shell variants have different syntax Arithmetic a pain
Page 80
Activity and Resources
Activity Debug an app with gdbserver Resources POSIX specs: http://www.unix.org/single_unix_specification/ Advanced Programming in the UNIX Environment, Richard Stevens, Addison-Wesley, 1992, http://www.kohala.com/start/
Page 81
Open-Source Software Licenses
Open-Source Software Licenses
GPLv2 Common properties LGPL MIT, modified-FreeBSD Resources
Page 83
Common Properties
Use at your own risk no guarantee don't sue me if it doesn't work Issues unknowingly incorporating software which contains patented material combining software with incompatible licenses
Page 84
GPLv2
GNU Public License Must deliver source together with binary to customers no customer, no delivery (internal corporate uses) no requirement to feed back mods or make them publicly available just must make source available to customer if deliver software Examples Linux kernel Pros tend to get mods fed back to common software baseline everybody benefits Cons linking extends GPL to non-GPL software - must provide source for all software linked with GPL software
Page 85
LGPL
Lesser or Library GPL Software linked with LGPL software not covered by LGPL source delivery not required Source code of LGPL code itself (together with any mods) must be made available to customer Examples glibc Pros Has allowed for non-open-source Linux application development
Situation less clear for kernel code such as loadable modules
Cons Still required to deliver source of libraries
Page 86
MIT, Modified-BSD
No source delivery required Pros preferred by businesses worried about exposing proprietary stuff Cons has led to fragmentation (e.g., multiple BSD implementations) slower progress (e.g., no good open-source Flash filesystem implementation in BSD's, even though iPhone uses BSDderived OS)
Page 87
Resources
Open-source software licenses described: http://www.gnu.org/licenses/license-list.html Understanding Open Source and Free Software Licensing, Andrew St. Laurent, O'Reilly, 2004, http://www.oreilly.com/catalog/osfreesoft/book/
Page 88
Linux Tools and Resources
Tools
gcc cross-compilation toolchain Pre-built: Code Sourcery: http://www.codesourcery.com/ Build your own: Dan Kegel's CrossTool: http://kegel.com/crosstool/ Insight (includes gdbserver): http://sourceware.org/insight/ Ksymoops
Page 90
Resources - Books
Linux Device Drivers, 3rd edition, Alessandro Rubini, O'Reilly
online version at http://lwn.net/Kernel/LDD3/ (pdf) 2nd edition in HTML: http://www.xml.com/ldd/chapter/book/
Linux Kernel Development, Robert Love, Sams Building Embedded Linux Systems, Karim Yaghmour, O'Reilly Embedded Linux: Hardware, Software and Interfacing, Craig Hollabaugh, Addison Wesley Understanding Open Source and Free Software Licensing, Andrew St. Laurent, O'Reilly, 2004 Advanced Programming in the UNIX Environment, Richard Stevens, Addison-Wesley Kernel Documentation subdirectory
Page 91
Resources - Web
Linux kernel cross-reference website: http://lxr.linux.no/ Linux Device Drivers, 3rd edition, Alessandro Rubini, O'Reilly
online version at http://lwn.net/Kernel/LDD3/ (pdf) 2nd edition in HTML: http://www.xml.com/ldd/chapter/book/
ARM Linux website: http://www.arm.linux.org.uk/
arm-linux-kernel mailing list
CELF Wiki: http://tree.celinuxforum.org/pubwiki/moin.cgi CELF Embedded Linux Conference: http://www.celinux.org/elc2007/index.html Linux Journal: http://www.linuxjournal.com/ Linux Magazine: http://www.linux-mag.com/ POSIX specs: http://www.unix.org/single_unix_specification/
Page 92
Resources Web (cont.)
Porting the Linux Kernel to a New ARM Platform (2.4-series kernel):
http://linux7110.sourceforge.net/howtos/netbook_new/porting2arm_ale ph.pdf
Linux Porting Guide (uses MIPS as example): http://www.embedded.com/shared/printableArticle.jhtml?articleID=990 0048 Linux kernel source repository: http://www.kernel.org Busybox: http://www.busybox.net uClibc: http://www.uclibc.org/ Qtopia: http://www.trolltech.com/products/qtopia/phone.html Open-source software licenses described:
http://www.gnu.org/licenses/license-list.html
Page 93
Page 94
