red hat enterprise linux kernel device...

RHD362 www.globalknowledge.com/en-sa/ [email protected] 00 966 92000 9278

Red Hat Enterprise Linux Kernel Device Drivers

Duration: 5 Days Course Code: RHD362

Overview:

Red Hat® Enterprise Linux® Kernel Device Drivers (RHD362) teaches experienced C programmers already familiar with the Linux kernelarchitecture the skills and strategies they need to develop device drivers.The course covers device driver models (including character, block, and network device drivers); device interaction (including port I/O, memorymapped I/O, interrupt handling, and DMA transfers); managing PCI and USB devices; strategies for deferring activity using tasklets and workqueues; device registration using the Unified Device model and the sysfs filesystem; and process interaction, including basic file operations,polling, and wait queues.

Target Audience:

Experienced C programmers with a good understanding of the Linux kernel who want to learn how to develop device drivers for Linux systems.

Objectives:

Introduction and Review of Kernel Programming

Direct Memory Access

Device Drivers

PCI Drivers

Unified Device Model

USB Drivers

Interrupt Handling

Introduction to Network Device Drivers

Advanced File Operations

Introduction to Block Device Drivers

Interacting With Devices

Prerequisites:

Experience in C programmingRed Hat Enterprise Linux Kernel Internals (RHD361) or equivalentexperience


Content:

Introduction and Review of Kernel USB DriversProgramming line lineline Linux Kernel Variants The Universal Serial Bus

* What is a Kernel? Interacting with the KernelKernel ImplementationThe Linux Source Tree line

line Writing Kernel Modules Linux Kernel VariantsLinux Kernel Variants Compiling Kernel Modules Interacting with the KernelInteracting with the Kernel More about Kernel Modules Kernel ImplementationKernel Implementation Review of Kernel Structures The Linux Source TreeThe Linux Source Tree Device Driver Design Writing Kernel ModulesWriting Kernel Modules Interacting with Character Device Drivers Compiling Kernel ModulesCompiling Kernel Modules Interacting with Block Device Drivers More about Kernel ModulesMore about Kernel Modules Interacting with Network Interface Cards Review of Kernel StructuresReview of Kernel Structures Device Nodes Device Driver DesignDevice Driver Design Character Device Drivers: Registration Interacting with Character Device DriversInteracting with Character Device Drivers The Device Node Problem Interacting with Block Device DriversInteracting with Block Device Drivers File Operations Interacting with Network Interface CardsInteracting with Network Interface Cards Defining File Operations Device NodesDevice Nodes Registering File Operations Character Device Drivers: RegistrationCharacter Device Drivers: Registration File I/O Conventions The Device Node ProblemThe Device Node Problem The sysfs filesystem File OperationsFile Operations Device Model Structures Defining File OperationsDefining File Operations Tying it all Together Registering File OperationsRegistering File Operations Netlink Sockets and User Events File I/O ConventionsFile I/O Conventions Userspace event agents The sysfs filesystemThe sysfs filesystem Device Registration Device Model StructuresDevice Model Structures Miscellaneous Devices Tying it all TogetherTying it all Together Handling Interrupts Netlink Sockets and User EventsNetlink Sockets and User Events Interrupt Structures Userspace event agentsUserspace event agents ISR Registration Device RegistrationDevice Registration System Context Miscellaneous DevicesMiscellaneous Devices Softirqs Handling InterruptsHandling Interrupts Deferred Activity: Tasklets Interrupt StructuresInterrupt Structures Deferred Activity: Work Queues ISR RegistrationISR Registration Custom Work Queues System ContextSystem Context Example: Serial Mouse SoftirqsSoftirqs IOCTL Conventions Deferred Activity: TaskletsDeferred Activity: Tasklets Implementing IOCTLs Deferred Activity: Work QueuesDeferred Activity: Work Queues Lockless IOCTLs Custom Work QueuesCustom Work Queues Sleeping Example: Serial MouseExample: Serial Mouse Wait Queues IOCTL ConventionsIOCTL Conventions Wait Queues Implementing IOCTLsImplementing IOCTLs Variations on wait_event() Lockless IOCTLsLockless IOCTLs Sleeping in System Calls SleepingSleeping Multiplexed I/O Wait QueuesWait Queues Polling Wait QueuesWait Queues Managing Exclusive Access Variations on wait_event()Variations on wait_event() I/O Ports Sleeping in System CallsSleeping in System Calls I/O Memory Buffers Multiplexed I/OMultiplexed I/O Accessing I/O Memory Buffers PollingPolling Userspace Drivers Managing Exclusive AccessManaging Exclusive Access Initializing DMA I/O PortsI/O Ports Coherent Allocations I/O Memory BuffersI/O Memory Buffers Streaming DMA Mappings Accessing I/O Memory BuffersAccessing I/O Memory Buffers PCI Configuration Space Userspace DriversUserspace Drivers PCI Driver Registration Initializing DMAInitializing DMA Registering PCI Drivers Coherent AllocationsCoherent Allocations Driver Probe Function Streaming DMA MappingsStreaming DMA Mappings Initializing PCI devices PCI Configuration SpacePCI Configuration Space Releasing a PCI Device PCI Driver RegistrationPCI Driver Registration Managing PCI Resources Registering PCI DriversRegistering PCI Drivers Accessing Configuration Space Driver Probe FunctionDriver Probe Function Listing PCI Devices Initializing PCI devices


Initializing PCI devices USB Descriptors Releasing a PCI DeviceReleasing a PCI Device USB Transfer Types Managing PCI ResourcesManaging PCI Resources Linux USB Implementation Accessing Configuration SpaceAccessing Configuration Space USB Drivers Listing PCI DevicesListing PCI Devices USB Registration USB DescriptorsUSB Descriptors Initializing USB Interfaces USB Transfer TypesUSB Transfer Types USB Class Drivers Linux USB ImplementationLinux USB Implementation USB Request Blocks USB DriversUSB Drivers Using USB request blocks USB RegistrationUSB Registration Synchronous USB Requests Initializing USB InterfacesInitializing USB Interfaces More information USB Class DriversUSB Class Drivers Network Devices USB Request BlocksUSB Request Blocks Network Device Callback Functions Using USB request blocksUsing USB request blocks Network Driver Initialization Synchronous USB RequestsSynchronous USB Requests Network Driver Transmission Queue More informationMore information Control Network DevicesNetwork Devices Network Statistics Network Device Callback FunctionsNetwork Device Callback Functions Socket Buffers (Packets) Network Driver InitializationNetwork Driver Initialization Socket Buffer API Network Driver Transmission QueueNetwork Driver Transmission Queue Control Transmission ControlNetwork Statistics Reception Network StatisticsSocket Buffers (Packets) Example Implementations Socket Buffers (Packets)Socket Buffer API I/O Scheduling Socket Buffer APITransmission Linux 2.6 Elevator Functions TransmissionReception Block Device Driver Implementation ReceptionExample Implementations Block Device Registration Example ImplementationsI/O Scheduling Block Device File Operations I/O SchedulingLinux 2.6 Elevator Functions The gendisk structure Linux 2.6 Elevator FunctionsBlock Device Driver Implementation Request Queues Block Device Driver ImplementationBlock Device Registration Initialization Example Block Device RegistrationBlock Device File Operations Handling Requests Block Device File OperationsThe gendisk structure The gendisk structureRequest Queues Request QueuesInitialization Example line Initialization ExampleHandling Requests Linux Kernel Variants Handling Requests

Interacting with the KernelKernel Implementation

line The Linux Source Tree lineLinux Kernel Variants Writing Kernel Modules Linux Kernel VariantsInteracting with the Kernel Compiling Kernel Modules Interacting with the KernelKernel Implementation More about Kernel Modules Kernel ImplementationThe Linux Source Tree Review of Kernel Structures The Linux Source TreeWriting Kernel Modules Device Driver Design Writing Kernel ModulesCompiling Kernel Modules Interacting with Character Device Drivers Compiling Kernel ModulesMore about Kernel Modules Interacting with Block Device Drivers More about Kernel ModulesReview of Kernel Structures Interacting with Network Interface Cards Review of Kernel StructuresDevice Driver Design Device Nodes Device Driver DesignInteracting with Character Device Drivers Character Device Drivers: Registration Interacting with Character Device DriversInteracting with Block Device Drivers The Device Node Problem Interacting with Block Device DriversInteracting with Network Interface Cards File Operations Interacting with Network Interface CardsDevice Nodes Defining File Operations Device NodesCharacter Device Drivers: Registration Registering File Operations Character Device Drivers: RegistrationThe Device Node Problem File I/O Conventions The Device Node ProblemFile Operations The sysfs filesystem File OperationsDefining File Operations Device Model Structures Defining File OperationsRegistering File Operations Tying it all Together Registering File OperationsFile I/O Conventions Netlink Sockets and User Events File I/O ConventionsThe sysfs filesystem Userspace event agents The sysfs filesystemDevice Model Structures Device Registration Device Model StructuresTying it all Together Miscellaneous Devices Tying it all TogetherNetlink Sockets and User Events Handling Interrupts Netlink Sockets and User EventsUserspace event agents Interrupt Structures Userspace event agentsDevice Registration ISR Registration Device RegistrationMiscellaneous Devices System Context Miscellaneous DevicesHandling Interrupts Softirqs Handling InterruptsInterrupt Structures Deferred Activity: Tasklets Interrupt Structures


ISR Registration Deferred Activity: Work Queues ISR RegistrationSystem Context Custom Work Queues System ContextSoftirqs Example: Serial Mouse SoftirqsDeferred Activity: Tasklets IOCTL Conventions Deferred Activity: TaskletsDeferred Activity: Work Queues Implementing IOCTLs Deferred Activity: Work QueuesCustom Work Queues Lockless IOCTLs Custom Work QueuesExample: Serial Mouse Sleeping Example: Serial MouseIOCTL Conventions Wait Queues IOCTL ConventionsImplementing IOCTLs Wait Queues Implementing IOCTLsLockless IOCTLs Variations on wait_event() Lockless IOCTLsSleeping Sleeping in System Calls SleepingWait Queues Multiplexed I/O Wait QueuesWait Queues Polling Wait QueuesVariations on wait_event() Managing Exclusive Access Variations on wait_event()Sleeping in System Calls I/O Ports Sleeping in System CallsMultiplexed I/O I/O Memory Buffers Multiplexed I/OPolling Accessing I/O Memory Buffers PollingManaging Exclusive Access Userspace Drivers Managing Exclusive AccessI/O Ports Initializing DMA I/O PortsI/O Memory Buffers Coherent Allocations I/O Memory BuffersAccessing I/O Memory Buffers Streaming DMA Mappings Accessing I/O Memory BuffersUserspace Drivers PCI Configuration Space Userspace DriversInitializing DMA PCI Driver Registration Initializing DMACoherent Allocations Registering PCI Drivers Coherent AllocationsStreaming DMA Mappings Driver Probe Function Streaming DMA MappingsPCI Configuration Space Initializing PCI devices PCI Configuration SpacePCI Driver Registration Releasing a PCI Device PCI Driver RegistrationRegistering PCI Drivers Managing PCI Resources Registering PCI DriversDriver Probe Function Accessing Configuration Space Driver Probe FunctionInitializing PCI devices Listing PCI Devices Initializing PCI devicesReleasing a PCI Device USB Descriptors Releasing a PCI DeviceManaging PCI Resources USB Transfer Types Managing PCI ResourcesAccessing Configuration Space Linux USB Implementation Accessing Configuration SpaceListing PCI Devices USB Drivers Listing PCI DevicesUSB Descriptors USB Registration USB DescriptorsUSB Transfer Types Initializing USB Interfaces USB Transfer TypesLinux USB Implementation USB Class Drivers Linux USB ImplementationUSB Drivers USB Request Blocks USB DriversUSB Registration Using USB request blocks USB RegistrationInitializing USB Interfaces Synchronous USB Requests Initializing USB InterfacesUSB Class Drivers More information USB Class DriversUSB Request Blocks Network Devices USB Request BlocksUsing USB request blocks Network Device Callback Functions Using USB request blocksSynchronous USB Requests Network Driver Initialization Synchronous USB RequestsMore information Network Driver Transmission Queue More informationNetwork Devices Control Network DevicesNetwork Device Callback Functions Network Statistics Network Device Callback FunctionsNetwork Driver Initialization Socket Buffers (Packets) Network Driver InitializationNetwork Driver Transmission Queue Control Socket Buffer API Network Driver Transmission QueueNetwork Statistics Transmission ControlSocket Buffers (Packets) Reception Network StatisticsSocket Buffer API Example Implementations Socket Buffers (Packets)Transmission I/O Scheduling Socket Buffer APIReception Linux 2.6 Elevator Functions TransmissionExample Implementations Block Device Driver Implementation ReceptionI/O Scheduling Block Device Registration Example ImplementationsLinux 2.6 Elevator Functions Block Device File Operations I/O SchedulingBlock Device Driver Implementation The gendisk structure Linux 2.6 Elevator FunctionsBlock Device Registration Request Queues Block Device Driver ImplementationBlock Device File Operations Initialization Example Block Device RegistrationThe gendisk structure Handling Requests Block Device File OperationsRequest Queues The gendisk structureInitialization Example Request QueuesHandling Requests line Initialization Example

Linux Kernel Variants Handling RequestsInteracting with the Kernel


line Kernel ImplementationLinux Kernel Variants The Linux Source Tree lineInteracting with the Kernel Writing Kernel Modules Linux Kernel VariantsKernel Implementation Compiling Kernel Modules Interacting with the KernelThe Linux Source Tree More about Kernel Modules Kernel ImplementationWriting Kernel Modules Review of Kernel Structures The Linux Source TreeCompiling Kernel Modules Device Driver Design Writing Kernel ModulesMore about Kernel Modules Interacting with Character Device Drivers Compiling Kernel ModulesReview of Kernel Structures Interacting with Block Device Drivers More about Kernel ModulesDevice Driver Design Interacting with Network Interface Cards Review of Kernel StructuresInteracting with Character Device Drivers Device Nodes Device Driver DesignInteracting with Block Device Drivers Character Device Drivers: Registration Interacting with Character Device DriversInteracting with Network Interface Cards The Device Node Problem Interacting with Block Device DriversDevice Nodes File Operations Interacting with Network Interface CardsCharacter Device Drivers: Registration Defining File Operations Device NodesThe Device Node Problem Registering File Operations Character Device Drivers: RegistrationFile Operations File I/O Conventions The Device Node ProblemDefining File Operations The sysfs filesystem File OperationsRegistering File Operations Device Model Structures Defining File OperationsFile I/O Conventions Tying it all Together Registering File OperationsThe sysfs filesystem Netlink Sockets and User Events File I/O ConventionsDevice Model Structures Userspace event agents The sysfs filesystemTying it all Together Device Registration Device Model StructuresNetlink Sockets and User Events Miscellaneous Devices Tying it all TogetherUserspace event agents Handling Interrupts Netlink Sockets and User EventsDevice Registration Interrupt Structures Userspace event agentsMiscellaneous Devices ISR Registration Device RegistrationHandling Interrupts System Context Miscellaneous DevicesInterrupt Structures Softirqs Handling InterruptsISR Registration Deferred Activity: Tasklets Interrupt StructuresSystem Context Deferred Activity: Work Queues ISR RegistrationSoftirqs Custom Work Queues System ContextDeferred Activity: Tasklets Example: Serial Mouse SoftirqsDeferred Activity: Work Queues IOCTL Conventions Deferred Activity: TaskletsCustom Work Queues Implementing IOCTLs Deferred Activity: Work QueuesExample: Serial Mouse Lockless IOCTLs Custom Work QueuesIOCTL Conventions Sleeping Example: Serial MouseImplementing IOCTLs Wait Queues IOCTL ConventionsLockless IOCTLs Wait Queues Implementing IOCTLsSleeping Variations on wait_event() Lockless IOCTLsWait Queues Sleeping in System Calls SleepingWait Queues Multiplexed I/O Wait QueuesVariations on wait_event() Polling Wait QueuesSleeping in System Calls Managing Exclusive Access Variations on wait_event()Multiplexed I/O I/O Ports Sleeping in System CallsPolling I/O Memory Buffers Multiplexed I/OManaging Exclusive Access Accessing I/O Memory Buffers PollingI/O Ports Userspace Drivers Managing Exclusive AccessI/O Memory Buffers Initializing DMA I/O PortsAccessing I/O Memory Buffers Coherent Allocations I/O Memory BuffersUserspace Drivers Streaming DMA Mappings Accessing I/O Memory BuffersInitializing DMA PCI Configuration Space Userspace DriversCoherent Allocations PCI Driver Registration Initializing DMAStreaming DMA Mappings Registering PCI Drivers Coherent AllocationsPCI Configuration Space Driver Probe Function Streaming DMA MappingsPCI Driver Registration Initializing PCI devices PCI Configuration SpaceRegistering PCI Drivers Releasing a PCI Device PCI Driver RegistrationDriver Probe Function Managing PCI Resources Registering PCI DriversInitializing PCI devices Accessing Configuration Space Driver Probe FunctionReleasing a PCI Device Listing PCI Devices Initializing PCI devicesManaging PCI Resources USB Descriptors Releasing a PCI DeviceAccessing Configuration Space USB Transfer Types Managing PCI ResourcesListing PCI Devices Linux USB Implementation Accessing Configuration SpaceUSB Descriptors USB Drivers Listing PCI DevicesUSB Transfer Types USB Registration USB DescriptorsLinux USB Implementation Initializing USB Interfaces USB Transfer Types


USB Drivers USB Class Drivers Linux USB ImplementationUSB Registration USB Request Blocks USB DriversInitializing USB Interfaces Using USB request blocks USB RegistrationUSB Class Drivers Synchronous USB Requests Initializing USB InterfacesUSB Request Blocks More information USB Class DriversUsing USB request blocks Network Devices USB Request BlocksSynchronous USB Requests Network Device Callback Functions Using USB request blocksMore information Network Driver Initialization Synchronous USB RequestsNetwork Devices Network Driver Transmission Queue More informationNetwork Device Callback Functions Control Network DevicesNetwork Driver Initialization Network Statistics Network Device Callback FunctionsNetwork Driver Transmission Queue Control Socket Buffers (Packets) Network Driver InitializationNetwork Statistics Socket Buffer API Network Driver Transmission QueueSocket Buffers (Packets) Transmission ControlSocket Buffer API Reception Network StatisticsTransmission Example Implementations Socket Buffers (Packets)Reception I/O Scheduling Socket Buffer APIExample Implementations Linux 2.6 Elevator Functions TransmissionI/O Scheduling Block Device Driver Implementation ReceptionLinux 2.6 Elevator Functions Block Device Registration Example ImplementationsBlock Device Driver Implementation Block Device File Operations I/O SchedulingBlock Device Registration The gendisk structure Linux 2.6 Elevator FunctionsBlock Device File Operations Request Queues Block Device Driver ImplementationThe gendisk structure Initialization Example Block Device RegistrationRequest Queues Handling Requests Block Device File OperationsInitialization Example The gendisk structureHandling Requests Request Queues

line Initialization ExampleLinux Kernel Variants Handling Requests

line Interacting with the KernelLinux Kernel Variants Kernel ImplementationInteracting with the Kernel The Linux Source Tree lineKernel Implementation Writing Kernel Modules Linux Kernel VariantsThe Linux Source Tree Compiling Kernel Modules Interacting with the KernelWriting Kernel Modules More about Kernel Modules Kernel ImplementationCompiling Kernel Modules Review of Kernel Structures The Linux Source TreeMore about Kernel Modules Device Driver Design Writing Kernel ModulesReview of Kernel Structures Interacting with Character Device Drivers Compiling Kernel ModulesDevice Driver Design Interacting with Block Device Drivers More about Kernel ModulesInteracting with Character Device Drivers Interacting with Network Interface Cards Review of Kernel StructuresInteracting with Block Device Drivers Device Nodes Device Driver DesignInteracting with Network Interface Cards Character Device Drivers: Registration Interacting with Character Device DriversDevice Nodes The Device Node Problem Interacting with Block Device DriversCharacter Device Drivers: Registration File Operations Interacting with Network Interface CardsThe Device Node Problem Defining File Operations Device NodesFile Operations Registering File Operations Character Device Drivers: RegistrationDefining File Operations File I/O Conventions The Device Node ProblemRegistering File Operations The sysfs filesystem File OperationsFile I/O Conventions Device Model Structures Defining File OperationsThe sysfs filesystem Tying it all Together Registering File OperationsDevice Model Structures Netlink Sockets and User Events File I/O ConventionsTying it all Together Userspace event agents The sysfs filesystemNetlink Sockets and User Events Device Registration Device Model StructuresUserspace event agents Miscellaneous Devices Tying it all TogetherDevice Registration Handling Interrupts Netlink Sockets and User EventsMiscellaneous Devices Interrupt Structures Userspace event agentsHandling Interrupts ISR Registration Device RegistrationInterrupt Structures System Context Miscellaneous DevicesISR Registration Softirqs Handling InterruptsSystem Context Deferred Activity: Tasklets Interrupt StructuresSoftirqs Deferred Activity: Work Queues ISR RegistrationDeferred Activity: Tasklets Custom Work Queues System ContextDeferred Activity: Work Queues Example: Serial Mouse SoftirqsCustom Work Queues IOCTL Conventions Deferred Activity: TaskletsExample: Serial Mouse Implementing IOCTLs Deferred Activity: Work QueuesIOCTL Conventions Lockless IOCTLs Custom Work Queues


Implementing IOCTLs Sleeping Example: Serial MouseLockless IOCTLs Wait Queues IOCTL ConventionsSleeping Wait Queues Implementing IOCTLsWait Queues Variations on wait_event() Lockless IOCTLsWait Queues Sleeping in System Calls SleepingVariations on wait_event() Multiplexed I/O Wait QueuesSleeping in System Calls Polling Wait QueuesMultiplexed I/O Managing Exclusive Access Variations on wait_event()Polling I/O Ports Sleeping in System CallsManaging Exclusive Access I/O Memory Buffers Multiplexed I/OI/O Ports Accessing I/O Memory Buffers PollingI/O Memory Buffers Userspace Drivers Managing Exclusive AccessAccessing I/O Memory Buffers Initializing DMA I/O PortsUserspace Drivers Coherent Allocations I/O Memory BuffersInitializing DMA Streaming DMA Mappings Accessing I/O Memory BuffersCoherent Allocations PCI Configuration Space Userspace DriversStreaming DMA Mappings PCI Driver Registration Initializing DMAPCI Configuration Space Registering PCI Drivers Coherent AllocationsPCI Driver Registration Driver Probe Function Streaming DMA MappingsRegistering PCI Drivers Initializing PCI devices PCI Configuration SpaceDriver Probe Function Releasing a PCI Device PCI Driver RegistrationInitializing PCI devices Managing PCI Resources Registering PCI DriversReleasing a PCI Device Accessing Configuration Space Driver Probe FunctionManaging PCI Resources Listing PCI Devices Initializing PCI devicesAccessing Configuration Space USB Descriptors Releasing a PCI DeviceListing PCI Devices USB Transfer Types Managing PCI ResourcesUSB Descriptors Linux USB Implementation Accessing Configuration SpaceUSB Transfer Types USB Drivers Listing PCI DevicesLinux USB Implementation USB Registration USB DescriptorsUSB Drivers Initializing USB Interfaces USB Transfer TypesUSB Registration USB Class Drivers Linux USB ImplementationInitializing USB Interfaces USB Request Blocks USB DriversUSB Class Drivers Using USB request blocks USB RegistrationUSB Request Blocks Synchronous USB Requests Initializing USB InterfacesUsing USB request blocks More information USB Class DriversSynchronous USB Requests Network Devices USB Request BlocksMore information Network Device Callback Functions Using USB request blocksNetwork Devices Network Driver Initialization Synchronous USB RequestsNetwork Device Callback Functions Network Driver Transmission Queue More informationNetwork Driver Initialization Control Network DevicesNetwork Driver Transmission Queue Control Network Statistics Network Device Callback FunctionsNetwork Statistics Socket Buffers (Packets) Network Driver InitializationSocket Buffers (Packets) Socket Buffer API Network Driver Transmission QueueSocket Buffer API Transmission ControlTransmission Reception Network StatisticsReception Example Implementations Socket Buffers (Packets)Example Implementations I/O Scheduling Socket Buffer APII/O Scheduling Linux 2.6 Elevator Functions TransmissionLinux 2.6 Elevator Functions Block Device Driver Implementation ReceptionBlock Device Driver Implementation Block Device Registration Example ImplementationsBlock Device Registration Block Device File Operations I/O SchedulingBlock Device File Operations The gendisk structure Linux 2.6 Elevator FunctionsThe gendisk structure Request Queues Block Device Driver ImplementationRequest Queues Initialization Example Block Device RegistrationInitialization Example Handling Requests Block Device File OperationsHandling Requests The gendisk structure

Advanced File Operations Request Queuesline Initialization Example

line IOCTLs Handling RequestsLinux Kernel VariantsInteracting with the KernelKernel Implementation line lineThe Linux Source Tree Linux Kernel Variants Linux Kernel VariantsWriting Kernel Modules Interacting with the Kernel Interacting with the KernelCompiling Kernel Modules Kernel Implementation Kernel ImplementationMore about Kernel Modules The Linux Source Tree The Linux Source Tree


Review of Kernel Structures Writing Kernel Modules Writing Kernel ModulesDevice Driver Design Compiling Kernel Modules Compiling Kernel ModulesInteracting with Character Device Drivers More about Kernel Modules More about Kernel ModulesInteracting with Block Device Drivers Review of Kernel Structures Review of Kernel StructuresInteracting with Network Interface Cards Device Driver Design Device Driver DesignDevice Nodes Interacting with Character Device Drivers Interacting with Character Device DriversCharacter Device Drivers: Registration Interacting with Block Device Drivers Interacting with Block Device DriversThe Device Node Problem Interacting with Network Interface Cards Interacting with Network Interface CardsFile Operations Device Nodes Device NodesDefining File Operations Character Device Drivers: Registration Character Device Drivers: RegistrationRegistering File Operations The Device Node Problem The Device Node ProblemFile I/O Conventions File Operations File OperationsThe sysfs filesystem Defining File Operations Defining File OperationsDevice Model Structures Registering File Operations Registering File OperationsTying it all Together File I/O Conventions File I/O ConventionsNetlink Sockets and User Events The sysfs filesystem The sysfs filesystemUserspace event agents Device Model Structures Device Model StructuresDevice Registration Tying it all Together Tying it all TogetherMiscellaneous Devices Netlink Sockets and User Events Netlink Sockets and User EventsHandling Interrupts Userspace event agents Userspace event agentsInterrupt Structures Device Registration Device RegistrationISR Registration Miscellaneous Devices Miscellaneous DevicesSystem Context Handling Interrupts Handling InterruptsSoftirqs Interrupt Structures Interrupt StructuresDeferred Activity: Tasklets ISR Registration ISR RegistrationDeferred Activity: Work Queues System Context System ContextCustom Work Queues Softirqs SoftirqsExample: Serial Mouse Deferred Activity: Tasklets Deferred Activity: TaskletsIOCTL Conventions Deferred Activity: Work Queues Deferred Activity: Work QueuesImplementing IOCTLs Custom Work Queues Custom Work QueuesLockless IOCTLs Example: Serial Mouse Example: Serial MouseSleeping IOCTL Conventions IOCTL ConventionsWait Queues Implementing IOCTLs Implementing IOCTLsWait Queues Lockless IOCTLs Lockless IOCTLsVariations on wait_event() Sleeping SleepingSleeping in System Calls Wait Queues Wait QueuesMultiplexed I/O Wait Queues Wait QueuesPolling Variations on wait_event() Variations on wait_event()Managing Exclusive Access Sleeping in System Calls Sleeping in System CallsI/O Ports Multiplexed I/O Multiplexed I/OI/O Memory Buffers Polling PollingAccessing I/O Memory Buffers Managing Exclusive Access Managing Exclusive AccessUserspace Drivers I/O Ports I/O PortsInitializing DMA I/O Memory Buffers I/O Memory BuffersCoherent Allocations Accessing I/O Memory Buffers Accessing I/O Memory BuffersStreaming DMA Mappings Userspace Drivers Userspace DriversPCI Configuration Space Initializing DMA Initializing DMAPCI Driver Registration Coherent Allocations Coherent AllocationsRegistering PCI Drivers Streaming DMA Mappings Streaming DMA MappingsDriver Probe Function PCI Configuration Space PCI Configuration SpaceInitializing PCI devices PCI Driver Registration PCI Driver RegistrationReleasing a PCI Device Registering PCI Drivers Registering PCI DriversManaging PCI Resources Driver Probe Function Driver Probe FunctionAccessing Configuration Space Initializing PCI devices Initializing PCI devicesListing PCI Devices Releasing a PCI Device Releasing a PCI DeviceUSB Descriptors Managing PCI Resources Managing PCI ResourcesUSB Transfer Types Accessing Configuration Space Accessing Configuration SpaceLinux USB Implementation Listing PCI Devices Listing PCI DevicesUSB Drivers USB Descriptors USB DescriptorsUSB Registration USB Transfer Types USB Transfer TypesInitializing USB Interfaces Linux USB Implementation Linux USB ImplementationUSB Class Drivers USB Drivers USB DriversUSB Request Blocks USB Registration USB RegistrationUsing USB request blocks Initializing USB Interfaces Initializing USB InterfacesSynchronous USB Requests USB Class Drivers USB Class DriversMore information USB Request Blocks USB Request Blocks


Network Devices Using USB request blocks Using USB request blocksNetwork Device Callback Functions Synchronous USB Requests Synchronous USB RequestsNetwork Driver Initialization More information More informationNetwork Driver Transmission Queue Control Network Devices Network DevicesNetwork Statistics Network Device Callback Functions Network Device Callback FunctionsSocket Buffers (Packets) Network Driver Initialization Network Driver InitializationSocket Buffer API Network Driver Transmission Queue Network Driver Transmission QueueTransmission Control ControlReception Network Statistics Network StatisticsExample Implementations Socket Buffers (Packets) Socket Buffers (Packets)I/O Scheduling Socket Buffer API Socket Buffer APILinux 2.6 Elevator Functions Transmission TransmissionBlock Device Driver Implementation Reception ReceptionBlock Device Registration Example Implementations Example ImplementationsBlock Device File Operations I/O Scheduling I/O SchedulingThe gendisk structure Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsRequest Queues Block Device Driver Implementation Block Device Driver ImplementationInitialization Example Block Device Registration Block Device RegistrationHandling Requests Block Device File Operations Block Device File Operations

The gendisk structure The gendisk structureRequest Queues Request Queues

line Initialization Example Initialization ExampleLinux Kernel Variants Handling Requests Handling RequestsInteracting with the KernelKernel ImplementationThe Linux Source Tree line lineWriting Kernel Modules Linux Kernel Variants Linux Kernel VariantsCompiling Kernel Modules Interacting with the Kernel Interacting with the KernelMore about Kernel Modules Kernel Implementation Kernel ImplementationReview of Kernel Structures The Linux Source Tree The Linux Source TreeDevice Driver Design Writing Kernel Modules Writing Kernel ModulesInteracting with Character Device Drivers Compiling Kernel Modules Compiling Kernel ModulesInteracting with Block Device Drivers More about Kernel Modules More about Kernel ModulesInteracting with Network Interface Cards Review of Kernel Structures Review of Kernel StructuresDevice Nodes Device Driver Design Device Driver DesignCharacter Device Drivers: Registration Interacting with Character Device Drivers Interacting with Character Device DriversThe Device Node Problem Interacting with Block Device Drivers Interacting with Block Device DriversFile Operations Interacting with Network Interface Cards Interacting with Network Interface CardsDefining File Operations Device Nodes Device NodesRegistering File Operations Character Device Drivers: Registration Character Device Drivers: RegistrationFile I/O Conventions The Device Node Problem The Device Node ProblemThe sysfs filesystem File Operations File OperationsDevice Model Structures Defining File Operations Defining File OperationsTying it all Together Registering File Operations Registering File OperationsNetlink Sockets and User Events File I/O Conventions File I/O ConventionsUserspace event agents The sysfs filesystem The sysfs filesystemDevice Registration Device Model Structures Device Model StructuresMiscellaneous Devices Tying it all Together Tying it all TogetherHandling Interrupts Netlink Sockets and User Events Netlink Sockets and User EventsInterrupt Structures Userspace event agents Userspace event agentsISR Registration Device Registration Device RegistrationSystem Context Miscellaneous Devices Miscellaneous DevicesSoftirqs Handling Interrupts Handling InterruptsDeferred Activity: Tasklets Interrupt Structures Interrupt StructuresDeferred Activity: Work Queues ISR Registration ISR RegistrationCustom Work Queues System Context System ContextExample: Serial Mouse Softirqs SoftirqsIOCTL Conventions Deferred Activity: Tasklets Deferred Activity: TaskletsImplementing IOCTLs Deferred Activity: Work Queues Deferred Activity: Work QueuesLockless IOCTLs Custom Work Queues Custom Work QueuesSleeping Example: Serial Mouse Example: Serial MouseWait Queues IOCTL Conventions IOCTL ConventionsWait Queues Implementing IOCTLs Implementing IOCTLsVariations on wait_event() Lockless IOCTLs Lockless IOCTLsSleeping in System Calls Sleeping SleepingMultiplexed I/O Wait Queues Wait Queues


Polling Wait Queues Wait QueuesManaging Exclusive Access Variations on wait_event() Variations on wait_event()I/O Ports Sleeping in System Calls Sleeping in System CallsI/O Memory Buffers Multiplexed I/O Multiplexed I/OAccessing I/O Memory Buffers Polling PollingUserspace Drivers Managing Exclusive Access Managing Exclusive AccessInitializing DMA I/O Ports I/O PortsCoherent Allocations I/O Memory Buffers I/O Memory BuffersStreaming DMA Mappings Accessing I/O Memory Buffers Accessing I/O Memory BuffersPCI Configuration Space Userspace Drivers Userspace DriversPCI Driver Registration Initializing DMA Initializing DMARegistering PCI Drivers Coherent Allocations Coherent AllocationsDriver Probe Function Streaming DMA Mappings Streaming DMA MappingsInitializing PCI devices PCI Configuration Space PCI Configuration SpaceReleasing a PCI Device PCI Driver Registration PCI Driver RegistrationManaging PCI Resources Registering PCI Drivers Registering PCI DriversAccessing Configuration Space Driver Probe Function Driver Probe FunctionListing PCI Devices Initializing PCI devices Initializing PCI devicesUSB Descriptors Releasing a PCI Device Releasing a PCI DeviceUSB Transfer Types Managing PCI Resources Managing PCI ResourcesLinux USB Implementation Accessing Configuration Space Accessing Configuration SpaceUSB Drivers Listing PCI Devices Listing PCI DevicesUSB Registration USB Descriptors USB DescriptorsInitializing USB Interfaces USB Transfer Types USB Transfer TypesUSB Class Drivers Linux USB Implementation Linux USB ImplementationUSB Request Blocks USB Drivers USB DriversUsing USB request blocks USB Registration USB RegistrationSynchronous USB Requests Initializing USB Interfaces Initializing USB InterfacesMore information USB Class Drivers USB Class DriversNetwork Devices USB Request Blocks USB Request BlocksNetwork Device Callback Functions Using USB request blocks Using USB request blocksNetwork Driver Initialization Synchronous USB Requests Synchronous USB RequestsNetwork Driver Transmission Queue Control More information More informationNetwork Statistics Network Devices Network DevicesSocket Buffers (Packets) Network Device Callback Functions Network Device Callback FunctionsSocket Buffer API Network Driver Initialization Network Driver InitializationTransmission Network Driver Transmission Queue Network Driver Transmission QueueReception Control ControlExample Implementations Network Statistics Network StatisticsI/O Scheduling Socket Buffers (Packets) Socket Buffers (Packets)Linux 2.6 Elevator Functions Socket Buffer API Socket Buffer APIBlock Device Driver Implementation Transmission TransmissionBlock Device Registration Reception ReceptionBlock Device File Operations Example Implementations Example ImplementationsThe gendisk structure I/O Scheduling I/O SchedulingRequest Queues Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsInitialization Example Block Device Driver Implementation Block Device Driver ImplementationHandling Requests Block Device Registration Block Device Registration

Block Device File Operations Block Device File OperationsThe gendisk structure The gendisk structure

line Request Queues Request QueuesLinux Kernel Variants Initialization Example Initialization ExampleInteracting with the Kernel Handling Requests Handling RequestsKernel ImplementationThe Linux Source TreeWriting Kernel Modules line lineCompiling Kernel Modules Linux Kernel Variants Linux Kernel VariantsMore about Kernel Modules Interacting with the Kernel Interacting with the KernelReview of Kernel Structures Kernel Implementation Kernel ImplementationDevice Driver Design The Linux Source Tree The Linux Source TreeInteracting with Character Device Drivers Writing Kernel Modules Writing Kernel ModulesInteracting with Block Device Drivers Compiling Kernel Modules Compiling Kernel ModulesInteracting with Network Interface Cards More about Kernel Modules More about Kernel ModulesDevice Nodes Review of Kernel Structures Review of Kernel StructuresCharacter Device Drivers: Registration Device Driver Design Device Driver DesignThe Device Node Problem Interacting with Character Device Drivers Interacting with Character Device Drivers


File Operations Interacting with Block Device Drivers Interacting with Block Device DriversDefining File Operations Interacting with Network Interface Cards Interacting with Network Interface CardsRegistering File Operations Device Nodes Device NodesFile I/O Conventions Character Device Drivers: Registration Character Device Drivers: RegistrationThe sysfs filesystem The Device Node Problem The Device Node ProblemDevice Model Structures File Operations File OperationsTying it all Together Defining File Operations Defining File OperationsNetlink Sockets and User Events Registering File Operations Registering File OperationsUserspace event agents File I/O Conventions File I/O ConventionsDevice Registration The sysfs filesystem The sysfs filesystemMiscellaneous Devices Device Model Structures Device Model StructuresHandling Interrupts Tying it all Together Tying it all TogetherInterrupt Structures Netlink Sockets and User Events Netlink Sockets and User EventsISR Registration Userspace event agents Userspace event agentsSystem Context Device Registration Device RegistrationSoftirqs Miscellaneous Devices Miscellaneous DevicesDeferred Activity: Tasklets Handling Interrupts Handling InterruptsDeferred Activity: Work Queues Interrupt Structures Interrupt StructuresCustom Work Queues ISR Registration ISR RegistrationExample: Serial Mouse System Context System ContextIOCTL Conventions Softirqs SoftirqsImplementing IOCTLs Deferred Activity: Tasklets Deferred Activity: TaskletsLockless IOCTLs Deferred Activity: Work Queues Deferred Activity: Work QueuesSleeping Custom Work Queues Custom Work QueuesWait Queues Example: Serial Mouse Example: Serial MouseWait Queues IOCTL Conventions IOCTL ConventionsVariations on wait_event() Implementing IOCTLs Implementing IOCTLsSleeping in System Calls Lockless IOCTLs Lockless IOCTLsMultiplexed I/O Sleeping SleepingPolling Wait Queues Wait QueuesManaging Exclusive Access Wait Queues Wait QueuesI/O Ports Variations on wait_event() Variations on wait_event()I/O Memory Buffers Sleeping in System Calls Sleeping in System CallsAccessing I/O Memory Buffers Multiplexed I/O Multiplexed I/OUserspace Drivers Polling PollingInitializing DMA Managing Exclusive Access Managing Exclusive AccessCoherent Allocations I/O Ports I/O PortsStreaming DMA Mappings I/O Memory Buffers I/O Memory BuffersPCI Configuration Space Accessing I/O Memory Buffers Accessing I/O Memory BuffersPCI Driver Registration Userspace Drivers Userspace DriversRegistering PCI Drivers Initializing DMA Initializing DMADriver Probe Function Coherent Allocations Coherent AllocationsInitializing PCI devices Streaming DMA Mappings Streaming DMA MappingsReleasing a PCI Device PCI Configuration Space PCI Configuration SpaceManaging PCI Resources PCI Driver Registration PCI Driver RegistrationAccessing Configuration Space Registering PCI Drivers Registering PCI DriversListing PCI Devices Driver Probe Function Driver Probe FunctionUSB Descriptors Initializing PCI devices Initializing PCI devicesUSB Transfer Types Releasing a PCI Device Releasing a PCI DeviceLinux USB Implementation Managing PCI Resources Managing PCI ResourcesUSB Drivers Accessing Configuration Space Accessing Configuration SpaceUSB Registration Listing PCI Devices Listing PCI DevicesInitializing USB Interfaces USB Descriptors USB DescriptorsUSB Class Drivers USB Transfer Types USB Transfer TypesUSB Request Blocks Linux USB Implementation Linux USB ImplementationUsing USB request blocks USB Drivers USB DriversSynchronous USB Requests USB Registration USB RegistrationMore information Initializing USB Interfaces Initializing USB InterfacesNetwork Devices USB Class Drivers USB Class DriversNetwork Device Callback Functions USB Request Blocks USB Request BlocksNetwork Driver Initialization Using USB request blocks Using USB request blocksNetwork Driver Transmission Queue Control Synchronous USB Requests Synchronous USB RequestsNetwork Statistics More information More informationSocket Buffers (Packets) Network Devices Network DevicesSocket Buffer API Network Device Callback Functions Network Device Callback FunctionsTransmission Network Driver Initialization Network Driver Initialization


Reception Network Driver Transmission Queue Network Driver Transmission QueueExample Implementations Control ControlI/O Scheduling Network Statistics Network StatisticsLinux 2.6 Elevator Functions Socket Buffers (Packets) Socket Buffers (Packets)Block Device Driver Implementation Socket Buffer API Socket Buffer APIBlock Device Registration Transmission TransmissionBlock Device File Operations Reception ReceptionThe gendisk structure Example Implementations Example ImplementationsRequest Queues I/O Scheduling I/O SchedulingInitialization Example Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsHandling Requests Block Device Driver Implementation Block Device Driver Implementation

Block Device Registration Block Device RegistrationBlock Device File Operations Block Device File Operations

line The gendisk structure The gendisk structureLinux Kernel Variants Request Queues Request QueuesInteracting with the Kernel Initialization Example Initialization ExampleKernel Implementation Handling Requests Handling RequestsThe Linux Source TreeWriting Kernel ModulesCompiling Kernel Modules line lineMore about Kernel Modules Linux Kernel Variants Linux Kernel VariantsReview of Kernel Structures Interacting with the Kernel Interacting with the KernelDevice Driver Design Kernel Implementation Kernel ImplementationInteracting with Character Device Drivers The Linux Source Tree The Linux Source TreeInteracting with Block Device Drivers Writing Kernel Modules Writing Kernel ModulesInteracting with Network Interface Cards Compiling Kernel Modules Compiling Kernel ModulesDevice Nodes More about Kernel Modules More about Kernel ModulesCharacter Device Drivers: Registration Review of Kernel Structures Review of Kernel StructuresThe Device Node Problem Device Driver Design Device Driver DesignFile Operations Interacting with Character Device Drivers Interacting with Character Device DriversDefining File Operations Interacting with Block Device Drivers Interacting with Block Device DriversRegistering File Operations Interacting with Network Interface Cards Interacting with Network Interface CardsFile I/O Conventions Device Nodes Device NodesThe sysfs filesystem Character Device Drivers: Registration Character Device Drivers: RegistrationDevice Model Structures The Device Node Problem The Device Node ProblemTying it all Together File Operations File OperationsNetlink Sockets and User Events Defining File Operations Defining File OperationsUserspace event agents Registering File Operations Registering File OperationsDevice Registration File I/O Conventions File I/O ConventionsMiscellaneous Devices The sysfs filesystem The sysfs filesystemHandling Interrupts Device Model Structures Device Model StructuresInterrupt Structures Tying it all Together Tying it all TogetherISR Registration Netlink Sockets and User Events Netlink Sockets and User EventsSystem Context Userspace event agents Userspace event agentsSoftirqs Device Registration Device RegistrationDeferred Activity: Tasklets Miscellaneous Devices Miscellaneous DevicesDeferred Activity: Work Queues Handling Interrupts Handling InterruptsCustom Work Queues Interrupt Structures Interrupt StructuresExample: Serial Mouse ISR Registration ISR RegistrationIOCTL Conventions System Context System ContextImplementing IOCTLs Softirqs SoftirqsLockless IOCTLs Deferred Activity: Tasklets Deferred Activity: TaskletsSleeping Deferred Activity: Work Queues Deferred Activity: Work QueuesWait Queues Custom Work Queues Custom Work QueuesWait Queues Example: Serial Mouse Example: Serial MouseVariations on wait_event() IOCTL Conventions IOCTL ConventionsSleeping in System Calls Implementing IOCTLs Implementing IOCTLsMultiplexed I/O Lockless IOCTLs Lockless IOCTLsPolling Sleeping SleepingManaging Exclusive Access Wait Queues Wait QueuesI/O Ports Wait Queues Wait QueuesI/O Memory Buffers Variations on wait_event() Variations on wait_event()Accessing I/O Memory Buffers Sleeping in System Calls Sleeping in System CallsUserspace Drivers Multiplexed I/O Multiplexed I/OInitializing DMA Polling PollingCoherent Allocations Managing Exclusive Access Managing Exclusive Access


Streaming DMA Mappings I/O Ports I/O PortsPCI Configuration Space I/O Memory Buffers I/O Memory BuffersPCI Driver Registration Accessing I/O Memory Buffers Accessing I/O Memory BuffersRegistering PCI Drivers Userspace Drivers Userspace DriversDriver Probe Function Initializing DMA Initializing DMAInitializing PCI devices Coherent Allocations Coherent AllocationsReleasing a PCI Device Streaming DMA Mappings Streaming DMA MappingsManaging PCI Resources PCI Configuration Space PCI Configuration SpaceAccessing Configuration Space PCI Driver Registration PCI Driver RegistrationListing PCI Devices Registering PCI Drivers Registering PCI DriversUSB Descriptors Driver Probe Function Driver Probe FunctionUSB Transfer Types Initializing PCI devices Initializing PCI devicesLinux USB Implementation Releasing a PCI Device Releasing a PCI DeviceUSB Drivers Managing PCI Resources Managing PCI ResourcesUSB Registration Accessing Configuration Space Accessing Configuration SpaceInitializing USB Interfaces Listing PCI Devices Listing PCI DevicesUSB Class Drivers USB Descriptors USB DescriptorsUSB Request Blocks USB Transfer Types USB Transfer TypesUsing USB request blocks Linux USB Implementation Linux USB ImplementationSynchronous USB Requests USB Drivers USB DriversMore information USB Registration USB RegistrationNetwork Devices Initializing USB Interfaces Initializing USB InterfacesNetwork Device Callback Functions USB Class Drivers USB Class DriversNetwork Driver Initialization USB Request Blocks USB Request BlocksNetwork Driver Transmission Queue Control Using USB request blocks Using USB request blocksNetwork Statistics Synchronous USB Requests Synchronous USB RequestsSocket Buffers (Packets) More information More informationSocket Buffer API Network Devices Network DevicesTransmission Network Device Callback Functions Network Device Callback FunctionsReception Network Driver Initialization Network Driver InitializationExample Implementations Network Driver Transmission Queue Network Driver Transmission QueueI/O Scheduling Control ControlLinux 2.6 Elevator Functions Network Statistics Network StatisticsBlock Device Driver Implementation Socket Buffers (Packets) Socket Buffers (Packets)Block Device Registration Socket Buffer API Socket Buffer APIBlock Device File Operations Transmission TransmissionThe gendisk structure Reception ReceptionRequest Queues Example Implementations Example ImplementationsInitialization Example I/O Scheduling I/O SchedulingHandling Requests Linux 2.6 Elevator Functions Linux 2.6 Elevator Functions

Block Device Driver Implementation Block Device Driver ImplementationDevice Drivers Block Device Registration Block Device Registrationline Block Device File Operations Block Device File Operations

Device Drivers The gendisk structure The gendisk structureRequest Queues Request QueuesInitialization Example Initialization Example

line Handling Requests Handling RequestsLinux Kernel VariantsInteracting with the KernelKernel Implementation line lineThe Linux Source Tree Linux Kernel Variants Linux Kernel VariantsWriting Kernel Modules Interacting with the Kernel Interacting with the KernelCompiling Kernel Modules Kernel Implementation Kernel ImplementationMore about Kernel Modules The Linux Source Tree The Linux Source TreeReview of Kernel Structures Writing Kernel Modules Writing Kernel ModulesDevice Driver Design Compiling Kernel Modules Compiling Kernel ModulesInteracting with Character Device Drivers More about Kernel Modules More about Kernel ModulesInteracting with Block Device Drivers Review of Kernel Structures Review of Kernel StructuresInteracting with Network Interface Cards Device Driver Design Device Driver DesignDevice Nodes Interacting with Character Device Drivers Interacting with Character Device DriversCharacter Device Drivers: Registration Interacting with Block Device Drivers Interacting with Block Device DriversThe Device Node Problem Interacting with Network Interface Cards Interacting with Network Interface CardsFile Operations Device Nodes Device NodesDefining File Operations Character Device Drivers: Registration Character Device Drivers: RegistrationRegistering File Operations The Device Node Problem The Device Node ProblemFile I/O Conventions File Operations File Operations


The sysfs filesystem Defining File Operations Defining File OperationsDevice Model Structures Registering File Operations Registering File OperationsTying it all Together File I/O Conventions File I/O ConventionsNetlink Sockets and User Events The sysfs filesystem The sysfs filesystemUserspace event agents Device Model Structures Device Model StructuresDevice Registration Tying it all Together Tying it all TogetherMiscellaneous Devices Netlink Sockets and User Events Netlink Sockets and User EventsHandling Interrupts Userspace event agents Userspace event agentsInterrupt Structures Device Registration Device RegistrationISR Registration Miscellaneous Devices Miscellaneous DevicesSystem Context Handling Interrupts Handling InterruptsSoftirqs Interrupt Structures Interrupt StructuresDeferred Activity: Tasklets ISR Registration ISR RegistrationDeferred Activity: Work Queues System Context System ContextCustom Work Queues Softirqs SoftirqsExample: Serial Mouse Deferred Activity: Tasklets Deferred Activity: TaskletsIOCTL Conventions Deferred Activity: Work Queues Deferred Activity: Work QueuesImplementing IOCTLs Custom Work Queues Custom Work QueuesLockless IOCTLs Example: Serial Mouse Example: Serial MouseSleeping IOCTL Conventions IOCTL ConventionsWait Queues Implementing IOCTLs Implementing IOCTLsWait Queues Lockless IOCTLs Lockless IOCTLsVariations on wait_event() Sleeping SleepingSleeping in System Calls Wait Queues Wait QueuesMultiplexed I/O Wait Queues Wait QueuesPolling Variations on wait_event() Variations on wait_event()Managing Exclusive Access Sleeping in System Calls Sleeping in System CallsI/O Ports Multiplexed I/O Multiplexed I/OI/O Memory Buffers Polling PollingAccessing I/O Memory Buffers Managing Exclusive Access Managing Exclusive AccessUserspace Drivers I/O Ports I/O PortsInitializing DMA I/O Memory Buffers I/O Memory BuffersCoherent Allocations Accessing I/O Memory Buffers Accessing I/O Memory BuffersStreaming DMA Mappings Userspace Drivers Userspace DriversPCI Configuration Space Initializing DMA Initializing DMAPCI Driver Registration Coherent Allocations Coherent AllocationsRegistering PCI Drivers Streaming DMA Mappings Streaming DMA MappingsDriver Probe Function PCI Configuration Space PCI Configuration SpaceInitializing PCI devices PCI Driver Registration PCI Driver RegistrationReleasing a PCI Device Registering PCI Drivers Registering PCI DriversManaging PCI Resources Driver Probe Function Driver Probe FunctionAccessing Configuration Space Initializing PCI devices Initializing PCI devicesListing PCI Devices Releasing a PCI Device Releasing a PCI DeviceUSB Descriptors Managing PCI Resources Managing PCI ResourcesUSB Transfer Types Accessing Configuration Space Accessing Configuration SpaceLinux USB Implementation Listing PCI Devices Listing PCI DevicesUSB Drivers USB Descriptors USB DescriptorsUSB Registration USB Transfer Types USB Transfer TypesInitializing USB Interfaces Linux USB Implementation Linux USB ImplementationUSB Class Drivers USB Drivers USB DriversUSB Request Blocks USB Registration USB RegistrationUsing USB request blocks Initializing USB Interfaces Initializing USB InterfacesSynchronous USB Requests USB Class Drivers USB Class DriversMore information USB Request Blocks USB Request BlocksNetwork Devices Using USB request blocks Using USB request blocksNetwork Device Callback Functions Synchronous USB Requests Synchronous USB RequestsNetwork Driver Initialization More information More informationNetwork Driver Transmission Queue Control Network Devices Network DevicesNetwork Statistics Network Device Callback Functions Network Device Callback FunctionsSocket Buffers (Packets) Network Driver Initialization Network Driver InitializationSocket Buffer API Network Driver Transmission Queue Network Driver Transmission QueueTransmission Control ControlReception Network Statistics Network StatisticsExample Implementations Socket Buffers (Packets) Socket Buffers (Packets)I/O Scheduling Socket Buffer API Socket Buffer APILinux 2.6 Elevator Functions Transmission Transmission


Block Device Driver Implementation Reception ReceptionBlock Device Registration Example Implementations Example ImplementationsBlock Device File Operations I/O Scheduling I/O SchedulingThe gendisk structure Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsRequest Queues Block Device Driver Implementation Block Device Driver ImplementationInitialization Example Block Device Registration Block Device RegistrationHandling Requests Block Device File Operations Block Device File Operations

The gendisk structure The gendisk structureRequest Queues Request Queues

line Initialization Example Initialization ExampleLinux Kernel Variants Handling Requests Handling RequestsInteracting with the KernelKernel ImplementationThe Linux Source Tree line lineWriting Kernel Modules Linux Kernel Variants Linux Kernel VariantsCompiling Kernel Modules Interacting with the Kernel Interacting with the KernelMore about Kernel Modules Kernel Implementation Kernel ImplementationReview of Kernel Structures The Linux Source Tree The Linux Source TreeDevice Driver Design Writing Kernel Modules Writing Kernel ModulesInteracting with Character Device Drivers Compiling Kernel Modules Compiling Kernel ModulesInteracting with Block Device Drivers More about Kernel Modules More about Kernel ModulesInteracting with Network Interface Cards Review of Kernel Structures Review of Kernel StructuresDevice Nodes Device Driver Design Device Driver DesignCharacter Device Drivers: Registration Interacting with Character Device Drivers Interacting with Character Device DriversThe Device Node Problem Interacting with Block Device Drivers Interacting with Block Device DriversFile Operations Interacting with Network Interface Cards Interacting with Network Interface CardsDefining File Operations Device Nodes Device NodesRegistering File Operations Character Device Drivers: Registration Character Device Drivers: RegistrationFile I/O Conventions The Device Node Problem The Device Node ProblemThe sysfs filesystem File Operations File OperationsDevice Model Structures Defining File Operations Defining File OperationsTying it all Together Registering File Operations Registering File OperationsNetlink Sockets and User Events File I/O Conventions File I/O ConventionsUserspace event agents The sysfs filesystem The sysfs filesystemDevice Registration Device Model Structures Device Model StructuresMiscellaneous Devices Tying it all Together Tying it all TogetherHandling Interrupts Netlink Sockets and User Events Netlink Sockets and User EventsInterrupt Structures Userspace event agents Userspace event agentsISR Registration Device Registration Device RegistrationSystem Context Miscellaneous Devices Miscellaneous DevicesSoftirqs Handling Interrupts Handling InterruptsDeferred Activity: Tasklets Interrupt Structures Interrupt StructuresDeferred Activity: Work Queues ISR Registration ISR RegistrationCustom Work Queues System Context System ContextExample: Serial Mouse Softirqs SoftirqsIOCTL Conventions Deferred Activity: Tasklets Deferred Activity: TaskletsImplementing IOCTLs Deferred Activity: Work Queues Deferred Activity: Work QueuesLockless IOCTLs Custom Work Queues Custom Work QueuesSleeping Example: Serial Mouse Example: Serial MouseWait Queues IOCTL Conventions IOCTL ConventionsWait Queues Implementing IOCTLs Implementing IOCTLsVariations on wait_event() Lockless IOCTLs Lockless IOCTLsSleeping in System Calls Sleeping SleepingMultiplexed I/O Wait Queues Wait QueuesPolling Wait Queues Wait QueuesManaging Exclusive Access Variations on wait_event() Variations on wait_event()I/O Ports Sleeping in System Calls Sleeping in System CallsI/O Memory Buffers Multiplexed I/O Multiplexed I/OAccessing I/O Memory Buffers Polling PollingUserspace Drivers Managing Exclusive Access Managing Exclusive AccessInitializing DMA I/O Ports I/O PortsCoherent Allocations I/O Memory Buffers I/O Memory BuffersStreaming DMA Mappings Accessing I/O Memory Buffers Accessing I/O Memory BuffersPCI Configuration Space Userspace Drivers Userspace DriversPCI Driver Registration Initializing DMA Initializing DMARegistering PCI Drivers Coherent Allocations Coherent Allocations


Driver Probe Function Streaming DMA Mappings Streaming DMA MappingsInitializing PCI devices PCI Configuration Space PCI Configuration SpaceReleasing a PCI Device PCI Driver Registration PCI Driver RegistrationManaging PCI Resources Registering PCI Drivers Registering PCI DriversAccessing Configuration Space Driver Probe Function Driver Probe FunctionListing PCI Devices Initializing PCI devices Initializing PCI devicesUSB Descriptors Releasing a PCI Device Releasing a PCI DeviceUSB Transfer Types Managing PCI Resources Managing PCI ResourcesLinux USB Implementation Accessing Configuration Space Accessing Configuration SpaceUSB Drivers Listing PCI Devices Listing PCI DevicesUSB Registration USB Descriptors USB DescriptorsInitializing USB Interfaces USB Transfer Types USB Transfer TypesUSB Class Drivers Linux USB Implementation Linux USB ImplementationUSB Request Blocks USB Drivers USB DriversUsing USB request blocks USB Registration USB RegistrationSynchronous USB Requests Initializing USB Interfaces Initializing USB InterfacesMore information USB Class Drivers USB Class DriversNetwork Devices USB Request Blocks USB Request BlocksNetwork Device Callback Functions Using USB request blocks Using USB request blocksNetwork Driver Initialization Synchronous USB Requests Synchronous USB RequestsNetwork Driver Transmission Queue Control More information More informationNetwork Statistics Network Devices Network DevicesSocket Buffers (Packets) Network Device Callback Functions Network Device Callback FunctionsSocket Buffer API Network Driver Initialization Network Driver InitializationTransmission Network Driver Transmission Queue Network Driver Transmission QueueReception Control ControlExample Implementations Network Statistics Network StatisticsI/O Scheduling Socket Buffers (Packets) Socket Buffers (Packets)Linux 2.6 Elevator Functions Socket Buffer API Socket Buffer APIBlock Device Driver Implementation Transmission TransmissionBlock Device Registration Reception ReceptionBlock Device File Operations Example Implementations Example ImplementationsThe gendisk structure I/O Scheduling I/O SchedulingRequest Queues Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsInitialization Example Block Device Driver Implementation Block Device Driver ImplementationHandling Requests Block Device Registration Block Device Registration

Block Device File Operations Block Device File OperationsThe gendisk structure The gendisk structure

line Request Queues Request QueuesLinux Kernel Variants Initialization Example Initialization ExampleInteracting with the Kernel Handling Requests Handling RequestsKernel ImplementationThe Linux Source TreeWriting Kernel Modules line lineCompiling Kernel Modules Linux Kernel Variants Linux Kernel VariantsMore about Kernel Modules Interacting with the Kernel Interacting with the KernelReview of Kernel Structures Kernel Implementation Kernel ImplementationDevice Driver Design The Linux Source Tree The Linux Source TreeInteracting with Character Device Drivers Writing Kernel Modules Writing Kernel ModulesInteracting with Block Device Drivers Compiling Kernel Modules Compiling Kernel ModulesInteracting with Network Interface Cards More about Kernel Modules More about Kernel ModulesDevice Nodes Review of Kernel Structures Review of Kernel StructuresCharacter Device Drivers: Registration Device Driver Design Device Driver DesignThe Device Node Problem Interacting with Character Device Drivers Interacting with Character Device DriversFile Operations Interacting with Block Device Drivers Interacting with Block Device DriversDefining File Operations Interacting with Network Interface Cards Interacting with Network Interface CardsRegistering File Operations Device Nodes Device NodesFile I/O Conventions Character Device Drivers: Registration Character Device Drivers: RegistrationThe sysfs filesystem The Device Node Problem The Device Node ProblemDevice Model Structures File Operations File OperationsTying it all Together Defining File Operations Defining File OperationsNetlink Sockets and User Events Registering File Operations Registering File OperationsUserspace event agents File I/O Conventions File I/O ConventionsDevice Registration The sysfs filesystem The sysfs filesystemMiscellaneous Devices Device Model Structures Device Model StructuresHandling Interrupts Tying it all Together Tying it all Together


Interrupt Structures Netlink Sockets and User Events Netlink Sockets and User EventsISR Registration Userspace event agents Userspace event agentsSystem Context Device Registration Device RegistrationSoftirqs Miscellaneous Devices Miscellaneous DevicesDeferred Activity: Tasklets Handling Interrupts Handling InterruptsDeferred Activity: Work Queues Interrupt Structures Interrupt StructuresCustom Work Queues ISR Registration ISR RegistrationExample: Serial Mouse System Context System ContextIOCTL Conventions Softirqs SoftirqsImplementing IOCTLs Deferred Activity: Tasklets Deferred Activity: TaskletsLockless IOCTLs Deferred Activity: Work Queues Deferred Activity: Work QueuesSleeping Custom Work Queues Custom Work QueuesWait Queues Example: Serial Mouse Example: Serial MouseWait Queues IOCTL Conventions IOCTL ConventionsVariations on wait_event() Implementing IOCTLs Implementing IOCTLsSleeping in System Calls Lockless IOCTLs Lockless IOCTLsMultiplexed I/O Sleeping SleepingPolling Wait Queues Wait QueuesManaging Exclusive Access Wait Queues Wait QueuesI/O Ports Variations on wait_event() Variations on wait_event()I/O Memory Buffers Sleeping in System Calls Sleeping in System CallsAccessing I/O Memory Buffers Multiplexed I/O Multiplexed I/OUserspace Drivers Polling PollingInitializing DMA Managing Exclusive Access Managing Exclusive AccessCoherent Allocations I/O Ports I/O PortsStreaming DMA Mappings I/O Memory Buffers I/O Memory BuffersPCI Configuration Space Accessing I/O Memory Buffers Accessing I/O Memory BuffersPCI Driver Registration Userspace Drivers Userspace DriversRegistering PCI Drivers Initializing DMA Initializing DMADriver Probe Function Coherent Allocations Coherent AllocationsInitializing PCI devices Streaming DMA Mappings Streaming DMA MappingsReleasing a PCI Device PCI Configuration Space PCI Configuration SpaceManaging PCI Resources PCI Driver Registration PCI Driver RegistrationAccessing Configuration Space Registering PCI Drivers Registering PCI DriversListing PCI Devices Driver Probe Function Driver Probe FunctionUSB Descriptors Initializing PCI devices Initializing PCI devicesUSB Transfer Types Releasing a PCI Device Releasing a PCI DeviceLinux USB Implementation Managing PCI Resources Managing PCI ResourcesUSB Drivers Accessing Configuration Space Accessing Configuration SpaceUSB Registration Listing PCI Devices Listing PCI DevicesInitializing USB Interfaces USB Descriptors USB DescriptorsUSB Class Drivers USB Transfer Types USB Transfer TypesUSB Request Blocks Linux USB Implementation Linux USB ImplementationUsing USB request blocks USB Drivers USB DriversSynchronous USB Requests USB Registration USB RegistrationMore information Initializing USB Interfaces Initializing USB InterfacesNetwork Devices USB Class Drivers USB Class DriversNetwork Device Callback Functions USB Request Blocks USB Request BlocksNetwork Driver Initialization Using USB request blocks Using USB request blocksNetwork Driver Transmission Queue Control Synchronous USB Requests Synchronous USB RequestsNetwork Statistics More information More informationSocket Buffers (Packets) Network Devices Network DevicesSocket Buffer API Network Device Callback Functions Network Device Callback FunctionsTransmission Network Driver Initialization Network Driver InitializationReception Network Driver Transmission Queue Network Driver Transmission QueueExample Implementations Control ControlI/O Scheduling Network Statistics Network StatisticsLinux 2.6 Elevator Functions Socket Buffers (Packets) Socket Buffers (Packets)Block Device Driver Implementation Socket Buffer API Socket Buffer APIBlock Device Registration Transmission TransmissionBlock Device File Operations Reception ReceptionThe gendisk structure Example Implementations Example ImplementationsRequest Queues I/O Scheduling I/O SchedulingInitialization Example Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsHandling Requests Block Device Driver Implementation Block Device Driver Implementation

Block Device Registration Block Device Registration


Block Device File Operations Block Device File Operationsline The gendisk structure The gendisk structure

Linux Kernel Variants Request Queues Request QueuesInteracting with the Kernel Initialization Example Initialization ExampleKernel Implementation Handling Requests Handling RequestsThe Linux Source TreeWriting Kernel Modules Introduction to Network Device DriversCompiling Kernel Modules line lineMore about Kernel Modules Linux Kernel Variants NetworkingReview of Kernel Structures Interacting with the KernelDevice Driver Design Kernel ImplementationInteracting with Character Device Drivers The Linux Source Tree lineInteracting with Block Device Drivers Writing Kernel Modules Linux Kernel VariantsInteracting with Network Interface Cards Compiling Kernel Modules Interacting with the KernelDevice Nodes More about Kernel Modules Kernel ImplementationCharacter Device Drivers: Registration Review of Kernel Structures The Linux Source TreeThe Device Node Problem Device Driver Design Writing Kernel ModulesFile Operations Interacting with Character Device Drivers Compiling Kernel ModulesDefining File Operations Interacting with Block Device Drivers More about Kernel ModulesRegistering File Operations Interacting with Network Interface Cards Review of Kernel StructuresFile I/O Conventions Device Nodes Device Driver DesignThe sysfs filesystem Character Device Drivers: Registration Interacting with Character Device DriversDevice Model Structures The Device Node Problem Interacting with Block Device DriversTying it all Together File Operations Interacting with Network Interface CardsNetlink Sockets and User Events Defining File Operations Device NodesUserspace event agents Registering File Operations Character Device Drivers: RegistrationDevice Registration File I/O Conventions The Device Node ProblemMiscellaneous Devices The sysfs filesystem File OperationsHandling Interrupts Device Model Structures Defining File OperationsInterrupt Structures Tying it all Together Registering File OperationsISR Registration Netlink Sockets and User Events File I/O ConventionsSystem Context Userspace event agents The sysfs filesystemSoftirqs Device Registration Device Model StructuresDeferred Activity: Tasklets Miscellaneous Devices Tying it all TogetherDeferred Activity: Work Queues Handling Interrupts Netlink Sockets and User EventsCustom Work Queues Interrupt Structures Userspace event agentsExample: Serial Mouse ISR Registration Device RegistrationIOCTL Conventions System Context Miscellaneous DevicesImplementing IOCTLs Softirqs Handling InterruptsLockless IOCTLs Deferred Activity: Tasklets Interrupt StructuresSleeping Deferred Activity: Work Queues ISR RegistrationWait Queues Custom Work Queues System ContextWait Queues Example: Serial Mouse SoftirqsVariations on wait_event() IOCTL Conventions Deferred Activity: TaskletsSleeping in System Calls Implementing IOCTLs Deferred Activity: Work QueuesMultiplexed I/O Lockless IOCTLs Custom Work QueuesPolling Sleeping Example: Serial MouseManaging Exclusive Access Wait Queues IOCTL ConventionsI/O Ports Wait Queues Implementing IOCTLsI/O Memory Buffers Variations on wait_event() Lockless IOCTLsAccessing I/O Memory Buffers Sleeping in System Calls SleepingUserspace Drivers Multiplexed I/O Wait QueuesInitializing DMA Polling Wait QueuesCoherent Allocations Managing Exclusive Access Variations on wait_event()Streaming DMA Mappings I/O Ports Sleeping in System CallsPCI Configuration Space I/O Memory Buffers Multiplexed I/OPCI Driver Registration Accessing I/O Memory Buffers PollingRegistering PCI Drivers Userspace Drivers Managing Exclusive AccessDriver Probe Function Initializing DMA I/O PortsInitializing PCI devices Coherent Allocations I/O Memory BuffersReleasing a PCI Device Streaming DMA Mappings Accessing I/O Memory BuffersManaging PCI Resources PCI Configuration Space Userspace DriversAccessing Configuration Space PCI Driver Registration Initializing DMAListing PCI Devices Registering PCI Drivers Coherent AllocationsUSB Descriptors Driver Probe Function Streaming DMA MappingsUSB Transfer Types Initializing PCI devices PCI Configuration Space


Linux USB Implementation Releasing a PCI Device PCI Driver RegistrationUSB Drivers Managing PCI Resources Registering PCI DriversUSB Registration Accessing Configuration Space Driver Probe FunctionInitializing USB Interfaces Listing PCI Devices Initializing PCI devicesUSB Class Drivers USB Descriptors Releasing a PCI DeviceUSB Request Blocks USB Transfer Types Managing PCI ResourcesUsing USB request blocks Linux USB Implementation Accessing Configuration SpaceSynchronous USB Requests USB Drivers Listing PCI DevicesMore information USB Registration USB DescriptorsNetwork Devices Initializing USB Interfaces USB Transfer TypesNetwork Device Callback Functions USB Class Drivers Linux USB ImplementationNetwork Driver Initialization USB Request Blocks USB DriversNetwork Driver Transmission Queue Control Using USB request blocks USB RegistrationNetwork Statistics Synchronous USB Requests Initializing USB InterfacesSocket Buffers (Packets) More information USB Class DriversSocket Buffer API Network Devices USB Request BlocksTransmission Network Device Callback Functions Using USB request blocksReception Network Driver Initialization Synchronous USB RequestsExample Implementations Network Driver Transmission Queue More informationI/O Scheduling Control Network DevicesLinux 2.6 Elevator Functions Network Statistics Network Device Callback FunctionsBlock Device Driver Implementation Socket Buffers (Packets) Network Driver InitializationBlock Device Registration Socket Buffer API Network Driver Transmission QueueBlock Device File Operations Transmission ControlThe gendisk structure Reception Network StatisticsRequest Queues Example Implementations Socket Buffers (Packets)Initialization Example I/O Scheduling Socket Buffer APIHandling Requests Linux 2.6 Elevator Functions Transmission

Block Device Driver Implementation ReceptionBlock Device Registration Example Implementations

line Block Device File Operations I/O SchedulingLinux Kernel Variants The gendisk structure Linux 2.6 Elevator FunctionsInteracting with the Kernel Request Queues Block Device Driver ImplementationKernel Implementation Initialization Example Block Device RegistrationThe Linux Source Tree Handling Requests Block Device File OperationsWriting Kernel Modules The gendisk structureCompiling Kernel Modules Request QueuesMore about Kernel Modules line Initialization ExampleReview of Kernel Structures Linux Kernel Variants Handling RequestsDevice Driver Design Interacting with the KernelInteracting with Character Device Drivers Kernel ImplementationInteracting with Block Device Drivers The Linux Source Tree lineInteracting with Network Interface Cards Writing Kernel Modules Linux Kernel VariantsDevice Nodes Compiling Kernel Modules Interacting with the KernelCharacter Device Drivers: Registration More about Kernel Modules Kernel ImplementationThe Device Node Problem Review of Kernel Structures The Linux Source TreeFile Operations Device Driver Design Writing Kernel ModulesDefining File Operations Interacting with Character Device Drivers Compiling Kernel ModulesRegistering File Operations Interacting with Block Device Drivers More about Kernel ModulesFile I/O Conventions Interacting with Network Interface Cards Review of Kernel StructuresThe sysfs filesystem Device Nodes Device Driver DesignDevice Model Structures Character Device Drivers: Registration Interacting with Character Device DriversTying it all Together The Device Node Problem Interacting with Block Device DriversNetlink Sockets and User Events File Operations Interacting with Network Interface CardsUserspace event agents Defining File Operations Device NodesDevice Registration Registering File Operations Character Device Drivers: RegistrationMiscellaneous Devices File I/O Conventions The Device Node ProblemHandling Interrupts The sysfs filesystem File OperationsInterrupt Structures Device Model Structures Defining File OperationsISR Registration Tying it all Together Registering File OperationsSystem Context Netlink Sockets and User Events File I/O ConventionsSoftirqs Userspace event agents The sysfs filesystemDeferred Activity: Tasklets Device Registration Device Model StructuresDeferred Activity: Work Queues Miscellaneous Devices Tying it all TogetherCustom Work Queues Handling Interrupts Netlink Sockets and User EventsExample: Serial Mouse Interrupt Structures Userspace event agents


IOCTL Conventions ISR Registration Device RegistrationImplementing IOCTLs System Context Miscellaneous DevicesLockless IOCTLs Softirqs Handling InterruptsSleeping Deferred Activity: Tasklets Interrupt StructuresWait Queues Deferred Activity: Work Queues ISR RegistrationWait Queues Custom Work Queues System ContextVariations on wait_event() Example: Serial Mouse SoftirqsSleeping in System Calls IOCTL Conventions Deferred Activity: TaskletsMultiplexed I/O Implementing IOCTLs Deferred Activity: Work QueuesPolling Lockless IOCTLs Custom Work QueuesManaging Exclusive Access Sleeping Example: Serial MouseI/O Ports Wait Queues IOCTL ConventionsI/O Memory Buffers Wait Queues Implementing IOCTLsAccessing I/O Memory Buffers Variations on wait_event() Lockless IOCTLsUserspace Drivers Sleeping in System Calls SleepingInitializing DMA Multiplexed I/O Wait QueuesCoherent Allocations Polling Wait QueuesStreaming DMA Mappings Managing Exclusive Access Variations on wait_event()PCI Configuration Space I/O Ports Sleeping in System CallsPCI Driver Registration I/O Memory Buffers Multiplexed I/ORegistering PCI Drivers Accessing I/O Memory Buffers PollingDriver Probe Function Userspace Drivers Managing Exclusive AccessInitializing PCI devices Initializing DMA I/O PortsReleasing a PCI Device Coherent Allocations I/O Memory BuffersManaging PCI Resources Streaming DMA Mappings Accessing I/O Memory BuffersAccessing Configuration Space PCI Configuration Space Userspace DriversListing PCI Devices PCI Driver Registration Initializing DMAUSB Descriptors Registering PCI Drivers Coherent AllocationsUSB Transfer Types Driver Probe Function Streaming DMA MappingsLinux USB Implementation Initializing PCI devices PCI Configuration SpaceUSB Drivers Releasing a PCI Device PCI Driver RegistrationUSB Registration Managing PCI Resources Registering PCI DriversInitializing USB Interfaces Accessing Configuration Space Driver Probe FunctionUSB Class Drivers Listing PCI Devices Initializing PCI devicesUSB Request Blocks USB Descriptors Releasing a PCI DeviceUsing USB request blocks USB Transfer Types Managing PCI ResourcesSynchronous USB Requests Linux USB Implementation Accessing Configuration SpaceMore information USB Drivers Listing PCI DevicesNetwork Devices USB Registration USB DescriptorsNetwork Device Callback Functions Initializing USB Interfaces USB Transfer TypesNetwork Driver Initialization USB Class Drivers Linux USB ImplementationNetwork Driver Transmission Queue Control USB Request Blocks USB DriversNetwork Statistics Using USB request blocks USB RegistrationSocket Buffers (Packets) Synchronous USB Requests Initializing USB InterfacesSocket Buffer API More information USB Class DriversTransmission Network Devices USB Request BlocksReception Network Device Callback Functions Using USB request blocksExample Implementations Network Driver Initialization Synchronous USB RequestsI/O Scheduling Network Driver Transmission Queue More informationLinux 2.6 Elevator Functions Control Network DevicesBlock Device Driver Implementation Network Statistics Network Device Callback FunctionsBlock Device Registration Socket Buffers (Packets) Network Driver InitializationBlock Device File Operations Socket Buffer API Network Driver Transmission QueueThe gendisk structure Transmission ControlRequest Queues Reception Network StatisticsInitialization Example Example Implementations Socket Buffers (Packets)Handling Requests I/O Scheduling Socket Buffer API

Linux 2.6 Elevator Functions TransmissionBlock Device Driver Implementation Reception

line Block Device Registration Example ImplementationsLinux Kernel Variants Block Device File Operations I/O SchedulingInteracting with the Kernel The gendisk structure Linux 2.6 Elevator FunctionsKernel Implementation Request Queues Block Device Driver ImplementationThe Linux Source Tree Initialization Example Block Device RegistrationWriting Kernel Modules Handling Requests Block Device File OperationsCompiling Kernel Modules The gendisk structure


More about Kernel Modules Request QueuesReview of Kernel Structures line Initialization ExampleDevice Driver Design Linux Kernel Variants Handling RequestsInteracting with Character Device Drivers Interacting with the KernelInteracting with Block Device Drivers Kernel ImplementationInteracting with Network Interface Cards The Linux Source Tree lineDevice Nodes Writing Kernel Modules Linux Kernel VariantsCharacter Device Drivers: Registration Compiling Kernel Modules Interacting with the KernelThe Device Node Problem More about Kernel Modules Kernel ImplementationFile Operations Review of Kernel Structures The Linux Source TreeDefining File Operations Device Driver Design Writing Kernel ModulesRegistering File Operations Interacting with Character Device Drivers Compiling Kernel ModulesFile I/O Conventions Interacting with Block Device Drivers More about Kernel ModulesThe sysfs filesystem Interacting with Network Interface Cards Review of Kernel StructuresDevice Model Structures Device Nodes Device Driver DesignTying it all Together Character Device Drivers: Registration Interacting with Character Device DriversNetlink Sockets and User Events The Device Node Problem Interacting with Block Device DriversUserspace event agents File Operations Interacting with Network Interface CardsDevice Registration Defining File Operations Device NodesMiscellaneous Devices Registering File Operations Character Device Drivers: RegistrationHandling Interrupts File I/O Conventions The Device Node ProblemInterrupt Structures The sysfs filesystem File OperationsISR Registration Device Model Structures Defining File OperationsSystem Context Tying it all Together Registering File OperationsSoftirqs Netlink Sockets and User Events File I/O ConventionsDeferred Activity: Tasklets Userspace event agents The sysfs filesystemDeferred Activity: Work Queues Device Registration Device Model StructuresCustom Work Queues Miscellaneous Devices Tying it all TogetherExample: Serial Mouse Handling Interrupts Netlink Sockets and User EventsIOCTL Conventions Interrupt Structures Userspace event agentsImplementing IOCTLs ISR Registration Device RegistrationLockless IOCTLs System Context Miscellaneous DevicesSleeping Softirqs Handling InterruptsWait Queues Deferred Activity: Tasklets Interrupt StructuresWait Queues Deferred Activity: Work Queues ISR RegistrationVariations on wait_event() Custom Work Queues System ContextSleeping in System Calls Example: Serial Mouse SoftirqsMultiplexed I/O IOCTL Conventions Deferred Activity: TaskletsPolling Implementing IOCTLs Deferred Activity: Work QueuesManaging Exclusive Access Lockless IOCTLs Custom Work QueuesI/O Ports Sleeping Example: Serial MouseI/O Memory Buffers Wait Queues IOCTL ConventionsAccessing I/O Memory Buffers Wait Queues Implementing IOCTLsUserspace Drivers Variations on wait_event() Lockless IOCTLsInitializing DMA Sleeping in System Calls SleepingCoherent Allocations Multiplexed I/O Wait QueuesStreaming DMA Mappings Polling Wait QueuesPCI Configuration Space Managing Exclusive Access Variations on wait_event()PCI Driver Registration I/O Ports Sleeping in System CallsRegistering PCI Drivers I/O Memory Buffers Multiplexed I/ODriver Probe Function Accessing I/O Memory Buffers PollingInitializing PCI devices Userspace Drivers Managing Exclusive AccessReleasing a PCI Device Initializing DMA I/O PortsManaging PCI Resources Coherent Allocations I/O Memory BuffersAccessing Configuration Space Streaming DMA Mappings Accessing I/O Memory BuffersListing PCI Devices PCI Configuration Space Userspace DriversUSB Descriptors PCI Driver Registration Initializing DMAUSB Transfer Types Registering PCI Drivers Coherent AllocationsLinux USB Implementation Driver Probe Function Streaming DMA MappingsUSB Drivers Initializing PCI devices PCI Configuration SpaceUSB Registration Releasing a PCI Device PCI Driver RegistrationInitializing USB Interfaces Managing PCI Resources Registering PCI DriversUSB Class Drivers Accessing Configuration Space Driver Probe FunctionUSB Request Blocks Listing PCI Devices Initializing PCI devicesUsing USB request blocks USB Descriptors Releasing a PCI DeviceSynchronous USB Requests USB Transfer Types Managing PCI Resources


More information Linux USB Implementation Accessing Configuration SpaceNetwork Devices USB Drivers Listing PCI DevicesNetwork Device Callback Functions USB Registration USB DescriptorsNetwork Driver Initialization Initializing USB Interfaces USB Transfer TypesNetwork Driver Transmission Queue Control USB Class Drivers Linux USB ImplementationNetwork Statistics USB Request Blocks USB DriversSocket Buffers (Packets) Using USB request blocks USB RegistrationSocket Buffer API Synchronous USB Requests Initializing USB InterfacesTransmission More information USB Class DriversReception Network Devices USB Request BlocksExample Implementations Network Device Callback Functions Using USB request blocksI/O Scheduling Network Driver Initialization Synchronous USB RequestsLinux 2.6 Elevator Functions Network Driver Transmission Queue More informationBlock Device Driver Implementation Control Network DevicesBlock Device Registration Network Statistics Network Device Callback FunctionsBlock Device File Operations Socket Buffers (Packets) Network Driver InitializationThe gendisk structure Socket Buffer API Network Driver Transmission QueueRequest Queues Transmission ControlInitialization Example Reception Network StatisticsHandling Requests Example Implementations Socket Buffers (Packets)

I/O Scheduling Socket Buffer APILinux 2.6 Elevator Functions Transmission

line Block Device Driver Implementation ReceptionLinux Kernel Variants Block Device Registration Example ImplementationsInteracting with the Kernel Block Device File Operations I/O SchedulingKernel Implementation The gendisk structure Linux 2.6 Elevator FunctionsThe Linux Source Tree Request Queues Block Device Driver ImplementationWriting Kernel Modules Initialization Example Block Device RegistrationCompiling Kernel Modules Handling Requests Block Device File OperationsMore about Kernel Modules The gendisk structureReview of Kernel Structures Interacting With Devices Request QueuesDevice Driver Design line Initialization ExampleInteracting with Character Device Drivers Device Interaction Handling RequestsInteracting with Block Device DriversInteracting with Network Interface CardsDevice Nodes line lineCharacter Device Drivers: Registration Linux Kernel Variants Linux Kernel VariantsThe Device Node Problem Interacting with the Kernel Interacting with the KernelFile Operations Kernel Implementation Kernel ImplementationDefining File Operations The Linux Source Tree The Linux Source TreeRegistering File Operations Writing Kernel Modules Writing Kernel ModulesFile I/O Conventions Compiling Kernel Modules Compiling Kernel ModulesThe sysfs filesystem More about Kernel Modules More about Kernel ModulesDevice Model Structures Review of Kernel Structures Review of Kernel StructuresTying it all Together Device Driver Design Device Driver DesignNetlink Sockets and User Events Interacting with Character Device Drivers Interacting with Character Device DriversUserspace event agents Interacting with Block Device Drivers Interacting with Block Device DriversDevice Registration Interacting with Network Interface Cards Interacting with Network Interface CardsMiscellaneous Devices Device Nodes Device NodesHandling Interrupts Character Device Drivers: Registration Character Device Drivers: RegistrationInterrupt Structures The Device Node Problem The Device Node ProblemISR Registration File Operations File OperationsSystem Context Defining File Operations Defining File OperationsSoftirqs Registering File Operations Registering File OperationsDeferred Activity: Tasklets File I/O Conventions File I/O ConventionsDeferred Activity: Work Queues The sysfs filesystem The sysfs filesystemCustom Work Queues Device Model Structures Device Model StructuresExample: Serial Mouse Tying it all Together Tying it all TogetherIOCTL Conventions Netlink Sockets and User Events Netlink Sockets and User EventsImplementing IOCTLs Userspace event agents Userspace event agentsLockless IOCTLs Device Registration Device RegistrationSleeping Miscellaneous Devices Miscellaneous DevicesWait Queues Handling Interrupts Handling InterruptsWait Queues Interrupt Structures Interrupt StructuresVariations on wait_event() ISR Registration ISR RegistrationSleeping in System Calls System Context System Context


Multiplexed I/O Softirqs SoftirqsPolling Deferred Activity: Tasklets Deferred Activity: TaskletsManaging Exclusive Access Deferred Activity: Work Queues Deferred Activity: Work QueuesI/O Ports Custom Work Queues Custom Work QueuesI/O Memory Buffers Example: Serial Mouse Example: Serial MouseAccessing I/O Memory Buffers IOCTL Conventions IOCTL ConventionsUserspace Drivers Implementing IOCTLs Implementing IOCTLsInitializing DMA Lockless IOCTLs Lockless IOCTLsCoherent Allocations Sleeping SleepingStreaming DMA Mappings Wait Queues Wait QueuesPCI Configuration Space Wait Queues Wait QueuesPCI Driver Registration Variations on wait_event() Variations on wait_event()Registering PCI Drivers Sleeping in System Calls Sleeping in System CallsDriver Probe Function Multiplexed I/O Multiplexed I/OInitializing PCI devices Polling PollingReleasing a PCI Device Managing Exclusive Access Managing Exclusive AccessManaging PCI Resources I/O Ports I/O PortsAccessing Configuration Space I/O Memory Buffers I/O Memory BuffersListing PCI Devices Accessing I/O Memory Buffers Accessing I/O Memory BuffersUSB Descriptors Userspace Drivers Userspace DriversUSB Transfer Types Initializing DMA Initializing DMALinux USB Implementation Coherent Allocations Coherent AllocationsUSB Drivers Streaming DMA Mappings Streaming DMA MappingsUSB Registration PCI Configuration Space PCI Configuration SpaceInitializing USB Interfaces PCI Driver Registration PCI Driver RegistrationUSB Class Drivers Registering PCI Drivers Registering PCI DriversUSB Request Blocks Driver Probe Function Driver Probe FunctionUsing USB request blocks Initializing PCI devices Initializing PCI devicesSynchronous USB Requests Releasing a PCI Device Releasing a PCI DeviceMore information Managing PCI Resources Managing PCI ResourcesNetwork Devices Accessing Configuration Space Accessing Configuration SpaceNetwork Device Callback Functions Listing PCI Devices Listing PCI DevicesNetwork Driver Initialization USB Descriptors USB DescriptorsNetwork Driver Transmission Queue Control USB Transfer Types USB Transfer TypesNetwork Statistics Linux USB Implementation Linux USB ImplementationSocket Buffers (Packets) USB Drivers USB DriversSocket Buffer API USB Registration USB RegistrationTransmission Initializing USB Interfaces Initializing USB InterfacesReception USB Class Drivers USB Class DriversExample Implementations USB Request Blocks USB Request BlocksI/O Scheduling Using USB request blocks Using USB request blocksLinux 2.6 Elevator Functions Synchronous USB Requests Synchronous USB RequestsBlock Device Driver Implementation More information More informationBlock Device Registration Network Devices Network DevicesBlock Device File Operations Network Device Callback Functions Network Device Callback FunctionsThe gendisk structure Network Driver Initialization Network Driver InitializationRequest Queues Network Driver Transmission Queue Network Driver Transmission QueueInitialization Example Control ControlHandling Requests Network Statistics Network Statistics

Socket Buffers (Packets) Socket Buffers (Packets)Socket Buffer API Socket Buffer API

line Transmission TransmissionLinux Kernel Variants Reception ReceptionInteracting with the Kernel Example Implementations Example ImplementationsKernel Implementation I/O Scheduling I/O SchedulingThe Linux Source Tree Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsWriting Kernel Modules Block Device Driver Implementation Block Device Driver ImplementationCompiling Kernel Modules Block Device Registration Block Device RegistrationMore about Kernel Modules Block Device File Operations Block Device File OperationsReview of Kernel Structures The gendisk structure The gendisk structureDevice Driver Design Request Queues Request QueuesInteracting with Character Device Drivers Initialization Example Initialization ExampleInteracting with Block Device Drivers Handling Requests Handling RequestsInteracting with Network Interface CardsDevice NodesCharacter Device Drivers: Registration line line


The Device Node Problem Linux Kernel Variants Linux Kernel VariantsFile Operations Interacting with the Kernel Interacting with the KernelDefining File Operations Kernel Implementation Kernel ImplementationRegistering File Operations The Linux Source Tree The Linux Source TreeFile I/O Conventions Writing Kernel Modules Writing Kernel ModulesThe sysfs filesystem Compiling Kernel Modules Compiling Kernel ModulesDevice Model Structures More about Kernel Modules More about Kernel ModulesTying it all Together Review of Kernel Structures Review of Kernel StructuresNetlink Sockets and User Events Device Driver Design Device Driver DesignUserspace event agents Interacting with Character Device Drivers Interacting with Character Device DriversDevice Registration Interacting with Block Device Drivers Interacting with Block Device DriversMiscellaneous Devices Interacting with Network Interface Cards Interacting with Network Interface CardsHandling Interrupts Device Nodes Device NodesInterrupt Structures Character Device Drivers: Registration Character Device Drivers: RegistrationISR Registration The Device Node Problem The Device Node ProblemSystem Context File Operations File OperationsSoftirqs Defining File Operations Defining File OperationsDeferred Activity: Tasklets Registering File Operations Registering File OperationsDeferred Activity: Work Queues File I/O Conventions File I/O ConventionsCustom Work Queues The sysfs filesystem The sysfs filesystemExample: Serial Mouse Device Model Structures Device Model StructuresIOCTL Conventions Tying it all Together Tying it all TogetherImplementing IOCTLs Netlink Sockets and User Events Netlink Sockets and User EventsLockless IOCTLs Userspace event agents Userspace event agentsSleeping Device Registration Device RegistrationWait Queues Miscellaneous Devices Miscellaneous DevicesWait Queues Handling Interrupts Handling InterruptsVariations on wait_event() Interrupt Structures Interrupt StructuresSleeping in System Calls ISR Registration ISR RegistrationMultiplexed I/O System Context System ContextPolling Softirqs SoftirqsManaging Exclusive Access Deferred Activity: Tasklets Deferred Activity: TaskletsI/O Ports Deferred Activity: Work Queues Deferred Activity: Work QueuesI/O Memory Buffers Custom Work Queues Custom Work QueuesAccessing I/O Memory Buffers Example: Serial Mouse Example: Serial MouseUserspace Drivers IOCTL Conventions IOCTL ConventionsInitializing DMA Implementing IOCTLs Implementing IOCTLsCoherent Allocations Lockless IOCTLs Lockless IOCTLsStreaming DMA Mappings Sleeping SleepingPCI Configuration Space Wait Queues Wait QueuesPCI Driver Registration Wait Queues Wait QueuesRegistering PCI Drivers Variations on wait_event() Variations on wait_event()Driver Probe Function Sleeping in System Calls Sleeping in System CallsInitializing PCI devices Multiplexed I/O Multiplexed I/OReleasing a PCI Device Polling PollingManaging PCI Resources Managing Exclusive Access Managing Exclusive AccessAccessing Configuration Space I/O Ports I/O PortsListing PCI Devices I/O Memory Buffers I/O Memory BuffersUSB Descriptors Accessing I/O Memory Buffers Accessing I/O Memory BuffersUSB Transfer Types Userspace Drivers Userspace DriversLinux USB Implementation Initializing DMA Initializing DMAUSB Drivers Coherent Allocations Coherent AllocationsUSB Registration Streaming DMA Mappings Streaming DMA MappingsInitializing USB Interfaces PCI Configuration Space PCI Configuration SpaceUSB Class Drivers PCI Driver Registration PCI Driver RegistrationUSB Request Blocks Registering PCI Drivers Registering PCI DriversUsing USB request blocks Driver Probe Function Driver Probe FunctionSynchronous USB Requests Initializing PCI devices Initializing PCI devicesMore information Releasing a PCI Device Releasing a PCI DeviceNetwork Devices Managing PCI Resources Managing PCI ResourcesNetwork Device Callback Functions Accessing Configuration Space Accessing Configuration SpaceNetwork Driver Initialization Listing PCI Devices Listing PCI DevicesNetwork Driver Transmission Queue Control USB Descriptors USB DescriptorsNetwork Statistics USB Transfer Types USB Transfer TypesSocket Buffers (Packets) Linux USB Implementation Linux USB ImplementationSocket Buffer API USB Drivers USB Drivers


Transmission USB Registration USB RegistrationReception Initializing USB Interfaces Initializing USB InterfacesExample Implementations USB Class Drivers USB Class DriversI/O Scheduling USB Request Blocks USB Request BlocksLinux 2.6 Elevator Functions Using USB request blocks Using USB request blocksBlock Device Driver Implementation Synchronous USB Requests Synchronous USB RequestsBlock Device Registration More information More informationBlock Device File Operations Network Devices Network DevicesThe gendisk structure Network Device Callback Functions Network Device Callback FunctionsRequest Queues Network Driver Initialization Network Driver InitializationInitialization Example Network Driver Transmission Queue Network Driver Transmission QueueHandling Requests Control Control

Network Statistics Network StatisticsSocket Buffers (Packets) Socket Buffers (Packets)

line Socket Buffer API Socket Buffer APILinux Kernel Variants Transmission TransmissionInteracting with the Kernel Reception ReceptionKernel Implementation Example Implementations Example ImplementationsThe Linux Source Tree I/O Scheduling I/O SchedulingWriting Kernel Modules Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsCompiling Kernel Modules Block Device Driver Implementation Block Device Driver ImplementationMore about Kernel Modules Block Device Registration Block Device RegistrationReview of Kernel Structures Block Device File Operations Block Device File OperationsDevice Driver Design The gendisk structure The gendisk structureInteracting with Character Device Drivers Request Queues Request QueuesInteracting with Block Device Drivers Initialization Example Initialization ExampleInteracting with Network Interface Cards Handling Requests Handling RequestsDevice NodesCharacter Device Drivers: RegistrationThe Device Node Problem line lineFile Operations Linux Kernel Variants Linux Kernel VariantsDefining File Operations Interacting with the Kernel Interacting with the KernelRegistering File Operations Kernel Implementation Kernel ImplementationFile I/O Conventions The Linux Source Tree The Linux Source TreeThe sysfs filesystem Writing Kernel Modules Writing Kernel ModulesDevice Model Structures Compiling Kernel Modules Compiling Kernel ModulesTying it all Together More about Kernel Modules More about Kernel ModulesNetlink Sockets and User Events Review of Kernel Structures Review of Kernel StructuresUserspace event agents Device Driver Design Device Driver DesignDevice Registration Interacting with Character Device Drivers Interacting with Character Device DriversMiscellaneous Devices Interacting with Block Device Drivers Interacting with Block Device DriversHandling Interrupts Interacting with Network Interface Cards Interacting with Network Interface CardsInterrupt Structures Device Nodes Device NodesISR Registration Character Device Drivers: Registration Character Device Drivers: RegistrationSystem Context The Device Node Problem The Device Node ProblemSoftirqs File Operations File OperationsDeferred Activity: Tasklets Defining File Operations Defining File OperationsDeferred Activity: Work Queues Registering File Operations Registering File OperationsCustom Work Queues File I/O Conventions File I/O ConventionsExample: Serial Mouse The sysfs filesystem The sysfs filesystemIOCTL Conventions Device Model Structures Device Model StructuresImplementing IOCTLs Tying it all Together Tying it all TogetherLockless IOCTLs Netlink Sockets and User Events Netlink Sockets and User EventsSleeping Userspace event agents Userspace event agentsWait Queues Device Registration Device RegistrationWait Queues Miscellaneous Devices Miscellaneous DevicesVariations on wait_event() Handling Interrupts Handling InterruptsSleeping in System Calls Interrupt Structures Interrupt StructuresMultiplexed I/O ISR Registration ISR RegistrationPolling System Context System ContextManaging Exclusive Access Softirqs SoftirqsI/O Ports Deferred Activity: Tasklets Deferred Activity: TaskletsI/O Memory Buffers Deferred Activity: Work Queues Deferred Activity: Work QueuesAccessing I/O Memory Buffers Custom Work Queues Custom Work QueuesUserspace Drivers Example: Serial Mouse Example: Serial MouseInitializing DMA IOCTL Conventions IOCTL Conventions


Coherent Allocations Implementing IOCTLs Implementing IOCTLsStreaming DMA Mappings Lockless IOCTLs Lockless IOCTLsPCI Configuration Space Sleeping SleepingPCI Driver Registration Wait Queues Wait QueuesRegistering PCI Drivers Wait Queues Wait QueuesDriver Probe Function Variations on wait_event() Variations on wait_event()Initializing PCI devices Sleeping in System Calls Sleeping in System CallsReleasing a PCI Device Multiplexed I/O Multiplexed I/OManaging PCI Resources Polling PollingAccessing Configuration Space Managing Exclusive Access Managing Exclusive AccessListing PCI Devices I/O Ports I/O PortsUSB Descriptors I/O Memory Buffers I/O Memory BuffersUSB Transfer Types Accessing I/O Memory Buffers Accessing I/O Memory BuffersLinux USB Implementation Userspace Drivers Userspace DriversUSB Drivers Initializing DMA Initializing DMAUSB Registration Coherent Allocations Coherent AllocationsInitializing USB Interfaces Streaming DMA Mappings Streaming DMA MappingsUSB Class Drivers PCI Configuration Space PCI Configuration SpaceUSB Request Blocks PCI Driver Registration PCI Driver RegistrationUsing USB request blocks Registering PCI Drivers Registering PCI DriversSynchronous USB Requests Driver Probe Function Driver Probe FunctionMore information Initializing PCI devices Initializing PCI devicesNetwork Devices Releasing a PCI Device Releasing a PCI DeviceNetwork Device Callback Functions Managing PCI Resources Managing PCI ResourcesNetwork Driver Initialization Accessing Configuration Space Accessing Configuration SpaceNetwork Driver Transmission Queue Control Listing PCI Devices Listing PCI DevicesNetwork Statistics USB Descriptors USB DescriptorsSocket Buffers (Packets) USB Transfer Types USB Transfer TypesSocket Buffer API Linux USB Implementation Linux USB ImplementationTransmission USB Drivers USB DriversReception USB Registration USB RegistrationExample Implementations Initializing USB Interfaces Initializing USB InterfacesI/O Scheduling USB Class Drivers USB Class DriversLinux 2.6 Elevator Functions USB Request Blocks USB Request BlocksBlock Device Driver Implementation Using USB request blocks Using USB request blocksBlock Device Registration Synchronous USB Requests Synchronous USB RequestsBlock Device File Operations More information More informationThe gendisk structure Network Devices Network DevicesRequest Queues Network Device Callback Functions Network Device Callback FunctionsInitialization Example Network Driver Initialization Network Driver InitializationHandling Requests Network Driver Transmission Queue Network Driver Transmission Queue

Control ControlNetwork Statistics Network Statistics

line Socket Buffers (Packets) Socket Buffers (Packets)Linux Kernel Variants Socket Buffer API Socket Buffer APIInteracting with the Kernel Transmission TransmissionKernel Implementation Reception ReceptionThe Linux Source Tree Example Implementations Example ImplementationsWriting Kernel Modules I/O Scheduling I/O SchedulingCompiling Kernel Modules Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsMore about Kernel Modules Block Device Driver Implementation Block Device Driver ImplementationReview of Kernel Structures Block Device Registration Block Device RegistrationDevice Driver Design Block Device File Operations Block Device File OperationsInteracting with Character Device Drivers The gendisk structure The gendisk structureInteracting with Block Device Drivers Request Queues Request QueuesInteracting with Network Interface Cards Initialization Example Initialization ExampleDevice Nodes Handling Requests Handling RequestsCharacter Device Drivers: RegistrationThe Device Node ProblemFile Operations line lineDefining File Operations Linux Kernel Variants Linux Kernel VariantsRegistering File Operations Interacting with the Kernel Interacting with the KernelFile I/O Conventions Kernel Implementation Kernel ImplementationThe sysfs filesystem The Linux Source Tree The Linux Source TreeDevice Model Structures Writing Kernel Modules Writing Kernel ModulesTying it all Together Compiling Kernel Modules Compiling Kernel Modules


Netlink Sockets and User Events More about Kernel Modules More about Kernel ModulesUserspace event agents Review of Kernel Structures Review of Kernel StructuresDevice Registration Device Driver Design Device Driver DesignMiscellaneous Devices Interacting with Character Device Drivers Interacting with Character Device DriversHandling Interrupts Interacting with Block Device Drivers Interacting with Block Device DriversInterrupt Structures Interacting with Network Interface Cards Interacting with Network Interface CardsISR Registration Device Nodes Device NodesSystem Context Character Device Drivers: Registration Character Device Drivers: RegistrationSoftirqs The Device Node Problem The Device Node ProblemDeferred Activity: Tasklets File Operations File OperationsDeferred Activity: Work Queues Defining File Operations Defining File OperationsCustom Work Queues Registering File Operations Registering File OperationsExample: Serial Mouse File I/O Conventions File I/O ConventionsIOCTL Conventions The sysfs filesystem The sysfs filesystemImplementing IOCTLs Device Model Structures Device Model StructuresLockless IOCTLs Tying it all Together Tying it all TogetherSleeping Netlink Sockets and User Events Netlink Sockets and User EventsWait Queues Userspace event agents Userspace event agentsWait Queues Device Registration Device RegistrationVariations on wait_event() Miscellaneous Devices Miscellaneous DevicesSleeping in System Calls Handling Interrupts Handling InterruptsMultiplexed I/O Interrupt Structures Interrupt StructuresPolling ISR Registration ISR RegistrationManaging Exclusive Access System Context System ContextI/O Ports Softirqs SoftirqsI/O Memory Buffers Deferred Activity: Tasklets Deferred Activity: TaskletsAccessing I/O Memory Buffers Deferred Activity: Work Queues Deferred Activity: Work QueuesUserspace Drivers Custom Work Queues Custom Work QueuesInitializing DMA Example: Serial Mouse Example: Serial MouseCoherent Allocations IOCTL Conventions IOCTL ConventionsStreaming DMA Mappings Implementing IOCTLs Implementing IOCTLsPCI Configuration Space Lockless IOCTLs Lockless IOCTLsPCI Driver Registration Sleeping SleepingRegistering PCI Drivers Wait Queues Wait QueuesDriver Probe Function Wait Queues Wait QueuesInitializing PCI devices Variations on wait_event() Variations on wait_event()Releasing a PCI Device Sleeping in System Calls Sleeping in System CallsManaging PCI Resources Multiplexed I/O Multiplexed I/OAccessing Configuration Space Polling PollingListing PCI Devices Managing Exclusive Access Managing Exclusive AccessUSB Descriptors I/O Ports I/O PortsUSB Transfer Types I/O Memory Buffers I/O Memory BuffersLinux USB Implementation Accessing I/O Memory Buffers Accessing I/O Memory BuffersUSB Drivers Userspace Drivers Userspace DriversUSB Registration Initializing DMA Initializing DMAInitializing USB Interfaces Coherent Allocations Coherent AllocationsUSB Class Drivers Streaming DMA Mappings Streaming DMA MappingsUSB Request Blocks PCI Configuration Space PCI Configuration SpaceUsing USB request blocks PCI Driver Registration PCI Driver RegistrationSynchronous USB Requests Registering PCI Drivers Registering PCI DriversMore information Driver Probe Function Driver Probe FunctionNetwork Devices Initializing PCI devices Initializing PCI devicesNetwork Device Callback Functions Releasing a PCI Device Releasing a PCI DeviceNetwork Driver Initialization Managing PCI Resources Managing PCI ResourcesNetwork Driver Transmission Queue Control Accessing Configuration Space Accessing Configuration SpaceNetwork Statistics Listing PCI Devices Listing PCI DevicesSocket Buffers (Packets) USB Descriptors USB DescriptorsSocket Buffer API USB Transfer Types USB Transfer TypesTransmission Linux USB Implementation Linux USB ImplementationReception USB Drivers USB DriversExample Implementations USB Registration USB RegistrationI/O Scheduling Initializing USB Interfaces Initializing USB InterfacesLinux 2.6 Elevator Functions USB Class Drivers USB Class DriversBlock Device Driver Implementation USB Request Blocks USB Request BlocksBlock Device Registration Using USB request blocks Using USB request blocksBlock Device File Operations Synchronous USB Requests Synchronous USB Requests


The gendisk structure More information More informationRequest Queues Network Devices Network DevicesInitialization Example Network Device Callback Functions Network Device Callback FunctionsHandling Requests Network Driver Initialization Network Driver Initialization

Network Driver Transmission Queue Network Driver Transmission QueueControl Control

line Network Statistics Network StatisticsLinux Kernel Variants Socket Buffers (Packets) Socket Buffers (Packets)Interacting with the Kernel Socket Buffer API Socket Buffer APIKernel Implementation Transmission TransmissionThe Linux Source Tree Reception ReceptionWriting Kernel Modules Example Implementations Example ImplementationsCompiling Kernel Modules I/O Scheduling I/O SchedulingMore about Kernel Modules Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsReview of Kernel Structures Block Device Driver Implementation Block Device Driver ImplementationDevice Driver Design Block Device Registration Block Device RegistrationInteracting with Character Device Drivers Block Device File Operations Block Device File OperationsInteracting with Block Device Drivers The gendisk structure The gendisk structureInteracting with Network Interface Cards Request Queues Request QueuesDevice Nodes Initialization Example Initialization ExampleCharacter Device Drivers: Registration Handling Requests Handling RequestsThe Device Node ProblemFile OperationsDefining File Operations line lineRegistering File Operations Linux Kernel Variants Linux Kernel VariantsFile I/O Conventions Interacting with the Kernel Interacting with the KernelThe sysfs filesystem Kernel Implementation Kernel ImplementationDevice Model Structures The Linux Source Tree The Linux Source TreeTying it all Together Writing Kernel Modules Writing Kernel ModulesNetlink Sockets and User Events Compiling Kernel Modules Compiling Kernel ModulesUserspace event agents More about Kernel Modules More about Kernel ModulesDevice Registration Review of Kernel Structures Review of Kernel StructuresMiscellaneous Devices Device Driver Design Device Driver DesignHandling Interrupts Interacting with Character Device Drivers Interacting with Character Device DriversInterrupt Structures Interacting with Block Device Drivers Interacting with Block Device DriversISR Registration Interacting with Network Interface Cards Interacting with Network Interface CardsSystem Context Device Nodes Device NodesSoftirqs Character Device Drivers: Registration Character Device Drivers: RegistrationDeferred Activity: Tasklets The Device Node Problem The Device Node ProblemDeferred Activity: Work Queues File Operations File OperationsCustom Work Queues Defining File Operations Defining File OperationsExample: Serial Mouse Registering File Operations Registering File OperationsIOCTL Conventions File I/O Conventions File I/O ConventionsImplementing IOCTLs The sysfs filesystem The sysfs filesystemLockless IOCTLs Device Model Structures Device Model StructuresSleeping Tying it all Together Tying it all TogetherWait Queues Netlink Sockets and User Events Netlink Sockets and User EventsWait Queues Userspace event agents Userspace event agentsVariations on wait_event() Device Registration Device RegistrationSleeping in System Calls Miscellaneous Devices Miscellaneous DevicesMultiplexed I/O Handling Interrupts Handling InterruptsPolling Interrupt Structures Interrupt StructuresManaging Exclusive Access ISR Registration ISR RegistrationI/O Ports System Context System ContextI/O Memory Buffers Softirqs SoftirqsAccessing I/O Memory Buffers Deferred Activity: Tasklets Deferred Activity: TaskletsUserspace Drivers Deferred Activity: Work Queues Deferred Activity: Work QueuesInitializing DMA Custom Work Queues Custom Work QueuesCoherent Allocations Example: Serial Mouse Example: Serial MouseStreaming DMA Mappings IOCTL Conventions IOCTL ConventionsPCI Configuration Space Implementing IOCTLs Implementing IOCTLsPCI Driver Registration Lockless IOCTLs Lockless IOCTLsRegistering PCI Drivers Sleeping SleepingDriver Probe Function Wait Queues Wait QueuesInitializing PCI devices Wait Queues Wait QueuesReleasing a PCI Device Variations on wait_event() Variations on wait_event()


Managing PCI Resources Sleeping in System Calls Sleeping in System CallsAccessing Configuration Space Multiplexed I/O Multiplexed I/OListing PCI Devices Polling PollingUSB Descriptors Managing Exclusive Access Managing Exclusive AccessUSB Transfer Types I/O Ports I/O PortsLinux USB Implementation I/O Memory Buffers I/O Memory BuffersUSB Drivers Accessing I/O Memory Buffers Accessing I/O Memory BuffersUSB Registration Userspace Drivers Userspace DriversInitializing USB Interfaces Initializing DMA Initializing DMAUSB Class Drivers Coherent Allocations Coherent AllocationsUSB Request Blocks Streaming DMA Mappings Streaming DMA MappingsUsing USB request blocks PCI Configuration Space PCI Configuration SpaceSynchronous USB Requests PCI Driver Registration PCI Driver RegistrationMore information Registering PCI Drivers Registering PCI DriversNetwork Devices Driver Probe Function Driver Probe FunctionNetwork Device Callback Functions Initializing PCI devices Initializing PCI devicesNetwork Driver Initialization Releasing a PCI Device Releasing a PCI DeviceNetwork Driver Transmission Queue Control Managing PCI Resources Managing PCI ResourcesNetwork Statistics Accessing Configuration Space Accessing Configuration SpaceSocket Buffers (Packets) Listing PCI Devices Listing PCI DevicesSocket Buffer API USB Descriptors USB DescriptorsTransmission USB Transfer Types USB Transfer TypesReception Linux USB Implementation Linux USB ImplementationExample Implementations USB Drivers USB DriversI/O Scheduling USB Registration USB RegistrationLinux 2.6 Elevator Functions Initializing USB Interfaces Initializing USB InterfacesBlock Device Driver Implementation USB Class Drivers USB Class DriversBlock Device Registration USB Request Blocks USB Request BlocksBlock Device File Operations Using USB request blocks Using USB request blocksThe gendisk structure Synchronous USB Requests Synchronous USB RequestsRequest Queues More information More informationInitialization Example Network Devices Network DevicesHandling Requests Network Device Callback Functions Network Device Callback Functions

Network Driver Initialization Network Driver InitializationUnified Device Model Network Driver Transmission Queue Network Driver Transmission Queueline Control Control

Device Model Objects Network Statistics Network StatisticsSocket Buffers (Packets) Socket Buffers (Packets)Socket Buffer API Socket Buffer API

line Transmission TransmissionLinux Kernel Variants Reception ReceptionInteracting with the Kernel Example Implementations Example ImplementationsKernel Implementation I/O Scheduling I/O SchedulingThe Linux Source Tree Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsWriting Kernel Modules Block Device Driver Implementation Block Device Driver ImplementationCompiling Kernel Modules Block Device Registration Block Device RegistrationMore about Kernel Modules Block Device File Operations Block Device File OperationsReview of Kernel Structures The gendisk structure The gendisk structureDevice Driver Design Request Queues Request QueuesInteracting with Character Device Drivers Initialization Example Initialization ExampleInteracting with Block Device Drivers Handling Requests Handling RequestsInteracting with Network Interface CardsDevice Nodes Direct Memory AccessCharacter Device Drivers: Registration line lineThe Device Node Problem Managing DMA Linux Kernel VariantsFile Operations Interacting with the KernelDefining File Operations Kernel ImplementationRegistering File Operations line The Linux Source TreeFile I/O Conventions Linux Kernel Variants Writing Kernel ModulesThe sysfs filesystem Interacting with the Kernel Compiling Kernel ModulesDevice Model Structures Kernel Implementation More about Kernel ModulesTying it all Together The Linux Source Tree Review of Kernel StructuresNetlink Sockets and User Events Writing Kernel Modules Device Driver DesignUserspace event agents Compiling Kernel Modules Interacting with Character Device DriversDevice Registration More about Kernel Modules Interacting with Block Device DriversMiscellaneous Devices Review of Kernel Structures Interacting with Network Interface Cards


Handling Interrupts Device Driver Design Device NodesInterrupt Structures Interacting with Character Device Drivers Character Device Drivers: RegistrationISR Registration Interacting with Block Device Drivers The Device Node ProblemSystem Context Interacting with Network Interface Cards File OperationsSoftirqs Device Nodes Defining File OperationsDeferred Activity: Tasklets Character Device Drivers: Registration Registering File OperationsDeferred Activity: Work Queues The Device Node Problem File I/O ConventionsCustom Work Queues File Operations The sysfs filesystemExample: Serial Mouse Defining File Operations Device Model StructuresIOCTL Conventions Registering File Operations Tying it all TogetherImplementing IOCTLs File I/O Conventions Netlink Sockets and User EventsLockless IOCTLs The sysfs filesystem Userspace event agentsSleeping Device Model Structures Device RegistrationWait Queues Tying it all Together Miscellaneous DevicesWait Queues Netlink Sockets and User Events Handling InterruptsVariations on wait_event() Userspace event agents Interrupt StructuresSleeping in System Calls Device Registration ISR RegistrationMultiplexed I/O Miscellaneous Devices System ContextPolling Handling Interrupts SoftirqsManaging Exclusive Access Interrupt Structures Deferred Activity: TaskletsI/O Ports ISR Registration Deferred Activity: Work QueuesI/O Memory Buffers System Context Custom Work QueuesAccessing I/O Memory Buffers Softirqs Example: Serial MouseUserspace Drivers Deferred Activity: Tasklets IOCTL ConventionsInitializing DMA Deferred Activity: Work Queues Implementing IOCTLsCoherent Allocations Custom Work Queues Lockless IOCTLsStreaming DMA Mappings Example: Serial Mouse SleepingPCI Configuration Space IOCTL Conventions Wait QueuesPCI Driver Registration Implementing IOCTLs Wait QueuesRegistering PCI Drivers Lockless IOCTLs Variations on wait_event()Driver Probe Function Sleeping Sleeping in System CallsInitializing PCI devices Wait Queues Multiplexed I/OReleasing a PCI Device Wait Queues PollingManaging PCI Resources Variations on wait_event() Managing Exclusive AccessAccessing Configuration Space Sleeping in System Calls I/O PortsListing PCI Devices Multiplexed I/O I/O Memory BuffersUSB Descriptors Polling Accessing I/O Memory BuffersUSB Transfer Types Managing Exclusive Access Userspace DriversLinux USB Implementation I/O Ports Initializing DMAUSB Drivers I/O Memory Buffers Coherent AllocationsUSB Registration Accessing I/O Memory Buffers Streaming DMA MappingsInitializing USB Interfaces Userspace Drivers PCI Configuration SpaceUSB Class Drivers Initializing DMA PCI Driver RegistrationUSB Request Blocks Coherent Allocations Registering PCI DriversUsing USB request blocks Streaming DMA Mappings Driver Probe FunctionSynchronous USB Requests PCI Configuration Space Initializing PCI devicesMore information PCI Driver Registration Releasing a PCI DeviceNetwork Devices Registering PCI Drivers Managing PCI ResourcesNetwork Device Callback Functions Driver Probe Function Accessing Configuration SpaceNetwork Driver Initialization Initializing PCI devices Listing PCI DevicesNetwork Driver Transmission Queue Control Releasing a PCI Device USB DescriptorsNetwork Statistics Managing PCI Resources USB Transfer TypesSocket Buffers (Packets) Accessing Configuration Space Linux USB ImplementationSocket Buffer API Listing PCI Devices USB DriversTransmission USB Descriptors USB RegistrationReception USB Transfer Types Initializing USB InterfacesExample Implementations Linux USB Implementation USB Class DriversI/O Scheduling USB Drivers USB Request BlocksLinux 2.6 Elevator Functions USB Registration Using USB request blocksBlock Device Driver Implementation Initializing USB Interfaces Synchronous USB RequestsBlock Device Registration USB Class Drivers More informationBlock Device File Operations USB Request Blocks Network DevicesThe gendisk structure Using USB request blocks Network Device Callback FunctionsRequest Queues Synchronous USB Requests Network Driver InitializationInitialization Example More information Network Driver Transmission QueueHandling Requests Network Devices Control


Network Device Callback Functions Network StatisticsNetwork Driver Initialization Socket Buffers (Packets)

line Network Driver Transmission Queue Socket Buffer APILinux Kernel Variants Control TransmissionInteracting with the Kernel Network Statistics ReceptionKernel Implementation Socket Buffers (Packets) Example ImplementationsThe Linux Source Tree Socket Buffer API I/O SchedulingWriting Kernel Modules Transmission Linux 2.6 Elevator FunctionsCompiling Kernel Modules Reception Block Device Driver ImplementationMore about Kernel Modules Example Implementations Block Device RegistrationReview of Kernel Structures I/O Scheduling Block Device File OperationsDevice Driver Design Linux 2.6 Elevator Functions The gendisk structureInteracting with Character Device Drivers Block Device Driver Implementation Request QueuesInteracting with Block Device Drivers Block Device Registration Initialization ExampleInteracting with Network Interface Cards Block Device File Operations Handling RequestsDevice Nodes The gendisk structureCharacter Device Drivers: Registration Request QueuesThe Device Node Problem Initialization Example lineFile Operations Handling Requests Linux Kernel VariantsDefining File Operations Interacting with the KernelRegistering File Operations Kernel ImplementationFile I/O Conventions line The Linux Source TreeThe sysfs filesystem Linux Kernel Variants Writing Kernel ModulesDevice Model Structures Interacting with the Kernel Compiling Kernel ModulesTying it all Together Kernel Implementation More about Kernel ModulesNetlink Sockets and User Events The Linux Source Tree Review of Kernel StructuresUserspace event agents Writing Kernel Modules Device Driver DesignDevice Registration Compiling Kernel Modules Interacting with Character Device DriversMiscellaneous Devices More about Kernel Modules Interacting with Block Device DriversHandling Interrupts Review of Kernel Structures Interacting with Network Interface CardsInterrupt Structures Device Driver Design Device NodesISR Registration Interacting with Character Device Drivers Character Device Drivers: RegistrationSystem Context Interacting with Block Device Drivers The Device Node ProblemSoftirqs Interacting with Network Interface Cards File OperationsDeferred Activity: Tasklets Device Nodes Defining File OperationsDeferred Activity: Work Queues Character Device Drivers: Registration Registering File OperationsCustom Work Queues The Device Node Problem File I/O ConventionsExample: Serial Mouse File Operations The sysfs filesystemIOCTL Conventions Defining File Operations Device Model StructuresImplementing IOCTLs Registering File Operations Tying it all TogetherLockless IOCTLs File I/O Conventions Netlink Sockets and User EventsSleeping The sysfs filesystem Userspace event agentsWait Queues Device Model Structures Device RegistrationWait Queues Tying it all Together Miscellaneous DevicesVariations on wait_event() Netlink Sockets and User Events Handling InterruptsSleeping in System Calls Userspace event agents Interrupt StructuresMultiplexed I/O Device Registration ISR RegistrationPolling Miscellaneous Devices System ContextManaging Exclusive Access Handling Interrupts SoftirqsI/O Ports Interrupt Structures Deferred Activity: TaskletsI/O Memory Buffers ISR Registration Deferred Activity: Work QueuesAccessing I/O Memory Buffers System Context Custom Work QueuesUserspace Drivers Softirqs Example: Serial MouseInitializing DMA Deferred Activity: Tasklets IOCTL ConventionsCoherent Allocations Deferred Activity: Work Queues Implementing IOCTLsStreaming DMA Mappings Custom Work Queues Lockless IOCTLsPCI Configuration Space Example: Serial Mouse SleepingPCI Driver Registration IOCTL Conventions Wait QueuesRegistering PCI Drivers Implementing IOCTLs Wait QueuesDriver Probe Function Lockless IOCTLs Variations on wait_event()Initializing PCI devices Sleeping Sleeping in System CallsReleasing a PCI Device Wait Queues Multiplexed I/OManaging PCI Resources Wait Queues PollingAccessing Configuration Space Variations on wait_event() Managing Exclusive AccessListing PCI Devices Sleeping in System Calls I/O PortsUSB Descriptors Multiplexed I/O I/O Memory Buffers


USB Transfer Types Polling Accessing I/O Memory BuffersLinux USB Implementation Managing Exclusive Access Userspace DriversUSB Drivers I/O Ports Initializing DMAUSB Registration I/O Memory Buffers Coherent AllocationsInitializing USB Interfaces Accessing I/O Memory Buffers Streaming DMA MappingsUSB Class Drivers Userspace Drivers PCI Configuration SpaceUSB Request Blocks Initializing DMA PCI Driver RegistrationUsing USB request blocks Coherent Allocations Registering PCI DriversSynchronous USB Requests Streaming DMA Mappings Driver Probe FunctionMore information PCI Configuration Space Initializing PCI devicesNetwork Devices PCI Driver Registration Releasing a PCI DeviceNetwork Device Callback Functions Registering PCI Drivers Managing PCI ResourcesNetwork Driver Initialization Driver Probe Function Accessing Configuration SpaceNetwork Driver Transmission Queue Control Initializing PCI devices Listing PCI DevicesNetwork Statistics Releasing a PCI Device USB DescriptorsSocket Buffers (Packets) Managing PCI Resources USB Transfer TypesSocket Buffer API Accessing Configuration Space Linux USB ImplementationTransmission Listing PCI Devices USB DriversReception USB Descriptors USB RegistrationExample Implementations USB Transfer Types Initializing USB InterfacesI/O Scheduling Linux USB Implementation USB Class DriversLinux 2.6 Elevator Functions USB Drivers USB Request BlocksBlock Device Driver Implementation USB Registration Using USB request blocksBlock Device Registration Initializing USB Interfaces Synchronous USB RequestsBlock Device File Operations USB Class Drivers More informationThe gendisk structure USB Request Blocks Network DevicesRequest Queues Using USB request blocks Network Device Callback FunctionsInitialization Example Synchronous USB Requests Network Driver InitializationHandling Requests More information Network Driver Transmission Queue

Network Devices ControlNetwork Device Callback Functions Network Statistics

line Network Driver Initialization Socket Buffers (Packets)Linux Kernel Variants Network Driver Transmission Queue Socket Buffer APIInteracting with the Kernel Control TransmissionKernel Implementation Network Statistics ReceptionThe Linux Source Tree Socket Buffers (Packets) Example ImplementationsWriting Kernel Modules Socket Buffer API I/O SchedulingCompiling Kernel Modules Transmission Linux 2.6 Elevator FunctionsMore about Kernel Modules Reception Block Device Driver ImplementationReview of Kernel Structures Example Implementations Block Device RegistrationDevice Driver Design I/O Scheduling Block Device File OperationsInteracting with Character Device Drivers Linux 2.6 Elevator Functions The gendisk structureInteracting with Block Device Drivers Block Device Driver Implementation Request QueuesInteracting with Network Interface Cards Block Device Registration Initialization ExampleDevice Nodes Block Device File Operations Handling RequestsCharacter Device Drivers: Registration The gendisk structureThe Device Node Problem Request Queues Introduction to Block Device DriversFile Operations Initialization Example lineDefining File Operations Handling Requests Block DevicesRegistering File OperationsFile I/O ConventionsThe sysfs filesystem line lineDevice Model Structures Linux Kernel Variants Linux Kernel VariantsTying it all Together Interacting with the Kernel Interacting with the KernelNetlink Sockets and User Events Kernel Implementation Kernel ImplementationUserspace event agents The Linux Source Tree The Linux Source TreeDevice Registration Writing Kernel Modules Writing Kernel ModulesMiscellaneous Devices Compiling Kernel Modules Compiling Kernel ModulesHandling Interrupts More about Kernel Modules More about Kernel ModulesInterrupt Structures Review of Kernel Structures Review of Kernel StructuresISR Registration Device Driver Design Device Driver DesignSystem Context Interacting with Character Device Drivers Interacting with Character Device DriversSoftirqs Interacting with Block Device Drivers Interacting with Block Device DriversDeferred Activity: Tasklets Interacting with Network Interface Cards Interacting with Network Interface CardsDeferred Activity: Work Queues Device Nodes Device NodesCustom Work Queues Character Device Drivers: Registration Character Device Drivers: Registration


Example: Serial Mouse The Device Node Problem The Device Node ProblemIOCTL Conventions File Operations File OperationsImplementing IOCTLs Defining File Operations Defining File OperationsLockless IOCTLs Registering File Operations Registering File OperationsSleeping File I/O Conventions File I/O ConventionsWait Queues The sysfs filesystem The sysfs filesystemWait Queues Device Model Structures Device Model StructuresVariations on wait_event() Tying it all Together Tying it all TogetherSleeping in System Calls Netlink Sockets and User Events Netlink Sockets and User EventsMultiplexed I/O Userspace event agents Userspace event agentsPolling Device Registration Device RegistrationManaging Exclusive Access Miscellaneous Devices Miscellaneous DevicesI/O Ports Handling Interrupts Handling InterruptsI/O Memory Buffers Interrupt Structures Interrupt StructuresAccessing I/O Memory Buffers ISR Registration ISR RegistrationUserspace Drivers System Context System ContextInitializing DMA Softirqs SoftirqsCoherent Allocations Deferred Activity: Tasklets Deferred Activity: TaskletsStreaming DMA Mappings Deferred Activity: Work Queues Deferred Activity: Work QueuesPCI Configuration Space Custom Work Queues Custom Work QueuesPCI Driver Registration Example: Serial Mouse Example: Serial MouseRegistering PCI Drivers IOCTL Conventions IOCTL ConventionsDriver Probe Function Implementing IOCTLs Implementing IOCTLsInitializing PCI devices Lockless IOCTLs Lockless IOCTLsReleasing a PCI Device Sleeping SleepingManaging PCI Resources Wait Queues Wait QueuesAccessing Configuration Space Wait Queues Wait QueuesListing PCI Devices Variations on wait_event() Variations on wait_event()USB Descriptors Sleeping in System Calls Sleeping in System CallsUSB Transfer Types Multiplexed I/O Multiplexed I/OLinux USB Implementation Polling PollingUSB Drivers Managing Exclusive Access Managing Exclusive AccessUSB Registration I/O Ports I/O PortsInitializing USB Interfaces I/O Memory Buffers I/O Memory BuffersUSB Class Drivers Accessing I/O Memory Buffers Accessing I/O Memory BuffersUSB Request Blocks Userspace Drivers Userspace DriversUsing USB request blocks Initializing DMA Initializing DMASynchronous USB Requests Coherent Allocations Coherent AllocationsMore information Streaming DMA Mappings Streaming DMA MappingsNetwork Devices PCI Configuration Space PCI Configuration SpaceNetwork Device Callback Functions PCI Driver Registration PCI Driver RegistrationNetwork Driver Initialization Registering PCI Drivers Registering PCI DriversNetwork Driver Transmission Queue Control Driver Probe Function Driver Probe FunctionNetwork Statistics Initializing PCI devices Initializing PCI devicesSocket Buffers (Packets) Releasing a PCI Device Releasing a PCI DeviceSocket Buffer API Managing PCI Resources Managing PCI ResourcesTransmission Accessing Configuration Space Accessing Configuration SpaceReception Listing PCI Devices Listing PCI DevicesExample Implementations USB Descriptors USB DescriptorsI/O Scheduling USB Transfer Types USB Transfer TypesLinux 2.6 Elevator Functions Linux USB Implementation Linux USB ImplementationBlock Device Driver Implementation USB Drivers USB DriversBlock Device Registration USB Registration USB RegistrationBlock Device File Operations Initializing USB Interfaces Initializing USB InterfacesThe gendisk structure USB Class Drivers USB Class DriversRequest Queues USB Request Blocks USB Request BlocksInitialization Example Using USB request blocks Using USB request blocksHandling Requests Synchronous USB Requests Synchronous USB Requests

More information More informationNetwork Devices Network Devices

line Network Device Callback Functions Network Device Callback FunctionsLinux Kernel Variants Network Driver Initialization Network Driver InitializationInteracting with the Kernel Network Driver Transmission Queue Network Driver Transmission QueueKernel Implementation Control ControlThe Linux Source Tree Network Statistics Network StatisticsWriting Kernel Modules Socket Buffers (Packets) Socket Buffers (Packets)


Compiling Kernel Modules Socket Buffer API Socket Buffer APIMore about Kernel Modules Transmission TransmissionReview of Kernel Structures Reception ReceptionDevice Driver Design Example Implementations Example ImplementationsInteracting with Character Device Drivers I/O Scheduling I/O SchedulingInteracting with Block Device Drivers Linux 2.6 Elevator Functions Linux 2.6 Elevator FunctionsInteracting with Network Interface Cards Block Device Driver Implementation Block Device Driver ImplementationDevice Nodes Block Device Registration Block Device RegistrationCharacter Device Drivers: Registration Block Device File Operations Block Device File OperationsThe Device Node Problem The gendisk structure The gendisk structureFile Operations Request Queues Request QueuesDefining File Operations Initialization Example Initialization ExampleRegistering File Operations Handling Requests Handling RequestsFile I/O ConventionsThe sysfs filesystem PCI DriversDevice Model Structures line lineTying it all Together Peripheral Component Interconnect Linux Kernel VariantsNetlink Sockets and User Events Interacting with the KernelUserspace event agents Kernel ImplementationDevice Registration line The Linux Source TreeMiscellaneous Devices Linux Kernel Variants Writing Kernel ModulesHandling Interrupts Interacting with the Kernel Compiling Kernel ModulesInterrupt Structures Kernel Implementation More about Kernel ModulesISR Registration The Linux Source Tree Review of Kernel StructuresSystem Context Writing Kernel Modules Device Driver DesignSoftirqs Compiling Kernel Modules Interacting with Character Device DriversDeferred Activity: Tasklets More about Kernel Modules Interacting with Block Device DriversDeferred Activity: Work Queues Review of Kernel Structures Interacting with Network Interface CardsCustom Work Queues Device Driver Design Device NodesExample: Serial Mouse Interacting with Character Device Drivers Character Device Drivers: RegistrationIOCTL Conventions Interacting with Block Device Drivers The Device Node ProblemImplementing IOCTLs Interacting with Network Interface Cards File OperationsLockless IOCTLs Device Nodes Defining File OperationsSleeping Character Device Drivers: Registration Registering File OperationsWait Queues The Device Node Problem File I/O ConventionsWait Queues File Operations The sysfs filesystemVariations on wait_event() Defining File Operations Device Model StructuresSleeping in System Calls Registering File Operations Tying it all TogetherMultiplexed I/O File I/O Conventions Netlink Sockets and User EventsPolling The sysfs filesystem Userspace event agentsManaging Exclusive Access Device Model Structures Device RegistrationI/O Ports Tying it all Together Miscellaneous DevicesI/O Memory Buffers Netlink Sockets and User Events Handling InterruptsAccessing I/O Memory Buffers Userspace event agents Interrupt StructuresUserspace Drivers Device Registration ISR RegistrationInitializing DMA Miscellaneous Devices System ContextCoherent Allocations Handling Interrupts SoftirqsStreaming DMA Mappings Interrupt Structures Deferred Activity: TaskletsPCI Configuration Space ISR Registration Deferred Activity: Work QueuesPCI Driver Registration System Context Custom Work QueuesRegistering PCI Drivers Softirqs Example: Serial MouseDriver Probe Function Deferred Activity: Tasklets IOCTL ConventionsInitializing PCI devices Deferred Activity: Work Queues Implementing IOCTLsReleasing a PCI Device Custom Work Queues Lockless IOCTLsManaging PCI Resources Example: Serial Mouse SleepingAccessing Configuration Space IOCTL Conventions Wait QueuesListing PCI Devices Implementing IOCTLs Wait QueuesUSB Descriptors Lockless IOCTLs Variations on wait_event()USB Transfer Types Sleeping Sleeping in System CallsLinux USB Implementation Wait Queues Multiplexed I/OUSB Drivers Wait Queues PollingUSB Registration Variations on wait_event() Managing Exclusive AccessInitializing USB Interfaces Sleeping in System Calls I/O PortsUSB Class Drivers Multiplexed I/O I/O Memory BuffersUSB Request Blocks Polling Accessing I/O Memory BuffersUsing USB request blocks Managing Exclusive Access Userspace Drivers


Synchronous USB Requests I/O Ports Initializing DMAMore information I/O Memory Buffers Coherent AllocationsNetwork Devices Accessing I/O Memory Buffers Streaming DMA MappingsNetwork Device Callback Functions Userspace Drivers PCI Configuration SpaceNetwork Driver Initialization Initializing DMA PCI Driver RegistrationNetwork Driver Transmission Queue Control Coherent Allocations Registering PCI DriversNetwork Statistics Streaming DMA Mappings Driver Probe FunctionSocket Buffers (Packets) PCI Configuration Space Initializing PCI devicesSocket Buffer API PCI Driver Registration Releasing a PCI DeviceTransmission Registering PCI Drivers Managing PCI ResourcesReception Driver Probe Function Accessing Configuration SpaceExample Implementations Initializing PCI devices Listing PCI DevicesI/O Scheduling Releasing a PCI Device USB DescriptorsLinux 2.6 Elevator Functions Managing PCI Resources USB Transfer TypesBlock Device Driver Implementation Accessing Configuration Space Linux USB ImplementationBlock Device Registration Listing PCI Devices USB DriversBlock Device File Operations USB Descriptors USB RegistrationThe gendisk structure USB Transfer Types Initializing USB InterfacesRequest Queues Linux USB Implementation USB Class DriversInitialization Example USB Drivers USB Request BlocksHandling Requests USB Registration Using USB request blocks

Initializing USB Interfaces Synchronous USB RequestsUSB Class Drivers More information

line USB Request Blocks Network DevicesLinux Kernel Variants Using USB request blocks Network Device Callback FunctionsInteracting with the Kernel Synchronous USB Requests Network Driver InitializationKernel Implementation More information Network Driver Transmission QueueThe Linux Source Tree Network Devices ControlWriting Kernel Modules Network Device Callback Functions Network StatisticsCompiling Kernel Modules Network Driver Initialization Socket Buffers (Packets)More about Kernel Modules Network Driver Transmission Queue Socket Buffer APIReview of Kernel Structures Control TransmissionDevice Driver Design Network Statistics ReceptionInteracting with Character Device Drivers Socket Buffers (Packets) Example ImplementationsInteracting with Block Device Drivers Socket Buffer API I/O SchedulingInteracting with Network Interface Cards Transmission Linux 2.6 Elevator FunctionsDevice Nodes Reception Block Device Driver ImplementationCharacter Device Drivers: Registration Example Implementations Block Device RegistrationThe Device Node Problem I/O Scheduling Block Device File OperationsFile Operations Linux 2.6 Elevator Functions The gendisk structureDefining File Operations Block Device Driver Implementation Request QueuesRegistering File Operations Block Device Registration Initialization ExampleFile I/O Conventions Block Device File Operations Handling RequestsThe sysfs filesystem The gendisk structureDevice Model Structures Request QueuesTying it all Together Initialization Example lineNetlink Sockets and User Events Handling Requests Linux Kernel VariantsUserspace event agents Interacting with the KernelDevice Registration Kernel ImplementationMiscellaneous Devices line The Linux Source TreeHandling Interrupts Linux Kernel Variants Writing Kernel ModulesInterrupt Structures Interacting with the Kernel Compiling Kernel ModulesISR Registration Kernel Implementation More about Kernel ModulesSystem Context The Linux Source Tree Review of Kernel StructuresSoftirqs Writing Kernel Modules Device Driver DesignDeferred Activity: Tasklets Compiling Kernel Modules Interacting with Character Device DriversDeferred Activity: Work Queues More about Kernel Modules Interacting with Block Device DriversCustom Work Queues Review of Kernel Structures Interacting with Network Interface CardsExample: Serial Mouse Device Driver Design Device NodesIOCTL Conventions Interacting with Character Device Drivers Character Device Drivers: RegistrationImplementing IOCTLs Interacting with Block Device Drivers The Device Node ProblemLockless IOCTLs Interacting with Network Interface Cards File OperationsSleeping Device Nodes Defining File OperationsWait Queues Character Device Drivers: Registration Registering File OperationsWait Queues The Device Node Problem File I/O ConventionsVariations on wait_event() File Operations The sysfs filesystem


Sleeping in System Calls Defining File Operations Device Model StructuresMultiplexed I/O Registering File Operations Tying it all TogetherPolling File I/O Conventions Netlink Sockets and User EventsManaging Exclusive Access The sysfs filesystem Userspace event agentsI/O Ports Device Model Structures Device RegistrationI/O Memory Buffers Tying it all Together Miscellaneous DevicesAccessing I/O Memory Buffers Netlink Sockets and User Events Handling InterruptsUserspace Drivers Userspace event agents Interrupt StructuresInitializing DMA Device Registration ISR RegistrationCoherent Allocations Miscellaneous Devices System ContextStreaming DMA Mappings Handling Interrupts SoftirqsPCI Configuration Space Interrupt Structures Deferred Activity: TaskletsPCI Driver Registration ISR Registration Deferred Activity: Work QueuesRegistering PCI Drivers System Context Custom Work QueuesDriver Probe Function Softirqs Example: Serial MouseInitializing PCI devices Deferred Activity: Tasklets IOCTL ConventionsReleasing a PCI Device Deferred Activity: Work Queues Implementing IOCTLsManaging PCI Resources Custom Work Queues Lockless IOCTLsAccessing Configuration Space Example: Serial Mouse SleepingListing PCI Devices IOCTL Conventions Wait QueuesUSB Descriptors Implementing IOCTLs Wait QueuesUSB Transfer Types Lockless IOCTLs Variations on wait_event()Linux USB Implementation Sleeping Sleeping in System CallsUSB Drivers Wait Queues Multiplexed I/OUSB Registration Wait Queues PollingInitializing USB Interfaces Variations on wait_event() Managing Exclusive AccessUSB Class Drivers Sleeping in System Calls I/O PortsUSB Request Blocks Multiplexed I/O I/O Memory BuffersUsing USB request blocks Polling Accessing I/O Memory BuffersSynchronous USB Requests Managing Exclusive Access Userspace DriversMore information I/O Ports Initializing DMANetwork Devices I/O Memory Buffers Coherent AllocationsNetwork Device Callback Functions Accessing I/O Memory Buffers Streaming DMA MappingsNetwork Driver Initialization Userspace Drivers PCI Configuration SpaceNetwork Driver Transmission Queue Control Initializing DMA PCI Driver RegistrationNetwork Statistics Coherent Allocations Registering PCI DriversSocket Buffers (Packets) Streaming DMA Mappings Driver Probe FunctionSocket Buffer API PCI Configuration Space Initializing PCI devicesTransmission PCI Driver Registration Releasing a PCI DeviceReception Registering PCI Drivers Managing PCI ResourcesExample Implementations Driver Probe Function Accessing Configuration SpaceI/O Scheduling Initializing PCI devices Listing PCI DevicesLinux 2.6 Elevator Functions Releasing a PCI Device USB DescriptorsBlock Device Driver Implementation Managing PCI Resources USB Transfer TypesBlock Device Registration Accessing Configuration Space Linux USB ImplementationBlock Device File Operations Listing PCI Devices USB DriversThe gendisk structure USB Descriptors USB RegistrationRequest Queues USB Transfer Types Initializing USB InterfacesInitialization Example Linux USB Implementation USB Class DriversHandling Requests USB Drivers USB Request Blocks

USB Registration Using USB request blocksInitializing USB Interfaces Synchronous USB Requests

line USB Class Drivers More informationLinux Kernel Variants USB Request Blocks Network DevicesInteracting with the Kernel Using USB request blocks Network Device Callback FunctionsKernel Implementation Synchronous USB Requests Network Driver InitializationThe Linux Source Tree More information Network Driver Transmission QueueWriting Kernel Modules Network Devices ControlCompiling Kernel Modules Network Device Callback Functions Network StatisticsMore about Kernel Modules Network Driver Initialization Socket Buffers (Packets)Review of Kernel Structures Network Driver Transmission Queue Socket Buffer APIDevice Driver Design Control TransmissionInteracting with Character Device Drivers Network Statistics ReceptionInteracting with Block Device Drivers Socket Buffers (Packets) Example ImplementationsInteracting with Network Interface Cards Socket Buffer API I/O SchedulingDevice Nodes Transmission Linux 2.6 Elevator Functions


Character Device Drivers: Registration Reception Block Device Driver ImplementationThe Device Node Problem Example Implementations Block Device RegistrationFile Operations I/O Scheduling Block Device File OperationsDefining File Operations Linux 2.6 Elevator Functions The gendisk structureRegistering File Operations Block Device Driver Implementation Request QueuesFile I/O Conventions Block Device Registration Initialization ExampleThe sysfs filesystem Block Device File Operations Handling RequestsDevice Model Structures The gendisk structureTying it all Together Request QueuesNetlink Sockets and User Events Initialization Example lineUserspace event agents Handling Requests Linux Kernel VariantsDevice Registration Interacting with the KernelMiscellaneous Devices Kernel ImplementationHandling Interrupts line The Linux Source TreeInterrupt Structures Linux Kernel Variants Writing Kernel ModulesISR Registration Interacting with the Kernel Compiling Kernel ModulesSystem Context Kernel Implementation More about Kernel ModulesSoftirqs The Linux Source Tree Review of Kernel StructuresDeferred Activity: Tasklets Writing Kernel Modules Device Driver DesignDeferred Activity: Work Queues Compiling Kernel Modules Interacting with Character Device DriversCustom Work Queues More about Kernel Modules Interacting with Block Device DriversExample: Serial Mouse Review of Kernel Structures Interacting with Network Interface CardsIOCTL Conventions Device Driver Design Device NodesImplementing IOCTLs Interacting with Character Device Drivers Character Device Drivers: RegistrationLockless IOCTLs Interacting with Block Device Drivers The Device Node ProblemSleeping Interacting with Network Interface Cards File OperationsWait Queues Device Nodes Defining File OperationsWait Queues Character Device Drivers: Registration Registering File OperationsVariations on wait_event() The Device Node Problem File I/O ConventionsSleeping in System Calls File Operations The sysfs filesystemMultiplexed I/O Defining File Operations Device Model StructuresPolling Registering File Operations Tying it all TogetherManaging Exclusive Access File I/O Conventions Netlink Sockets and User EventsI/O Ports The sysfs filesystem Userspace event agentsI/O Memory Buffers Device Model Structures Device RegistrationAccessing I/O Memory Buffers Tying it all Together Miscellaneous DevicesUserspace Drivers Netlink Sockets and User Events Handling InterruptsInitializing DMA Userspace event agents Interrupt StructuresCoherent Allocations Device Registration ISR RegistrationStreaming DMA Mappings Miscellaneous Devices System ContextPCI Configuration Space Handling Interrupts SoftirqsPCI Driver Registration Interrupt Structures Deferred Activity: TaskletsRegistering PCI Drivers ISR Registration Deferred Activity: Work QueuesDriver Probe Function System Context Custom Work QueuesInitializing PCI devices Softirqs Example: Serial MouseReleasing a PCI Device Deferred Activity: Tasklets IOCTL ConventionsManaging PCI Resources Deferred Activity: Work Queues Implementing IOCTLsAccessing Configuration Space Custom Work Queues Lockless IOCTLsListing PCI Devices Example: Serial Mouse SleepingUSB Descriptors IOCTL Conventions Wait QueuesUSB Transfer Types Implementing IOCTLs Wait QueuesLinux USB Implementation Lockless IOCTLs Variations on wait_event()USB Drivers Sleeping Sleeping in System CallsUSB Registration Wait Queues Multiplexed I/OInitializing USB Interfaces Wait Queues PollingUSB Class Drivers Variations on wait_event() Managing Exclusive AccessUSB Request Blocks Sleeping in System Calls I/O PortsUsing USB request blocks Multiplexed I/O I/O Memory BuffersSynchronous USB Requests Polling Accessing I/O Memory BuffersMore information Managing Exclusive Access Userspace DriversNetwork Devices I/O Ports Initializing DMANetwork Device Callback Functions I/O Memory Buffers Coherent AllocationsNetwork Driver Initialization Accessing I/O Memory Buffers Streaming DMA MappingsNetwork Driver Transmission Queue Control Userspace Drivers PCI Configuration SpaceNetwork Statistics Initializing DMA PCI Driver RegistrationSocket Buffers (Packets) Coherent Allocations Registering PCI Drivers


Socket Buffer API Streaming DMA Mappings Driver Probe FunctionTransmission PCI Configuration Space Initializing PCI devicesReception PCI Driver Registration Releasing a PCI DeviceExample Implementations Registering PCI Drivers Managing PCI ResourcesI/O Scheduling Driver Probe Function Accessing Configuration SpaceLinux 2.6 Elevator Functions Initializing PCI devices Listing PCI DevicesBlock Device Driver Implementation Releasing a PCI Device USB DescriptorsBlock Device Registration Managing PCI Resources USB Transfer TypesBlock Device File Operations Accessing Configuration Space Linux USB ImplementationThe gendisk structure Listing PCI Devices USB DriversRequest Queues USB Descriptors USB RegistrationInitialization Example USB Transfer Types Initializing USB InterfacesHandling Requests Linux USB Implementation USB Class Drivers

USB Drivers USB Request BlocksUSB Registration Using USB request blocks

line Initializing USB Interfaces Synchronous USB RequestsLinux Kernel Variants USB Class Drivers More informationInteracting with the Kernel USB Request Blocks Network DevicesKernel Implementation Using USB request blocks Network Device Callback FunctionsThe Linux Source Tree Synchronous USB Requests Network Driver InitializationWriting Kernel Modules More information Network Driver Transmission QueueCompiling Kernel Modules Network Devices ControlMore about Kernel Modules Network Device Callback Functions Network StatisticsReview of Kernel Structures Network Driver Initialization Socket Buffers (Packets)Device Driver Design Network Driver Transmission Queue Socket Buffer APIInteracting with Character Device Drivers Control TransmissionInteracting with Block Device Drivers Network Statistics ReceptionInteracting with Network Interface Cards Socket Buffers (Packets) Example ImplementationsDevice Nodes Socket Buffer API I/O SchedulingCharacter Device Drivers: Registration Transmission Linux 2.6 Elevator FunctionsThe Device Node Problem Reception Block Device Driver ImplementationFile Operations Example Implementations Block Device RegistrationDefining File Operations I/O Scheduling Block Device File OperationsRegistering File Operations Linux 2.6 Elevator Functions The gendisk structureFile I/O Conventions Block Device Driver Implementation Request QueuesThe sysfs filesystem Block Device Registration Initialization ExampleDevice Model Structures Block Device File Operations Handling RequestsTying it all Together The gendisk structureNetlink Sockets and User Events Request QueuesUserspace event agents Initialization Example lineDevice Registration Handling Requests Linux Kernel VariantsMiscellaneous Devices Interacting with the KernelHandling Interrupts Kernel ImplementationInterrupt Structures line The Linux Source TreeISR Registration Linux Kernel Variants Writing Kernel ModulesSystem Context Interacting with the Kernel Compiling Kernel ModulesSoftirqs Kernel Implementation More about Kernel ModulesDeferred Activity: Tasklets The Linux Source Tree Review of Kernel StructuresDeferred Activity: Work Queues Writing Kernel Modules Device Driver DesignCustom Work Queues Compiling Kernel Modules Interacting with Character Device DriversExample: Serial Mouse More about Kernel Modules Interacting with Block Device DriversIOCTL Conventions Review of Kernel Structures Interacting with Network Interface CardsImplementing IOCTLs Device Driver Design Device NodesLockless IOCTLs Interacting with Character Device Drivers Character Device Drivers: RegistrationSleeping Interacting with Block Device Drivers The Device Node ProblemWait Queues Interacting with Network Interface Cards File OperationsWait Queues Device Nodes Defining File OperationsVariations on wait_event() Character Device Drivers: Registration Registering File OperationsSleeping in System Calls The Device Node Problem File I/O ConventionsMultiplexed I/O File Operations The sysfs filesystemPolling Defining File Operations Device Model StructuresManaging Exclusive Access Registering File Operations Tying it all TogetherI/O Ports File I/O Conventions Netlink Sockets and User EventsI/O Memory Buffers The sysfs filesystem Userspace event agentsAccessing I/O Memory Buffers Device Model Structures Device RegistrationUserspace Drivers Tying it all Together Miscellaneous Devices


Initializing DMA Netlink Sockets and User Events Handling InterruptsCoherent Allocations Userspace event agents Interrupt StructuresStreaming DMA Mappings Device Registration ISR RegistrationPCI Configuration Space Miscellaneous Devices System ContextPCI Driver Registration Handling Interrupts SoftirqsRegistering PCI Drivers Interrupt Structures Deferred Activity: TaskletsDriver Probe Function ISR Registration Deferred Activity: Work QueuesInitializing PCI devices System Context Custom Work QueuesReleasing a PCI Device Softirqs Example: Serial MouseManaging PCI Resources Deferred Activity: Tasklets IOCTL ConventionsAccessing Configuration Space Deferred Activity: Work Queues Implementing IOCTLsListing PCI Devices Custom Work Queues Lockless IOCTLsUSB Descriptors Example: Serial Mouse SleepingUSB Transfer Types IOCTL Conventions Wait QueuesLinux USB Implementation Implementing IOCTLs Wait QueuesUSB Drivers Lockless IOCTLs Variations on wait_event()USB Registration Sleeping Sleeping in System CallsInitializing USB Interfaces Wait Queues Multiplexed I/OUSB Class Drivers Wait Queues PollingUSB Request Blocks Variations on wait_event() Managing Exclusive AccessUsing USB request blocks Sleeping in System Calls I/O PortsSynchronous USB Requests Multiplexed I/O I/O Memory BuffersMore information Polling Accessing I/O Memory BuffersNetwork Devices Managing Exclusive Access Userspace DriversNetwork Device Callback Functions I/O Ports Initializing DMANetwork Driver Initialization I/O Memory Buffers Coherent AllocationsNetwork Driver Transmission Queue Control Accessing I/O Memory Buffers Streaming DMA MappingsNetwork Statistics Userspace Drivers PCI Configuration SpaceSocket Buffers (Packets) Initializing DMA PCI Driver RegistrationSocket Buffer API Coherent Allocations Registering PCI DriversTransmission Streaming DMA Mappings Driver Probe FunctionReception PCI Configuration Space Initializing PCI devicesExample Implementations PCI Driver Registration Releasing a PCI DeviceI/O Scheduling Registering PCI Drivers Managing PCI ResourcesLinux 2.6 Elevator Functions Driver Probe Function Accessing Configuration SpaceBlock Device Driver Implementation Initializing PCI devices Listing PCI DevicesBlock Device Registration Releasing a PCI Device USB DescriptorsBlock Device File Operations Managing PCI Resources USB Transfer TypesThe gendisk structure Accessing Configuration Space Linux USB ImplementationRequest Queues Listing PCI Devices USB DriversInitialization Example USB Descriptors USB RegistrationHandling Requests USB Transfer Types Initializing USB Interfaces

Linux USB Implementation USB Class DriversInterrupt Handling USB Drivers USB Request Blocksline USB Registration Using USB request blocks

Interrupt Context Initializing USB Interfaces Synchronous USB RequestsUSB Class Drivers More informationUSB Request Blocks Network Devices

line Using USB request blocks Network Device Callback FunctionsLinux Kernel Variants Synchronous USB Requests Network Driver InitializationInteracting with the Kernel More information Network Driver Transmission QueueKernel Implementation Network Devices ControlThe Linux Source Tree Network Device Callback Functions Network StatisticsWriting Kernel Modules Network Driver Initialization Socket Buffers (Packets)Compiling Kernel Modules Network Driver Transmission Queue Socket Buffer APIMore about Kernel Modules Control TransmissionReview of Kernel Structures Network Statistics ReceptionDevice Driver Design Socket Buffers (Packets) Example ImplementationsInteracting with Character Device Drivers Socket Buffer API I/O SchedulingInteracting with Block Device Drivers Transmission Linux 2.6 Elevator FunctionsInteracting with Network Interface Cards Reception Block Device Driver ImplementationDevice Nodes Example Implementations Block Device RegistrationCharacter Device Drivers: Registration I/O Scheduling Block Device File OperationsThe Device Node Problem Linux 2.6 Elevator Functions The gendisk structureFile Operations Block Device Driver Implementation Request QueuesDefining File Operations Block Device Registration Initialization Example


Registering File Operations Block Device File Operations Handling RequestsFile I/O Conventions The gendisk structureThe sysfs filesystem Request QueuesDevice Model Structures Initialization Example lineTying it all Together Handling Requests Linux Kernel VariantsNetlink Sockets and User Events Interacting with the KernelUserspace event agents Kernel ImplementationDevice Registration line The Linux Source TreeMiscellaneous Devices Linux Kernel Variants Writing Kernel ModulesHandling Interrupts Interacting with the Kernel Compiling Kernel ModulesInterrupt Structures Kernel Implementation More about Kernel ModulesISR Registration The Linux Source Tree Review of Kernel StructuresSystem Context Writing Kernel Modules Device Driver DesignSoftirqs Compiling Kernel Modules Interacting with Character Device DriversDeferred Activity: Tasklets More about Kernel Modules Interacting with Block Device DriversDeferred Activity: Work Queues Review of Kernel Structures Interacting with Network Interface CardsCustom Work Queues Device Driver Design Device NodesExample: Serial Mouse Interacting with Character Device Drivers Character Device Drivers: RegistrationIOCTL Conventions Interacting with Block Device Drivers The Device Node ProblemImplementing IOCTLs Interacting with Network Interface Cards File OperationsLockless IOCTLs Device Nodes Defining File OperationsSleeping Character Device Drivers: Registration Registering File OperationsWait Queues The Device Node Problem File I/O ConventionsWait Queues File Operations The sysfs filesystemVariations on wait_event() Defining File Operations Device Model StructuresSleeping in System Calls Registering File Operations Tying it all TogetherMultiplexed I/O File I/O Conventions Netlink Sockets and User EventsPolling The sysfs filesystem Userspace event agentsManaging Exclusive Access Device Model Structures Device RegistrationI/O Ports Tying it all Together Miscellaneous DevicesI/O Memory Buffers Netlink Sockets and User Events Handling InterruptsAccessing I/O Memory Buffers Userspace event agents Interrupt StructuresUserspace Drivers Device Registration ISR RegistrationInitializing DMA Miscellaneous Devices System ContextCoherent Allocations Handling Interrupts SoftirqsStreaming DMA Mappings Interrupt Structures Deferred Activity: TaskletsPCI Configuration Space ISR Registration Deferred Activity: Work QueuesPCI Driver Registration System Context Custom Work QueuesRegistering PCI Drivers Softirqs Example: Serial MouseDriver Probe Function Deferred Activity: Tasklets IOCTL ConventionsInitializing PCI devices Deferred Activity: Work Queues Implementing IOCTLsReleasing a PCI Device Custom Work Queues Lockless IOCTLsManaging PCI Resources Example: Serial Mouse SleepingAccessing Configuration Space IOCTL Conventions Wait QueuesListing PCI Devices Implementing IOCTLs Wait QueuesUSB Descriptors Lockless IOCTLs Variations on wait_event()USB Transfer Types Sleeping Sleeping in System CallsLinux USB Implementation Wait Queues Multiplexed I/OUSB Drivers Wait Queues PollingUSB Registration Variations on wait_event() Managing Exclusive AccessInitializing USB Interfaces Sleeping in System Calls I/O PortsUSB Class Drivers Multiplexed I/O I/O Memory BuffersUSB Request Blocks Polling Accessing I/O Memory BuffersUsing USB request blocks Managing Exclusive Access Userspace DriversSynchronous USB Requests I/O Ports Initializing DMAMore information I/O Memory Buffers Coherent AllocationsNetwork Devices Accessing I/O Memory Buffers Streaming DMA MappingsNetwork Device Callback Functions Userspace Drivers PCI Configuration SpaceNetwork Driver Initialization Initializing DMA PCI Driver RegistrationNetwork Driver Transmission Queue Control Coherent Allocations Registering PCI DriversNetwork Statistics Streaming DMA Mappings Driver Probe FunctionSocket Buffers (Packets) PCI Configuration Space Initializing PCI devicesSocket Buffer API PCI Driver Registration Releasing a PCI DeviceTransmission Registering PCI Drivers Managing PCI ResourcesReception Driver Probe Function Accessing Configuration SpaceExample Implementations Initializing PCI devices Listing PCI Devices


I/O Scheduling Releasing a PCI Device USB DescriptorsLinux 2.6 Elevator Functions Managing PCI Resources USB Transfer TypesBlock Device Driver Implementation Accessing Configuration Space Linux USB ImplementationBlock Device Registration Listing PCI Devices USB DriversBlock Device File Operations USB Descriptors USB RegistrationThe gendisk structure USB Transfer Types Initializing USB InterfacesRequest Queues Linux USB Implementation USB Class DriversInitialization Example USB Drivers USB Request BlocksHandling Requests USB Registration Using USB request blocks

Initializing USB Interfaces Synchronous USB RequestsUSB Class Drivers More information

line USB Request Blocks Network DevicesLinux Kernel Variants Using USB request blocks Network Device Callback FunctionsInteracting with the Kernel Synchronous USB Requests Network Driver InitializationKernel Implementation More information Network Driver Transmission QueueThe Linux Source Tree Network Devices ControlWriting Kernel Modules Network Device Callback Functions Network StatisticsCompiling Kernel Modules Network Driver Initialization Socket Buffers (Packets)More about Kernel Modules Network Driver Transmission Queue Socket Buffer APIReview of Kernel Structures Control TransmissionDevice Driver Design Network Statistics ReceptionInteracting with Character Device Drivers Socket Buffers (Packets) Example ImplementationsInteracting with Block Device Drivers Socket Buffer API I/O SchedulingInteracting with Network Interface Cards Transmission Linux 2.6 Elevator FunctionsDevice Nodes Reception Block Device Driver ImplementationCharacter Device Drivers: Registration Example Implementations Block Device RegistrationThe Device Node Problem I/O Scheduling Block Device File OperationsFile Operations Linux 2.6 Elevator Functions The gendisk structureDefining File Operations Block Device Driver Implementation Request QueuesRegistering File Operations Block Device Registration Initialization ExampleFile I/O Conventions Block Device File Operations Handling RequestsThe sysfs filesystem The gendisk structureDevice Model Structures Request QueuesTying it all Together Initialization Example lineNetlink Sockets and User Events Handling Requests Linux Kernel VariantsUserspace event agents Interacting with the KernelDevice Registration Kernel ImplementationMiscellaneous Devices line The Linux Source TreeHandling Interrupts Linux Kernel Variants Writing Kernel ModulesInterrupt Structures Interacting with the Kernel Compiling Kernel ModulesISR Registration Kernel Implementation More about Kernel ModulesSystem Context The Linux Source Tree Review of Kernel StructuresSoftirqs Writing Kernel Modules Device Driver DesignDeferred Activity: Tasklets Compiling Kernel Modules Interacting with Character Device DriversDeferred Activity: Work Queues More about Kernel Modules Interacting with Block Device DriversCustom Work Queues Review of Kernel Structures Interacting with Network Interface CardsExample: Serial Mouse Device Driver Design Device NodesIOCTL Conventions Interacting with Character Device Drivers Character Device Drivers: RegistrationImplementing IOCTLs Interacting with Block Device Drivers The Device Node ProblemLockless IOCTLs Interacting with Network Interface Cards File OperationsSleeping Device Nodes Defining File OperationsWait Queues Character Device Drivers: Registration Registering File OperationsWait Queues The Device Node Problem File I/O ConventionsVariations on wait_event() File Operations The sysfs filesystemSleeping in System Calls Defining File Operations Device Model StructuresMultiplexed I/O Registering File Operations Tying it all TogetherPolling File I/O Conventions Netlink Sockets and User EventsManaging Exclusive Access The sysfs filesystem Userspace event agentsI/O Ports Device Model Structures Device RegistrationI/O Memory Buffers Tying it all Together Miscellaneous DevicesAccessing I/O Memory Buffers Netlink Sockets and User Events Handling InterruptsUserspace Drivers Userspace event agents Interrupt StructuresInitializing DMA Device Registration ISR RegistrationCoherent Allocations Miscellaneous Devices System ContextStreaming DMA Mappings Handling Interrupts SoftirqsPCI Configuration Space Interrupt Structures Deferred Activity: Tasklets


PCI Driver Registration ISR Registration Deferred Activity: Work QueuesRegistering PCI Drivers System Context Custom Work QueuesDriver Probe Function Softirqs Example: Serial MouseInitializing PCI devices Deferred Activity: Tasklets IOCTL ConventionsReleasing a PCI Device Deferred Activity: Work Queues Implementing IOCTLsManaging PCI Resources Custom Work Queues Lockless IOCTLsAccessing Configuration Space Example: Serial Mouse SleepingListing PCI Devices IOCTL Conventions Wait QueuesUSB Descriptors Implementing IOCTLs Wait QueuesUSB Transfer Types Lockless IOCTLs Variations on wait_event()Linux USB Implementation Sleeping Sleeping in System CallsUSB Drivers Wait Queues Multiplexed I/OUSB Registration Wait Queues PollingInitializing USB Interfaces Variations on wait_event() Managing Exclusive AccessUSB Class Drivers Sleeping in System Calls I/O PortsUSB Request Blocks Multiplexed I/O I/O Memory BuffersUsing USB request blocks Polling Accessing I/O Memory BuffersSynchronous USB Requests Managing Exclusive Access Userspace DriversMore information I/O Ports Initializing DMANetwork Devices I/O Memory Buffers Coherent AllocationsNetwork Device Callback Functions Accessing I/O Memory Buffers Streaming DMA MappingsNetwork Driver Initialization Userspace Drivers PCI Configuration SpaceNetwork Driver Transmission Queue Control Initializing DMA PCI Driver RegistrationNetwork Statistics Coherent Allocations Registering PCI DriversSocket Buffers (Packets) Streaming DMA Mappings Driver Probe FunctionSocket Buffer API PCI Configuration Space Initializing PCI devicesTransmission PCI Driver Registration Releasing a PCI DeviceReception Registering PCI Drivers Managing PCI ResourcesExample Implementations Driver Probe Function Accessing Configuration SpaceI/O Scheduling Initializing PCI devices Listing PCI DevicesLinux 2.6 Elevator Functions Releasing a PCI Device USB DescriptorsBlock Device Driver Implementation Managing PCI Resources USB Transfer TypesBlock Device Registration Accessing Configuration Space Linux USB ImplementationBlock Device File Operations Listing PCI Devices USB DriversThe gendisk structure USB Descriptors USB RegistrationRequest Queues USB Transfer Types Initializing USB InterfacesInitialization Example Linux USB Implementation USB Class DriversHandling Requests USB Drivers USB Request Blocks

USB Registration Using USB request blocksInitializing USB Interfaces Synchronous USB Requests

line USB Class Drivers More informationLinux Kernel Variants USB Request Blocks Network DevicesInteracting with the Kernel Using USB request blocks Network Device Callback FunctionsKernel Implementation Synchronous USB Requests Network Driver InitializationThe Linux Source Tree More information Network Driver Transmission QueueWriting Kernel Modules Network Devices ControlCompiling Kernel Modules Network Device Callback Functions Network StatisticsMore about Kernel Modules Network Driver Initialization Socket Buffers (Packets)Review of Kernel Structures Network Driver Transmission Queue Socket Buffer APIDevice Driver Design Control TransmissionInteracting with Character Device Drivers Network Statistics ReceptionInteracting with Block Device Drivers Socket Buffers (Packets) Example ImplementationsInteracting with Network Interface Cards Socket Buffer API I/O SchedulingDevice Nodes Transmission Linux 2.6 Elevator FunctionsCharacter Device Drivers: Registration Reception Block Device Driver ImplementationThe Device Node Problem Example Implementations Block Device RegistrationFile Operations I/O Scheduling Block Device File OperationsDefining File Operations Linux 2.6 Elevator Functions The gendisk structureRegistering File Operations Block Device Driver Implementation Request QueuesFile I/O Conventions Block Device Registration Initialization ExampleThe sysfs filesystem Block Device File Operations Handling RequestsDevice Model Structures The gendisk structureTying it all Together Request QueuesNetlink Sockets and User Events Initialization Example lineUserspace event agents Handling Requests Linux Kernel VariantsDevice Registration Interacting with the Kernel


Miscellaneous Devices Kernel ImplementationHandling Interrupts line The Linux Source TreeInterrupt Structures Linux Kernel Variants Writing Kernel ModulesISR Registration Interacting with the Kernel Compiling Kernel ModulesSystem Context Kernel Implementation More about Kernel ModulesSoftirqs The Linux Source Tree Review of Kernel StructuresDeferred Activity: Tasklets Writing Kernel Modules Device Driver DesignDeferred Activity: Work Queues Compiling Kernel Modules Interacting with Character Device DriversCustom Work Queues More about Kernel Modules Interacting with Block Device DriversExample: Serial Mouse Review of Kernel Structures Interacting with Network Interface CardsIOCTL Conventions Device Driver Design Device NodesImplementing IOCTLs Interacting with Character Device Drivers Character Device Drivers: RegistrationLockless IOCTLs Interacting with Block Device Drivers The Device Node ProblemSleeping Interacting with Network Interface Cards File OperationsWait Queues Device Nodes Defining File OperationsWait Queues Character Device Drivers: Registration Registering File OperationsVariations on wait_event() The Device Node Problem File I/O ConventionsSleeping in System Calls File Operations The sysfs filesystemMultiplexed I/O Defining File Operations Device Model StructuresPolling Registering File Operations Tying it all TogetherManaging Exclusive Access File I/O Conventions Netlink Sockets and User EventsI/O Ports The sysfs filesystem Userspace event agentsI/O Memory Buffers Device Model Structures Device RegistrationAccessing I/O Memory Buffers Tying it all Together Miscellaneous DevicesUserspace Drivers Netlink Sockets and User Events Handling InterruptsInitializing DMA Userspace event agents Interrupt StructuresCoherent Allocations Device Registration ISR RegistrationStreaming DMA Mappings Miscellaneous Devices System ContextPCI Configuration Space Handling Interrupts SoftirqsPCI Driver Registration Interrupt Structures Deferred Activity: TaskletsRegistering PCI Drivers ISR Registration Deferred Activity: Work QueuesDriver Probe Function System Context Custom Work QueuesInitializing PCI devices Softirqs Example: Serial MouseReleasing a PCI Device Deferred Activity: Tasklets IOCTL ConventionsManaging PCI Resources Deferred Activity: Work Queues Implementing IOCTLsAccessing Configuration Space Custom Work Queues Lockless IOCTLsListing PCI Devices Example: Serial Mouse SleepingUSB Descriptors IOCTL Conventions Wait QueuesUSB Transfer Types Implementing IOCTLs Wait QueuesLinux USB Implementation Lockless IOCTLs Variations on wait_event()USB Drivers Sleeping Sleeping in System CallsUSB Registration Wait Queues Multiplexed I/OInitializing USB Interfaces Wait Queues PollingUSB Class Drivers Variations on wait_event() Managing Exclusive AccessUSB Request Blocks Sleeping in System Calls I/O PortsUsing USB request blocks Multiplexed I/O I/O Memory BuffersSynchronous USB Requests Polling Accessing I/O Memory BuffersMore information Managing Exclusive Access Userspace DriversNetwork Devices I/O Ports Initializing DMANetwork Device Callback Functions I/O Memory Buffers Coherent AllocationsNetwork Driver Initialization Accessing I/O Memory Buffers Streaming DMA MappingsNetwork Driver Transmission Queue Control Userspace Drivers PCI Configuration SpaceNetwork Statistics Initializing DMA PCI Driver RegistrationSocket Buffers (Packets) Coherent Allocations Registering PCI DriversSocket Buffer API Streaming DMA Mappings Driver Probe FunctionTransmission PCI Configuration Space Initializing PCI devicesReception PCI Driver Registration Releasing a PCI DeviceExample Implementations Registering PCI Drivers Managing PCI ResourcesI/O Scheduling Driver Probe Function Accessing Configuration SpaceLinux 2.6 Elevator Functions Initializing PCI devices Listing PCI DevicesBlock Device Driver Implementation Releasing a PCI Device USB DescriptorsBlock Device Registration Managing PCI Resources USB Transfer TypesBlock Device File Operations Accessing Configuration Space Linux USB ImplementationThe gendisk structure Listing PCI Devices USB DriversRequest Queues USB Descriptors USB RegistrationInitialization Example USB Transfer Types Initializing USB Interfaces


Handling Requests Linux USB Implementation USB Class DriversUSB Drivers USB Request BlocksUSB Registration Using USB request blocks

line Initializing USB Interfaces Synchronous USB RequestsLinux Kernel Variants USB Class Drivers More informationInteracting with the Kernel USB Request Blocks Network DevicesKernel Implementation Using USB request blocks Network Device Callback FunctionsThe Linux Source Tree Synchronous USB Requests Network Driver InitializationWriting Kernel Modules More information Network Driver Transmission QueueCompiling Kernel Modules Network Devices ControlMore about Kernel Modules Network Device Callback Functions Network StatisticsReview of Kernel Structures Network Driver Initialization Socket Buffers (Packets)Device Driver Design Network Driver Transmission Queue Socket Buffer APIInteracting with Character Device Drivers Control TransmissionInteracting with Block Device Drivers Network Statistics ReceptionInteracting with Network Interface Cards Socket Buffers (Packets) Example ImplementationsDevice Nodes Socket Buffer API I/O SchedulingCharacter Device Drivers: Registration Transmission Linux 2.6 Elevator FunctionsThe Device Node Problem Reception Block Device Driver ImplementationFile Operations Example Implementations Block Device RegistrationDefining File Operations I/O Scheduling Block Device File OperationsRegistering File Operations Linux 2.6 Elevator Functions The gendisk structureFile I/O Conventions Block Device Driver Implementation Request QueuesThe sysfs filesystem Block Device Registration Initialization ExampleDevice Model Structures Block Device File Operations Handling RequestsTying it all Together The gendisk structureNetlink Sockets and User Events Request QueuesUserspace event agents Initialization Example lineDevice Registration Handling Requests Linux Kernel VariantsMiscellaneous Devices Interacting with the KernelHandling Interrupts Kernel ImplementationInterrupt Structures line The Linux Source TreeISR Registration Linux Kernel Variants Writing Kernel ModulesSystem Context Interacting with the Kernel Compiling Kernel ModulesSoftirqs Kernel Implementation More about Kernel ModulesDeferred Activity: Tasklets The Linux Source Tree Review of Kernel StructuresDeferred Activity: Work Queues Writing Kernel Modules Device Driver DesignCustom Work Queues Compiling Kernel Modules Interacting with Character Device DriversExample: Serial Mouse More about Kernel Modules Interacting with Block Device DriversIOCTL Conventions Review of Kernel Structures Interacting with Network Interface CardsImplementing IOCTLs Device Driver Design Device NodesLockless IOCTLs Interacting with Character Device Drivers Character Device Drivers: RegistrationSleeping Interacting with Block Device Drivers The Device Node ProblemWait Queues Interacting with Network Interface Cards File OperationsWait Queues Device Nodes Defining File OperationsVariations on wait_event() Character Device Drivers: Registration Registering File OperationsSleeping in System Calls The Device Node Problem File I/O ConventionsMultiplexed I/O File Operations The sysfs filesystemPolling Defining File Operations Device Model StructuresManaging Exclusive Access Registering File Operations Tying it all TogetherI/O Ports File I/O Conventions Netlink Sockets and User EventsI/O Memory Buffers The sysfs filesystem Userspace event agentsAccessing I/O Memory Buffers Device Model Structures Device RegistrationUserspace Drivers Tying it all Together Miscellaneous DevicesInitializing DMA Netlink Sockets and User Events Handling InterruptsCoherent Allocations Userspace event agents Interrupt StructuresStreaming DMA Mappings Device Registration ISR RegistrationPCI Configuration Space Miscellaneous Devices System ContextPCI Driver Registration Handling Interrupts SoftirqsRegistering PCI Drivers Interrupt Structures Deferred Activity: TaskletsDriver Probe Function ISR Registration Deferred Activity: Work QueuesInitializing PCI devices System Context Custom Work QueuesReleasing a PCI Device Softirqs Example: Serial MouseManaging PCI Resources Deferred Activity: Tasklets IOCTL ConventionsAccessing Configuration Space Deferred Activity: Work Queues Implementing IOCTLsListing PCI Devices Custom Work Queues Lockless IOCTLs


USB Descriptors Example: Serial Mouse SleepingUSB Transfer Types IOCTL Conventions Wait QueuesLinux USB Implementation Implementing IOCTLs Wait QueuesUSB Drivers Lockless IOCTLs Variations on wait_event()USB Registration Sleeping Sleeping in System CallsInitializing USB Interfaces Wait Queues Multiplexed I/OUSB Class Drivers Wait Queues PollingUSB Request Blocks Variations on wait_event() Managing Exclusive AccessUsing USB request blocks Sleeping in System Calls I/O PortsSynchronous USB Requests Multiplexed I/O I/O Memory BuffersMore information Polling Accessing I/O Memory BuffersNetwork Devices Managing Exclusive Access Userspace DriversNetwork Device Callback Functions I/O Ports Initializing DMANetwork Driver Initialization I/O Memory Buffers Coherent AllocationsNetwork Driver Transmission Queue Control Accessing I/O Memory Buffers Streaming DMA MappingsNetwork Statistics Userspace Drivers PCI Configuration SpaceSocket Buffers (Packets) Initializing DMA PCI Driver RegistrationSocket Buffer API Coherent Allocations Registering PCI DriversTransmission Streaming DMA Mappings Driver Probe FunctionReception PCI Configuration Space Initializing PCI devicesExample Implementations PCI Driver Registration Releasing a PCI DeviceI/O Scheduling Registering PCI Drivers Managing PCI ResourcesLinux 2.6 Elevator Functions Driver Probe Function Accessing Configuration SpaceBlock Device Driver Implementation Initializing PCI devices Listing PCI DevicesBlock Device Registration Releasing a PCI Device USB DescriptorsBlock Device File Operations Managing PCI Resources USB Transfer TypesThe gendisk structure Accessing Configuration Space Linux USB ImplementationRequest Queues Listing PCI Devices USB DriversInitialization Example USB Descriptors USB RegistrationHandling Requests USB Transfer Types Initializing USB Interfaces

Linux USB Implementation USB Class DriversUSB Drivers USB Request Blocks

line USB Registration Using USB request blocksLinux Kernel Variants Initializing USB Interfaces Synchronous USB RequestsInteracting with the Kernel USB Class Drivers More informationKernel Implementation USB Request Blocks Network DevicesThe Linux Source Tree Using USB request blocks Network Device Callback FunctionsWriting Kernel Modules Synchronous USB Requests Network Driver InitializationCompiling Kernel Modules More information Network Driver Transmission QueueMore about Kernel Modules Network Devices ControlReview of Kernel Structures Network Device Callback Functions Network StatisticsDevice Driver Design Network Driver Initialization Socket Buffers (Packets)Interacting with Character Device Drivers Network Driver Transmission Queue Socket Buffer APIInteracting with Block Device Drivers Control TransmissionInteracting with Network Interface Cards Network Statistics ReceptionDevice Nodes Socket Buffers (Packets) Example ImplementationsCharacter Device Drivers: Registration Socket Buffer API I/O SchedulingThe Device Node Problem Transmission Linux 2.6 Elevator FunctionsFile Operations Reception Block Device Driver ImplementationDefining File Operations Example Implementations Block Device RegistrationRegistering File Operations I/O Scheduling Block Device File OperationsFile I/O Conventions Linux 2.6 Elevator Functions The gendisk structureThe sysfs filesystem Block Device Driver Implementation Request QueuesDevice Model Structures Block Device Registration Initialization ExampleTying it all Together Block Device File Operations Handling RequestsNetlink Sockets and User Events The gendisk structureUserspace event agents Request QueuesDevice Registration Initialization ExampleMiscellaneous Devices Handling RequestsHandling InterruptsInterrupt StructuresISR Registration lineSystem Context Linux Kernel VariantsSoftirqs Interacting with the KernelDeferred Activity: Tasklets Kernel ImplementationDeferred Activity: Work Queues The Linux Source Tree


Custom Work Queues Writing Kernel ModulesExample: Serial Mouse Compiling Kernel ModulesIOCTL Conventions More about Kernel ModulesImplementing IOCTLs Review of Kernel StructuresLockless IOCTLs Device Driver DesignSleeping Interacting with Character Device DriversWait Queues Interacting with Block Device DriversWait Queues Interacting with Network Interface CardsVariations on wait_event() Device NodesSleeping in System Calls Character Device Drivers: RegistrationMultiplexed I/O The Device Node ProblemPolling File OperationsManaging Exclusive Access Defining File OperationsI/O Ports Registering File OperationsI/O Memory Buffers File I/O ConventionsAccessing I/O Memory Buffers The sysfs filesystemUserspace Drivers Device Model StructuresInitializing DMA Tying it all TogetherCoherent Allocations Netlink Sockets and User EventsStreaming DMA Mappings Userspace event agentsPCI Configuration Space Device RegistrationPCI Driver Registration Miscellaneous DevicesRegistering PCI Drivers Handling InterruptsDriver Probe Function Interrupt StructuresInitializing PCI devices ISR RegistrationReleasing a PCI Device System ContextManaging PCI Resources SoftirqsAccessing Configuration Space Deferred Activity: TaskletsListing PCI Devices Deferred Activity: Work QueuesUSB Descriptors Custom Work QueuesUSB Transfer Types Example: Serial MouseLinux USB Implementation IOCTL ConventionsUSB Drivers Implementing IOCTLsUSB Registration Lockless IOCTLsInitializing USB Interfaces SleepingUSB Class Drivers Wait QueuesUSB Request Blocks Wait QueuesUsing USB request blocks Variations on wait_event()Synchronous USB Requests Sleeping in System CallsMore information Multiplexed I/ONetwork Devices PollingNetwork Device Callback Functions Managing Exclusive AccessNetwork Driver Initialization I/O PortsNetwork Driver Transmission Queue Control I/O Memory BuffersNetwork Statistics Accessing I/O Memory BuffersSocket Buffers (Packets) Userspace DriversSocket Buffer API Initializing DMATransmission Coherent AllocationsReception Streaming DMA MappingsExample Implementations PCI Configuration SpaceI/O Scheduling PCI Driver RegistrationLinux 2.6 Elevator Functions Registering PCI DriversBlock Device Driver Implementation Driver Probe FunctionBlock Device Registration Initializing PCI devicesBlock Device File Operations Releasing a PCI DeviceThe gendisk structure Managing PCI ResourcesRequest Queues Accessing Configuration SpaceInitialization Example Listing PCI DevicesHandling Requests USB Descriptors

USB Transfer TypesLinux USB ImplementationUSB DriversUSB RegistrationInitializing USB InterfacesUSB Class DriversUSB Request Blocks


Using USB request blocksSynchronous USB RequestsMore informationNetwork DevicesNetwork Device Callback FunctionsNetwork Driver InitializationNetwork Driver Transmission QueueControlNetwork StatisticsSocket Buffers (Packets)Socket Buffer APITransmissionReceptionExample ImplementationsI/O SchedulingLinux 2.6 Elevator FunctionsBlock Device Driver ImplementationBlock Device RegistrationBlock Device File OperationsThe gendisk structureRequest QueuesInitialization ExampleHandling Requests

Further Information:

For More information, or to book your course, please call us on 00 966 92000 9278

[email protected]

www.globalknowledge.com/en-sa/

Global Knowledge - KSA, 393 Al-Uroubah Road, Al Worood, Riyadh 3140, Saudi Arabia

http://www.globalknowledge.com/en-sa/

red hat enterprise linux kernel device...

Documents