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

Removable Devices

Thus far, we have ignored the final two file operations in the block_device_operations structure, which deal with devices that support removable media. It’s now time to look at them; sbull isn’t actually removable but it pretends to be, and therefore it implements these methods.

The operations in question are check_media_change and revalidate. The former is used to find out if the device has changed since the last access, and the latter re-initializes the driver’s status after a disk change.

As far as sbull is concerned, the data area associated with a device is released half a minute after its usage count drops to zero. Leaving the device unmounted (or closed) long enough simulates a disk change, and the next access to the device allocates a new memory area.

This kind of “timely expiration” is implemented using a kernel timer.

check_media_change

The checking function receives kdev_t as a single argument that identifies the device. The return value is 1 if the medium has been changed and 0 otherwise. A block driver that doesn’t support removable devices can avoid declaring the function by setting bdops->check_media_change to NULL.

It’s interesting to note that when the device is removable but there is no way to know if it changed, returning 1 is a safe choice. This is the behavior of the IDE driver when dealing with removable disks.

The implementation in sbull returns 1 if the device has already been removed from memory due to the timer expiration, ...