book

Linux Device Drivers, Second Edition

by Jonathan Corbet, Alessandro Rubini

June 2001

Intermediate to advanced

592 pages

19h 20m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Alessandro’s Introduction

The Role of the Device Driver
Kernel Modules Versus ApplicationsUser Space and Kernel SpaceConcurrency in the KernelThe Current Process
Version DependencyPlatform Dependency
Error Handling in init_moduleThe Usage CountUnloadingExplicit Initialization and Cleanup Functions
I/O Ports and I/O MemoryPortsMemoryResource Allocation in Linux 2.4
Changes in Resource ManagementCompiling for Multiprocessor SystemsExporting Symbols in Linux 2.0Module Configuration Parameters
The Design of scull
Dynamic Allocation of Major NumbersRemoving a Driver from the Systemdev_t and kdev_t
The open MethodThe release Method
The read MethodThe write Methodreadv and writev
Using devfs in PracticePortability Issues and devfs
Changes in the File Operations StructureThe Module Usage CountChanges in Semaphore SupportChanges in Access to User Space
Debugging by PrintingprintkHow Messages Get LoggedTurning the Messages On and Off
Using the /proc FilesystemThe ioctl Method
Oops MessagesUsing klogdUsing ksymoopsSystem Hangs
Using gdbThe kdb Kernel DebuggerThe Integrated Kernel Debugger PatchThe kgdb PatchKernel Crash Dump AnalyzersThe User-Mode Linux PortThe Linux Trace ToolkitDynamic Probes
ioctlChoosing the ioctl CommandsThe Return ValueThe Predefined CommandsUsing the ioctl ArgumentCapabilities and Restricted OperationsThe Implementation of the ioctl CommandsDevice Control Without ioctl
Going to Sleep and AwakeningA Deeper Look at Wait QueuesWriting Reentrant CodeBlocking and Nonblocking OperationsA Sample Implementation: scullpipe
Interaction with read and writeReading data from the deviceWriting to the deviceFlushing pending outputThe Underlying Data Structure
The Driver’s Point of View
The llseek Implementation
Single-Open DevicesAnother Digression into Race ConditionsRestricting Access to a Single User at a TimeBlocking open as an Alternative to EBUSYCloning the Device on Open
Wait Queues in Linux 2.2 and 2.0Asynchronous NotificationThe fsync MethodAccess to User Space in Linux 2.0Capabilities in 2.0The Linux 2.0 select MethodSeeking in Linux 2.02.0 and SMP
Time Intervals in the KernelProcessor-Specific Registers
Long DelaysShort Delays
The Nature of Task QueuesHow Task Queues Are RunPredefined Task QueuesHow the examples workThe scheduler queueThe timer queueThe immediate queueRunning Your Own Task QueuesTasklets
The Real Story of kmallocThe Flags ArgumentMemory zonesThe Size Argument
A scull Based on the Slab Caches: scullc
A scull Using Whole Pages: scullp
A scull Using Virtual Addresses: scullv
Acquiring a Dedicated Buffer at Boot TimeThe bigphysarea PatchReserving High RAM Addresses
I/O Ports and I/O MemoryI/O Registers and Conventional Memory
String OperationsPausing I/OPlatform Dependencies
An Overview of the Parallel PortA Sample Driver
Directly Mapped MemoryReusing short for I/O MemorySoftware-Mapped I/O MemoryISA Memory Below 1 MBisa_readb and FriendsProbing for ISA Memory
Overall Control of Interrupts
The /proc InterfaceAutodetecting the IRQ NumberKernel-assisted probingDo-it-yourself probingFast and Slow HandlersThe internals of interrupt handling on the x86
Using ArgumentsEnabling and Disabling Interrupts
TaskletsThe BH MechanismWriting a BH Bottom Half
Installing a Shared HandlerRunning the HandlerThe /proc Interface
Using Circular BuffersUsing SpinlocksUsing Lock VariablesBit operationsAtomic integer operationsGoing to Sleep Without Races
Differences in the 2.2 KernelFurther Differences in the 2.0 Kernel
Use of Standard C Types
Time IntervalsPage SizeByte OrderData Alignment
Loading Modules on DemandRequesting Modules in the KernelThe User-Space SideModule Loading and SecurityModule Loading ExampleRunning User-Mode Helper Programs
Using Version Support in ModulesExporting Versioned Symbols
Registering the Driver
The Request QueuePerforming the Actual Data Transfer
The I/O Request QueueThe request structure and the buffer cacheRequest queue manipulationThe I/O request lockHow the blk.h macros and functions workClustered RequestsThe active queue headMultiqueue Block DriversDoing Without the Request Queue
check_media_changeRevalidationExtra Care
The Generic Hard DiskPartition DetectionPartition Detection Using initrdThe Device Methods for spull
Memory Management in LinuxAddress TypesHigh and Low MemoryThe Memory Map and struct pagePage TablesVirtual Memory Areas
Using remap_page_rangeA Simple ImplementationAdding VMA OperationsMapping Memory with nopageRemapping Specific I/O RegionsRemapping RAMRemapping RAM with the nopage methodRemapping Virtual Addresses
The kiobuf StructureMapping User-Space Buffers and Raw I/O
Overview of a DMA Data TransferAllocating the DMA BufferDo-it-yourself allocationBus AddressesDMA on the PCI BusDealing with difficult hardwareDMA mappingsSetting up consistent DMA mappingsSetting up streaming DMA mappingsScatter-gather mappingsHow different architectures support PCI DMAA simple PCI DMA exampleA quick look at SBusDMA for ISA DevicesRegistering DMA usageTalking to the DMA controller
Changes to Memory ManagementChanges to DMA
How snull Is DesignedAssigning IP NumbersThe Physical Transport of Packets
Module LoadingInitializing Each DeviceModule UnloadingModularized and Nonmodularized Drivers
The Visible HeadThe Hidden FieldsInterface informationThe device methodsUtility fields
Controlling Transmission ConcurrencyTransmission Timeouts
The Important FieldsFunctions Acting on Socket Buffers
Using ARP with EthernetOverriding ARPNon-Ethernet Headers
Kernel Support for MulticastingA Typical Implementation
Differences in Linux 2.2Further Differences in Linux 2.0Probing and HAVE_DEVLIST
The PCI InterfacePCI AddressingBoot TimeConfiguration Registers and InitializationAccessing the Configuration SpaceLooking at a configuration snapshotAccessing the I/O and Memory SpacesPCI I/O resources in Linux 2.4Peeking at the base address registersPCI InterruptsHandling Hot-Pluggable DevicesThe pci_driver structureHardware Abstractions
Hardware ResourcesISA ProgrammingThe Plug-and-Play Specification
MCAEISAVLB
USBWriting a USB Driver
Booting the Kernel
drivers/chardrivers/blockdrivers/idedrivers/mddrivers/cdromdrivers/scsidrivers/netdrivers/sounddrivers/videodrivers/inputdrivers/mediaBus-Specific DirectoriesPlatform-Specific DirectoriesOther Subdirectories
Linux Kernel BooksUnix Design and Internals

Content preview from Linux Device Drivers, Second Edition

Other Portability Issues

In addition to data typing, there are a few other software issues to keep in mind when writing a driver if you want it to be portable across Linux platforms.

A general rule is to be suspicious of explicit constant values. Usually the code has been parameterized using preprocessor macros. This section lists the most important portability problems. Whenever you encounter other values that have been parameterized, you’ll be able to find hints in the header files and in the device drivers distributed with the official kernel.

Time Intervals

When dealing with time intervals, don’t assume that there are 100 jiffies per second. Although this is currently true for Linux-x86, not every Linux platform runs at 100 Hz (as of 2.4 you find values ranging from 20 to 1200, although 20 is only used in the IA-64 simulator). The assumption can be false even for the x86 if you play with the HZ value (as some people do), and nobody knows what will happen in future kernels. Whenever you calculate time intervals using jiffies, scale your times using HZ (the number of timer interrupts per second). For example, to check against a timeout of half a second, compare the elapsed time against HZ/2. More generally, the number of jiffies corresponding to msec milliseconds is always msec*HZ/1000. This detail had to be fixed in many network drivers when porting them to the Alpha; some of them didn’t work on that platform because they assumed HZ to be 100.