D

daemons, The Hello World Module, printk, How Messages Get Logged

klogd, The Hello World Module, printk

syslogd, How Messages Get Logged

data, Assigning an Explicit Size to Data Items, Data Alignment, Direct Memory Access–Talking to the DMA controller, The Physical Transport of Packets

explicitly sizing, Assigning an Explicit Size to Data Items

physical packet transport, The Physical Transport of Packets

transferring with DMA, Direct Memory Access–Talking to the DMA controller

unaligned, portability and, Data Alignment

data attribute (firmware), How It Works

data functions (USB), Other USB Data Functions

data structures, Some Important Data Structures, File Operations–File Operations, Data Alignment

file operations, File Operations–File Operations

portability of, Data Alignment

data types, Use of Standard C Types, Use of Standard C Types, Use of Standard C Types, Use of Standard C Types, Assigning an Explicit Size to Data Items, Assigning an Explicit Size to Data Items, Assigning an Explicit Size to Data Items, Interface-Specific Types, Interface-Specific Types

for explicitly sizing data, Assigning an Explicit Size to Data Items

inptr_t (C99 standard), Use of Standard C Types

int, Use of Standard C Types

interface-specific, Interface-Specific Types

loose typing for I/O functions, Interface-Specific Types

mixing different, Use of Standard C Types

standard C types, Use of Standard C Types

u8, u16, u32, u64, Assigning an Explicit Size to Data Items

uint8_t/unit32_t, Assigning an Explicit Size to Data Items

dataalign program, Data Alignment

datasize program, Use of Standard C Types

dd utility and scull driver example, scull's Memory Usage

deadline schedulers (I/O), Request Queues

deadlocks avoiding, Spinlocks, Lock Ordering Rules

(see also locking)

debugging, Concurrency in the Kernel, Debugging Support in the Kernel–Debugging Support in the Kernel, Debugging Support in the Kernel, Debugging by Printing–Printing Device Numbers, Turning the Messages On and Off, Turning the Messages On and Off, Debugging by Querying–The ioctl Method, The ioctl Method, The ioctl Method, Debugging by Watching, Debugging System Faults, System Hangs, System Hangs, Debuggers and Related Tools, The kgdb Patches, The User-Mode Linux Port, The Linux Trace Toolkit, Dynamic Probes, Handler Arguments and Return Value

(see also troubleshooting)

concurrency, Concurrency in the Kernel

using a debugger, Debuggers and Related Tools

using Dynamic Probes, Dynamic Probes

interrupt handlers, Handler Arguments and Return Value

with ioctl method, The ioctl Method

kernels, Debugging Support in the Kernel–Debugging Support in the Kernel, Debugging by Printing–Printing Device Numbers, Debugging by Querying–The ioctl Method, Debugging by Watching

monitoring, Debugging by Watching

by printing, Debugging by Printing–Printing Device Numbers

by querying, Debugging by Querying–The ioctl Method

support, Debugging Support in the Kernel–Debugging Support in the Kernel

using kgdb, The kgdb Patches

levels (implementation of), Turning the Messages On and Off

using LTT, The Linux Trace Toolkit

locked keyboard, System Hangs

by printing, Turning the Messages On and Off

by querying, The ioctl Method

system faults, Debugging System Faults

system hangs, System Hangs

using User-Mode Linux, The User-Mode Linux Port

declaration of array parameters, Module Parameters

DECLARE_TASKLET macro, Tasklets

default attributes (kobjects), Default Attributes

default_attrs field (kobjects), Default Attributes

DEFAULT_CONSOLE_LOGLEVEL, printk

DEFAULT_MESSAGE_LOGLEVEL, printk

delaying execution of code, Delaying Execution–Short Delays, Delays

deleting, Creating your /proc file, Nondefault Attributes, Symbolic Links, Bus attributes, Remove a Device, Remove a Driver, Setting up streaming DMA mappings, Queue creation and deletion

attributes, Nondefault Attributes, Bus attributes

devices, Remove a Device

drivers, Remove a Driver

mappings (DMA), Setting up streaming DMA mappings

/proc files, Creating your /proc file

queues, Queue creation and deletion

symbolic links, Symbolic Links

del_timer_sync function, The Timer API

dentry field (file structure), The file Structure

dependency, Version Dependency, Platform Dependency

platform, Platform Dependency

version, Version Dependency

dereferencing memory addresses, Use of Standard C Types

descriptors (USB), Other USB Data Functions

design, The Role of the Device Driver, The Design of scull, The Design of scull, Concurrency and Its Management–Concurrency and Its Management

(see also configuration)

concurrency, Concurrency and Its Management–Concurrency and Its Management

policy-free drivers, The Role of the Device Driver

of scull, The Design of scull

desktops, PCI Drivers, USB Drivers

PCI, PCI Drivers (see PCI)

USB, USB Drivers (see USB)

destroying urbs (USB), Creating and Destroying Urbs

destructor function (kmem_cache_create), Lookaside Caches

/dev directory, Major and Minor Numbers

/dev nodes, Classes of Devices and Modules, Major and Minor Numbers, Dynamic Allocation of Major Numbers, Installing an Interrupt Handler, Installing an Interrupt Handler

char devices and, Major and Minor Numbers

/dev/random device, Installing an Interrupt Handler

/dev/urandom device, Installing an Interrupt Handler

dynamic major number allocation, Dynamic Allocation of Major Numbers

/dev tree, udev

development community (kernel), joining, Joining the Kernel Development Community

development kernels, Version Numbering

device attribute (firmware), How It Works

DEVICE variable, USB

deviceID register (PCI), Configuration Registers and Initialization

devices, Splitting the Kernel, The Design of scull, Major and Minor Numbers, Major and Minor Numbers, The Internal Representation of Device Numbers, Allocating and Freeing Device Numbers, Allocating and Freeing Device Numbers, Dynamic Allocation of Major Numbers, Dynamic Allocation of Major Numbers, File Operations, The Older Way, The open Method, read and write, Printing Device Numbers, Concurrency and Its Management–Concurrency and Its Management, ioctl–Device Control Without ioctl, Device Control Without ioctl, A Blocking I/O Example–Testing the Scullpipe Driver, Reading data from the device, Writing to the device, Seeking a Device, Access Control on a Device File, Single-Open Devices, Single-Open Devices, Single-Open Devices, Cloning the Device on open, Hardware Resources, USB Drivers, The Linux Device Model–The Linux Device Model, The Linux Device Model, The Linux Device Model, Kobjects, Ksets, and Subsystems–Subsystems, Low-Level Sysfs Operations–Symbolic Links, Hotplug Event Generation, Buses–Bus attributes, Iterating over devices and drivers, Devices–Driver structure embedding, Device registration, Device attributes, Device structure embedding, Device Drivers, Classes–Class interfaces, Class devices, Putting It All Together–Remove a Driver, Add a Device, Remove a Device, Hotplug–udev, Dynamic Devices, Networking, Input, SCSI, Dealing with Firmware–How It Works, Buses, Devices, and Drivers, Using remap_pfn_range, Network Drivers, Device Registration, Initializing Each Device, The Device Methods, The Device Methods

(see also drivers)

access to files, Access Control on a Device File

adding, Add a Device

allocation of numbers, Allocating and Freeing Device Numbers

attributes, Device attributes

caching problems, Using remap_pfn_range

char drivers, The Older Way (see char drivers)

classes of, The Linux Device Model, Class devices

cloning, Cloning the Device on open

concurrency, Concurrency and Its Management–Concurrency and Its Management

control operations, Splitting the Kernel

deleting, Remove a Device

drivers, Device Drivers

dynamic, Dynamic Devices

dynamic allocation of major numbers, Dynamic Allocation of Major Numbers

FIFO, The Design of scull

file operations on, File Operations

files, Major and Minor Numbers

functions, Buses, Devices, and Drivers

hotpluggable, The Linux Device Model

identifying type with ls command, Major and Minor Numbers

initialization, Initializing Each Device

input (hotplugging), Input

internal representation of numbers, The Internal Representation of Device Numbers

ioctl method, ioctl–Device Control Without ioctl

ISA, Hardware Resources

iteration, Iterating over devices and drivers

Linux device model, The Linux Device Model–The Linux Device Model, Kobjects, Ksets, and Subsystems–Subsystems, Low-Level Sysfs Operations–Symbolic Links, Hotplug Event Generation, Buses–Bus attributes, Devices–Driver structure embedding, Classes–Class interfaces, Putting It All Together–Remove a Driver, Hotplug–udev, Dealing with Firmware–How It Works

buses, Buses–Bus attributes

classes, Classes–Class interfaces

firmware, Dealing with Firmware–How It Works

hotplug events, Hotplug Event Generation

hotplugging, Hotplug–udev

kobjects, Kobjects, Ksets, and Subsystems–Subsystems

lifecycles, Putting It All Together–Remove a Driver

low-level sysfs operations, Low-Level Sysfs Operations–Symbolic Links

methods, The Device Methods

names of, Dynamic Allocation of Major Numbers

network, Networking

network drivers, Network Drivers

numbers (printing), Printing Device Numbers

operations, The Device Methods

reading and writing, read and write

reading data from, Reading data from the device

registration, Device registration, Device Registration

SCSI, SCSI

scullpipe (example), A Blocking I/O Example–Testing the Scullpipe Driver

scullsingle, Single-Open Devices

seeking, Seeking a Device

single-open, Single-Open Devices, Single-Open Devices

structures (embedding), Device structure embedding

truncating on open, The open Method

USB, USB Drivers (see USB)

writing, Device Control Without ioctl, Writing to the device

control sequences to, Device Control Without ioctl

data to, Writing to the device

DEVPATH variable, The /sbin/hotplug Utility

dev_alloc_skb function, Functions Acting on Socket Buffers

dev_id pointer (installing shared handlers), Installing a Shared Handler

dev_kfree_skb function, The Interrupt Handler, Functions Acting on Socket Buffers

dev_mc_list structure, Kernel Support for Multicasting

dev_t i_rdev (inode structure field), The inode Structure

direct I/O, Performing Direct I/O–An asynchronous I/O example, Performing Direct I/O, Implementing Direct I/O

(see also I/O)

implementation, Implementing Direct I/O

direct memory access, Memory Mapping and DMA (see DMA)

directories, Kernel Modules Versus Applications, Major and Minor Numbers, The file Structure, Redirecting Console Messages, Creating your /proc file, Testing the Scullpipe Driver, USB and Sysfs–USB and Sysfs, Low-Level Sysfs Operations–Symbolic Links, TTY Drivers, struct termios, proc and sysfs Handling of TTY Devices

/dev, Major and Minor Numbers

entries (file structure), The file Structure

of kernel headers, Kernel Modules Versus Applications

misc-progs source, Redirecting Console Messages, Testing the Scullpipe Driver

/proc file hierarchy connections, Creating your /proc file

/proc/tty/driver, TTY Drivers

sysfs, USB and Sysfs–USB and Sysfs, Low-Level Sysfs Operations–Symbolic Links, struct termios

low-level operations, Low-Level Sysfs Operations–Symbolic Links

tty driver, struct termios

USB, USB and Sysfs–USB and Sysfs

tty drivers, proc and sysfs Handling of TTY Devices

*dir_notify method, File Operations

disable_dma function, Talking to the DMA controller

disable_irq function, Installing a Shared Handler

disabling, Turning the Messages On and Off, Enabling and Disabling Interrupts, Controlling Transmission Concurrency

interrupt handlers, Enabling and Disabling Interrupts

packet transmissions, Controlling Transmission Concurrency

print statements, Turning the Messages On and Off

disclosure of data, Security Issues

disconnect function (USB), Registering a USB Driver, probe and disconnect in Detail

disks, The file Structure, Disk Registration, The gendisk structure

files versus open files, The file Structure

freeing, The gendisk structure

registration, Disk Registration

distribution, writing drivers for, Platform Dependency

DMA (direct memory access), Direct Memory Access, Direct Memory Access, Overview of a DMA Data Transfer, Scatter/gather mappings, A simple PCI DMA example, Registering DMA usage, Direct Memory Access, Block requests and DMA

block requests and, Block requests and DMA

mappings (scatter-gather), Scatter/gather mappings

PCI devices and, A simple PCI DMA example

registering usage, Registering DMA usage

ring buffers, Overview of a DMA Data Transfer

DMA-capable memory zone, Memory zones, Lookaside Caches

SLAB_CACHE_DMA flag and, Lookaside Caches

dma.h header file, Registering DMA usage

DMAC (DMA controller), DMA for ISA Devices

dma_addr_t setup_dma field (USB), struct urb

dma_addr_t transfer_dma field (USB), struct urb

DMA_BIDIRECTIONAL symbol, Setting up streaming DMA mappings, Direct Memory Access

dma_free_coherent function, Setting up coherent DMA mappings

DMA_FROM_DEVICE symbol, Setting up streaming DMA mappings, Setting up streaming DMA mappings, Direct Memory Access

DMA_NONE symbol, Setting up streaming DMA mappings, Direct Memory Access

dma_spin_lock, Talking to the DMA controller

DMA_TO_DEVICE symbol, Setting up streaming DMA mappings, Direct Memory Access

dmesg command, printk

do-it-yourself probing, Do-it-yourself probing

double underscore (__) functions, A Few Other Details

double-address cycle mappings (PCI), PCI double-address cycle mappings

doubly linked lists (portability), Linked Lists, Quick Reference

down function, The Linux Semaphore Implementation

do_close function, open and close

do_gettimeofday function, Knowing the Current Time

do_ioctl method, The Device Methods, Custom ioctl Commands

do_IRQ function, The internals of interrupt handling on the x86

drivers, The Role of the Device Driver, The Role of the Device Driver–The Role of the Device Driver, Classes of Devices and Modules, Classes of Devices and Modules, Classes of Devices and Modules, Classes of Devices and Modules, Security Issues, Doing It in User Space, The Design of scull, File Operations, Concurrency and Race Conditions, Choosing the ioctl Commands, Device Control Without ioctl, The Driver's Point of View, A scull Based on the Slab Caches: scullc, A scull Using Whole Pages: scullp, A scull Using Virtual Addresses: scullv, Quick Reference, A Sample Driver, Reusing short for I/O Memory, Installing an Interrupt Handler, Do-it-yourself probing, Implementing a Handler, A Write-Buffering Example–A Write-Buffering Example, Bus methods, Iterating over devices and drivers, Device Drivers, Driver structure embedding, Driver structure embedding, Add a Driver, Remove a Driver, Buses, Devices, and Drivers, Block Drivers, Initialization in sbull, A Simple request Method, Network Drivers, How snull Is Designed–The Physical Transport of Packets, Connecting to the Kernel–Utility Fields, Opening and Closing–Opening and Closing, The Interrupt Handler, Changes in Link State, MAC Address Resolution–Non-Ethernet Headers, Custom ioctl Commands, Statistical Information, Multicast–A Typical Implementation, Quick Reference–Quick Reference, TTY Drivers–A Small TTY Driver, struct termios–struct termios, tty_driver Function Pointers–No read Function?, Other Buffering Functions, TTY Line Settings, proc and sysfs Handling of TTY Devices, The tty_driver Structure in Detail, The tty_operations Structure in Detail, The tty_struct Structure in Detail, Quick Reference

adding, Add a Driver

asynchronous notification and, The Driver's Point of View

attributes, Driver structure embedding

block, Block Drivers (see block drivers)

command-oriented, Device Control Without ioctl

deleting, Remove a Driver

devices, Device Drivers

file operations, File Operations

FireWire, Classes of Devices and Modules

functions, Buses, Devices, and Drivers

I2O, Classes of Devices and Modules

ioctl numbers for, Choosing the ioctl Commands

iteration, Iterating over devices and drivers

lddbus, Bus methods

mechanism, The Role of the Device Driver, The Role of the Device Driver–The Role of the Device Driver, The Design of scull

policy versus, The Role of the Device Driver

separation from policies, The Role of the Device Driver–The Role of the Device Driver

modules, Classes of Devices and Modules

network, Network Drivers, How snull Is Designed–The Physical Transport of Packets, Connecting to the Kernel–Utility Fields, Opening and Closing–Opening and Closing, The Interrupt Handler, Changes in Link State, MAC Address Resolution–Non-Ethernet Headers, Custom ioctl Commands, Statistical Information, Multicast–A Typical Implementation, Quick Reference–Quick Reference

connecting to kernels, Connecting to the Kernel–Utility Fields

functions, Quick Reference–Quick Reference

interrupt handlers for, The Interrupt Handler

ioctl commands, Custom ioctl Commands

link state (changes in), Changes in Link State

MAC addresses (resolution of), MAC Address Resolution–Non-Ethernet Headers

multicasting, Multicast–A Typical Implementation

opening, Opening and Closing–Opening and Closing

snull, How snull Is Designed–The Physical Transport of Packets

statistics, Statistical Information

sbull, Initialization in sbull, A Simple request Method

initialization, Initialization in sbull

request method, A Simple request Method

SCSI, Classes of Devices and Modules

scull, Concurrency and Race Conditions (see scull)

scullc (example), A scull Based on the Slab Caches: scullc

scullp (example), A scull Using Whole Pages: scullp

scullv (example), A scull Using Virtual Addresses: scullv, Quick Reference

security issues, Security Issues

short (example), A Sample Driver, Reusing short for I/O Memory, Installing an Interrupt Handler, Do-it-yourself probing, Implementing a Handler

accessing I/O memory, Reusing short for I/O Memory

implementing interrupt handlers, Implementing a Handler

installing interrupt handlers, Installing an Interrupt Handler

probing, Do-it-yourself probing

shortprint, A Write-Buffering Example–A Write-Buffering Example

structures (embedding), Driver structure embedding

tty, TTY Drivers–A Small TTY Driver, struct termios–struct termios, tty_driver Function Pointers–No read Function?, Other Buffering Functions, TTY Line Settings, proc and sysfs Handling of TTY Devices, The tty_driver Structure in Detail, The tty_operations Structure in Detail, The tty_struct Structure in Detail, Quick Reference

buffers, Other Buffering Functions

directories, proc and sysfs Handling of TTY Devices

functions, Quick Reference

line settings, TTY Line Settings

pointers, tty_driver Function Pointers–No read Function?

struct termios, struct termios–struct termios

tty_driver structure, The tty_driver Structure in Detail

tty_operations structure, The tty_operations Structure in Detail

tty_struct structure, The tty_struct Structure in Detail

user-space, Doing It in User Space

DRIVER_ATTR macro, Driver structure embedding

driver_unregister function, Remove a Driver

dynamic devices, Dynamic Devices

Dynamic Probes debugging tool, Dynamic Probes