Index

Symbols

16-bit hardware addresses (PCI), PCI Addressing
16-bit PCI registers, Configuration Registers and Initialization
16-bit ports, Using I/O Ports
string functions for, String Operations
32-bit addresses
PCI bus I/O and memory space, PCI Addressing
32-bit PCI registers, Accessing the I/O and Memory Spaces, Peeking at the base address registers, Peeking at the base address registers
32-bit ports, Using I/O Ports
accessing, Using I/O Ports
string functions for, String Operations
64-bit addresses
accessing PCI bus memory space, PCI Addressing
64-bit programmable decoder, Peeking at the base address registers
64-bit regions and PCI registers, Accessing the I/O and Memory Spaces
8-bit ports, Using I/O Ports
reading/writing, Using I/O Ports
string functions for, String Operations

A

access
blocking open requests, Blocking open as an Alternative to EBUSY
cloning devices on open, Cloning the Device on Open, Cloning the Device on Open
concurrent (see race conditions)
to device files, Access Control on a Device File, Cloning the Device on Open
to drivers, Dynamic Allocation of Major Numbers
to expansion board memory, Using I/O Memory, Probing for ISA Memory
PCI configuration space, Accessing the Configuration Space, Looking at a configuration snapshot
restricting
to simultaneous users, Restricting Access to a Single User at a Time
via capabilities, Capabilities and Restricted Operations
to user space in Linux 2.0, Access to User Space in Linux 2.0, Access to User Space in Linux 2.0
access_ok(), Using the ioctl Argument
active queue heads, The active queue head
Address Resolution Protocol (see ARP)
address types, Address Types
addresses
bus (see bus addresses)
hardware (see hardware addresses)
PCI, PCI Addressing, PCI Addressing
for peripheral boards, PCI Addressing
Plug and Play, The Plug-and-Play Specification
resolving, MAC Address Resolution, Non-Ethernet Headers
add_timer(), Kernel Timers, Kernel Timers, Quick Reference
__add_wait_queue(), Going to Sleep Without Races, Quick Reference
add_wait_queue(), Quick Reference, Going to Sleep Without Races, Quick Reference
add_wait_queue_exclusive(), A Deeper Look at Wait Queues, Quick Reference
Adelson-Velski-Landis (AVL) tree, The mm Directory
alias directive (modprobe), The User-Space Side
aliases for device names, The open Method
alignment, data, Data Alignment
allocate_resource structure, Resource Allocation in Linux 2.4
allocating
DMA buffers, Allocating the DMA Buffer, Do-it-yourself allocation
major device numbers, Dynamic Allocation of Major Numbers, Dynamic Allocation of Major Numbers
memory, Using Resources, scull’s Memory Usage, scull’s Memory Usage
at boot time, Boot-Time Allocation, Reserving High RAM Addresses
determining how much, The Size Argument
kmalloc for, The Real Story of kmalloc, The Size Argument
by page, get_free_page and Friends, A scull Using Whole Pages: scullp
vmalloc for, vmalloc and Friends, A scull Using Virtual Addresses: scullv
ports, I/O Ports and I/O Memory, Resource Allocation in Linux 2.4
resources in Linux 2.4, Resource Allocation in Linux 2.4
socket buffers, Packet Reception, Functions Acting on Socket Buffers
allocator module, Reserving High RAM Addresses
alloc_bootmem(), Acquiring a Dedicated Buffer at Boot Time, Quick Reference
alloc_bootmem_low(), Acquiring a Dedicated Buffer at Boot Time, Quick Reference
alloc_bootmem_low_pages(), Acquiring a Dedicated Buffer at Boot Time, Quick Reference
alloc_bootmem_pages(), Acquiring a Dedicated Buffer at Boot Time, Quick Reference
alloc_kiovec(), The kiobuf Structure, Quick Reference
map_user_kiobuf and, Mapping User-Space Buffers and Raw I/O
alloc_skb(), Functions Acting on Socket Buffers, Quick Reference
Alpha architecture
I/O memory management support, How different architectures support PCI DMA
porting and, Platform Dependencies
alpha_machine_vector structure, Hardware Abstractions
analyzing crash dumps, Kernel Crash Dump Analyzers
applications vs. kernel modules, Kernel Modules Versus Applications, The Current Process
arch directory, include and arch
ARM architecture
layout of boot code, Before Booting
PCI DMA interface support, How different architectures support PCI DMA
porting and, Platform Dependencies
ARP (Address Resolution Protocol)
Ethernet and, Using ARP with Ethernet
IFF_NOARP flag and, Initializing Each Device, Interface information
overriding, Overriding ARP
asm directory, Kernel Modules Versus Applications
<asm/atomic.h> header file, Atomic integer operations, Quick Reference
<asm/bitops.h> header file, Bit operations, Quick Reference
<asm/byteorder.h> header file, Byte Order, Quick Reference
<asm/current.h> header file, The Current Process
<asm/dma.h> header file, Registering DMA usage, Talking to the DMA controller, Quick Reference
<asm/io.h> header file, Quick Reference, Quick Reference
accessing I/O ports, Using I/O Ports
converting between bus/virtual addresses, Bus Addresses
<asm/ioctl.h> header file, Choosing the ioctl Commands
<asm/irq.h> header file, Do-it-yourself probing, Enabling and Disabling Interrupts
<asm/msr.h> header file, Processor-Specific Registers, Quick Reference
<asm/page.h> header file, Page Size, Quick Reference, Address Types, Page Tables
<asm/pcibios.h> header file, Backward Compatibility
<asm/pgtable.h> header file, vmalloc and Friends, Page Tables
<asm/processor.h> header file, MCA
<asm/sbus.h> header file, A quick look at SBus
<asm/segment.h> header file, Quick Reference
<asm/semaphore.h> header file, A Brief Introduction to Race Conditions, Quick Reference
<asm/system.h> header file, I/O Registers and Conventional Memory, Quick Reference
<asm/types.h> header file, Assigning an Explicit Size to Data Items
<asm/uaccess.h> header file, read and write, Quick Reference, Using the ioctl Argument, Quick Reference
<asm/unaligned.h> header file, Data Alignment, Quick Reference
assembly language dump of code, Using ksymoops
asynchronous DMA, Overview of a DMA Data Transfer
asynchronous notification, Asynchronous Notification, The Driver’s Point of View
backward compatibility issues, Asynchronous Notification
drivers and, The Driver’s Point of View
asynchronous running of task queues, How Task Queues Are Run
atomic bit operations, Bit operations
backward compatibility issues, Further Differences in the 2.0 Kernel
atomic integer operations, Atomic integer operations
atomic.h header file, Atomic integer operations, Quick Reference
atomic_add(), Atomic integer operations, Quick Reference
atomic_add_and_test(), Atomic integer operations
atomic_dec(), Atomic integer operations, Quick Reference
atomic_dec_and_test(), Atomic integer operations, Quick Reference
atomic_inc(), Atomic integer operations, Quick Reference
atomic_inc_and_test(), Atomic integer operations
atomic_read(), Atomic integer operations
atomic_set(), Atomic integer operations
atomic_sub(), Atomic integer operations, Quick Reference
atomic_sub_and_test(), Atomic integer operations
atomic_t data type, Atomic integer operations
autoconf.h header file, Using Version Support in Modules
autodetecting parameter values, Automatic and Manual Configuration
autoirq_report(), Kernel-assisted probing
autoirq_setup(), Kernel-assisted probing
automatic
device parameters detection, Automatic and Manual Configuration
driver configuration, Automatic and Manual Configuration
IRQ number detection, Autodetecting the IRQ Number, Do-it-yourself probing
shared interrupts and, Installing a Shared Handler
module loading/unloading, Loading Modules on Demand, Running User-Mode Helper Programs
AVL (Adelson-Velski-Landis) tree, The mm Directory

B

backward compatibility
access to user space, Access to User Space in Linux 2.0, Access to User Space in Linux 2.0
asynchronous notification, Asynchronous Notification
block drivers, Backward Compatibility, Backward Compatibility
capabilities, Capabilities in 2.0
compiling for multiprocessor systems, Compiling for Multiprocessor Systems
demand-loading capability, Backward Compatibility
DMA (direct memory access), Changes to DMA
exporting symbols, Exporting Symbols in Linux 2.0, Module Configuration Parameters
file_operations structure, Changes in the File Operations Structure, The Module Usage Count
fsync method, The fsync Method
hardware management, Backward Compatibility
interrupt handling, Backward Compatibility
memory management, Changes to Memory Management, Changes to Memory Management
programming interface, Backward Compatibility
module configuration parameters, Module Configuration Parameters
module usage count, The Module Usage Count
networking, Backward Compatibility, Probing and HAVE_DEVLIST
peripheral buses, Backward Compatibility
resource management, Changes in Resource Management
seeking, Seeking in Linux 2.0
select method in Linux version 2.0, The Linux 2.0 select Method
semaphore support, Changes in Semaphore Support
task queues/timing issues, Backward Compatibility
user space, access to, Changes in Access to User Space
wait queues, Wait Queues in Linux 2.2 and 2.0
barrier(), I/O Registers and Conventional Memory, Quick Reference
base address registers, Peeking at the base address registers, Peeking at the base address registers
base module parameter, A Sample Driver
base name, device, The Generic Hard Disk
bdops (see block_device_operations structure)
bfd (binary format description) library and ksymoops, Using ksymoops
BH (see bottom halves)
bh->b_end_io(), How the blk.h macros and functions work, Quick Reference
clustered I/O, Clustered Requests
“make request” function and, Doing Without the Request Queue
bibliography, Bibliography
big-endian byte order, Byte Order
bigphysarea patch, The bigphysarea Patch
__BIG_ENDIAN symbol, Byte Order, Quick Reference
binary format description (bfd) library and ksymoops, Using ksymoops
binary formats, The fs Directory
binfmt_elf.c file, The fs Directory
bit operations, Bit operations
backward compatibility issues, Further Differences in the 2.0 Kernel
bit specifications, An Overview of the Parallel Port
bit splitting and minor numbers, The open Method
bitfields, defining ioctl commands, Choosing the ioctl Commands, Quick Reference
bitops.h header file, Bit operations, Quick Reference
bits, clearing, Implementing a Handler
blk.h header file, The Header File blk.h, The Header File blk.h, Quick Reference
clustered requests and, Clustered Requests
declaring DEVICE_NR first, The Device Methods for spull
how macros and functions work, How the blk.h macros and functions work
blkdev.h header file, Registering the Driver, Quick Reference
blkdev_dequeue_request(), Request queue manipulation, Quick Reference
end_request() and, How the blk.h macros and functions work
blkdev_entry_next_request(), Request queue manipulation, Quick Reference
blkdev_next_request(), Request queue manipulation, Quick Reference
blkdev_prev_request(), Request queue manipulation, Quick Reference
blkdev_release_request(), Request queue manipulation, Quick Reference
BLKELVGET command, The ioctl Method
BLKELVSET command, The ioctl Method
BLKFLSBUF command, The ioctl Method
BLKFRAGET command, The ioctl Method
BLKFRASET command, The ioctl Method
BLKGETSIZE command, The ioctl Method, The Device Methods for spull
BLKPG command, The ioctl Method
blkpg.c file, drivers/block
blkpg.h header file, The ioctl Method
BLKRAGET command, The ioctl Method
BLKRASET command, The ioctl Method
BLKROGET command, The ioctl Method
BLKROSET command, The ioctl Method
BLKRRPART command, The ioctl Method, The Device Methods for spull
BLKSECTGET command, The ioctl Method
BLKSECTSET command, The ioctl Method
blksize_size global array, Registering the Driver, Quick Reference
BLKSSZGET command, The ioctl Method
blk_cleanup_queue(), Registering the Driver, Quick Reference
BLK_DEFAULT_QUEUE macro, Registering the Driver, Quick Reference
blk_dev global array, Registering the Driver, Backward Compatibility, Quick Reference
blk_dev_struct structure, Registering the Driver
blk_init_queue(), Registering the Driver, Quick Reference
initializing device-specific queues, Multiqueue Block Drivers
blk_ioctl(), The ioctl Method, Quick Reference, drivers/block
backward compatibility issues, Backward Compatibility
blk_queue_headactive(), The active queue head, Quick Reference
blk_queue_make_request(), Doing Without the Request Queue, Quick Reference
blk_size global array, Registering the Driver, Quick Reference
sizes array and, The Generic Hard Disk
block drivers, Classes of Devices and Modules
<linux/blk.h> header file (see blk.h header file)
arrays for information about, Registering the Driver
backward compatibility, Backward Compatibility, Backward Compatibility
generic hard disk support, The Generic Hard Disk
handling requests, Handling Requests: A Simple Introduction, Doing Without the Request Queue
interrupt-driven, Interrupt-Driven Block Drivers, Interrupt-Driven Block Drivers
ioctl method and, The ioctl Method, The ioctl Method
io_request_lock and, The I/O request lock
loading/unloading, Loading Block Drivers, Extra Care
mounting devices, How Mounting and Unmounting Works
multiqueue, Multiqueue Block Drivers, Multiqueue Block Drivers
partitionable devices and, Partitionable Devices, The Device Methods for spull
raw I/O capability, Mapping User-Space Buffers and Raw I/O
registering/unregistering, Registering the Driver, Registering the Driver
removable block devices, Removable Devices, Extra Care
vs. char drivers, Loading Block Drivers
blocking I/O operations, Blocking I/O, A Sample Implementation: scullpipe
blocking open requests, Blocking open as an Alternative to EBUSY
testing, A Sample Implementation: scullpipe
block_dev.c file, The fs Directory
block_device_operations structure, Registering the Driver
backward compatibility issues, Backward Compatibility
I/O operations, Registering the Driver
removable devices, Removable Devices
block_fsync method, Flushing pending output, Registering the Driver
BogoMips value, Short Delays
books
Linux kernel, Bibliography
Unix design/internals, Bibliography
booting
acquiring a dedicated buffer at, Acquiring a Dedicated Buffer at Boot Time
allocating memory while, Boot-Time Allocation, Reserving High RAM Addresses
kernels, Booting the Kernel, Booting the Kernel
(non)modularized drivers and, Modularized and Nonmodularized Drivers
PCI and, Boot Time
what happens before, Before Booting, Before Booting
bootmem.h header file, Acquiring a Dedicated Buffer at Boot Time, Quick Reference
bottom halves
BH mechanism, The BH Mechanism
of interrupt handlers, Tasklets and Bottom-Half Processing, Writing a BH Bottom Half
marking, The BH Mechanism
task queues, The Nature of Task Queues, The immediate queue
tasklets and, Tasklets, Tasklets, Tasklets
writing, Writing a BH Bottom Half
bounce buffers, DMA mappings
architectures not supporting, How different architectures support PCI DMA
streaming DMA mappings and, Setting up streaming DMA mappings
bridge subdirectory, The net directory
bridges for PCI systems, PCI Addressing
ignored by pcidata module, Looking at a configuration snapshot
BSS segments, Virtual Memory Areas
buffer cache and request structure, The request structure and the buffer cache
buffer.c file, The fs Directory
buffering and interrupt-driven I/O, Interrupt-Driven I/O
buffers
buffer overruns, Oops Messages
DMA, Allocating the DMA Buffer, Do-it-yourself allocation
for printk(), How Messages Get Logged
in request queues, The request structure and the buffer cache
socket (see socket buffers)
user-space and raw I/O, Mapping User-Space Buffers and Raw I/O, Mapping User-Space Buffers and Raw I/O
buffer_head structure, Performing the Actual Data Transfer
fields for, The request structure and the buffer cache
performing clustered I/O, Clustered Requests
bugs (see debugging; troubleshooting)
bus addresses, Address Types
converting between virtual addresses and, Bus Addresses
DMA-based hardware and, Bus Addresses
dma_addr_t type and, DMA mappings
bus architecture, Overview of Peripheral Buses, Quick Reference
backward compatibility issues, Backward Compatibility
device-specific directories, Bus-Specific Directories
ISA interface, A Look Back: ISA, The Plug-and-Play Specification
PC/104 and PC/104+, PC/104 and PC/104+
PCI interface, The PCI Interface, Hardware Abstractions
busy loops, Long Delays
busy waiting implementation, Long Delays
bus_to_virt(), Bus Addresses, Quick Reference
byte order
PCI registers and, Configuration Registers and Initialization, Accessing the Configuration Space
portability and, Byte Order
byteorder.h header file, Byte Order, Quick Reference
bzImage file, Before Booting
b_end_io(), How the blk.h macros and functions work, Quick Reference
clustered I/O, Clustered Requests
“make request” function and, Doing Without the Request Queue

C

caches, lookaside, Lookaside Caches, A scull Based on the Slab Caches: scullc
backward compatibility issues, Backward Compatibility
caching problems for devices, I/O Registers and Conventional Memory, Using remap_page_range
call_usermodehelper(), Running User-Mode Helper Programs, Quick Reference
capabilities
restricted operations and, Capabilities and Restricted Operations
testing for, using request_module, Requesting Modules in the Kernel
capability.h header file, Capabilities and Restricted Operations, Quick Reference
capable(), Capabilities and Restricted Operations, Quick Reference
CAP_DAC_OVERRIDE capability, Capabilities and Restricted Operations
single-user access to devices, Restricting Access to a Single User at a Time
CAP_NET_ADMIN capability, Capabilities and Restricted Operations
CAP_SYS_ADMIN capability, Capabilities and Restricted Operations
CAP_SYS_MODULE capability, Capabilities and Restricted Operations
CAP_SYS_RAWIO capability, Capabilities and Restricted Operations
CAP_SYS_TTY_CONFIG capability, Capabilities and Restricted Operations
Card Select Number (CSN), The Plug-and-Play Specification
cardctl program, The Role of the Device Driver
carrier signals, Changes in Link State
cdrom.c file, drivers/cdrom
cdrom_device_info structure, drivers/cdrom
CFLAGS variable (make), Compiling and Loading
change_bit(), Bit operations, Quick Reference
change_mtu method, The device methods
improving performance using socket buffers, Packet Reception
channels, DMA, DMA for ISA Devices, Registering DMA usage
char drivers, Classes of Devices and Modules, Char Drivers, Quick Reference
defining mechanism of, The Design of scull
version numbers, Major and Minor Numbers, dev_t and kdev_t
vs. block drivers, Loading Block Drivers
checksums
adding to symbol names, Version Control in Modules
building, Exporting Versioned Symbols
CHECKSUM_ symbols, Packet Reception
check_disk_change(), Extra Care, Quick Reference
check_media_change method, check_media_change
backward compatibility issues, Backward Compatibility
check_mem_region(), Quick Reference, Quick Reference
backward compatibility issues, Changes in Resource Management
working with I/O memory, Memory, Using I/O Memory
check_region(), Quick Reference, Quick Reference
backward compatibility issues, Changes in Resource Management
working with I/O ports, Ports, Using I/O Ports
circular buffers, Using Circular Buffers
implementing interrupt handlers, Implementing a Handler, Implementing a Handler
for printk(), How Messages Get Logged
claim_dma_lock(), Talking to the DMA controller, Quick Reference
class PCI register, Configuration Registers and Initialization
classes, module, Splitting the Kernel, Classes of Devices and Modules
cleanup_module(), Kernel Modules Versus Applications, Quick Reference
error handling and, Error Handling in init_module
network drivers and, Module Unloading
releasing ports, Ports
unregistering items, Unloading
using unique names instead of, Explicit Initialization and Cleanup Functions
clearing bits on interface board, Implementing a Handler
clear_bit(), Bit operations, Quick Reference
clear_dma_ff(), Talking to the DMA controller, Quick Reference
CLEAR_INTR macro, The Header File blk.h
cli(), Overall Control of Interrupts
clock cycles, counting, Processor-Specific Registers
clock ticks (see jiffies value)
cloning devices on open requests, Cloning the Device on Open, Cloning the Device on Open
close method, The release Method
(see also release method)
accessing data within partitions, The Device Methods for spull
adding VMA operations, Adding VMA Operations
after cloning devices on open, Cloning the Device on Open
for single-open devices, Single-Open Devices
vm_operations_struct structure, Virtual Memory Areas
closing network interface, Opening and Closing, Opening and Closing
clustered requests, Clustered Requests
code, delaying execution of, Delaying Execution, Short Delays
coding style, Compiling and Loading
collisions, device, I/O Ports and I/O Memory, Ports
command numbers, ioctl, Choosing the ioctl Commands, Choosing the ioctl Commands
command-line parsing, Booting the Kernel
command-oriented drivers, Device Control Without ioctl
compiler optimizations, I/O Registers and Conventional Memory
concurrency, Concurrency in the Kernel, Race Conditions, Going to Sleep Without Races
controlling transmission, Controlling Transmission Concurrency
multiqueue block drivers and, Multiqueue Block Drivers
concurrent access (see race conditions)
conditional compilation, avoiding, Portability Issues and devfs
config.h header file, Using Version Support in Modules, Quick Reference, Configuration Registers and Initialization, Quick Reference
configuration space, PCI, PCI Addressing, Accessing the Configuration Space, Looking at a configuration snapshot
configuration transactions, PCI, PCI Addressing
configuring
DMA controller, Talking to the DMA controller, Talking to the DMA controller
drivers, Automatic and Manual Configuration, Automatic and Manual Configuration
network devices, The device methods
PCI registers, Configuration Registers and Initialization, Configuration Registers and Initialization
CONFIG_DEVFS_FS, The Device Filesystem
portability issues and, Portability Issues and devfs
CONFIG_MODVERSIONS(), Using Version Support in Modules, Quick Reference
CONFIG_PCI(), Configuration Registers and Initialization, Quick Reference
CONFIG_SMP configuration option, Compiling for Multiprocessor Systems
consistent DMA mappings, DMA mappings
setting up, Setting up consistent DMA mappings
console.c file, drivers/char, drivers/video
consoles
drivers/char directory and, drivers/char
frame buffer consoles, drivers/video
selecting for messages, printk
wrong font on, Device Control Without ioctl
console_loglevel variable, printk
debugging system hangs, System Hangs
constructor function (kmem_cache_create), Lookaside Caches
controlling access (see access)
controlling-by-write, Device Control Without ioctl
converting virtual addresses, Bus Addresses
copying, cross-space, read and write
__copy_from_user, read and write, Quick Reference
copy_from_user(), read and write
memcpy_tofs and, Changes in Access to User Space
vmalloc() and, vmalloc and Friends
__copy_to_user, read and write, Quick Reference
copy_to_user(), read and write
memcpy_fromfs and, Changes in Access to User Space
using put_user() instead of, Using the ioctl Argument
core files, Using gdb
core-file (gdb command), Using gdb
core/skbuff.c file, The net directory
counter registers, Processor-Specific Registers
CPU modalities (levels), User Space and Kernel Space
__cpu_to_le32 macro, Byte Order, Quick Reference
crash dump analyzers, Kernel Crash Dump Analyzers
CRC (cyclic redundancy check) algorithm and module version control, Version Control in Modules
create_bounce(), Doing Without the Request Queue
create_module system call, Security Issues
using vmalloc() and, vmalloc and Friends
create_proc_read_entry(), Using the /proc Filesystem
cross compilation and platform dependency, Platform Dependency
cross-space copying, read and write
CSN (Card Select Number), The Plug-and-Play Specification
current process, The Current Process, Quick Reference
current time, retrieving, Knowing the Current Time
CURRENT(), The Request Queue, Quick Reference
accessing fields in request structure, Performing the Actual Data Transfer
current.h header file, The Current Process
currentime file (jit module), Knowing the Current Time
CURRENT_DEV macro, The Header File blk.h, Performing the Actual Data Transfer
current_nr_sectors field, Performing the Actual Data Transfer
custom
data types, Interface-Specific Types
ioctl methods for networking, Custom ioctl Commands
task queues, Running Your Own Task Queues
cycles_t type, Processor-Specific Registers

D

data
explicitly sizing, Assigning an Explicit Size to Data Items
physical packet transport, The Physical Transport of Packets, Packet Transmission, Packet Reception
protecting from race conditions, Race Conditions
transferring
for block driver requests, Performing the Actual Data Transfer, Performing the Actual Data Transfer
with DMA, Direct Memory Access and Bus Mastering, Talking to the DMA controller
using ioctl method, Choosing the ioctl Commands
unaligned, portability and, Data Alignment
data structures, portability of, Data Alignment
data types
for explicitly sizing data, Assigning an Explicit Size to Data Items
interface-specific, Interface-Specific Types
loose typing for I/O functions, Interface-Specific Types
mixing different, Use of Standard C Types
portability and, Judicious Use of Data Types, Interface-Specific Types
standard C types, Use of Standard C Types
dataalign program, Data Alignment
datasize program, Use of Standard C Types
dcache.c file, The fs Directory
dd utility and scull driver example, scull’s Memory Usage
deadlocks
avoiding, A Brief Introduction to Race Conditions
detecting with IKD, The Integrated Kernel Debugger Patch
deallocating (see allocating)
debugging, Debugging Techniques, Dynamic Probes
(see also troubleshooting)
using a debugger, Debuggers and Related Tools, Dynamic Probes
using Dynamic Probes, Dynamic Probes
using gdb, Using gdb, Using gdb
using IKD (integrated kernel debugger), The Integrated Kernel Debugger Patch
implementing debug levels, Turning the Messages On and Off
interrupt handling, Using Arguments
with ioctl method, The ioctl Method
using kdb kernel debugger, The kdb Kernel Debugger, The kdb Kernel Debugger
using kgdb, The kgdb Patch
using Linux Trace Toolkit (LTT), The Linux Trace Toolkit
locked keyboard, System Hangs
module loading, Version Dependency
modules, Using klogd, Using ksymoops
by printing, Debugging by Printing, Turning the Messages On and Off
with /proc filesystem, Using the /proc Filesystem, Using the /proc Filesystem
by querying, Debugging by Querying, The ioctl Method
race conditions, Race Conditions, Going to Sleep Without Races
system faults, Debugging System Faults, System Hangs
system hangs, System Hangs
using User-Mode Linux, The User-Mode Linux Port
by watching in user space, Debugging by Watching, Debugging by Watching
DECLARE_TASKLET, Tasklets, Quick Reference, Tasklets, Quick Reference
DECLARE_TASKLET_DISABLED, Tasklets, Quick Reference
DECLARE_TASK_QUEUE, The Nature of Task Queues, Running Your Own Task Queues, Quick Reference
DECLARE_WAIT_QUEUE_HEAD, Going to Sleep and Awakening
jiq module and , How the examples work
decoders, programmable, Peeking at the base address registers
decoding oops messages, Using klogd, Using ksymoops
DEFAULT_CONSOLE_LOGLEVEL, printk
DEFAULT_MESSAGE_LOGLEVEL, printk
delay.h header file, Short Delays, Quick Reference
delaying execution of code, Delaying Execution, Long Delays
delete_module system call, Unloading
del_timer(), Kernel Timers, Quick Reference
del_timer_sync(), Kernel Timers, Quick Reference
avoiding race conditions, Kernel Timers
backward compatibility issues, Backward Compatibility
demand-loading modules, Loading Modules on Demand, Running User-Mode Helper Programs
slave/master modules example, Module Loading Example
dentry field (file structure), The file Structure
backward compatibility issues, Changes in the File Operations Structure
depmod program, Quick Reference
dereferencing
I/O pointers, not recommended, Directly Mapped Memory
invalid pointers, Oops Messages, Using ksymoops
memory addresses, Use of Standard C Types
physical addresses, Directly Mapped Memory
destructor function (kmem_cache_create), Lookaside Caches
/dev nodes, Classes of Devices and Modules
assigning, Major and Minor Numbers
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
removing, Removing a Driver from the System
dev structure and device initialization, Initializing Each Device
development kernels, Version Numbering
devfs (device filesystem), Major and Minor Numbers, The Device Filesystem, Portability Issues and devfs
advantages of, The Device Filesystem
dual-mode initialization, Using devfs in Practice
flags, The Device Filesystem
portability issues and, Portability Issues and devfs
DEVFS_FL_AUTO_DEVNUM flag, The Device Filesystem
DEVFS_FL_AUTO_OWNER flag, The Device Filesystem
DEVFS_FL_DEFAULT flag, The Device Filesystem
DEVFS_FL_HIDE flag, The Device Filesystem
DEVFS_FL_NONE flag, The Device Filesystem
DEVFS_FL_NO_PERSISTENCE flag, The Device Filesystem
DEVFS_FL_SHOW_UNREG flag, The Device Filesystem
devfs_fs_kernel.h header file, Quick Reference
devfs_get_flags(), The Device Filesystem
devfs_mk_dir(), The Device Filesystem
devfs_register(), The Device Filesystem
devfs_set_flags(), The Device Filesystem
devfs_unregister(), The Device Filesystem
device control operations, Splitting the Kernel
device entry points, filesystem for, The Device Filesystem, Portability Issues and devfs
device files, Major and Minor Numbers
controlling access, Access Control on a Device File, Cloning the Device on Open
deleting, Removing a Driver from the System
device filesystem (see devfs)
device memory (see I/O memory)
device-dependent symbols, The Header File blk.h, The Header File blk.h
deviceID PCI register, Configuration Registers and Initialization
devices
assigning virtual addresses to, Software-Mapped I/O Memory
autodetecting parameters of, Automatic and Manual Configuration
base name of, The Generic Hard Disk
block (see block drivers)
caching problems, I/O Registers and Conventional Memory, Using remap_page_range
character (see char drivers)
classes of, Classes of Devices and Modules, Classes of Devices and Modules
cloning on open requests, Cloning the Device on Open, Cloning the Device on Open
collisions between, I/O Ports and I/O Memory
creating using devfs, The Device Filesystem, Using devfs in Practice
DMA and, Direct Memory Access and Bus Mastering, Talking to the DMA controller
file operations on, File Operations, File Operations
hardware management, Hardware Management, Quick Reference
hot-pluggable, handling, Handling Hot-Pluggable Devices, The pci_driver structure
identifying type with ls command, Major and Minor Numbers
interrupts (see interrupt handlers)
names of, Major and Minor Numbers
aliases for, The open Method
dynamic major number allocation, Dynamic Allocation of Major Numbers
removing, Removing a Driver from the System
network (see network drivers)
partitionable, Partitionable Devices, The Device Methods for spull
accessing data within partitions, The Device Methods for spull
PCI (see PCI)
reading and writing, read and write, readv and writev
reading data from, Reading data from the device
removable, Removable Devices, Extra Care
removing using devfs, The Device Filesystem
seeking, Seeking a Device
single-open, Single-Open Devices
single-user access to, Restricting Access to a Single User at a Time
truncating on open, The open Method
version (see version numbering)
writing control sequences to, Device Control Without ioctl
writing data to, Writing to the device
devices.c file, The fs Directory
DEVICE_INTR symbol, The Header File blk.h, Quick Reference
DEVICE_NAME symbol, The Header File blk.h, Quick Reference
DEVICE_NO_RANDOM symbol, The Header File blk.h
DEVICE_NR symbol, The Header File blk.h, Quick Reference
minor_shift value and, The Generic Hard Disk
DEVICE_OFF macro, The Header File blk.h
DEVICE_ON macro, The Header File blk.h
DEVICE_REQUEST symbol, The Header File blk.h
dev_alloc_skb(), Packet Reception, Functions Acting on Socket Buffers, Quick Reference
dev_id pointer, Installing an Interrupt Handler, Using Arguments
installing shared handlers, Installing a Shared Handler
dev_kfree_skb(), Functions Acting on Socket Buffers, Quick Reference
dev_mc_list structure, Kernel Support for Multicasting
dev_t type (Unix), dev_t and kdev_t
dev_table.c file, drivers/sound
dev_tint(), backward compatibility issues for, Further Differences in Linux 2.0
digital I/O ports, Using Digital I/O Ports, A Sample Driver
direct memory access (see DMA)
directly mapped I/O memory, Directly Mapped Memory
directories of kernel headers, Kernel Modules Versus Applications
directory entry (file structure), The file Structure
backward compatibility issues, Changes in the File Operations Structure
disable_dma(), Talking to the DMA controller, Quick Reference
disable_irq(), Enabling and Disabling Interrupts, Quick Reference
backward compatibility issues, Further Differences in the 2.0 Kernel
shared handlers and, Installing a Shared Handler
disable_irq_nosync(), Enabling and Disabling Interrupts, Quick Reference
backward compatibility issues, Further Differences in the 2.0 Kernel
disabling interrupts, Enabling and Disabling Interrupts
using save_flags/restore_flags, Overall Control of Interrupts
disassemble command (gdb), Using gdb
disassembled code and ksymoops, Using ksymoops
disk changes, Removable Devices, Extra Care
disk files vs. open files, The file Structure
disk geometry, retrieving, The ioctl Method
DMA (direct memory access), Direct Memory Access and Bus Mastering, Talking to the DMA controller
allocating buffers for, Allocating the DMA Buffer, Do-it-yourself allocation
backward compatibility issues, Changes to DMA
configuring controller, Talking to the DMA controller, Talking to the DMA controller
dedicated buffers at boot time, Acquiring a Dedicated Buffer at Boot Time
__get_dma_pages() and, get_free_page and Friends, Backward Compatibility
__GFP_DMA flag and, The Flags Argument
for ISA memory, DMA for ISA Devices, Talking to the DMA controller
PCI devices and, DMA on the PCI Bus, A quick look at SBus
dealing with difficult hardware, Dealing with difficult hardware
DMA mappings (see DMA mappings)
hardware dependencies for, How different architectures support PCI DMA
simple example of, A simple PCI DMA example
registering usage, Registering DMA usage
ring buffers, Overview of a DMA Data Transfer
DMA mappings, DMA mappings, Scatter-gather mappings
consistent, DMA mappings
setting up, Setting up consistent DMA mappings
scatter-gather, Scatter-gather mappings
streaming, DMA mappings
setting up, Setting up streaming DMA mappings, Setting up streaming DMA mappings
DMA-capable memory zone, Memory zones
SLAB_CACHE_DMA flag and, Lookaside Caches
dma.h header file, Registering DMA usage, Talking to the DMA controller, Quick Reference
DMAC (DMA controller), DMA for ISA Devices
dma_addr_t type, DMA mappings
dma_spin_lock, Talking to the DMA controller
dmesg command, Using ksymoops
down(), A Brief Introduction to Race Conditions
down_interruptible(), A Brief Introduction to Race Conditions, Quick Reference
do_basic_setup(), Booting the Kernel
do_gettimeofday(), Knowing the Current Time, Quick Reference
do_initcalls(), Booting the Kernel
do_ioctl method, The device methods, Custom ioctl Commands
do_IRQ(), The internals of interrupt handling on the x86
do_map_pgoff(), The mm Directory
do_timer(), Predefined Task Queues
BH mechanism and, The BH Mechanism
dquot.c file, The fs Directory
driver modules, Classes of Devices and Modules
driver-specific symbols, The Header File blk.h, The Header File blk.h
drivers
adding new, Major and Minor Numbers, Removing a Driver from the System
asynchronous notification and, The Driver’s Point of View
character (see char drivers)
choosing ioctl numbers for, Choosing the ioctl Commands
command-oriented, Device Control Without ioctl
configuring, Automatic and Manual Configuration, Automatic and Manual Configuration
device names (see devices, names of)
file operations, File Operations, File Operations
FireWire, Classes of Devices and Modules
I2O, Classes of Devices and Modules
input/output buffers and, Blocking and Nonblocking Operations
interrupt-driven, Interrupt-Driven Block Drivers, Interrupt-Driven Block Drivers
mechanism of (see mechanism, driver)
monitoring with preprocessor, Turning the Messages On and Off, Turning the Messages On and Off
network drivers, Network Drivers, Quick Reference
probing for IRQ numbers, Do-it-yourself probing
removing (see unloading modules)
SCSI, Classes of Devices and Modules
security issues, Security Issues
USB (see USB drivers)
user-space, Doing It in User Space
version (see version numbering)
writing, using devfs, The Device Filesystem, Portability Issues and devfs
drivers/block directory, drivers/block
drivers/cdrom directory, drivers/cdrom
drivers/char directory, drivers/char
drivers/i2c directory, Other Subdirectories
drivers/ide directory, drivers/ide
drivers/input directory, drivers/input
drivers/md directory, drivers/md
drivers/media directory, drivers/media
drivers/mtd directory, Other Subdirectories
drivers/net directory, drivers/net
drivers/scsi directory, drivers/scsi
drivers/sound directory, drivers/sound
drivers/video directory, drivers/video
dump analyzers, Kernel Crash Dump Analyzers
Dynamic Probes debugging tool, Dynamic Probes

E

EBUSY error, Blocking open as an Alternative to EBUSY
edge-triggered vs. level-triggered interrupt lines, Interrupt Sharing, Hardware Resources
EISA (Extended ISA) buses, EISA
elevator.o file, drivers/block
ELF sections
avoiding #ifdefs, Booting the Kernel
changes to kernel compilation, Booting the Kernel
embedded systems, different ld scripts needed for , Before Booting
enable_dma(), Talking to the DMA controller, Quick Reference
enable_irq(), Enabling and Disabling Interrupts, Quick Reference
backward compatibility issues, Further Differences in the 2.0 Kernel
shared handlers and, Installing a Shared Handler
enabling interrupts, Enabling and Disabling Interrupts
using save_flags/restore_flags, Overall Control of Interrupts
end-of-file
poll method and, poll and select
seeking relative to, The llseek Implementation
endless loops, preventing, System Hangs
end_request(), The Request Queue, Quick Reference
DEVICE_NO_RANDOM symbol and, The Header File blk.h
interrupt-driven block drivers and, Interrupt-Driven Block Drivers
splitting up multibuffer requests, How the blk.h macros and functions work
end_that_request_first(), How the blk.h macros and functions work, Quick Reference
end_that_request_last(), How the blk.h macros and functions work, Quick Reference
enet_statistics structure, Linux 2.0, Further Differences in Linux 2.0
entropy pool and SA_SAMPLE_RANDOM flag, Installing an Interrupt Handler
errno.h header file, Error Handling in init_module
error codes, Error Handling in init_module
errors
handling in init_module(), Error Handling in init_module, Error Handling in init_module
read/write, read and write
strace command to debug, Debugging by Watching
/etc/hosts file, Assigning IP Numbers
/etc/modules.conf file, The User-Space Side, Quick Reference
/etc/networks file, Assigning IP Numbers
/etc/syslog.conf file, How Messages Get Logged
avoiding performance problems, Debugging by Querying
etherdevice.h header file, Quick Reference
Ethernet, The Physical Transport of Packets
address resolution, MAC Address Resolution, Non-Ethernet Headers
ARP and, Using ARP with Ethernet
non-Ethernet headers, Non-Ethernet Headers
ethernet subdirectory, The net directory
ether_setup(), Initializing Each Device, Quick Reference
setting up interface information, Interface information, Interface information
ETH_ALEN macro, Opening and Closing, Quick Reference
eth_header method, The device methods
ETH_P_IP macro, Non-Ethernet Headers, Quick Reference
eth_type_trans(), Quick Reference
overriding ARP, Overriding ARP
exclusive sleep, A Deeper Look at Wait Queues
exclusive waits, A Deeper Look at Wait Queues
exec.c file, The fs Directory
execution modes, User Space and Kernel Space
execve(), The init Process
__exit attribute, Explicit Initialization and Cleanup Functions
exit system call, The kernel Directory
expansion board memory, Using I/O Memory, Probing for ISA Memory
experimental kernels, Version Numbering
expires field (timer_list structure), Kernel Timers
exporting symbols, The Kernel Symbol Table, Exporting Versioned Symbols
in Linux 2.0, Exporting Symbols in Linux 2.0, Module Configuration Parameters
EXPORT_NO_SYMBOLS macro, The Kernel Symbol Table, Quick Reference
in Linux 2.0, Exporting Symbols in Linux 2.0
EXPORT_SYMBOL macro, Initialization and Shutdown, Module Configuration Parameters, Quick Reference
EXPORT_SYMBOL_NOVERS macro, The Kernel Symbol Table, Quick Reference
EXPORT_SYMTAB macro, The Kernel Symbol Table, Quick Reference
Extended ISA (EISA) buses, EISA
external buses, External Buses, Writing a USB Driver
directories for, Bus-Specific Directories

F

facilities, (un)registering in init_module(), Initialization and Shutdown, Error Handling in init_module
fast interrupt handlers, Fast and Slow Handlers, The internals of interrupt handling on the x86
backward compatibility issues, Further Differences in the 2.0 Kernel
fasync method, File Operations
asynchronous notification and, The Driver’s Point of View
backward compatibility issues, Asynchronous Notification
fasync_helper(), The Driver’s Point of View, Quick Reference
fasync_struct structure, The Driver’s Point of View
faults (see system faults)
faulty_write()
klogd and, Using klogd
ksymoops and, Using ksymoops
fbmem.c file, drivers/video
fb_info structure, drivers/video
fcntl system call
F_SETOWN/F_SETFL commands, Asynchronous Notification
vs. ioctl method, The Predefined Commands
fcntl.h header file, Blocking and Nonblocking Operations
fc_setup(), Interface information
fdatasync system call, Flushing pending output
FDDI networks, configuring interfaces, Interface information
fddi_setup(), Interface information
fdisk program, Partitionable Devices, The Device Methods for spull
fiber channel devices, initializing, Interface information
FIFO (first-in-first-out) devices, The Design of scull
poll method and, poll and select
fifo.c file, The fs Directory
file flags, The file Structure
file handling and fs directory , The fs Directory
file modes, The file Structure
file structure, File Operations, The file Structure
File System header (fs.h), Quick Reference
file.c file, The fs Directory
filemap.c file, The mm Directory
filesystem modules, Classes of Devices and Modules
filesystem nodes, Splitting the Kernel
block drivers accessed by, Classes of Devices and Modules
names, device (see devices, names of)
file_operations structure, Major and Minor Numbers, File Operations, File Operations, The file Structure
backward compatibility issues, Changes in the File Operations Structure, The Module Usage Count
declaring using tagged initialization, File Operations
mmap method and, The mmap Device Operation
filp pointer, The file Structure
in ioctl method, ioctl
mounting block drivers, How Mounting and Unmounting Works
in read/write methods, read and write
retrieving inode pointers from, Changes in the File Operations Structure
filp->f_op, The file Structure
implementing multiple fops, The open Method
initializing, Using devfs in Practice
filp->private_data
initializing, Using devfs in Practice
FIOASYNC command, The Predefined Commands
FIOCLEX command, The Predefined Commands
FIONBIO command, The Predefined Commands
FIONCLEX command, The Predefined Commands
FireWire drivers, Classes of Devices and Modules
firmware, PCI-aware, Boot Time
first-in-first-out (FIFO) devices, The Design of scull
poll method and, poll and select
flags
devfs, The Device Filesystem
file, The file Structure
flash memory, executing kernel from, Before Booting
flush method, File Operations
backward compatibility issues, Changes in the File Operations Structure
close system call and, The release Method
flushing pending output, Flushing pending output
font, incorrect on console, Device Control Without ioctl
fops pointers, File Operations
as argument to register_chrdev, Major and Minor Numbers
implementing multiple, The open Method
fops->open, The open Method
forcing module load, Version Dependency
fork system call, The kernel Directory
fragmentation, Do-it-yourself allocation
frame buffer video devices directory, drivers/video
free command, Playing with the New Devices
free_dma(), Registering DMA usage, Quick Reference
free_irq(), Installing an Interrupt Handler, Quick Reference
when to call, Installing an Interrupt Handler
free_kiovec(), The kiobuf Structure, Quick Reference
free_page(), get_free_page and Friends, Quick Reference
free_pages(), get_free_page and Friends, Quick Reference
fs directory, The fs Directory
fs.h header file, Quick Reference, Quick Reference, Registering the Driver, Quick Reference
asynchronous notification and, The Driver’s Point of View
block driver commands and, The ioctl Method
blocking/nonblocking operations, Blocking and Nonblocking Operations
file structure and, The file Structure
kdev_t type and, dev_t and kdev_t
register_chrdev(), Major and Minor Numbers
fsync method, File Operations, Flushing pending output
backward compatibility issue, The fsync Method
fsync_dev method, Registering the Driver
flushing all partitions, Partition Detection
functions
accessing memory in Linux 2.0, Access to User Space in Linux 2.0, Access to User Space in Linux 2.0
calling from modules/applications, Kernel Modules Versus Applications
disassembling with gdb, Using gdb
inserting schedule() calls in, System Hangs
f_dentry pointer, The file Structure
backward compatibility issues, Changes in the File Operations Structure
f_flags field (file structure), The file Structure
O_NONBLOCK flag, The Predefined Commands, Blocking and Nonblocking Operations
f_mode field (file structure), The file Structure
f_op pointer, The file Structure
f_pos field (file structure), The file Structure, Changes in the File Operations Structure
read_proc/get_info() and, Using the /proc Filesystem
F_SETFL command, The Predefined Commands, The Driver’s Point of View
fcntl system call and, Asynchronous Notification
F_SETOWN command, The Driver’s Point of View
fcntl system call and, Asynchronous Notification

G

gcc compiler
-g option, Using gdb
inline assembly code, Processor-Specific Registers
-O flag, Compiling and Loading
SPARC platforms and, Platform Dependency
-Wall flag, Compiling and Loading
gdb debugger, Using gdb, Using gdb
kgdb patch and, The kgdb Patch
gendisk_head, Partition Detection , Quick Reference
gendisk_struct structure, The Generic Hard Disk, Quick Reference
adding to global list, Partition Detection
removing from global list, Partition Detection
General Public License (GPL), License Terms
generic hard disk support, The Generic Hard Disk
genhd.c file, drivers/block
genhd.h header file, The Generic Hard Disk, Quick Reference
__GENKSYMS__, Quick Reference
genksyms program, Exporting Versioned Symbols
geographical addressing, PCI Addressing
lack of in ISA devices, A Look Back: ISA
MCA buses and, MCA
NuBus and, NuBus
Plug and Play, The Plug-and-Play Specification
SBus and, SBus
geometry, disk, The ioctl Method
getdents system call, The fs Directory
get_cycles(), Processor-Specific Registers
__get_dma_pages(), get_free_page and Friends, Quick Reference
get_dma_residue(), Talking to the DMA controller, Quick Reference
get_fast_time(), Knowing the Current Time, Quick Reference
__get_free_page(), get_free_page and Friends, Quick Reference
advantage of using, A scull Using Whole Pages: scullp
__get_free_pages(), get_free_page and Friends, Quick Reference
get_free_pages(), The Flags Argument
allocating memory using, Page Size
limitations on memory allocation, Allocating the DMA Buffer
mmap method and, Remapping RAM with the nopage method
returning virtual addresses, vmalloc and Friends
get_info(), Using the /proc Filesystem, Using the /proc Filesystem
get_kernel_syms system call, Compiling and Loading
get_page(), Mapping Memory with nopage
backward compatibility issues, Changes to Memory Management
get_stats method, The device methods, Statistical Information
get_unaligned(), Data Alignment, Quick Reference
__get_user(), Using the ioctl Argument, Quick Reference
get_user(), Using the ioctl Argument, Quick Reference
Linux 2.0 version, Access to User Space in Linux 2.0
get_zeroed_page(), get_free_page and Friends, Quick Reference
GFP_ATOMIC flag, The Flags Argument, Quick Reference
page-oriented allocation functions, get_free_page and Friends
preparing for allocation failure, get_free_page and Friends
GFP_BUFFER flag, The Flags Argument
__GFP_DMA flag, The Flags Argument, Quick Reference
memory zones and, Memory zones
page-oriented allocation functions, get_free_page and Friends
__GFP_HIGHMEM flag, The Flags Argument, Quick Reference
memory zones and, Memory zones
page-oriented allocation functions, get_free_page and Friends
GFP_HIGHUSER flag, The Flags Argument
GFP_KERNEL flag, Using Resources, The Flags Argument, Quick Reference
page-oriented allocation functions, get_free_page and Friends
GFP_USER flag, Using Resources, The Flags Argument
GKSMP symbol, Exporting Versioned Symbols
global
memory areas, The Design of scull
message enabling/disabling, Turning the Messages On and Off
goto statement, Error Handling in init_module
GPL (General Public License), License Terms
gpm mouse server, Doing It in User Space, System Hangs
group, device, Dynamic Allocation of Major Numbers

H

handle_IRQ_event(), The internals of interrupt handling on the x86
handle_scancode(), drivers/char
HARDRESET command, Choosing the ioctl Commands
hardsect_size global array, Registering the Driver, Quick Reference
hardware (see devices)
hardware abstractions (PCI), Hardware Abstractions
hardware addresses, Interface information
assigning, Opening and Closing
changing, using set_mac_address method, The device methods
multicasting and, Multicasting, A Typical Implementation
used with PCI peripherals, PCI Addressing, PCI Addressing
hardware headers
adding before transmitting packets, Functions Acting on Socket Buffers
backward compatibility issues, Further Differences in Linux 2.0
building, The device methods
encapsulating information, Non-Ethernet Headers
overriding ARP, Overriding ARP
hardware memory barriers, I/O Registers and Conventional Memory, Quick Reference
backward compatibility issues, Backward Compatibility
hard_header method, The device methods, Non-Ethernet Headers
backward compatibility issues, Further Differences in Linux 2.0
building packets with ARP query results, Using ARP with Ethernet
hard_header_parse method, The device methods
hard_start_transmit method, Packet Transmission
hard_start_xmit method, The device methods, Packet Transmission
backward compatibility issues, Differences in Linux 2.2
HAVE_DEVLIST, backward compatibility issues for, Probing and HAVE_DEVLIST
HDIO_GETGEO command, The ioctl Method
hdreg.h header file, The ioctl Method
head pointers and circular buffers, Using Circular Buffers
header files, Kernel Modules Versus Applications
include directory and, include and arch
managing symbol visibility, The Kernel Symbol Table
removing conditional compilation, Portability Issues and devfs
headers, Ethernet (see Ethernet)
headers, non-Ethernet, Non-Ethernet Headers
header_cache method, The device methods
header_cache_update method, The device methods
helper programs, running, Running User-Mode Helper Programs
hex values of oops messages, Using ksymoops
hiding global symbols, The Kernel Symbol Table
in Linux 2.0, Exporting Symbols in Linux 2.0
high memory, High and Low Memory
request queues and, Doing Without the Request Queue
high memory zone, Memory zones
high RAM addresses, reserving, Reserving High RAM Addresses
highmem.c file, The mm Directory
highmem.h header file, The Memory Map and struct page
HIPPI drivers, preparing fields for, Interface information
hippi_setup(), Interface information
host adapters, plugging into core system, drivers/scsi
host numbers, Assigning IP Numbers
hosts.c file, drivers/scsi
hot-pluggable devices, handling, Handling Hot-Pluggable Devices, The pci_driver structure
hung system, System Hangs
HZ (time frequency) symbol, Time Intervals in the Kernel, Time Intervals

I

I/O, Flushing pending output
(see also reading; writing)
accessing, PCI and, Accessing the I/O and Memory Spaces, Peeking at the base address registers
asynchronous notification, Asynchronous Notification, The Driver’s Point of View
blocking, Blocking I/O, A Sample Implementation: scullpipe
blocking/nonblocking, Blocking and Nonblocking Operations
buffers for, Blocking and Nonblocking Operations
flushing pending, Flushing pending output
interrupt-driven, Interrupt-Driven I/O
ISA devices and, Hardware Resources
pausing, Pausing I/O
remapping specific regions of, Remapping Specific I/O Regions
space for, in PCI buses, PCI Addressing
string operations, String Operations
transferring data with DMA, Direct Memory Access and Bus Mastering, Talking to the DMA controller
I/O memory, Memory, Resource Allocation in Linux 2.4, I/O Ports and I/O Memory, Using I/O Memory, Probing for ISA Memory
directly mapped, Directly Mapped Memory
page tables and, Using I/O Memory
software-mapped, Software-Mapped I/O Memory
I/O ports, I/O Ports and I/O Memory, Resource Allocation in Linux 2.4, I/O Ports and I/O Memory, Using I/O Ports, Platform Dependencies
allocating, Ports
digital, Using Digital I/O Ports, A Sample Driver
inline functions for accessing, Using I/O Ports
parallel (see parallel ports)
I/O registers vs. RAM, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory
I/O registry, accessing, Ports
I/O request queues (see request queues)
I2O drivers, Classes of Devices and Modules
IA-64 architecture
PCI DMA interface support, How different architectures support PCI DMA
porting and, Platform Dependencies
/proc/interrupts file, snapshot of, The /proc Interface
IDE device drivers, directory for, drivers/ide
if.h header file, Interface information, Custom ioctl Commands, Quick Reference
ifconfig command
net_device structure and, The Visible Head
opening/closing interfaces, Opening and Closing
#ifdef constructs
avoiding with devfs, Portability Issues and devfs
avoiding with init calls, Booting the Kernel
IFF_ symbols, Interface information, Kernel Support for Multicasting
IFF_NOARP flag, Initializing Each Device
ifreq structure, Custom ioctl Commands
if_ether.h header file, Quick Reference
IKD (integrated kernel debugger) patch, The Integrated Kernel Debugger Patch
immediate queue, Predefined Task Queues, The immediate queue, Quick Reference
BH mechanism and, The BH Mechanism
writing a BH bottom half, Writing a BH Bottom Half
IMMEDIATE_BH bottom half, The BH Mechanism
writing a BH bottom half, Writing a BH Bottom Half
inb(), Using I/O Ports, Quick Reference
inb_p(), Pausing I/O, Quick Reference
include/asm directory (see entries under <asm/>)
include directory, include and arch
infinite loops, preventing, System Hangs
inflate.c file, ipc and lib
__init attribute, Explicit Initialization and Cleanup Functions
init calls and #ifdef constructs, Booting the Kernel
init process, The init Process
init scripts and loading/unloading modules, Dynamic Allocation of Major Numbers
init thread, Booting the Kernel
init.h header file, Explicit Initialization and Cleanup Functions, Quick Reference
__initdata attribute, Explicit Initialization and Cleanup Functions
initialization functions and boot-time memory allocation, Acquiring a Dedicated Buffer at Boot Time
initializing
kernel data structures, Booting the Kernel
modules, Initialization and Shutdown, Error Handling in init_module
explicitly naming functions for, Explicit Initialization and Cleanup Functions
network devices, Initializing Each Device
semaphores, A Brief Introduction to Race Conditions
initrd utility, Partition Detection Using initrd
INIT_LIST_HEAD macro, Linked Lists
init_module(), Kernel Modules Versus Applications, Initialization and Shutdown, Error Handling in init_module, Quick Reference
error handling in, Error Handling in init_module, Error Handling in init_module
EXPORT_NO_SYMBOLS macro and, The Kernel Symbol Table
hiding global symbols, Exporting Symbols in Linux 2.0
unregistering facilities from, Error Handling in init_module
using unique names instead of, Explicit Initialization and Cleanup Functions
INIT_REQUEST(), The Request Queue, Quick Reference
splitting up multibuffer requests, How the blk.h macros and functions work
init_timer(), Kernel Timers, Quick Reference
inl(), Using I/O Ports, Quick Reference
inline assembly code (example), Processor-Specific Registers
inline functions, Compiling and Loading
for accessing I/O ports, Using I/O Ports
inode pointer
backward compatibility issues, Changes in the File Operations Structure
in ioctl method, ioctl
retrieving from filp pointer, Changes in the File Operations Structure
inode structure
accessing device numbers, dev_t and kdev_t, The open Method, Quick Reference
mounting block drivers, How Mounting and Unmounting Works
inode->i_rdev, dev_t and kdev_t, The open Method, Quick Reference
inode.c file, The fs Directory
input buffers, driver, Blocking and Nonblocking Operations
input files, enabling asynchronous notification from, Asynchronous Notification
input management, directory for, drivers/input
input module, The Kernel Symbol Table
input pins, Hardware Management, Using Digital I/O Ports
reading values from parallel port, A Sample Driver
input.c file, drivers/input
input.h header file, Quick Reference
input_register_device(), drivers/input
input_register_handler(), drivers/input
insb(), String Operations, Quick Reference
insl(), String Operations, Quick Reference
insmod program, Splitting the Kernel, Compiling and Loading
assigning parameter values, Automatic and Manual Configuration
backward compatibility issues, Backward Compatibility
dynamically allocating major numbers, Dynamic Allocation of Major Numbers
-f switch, Version Dependency
modprobe program vs., The Kernel Symbol Table
module loading and security, Module Loading and Security
testing modules using, Building and Running Modules
version control in modules, Version Control in Modules
vmalloc() and, vmalloc and Friends
installing interrupt handlers, Installing an Interrupt Handler, The internals of interrupt handling on the x86
insw(), String Operations, Quick Reference
int data type, Use of Standard C Types
integrated kernel debugger (IKD) patch, The Integrated Kernel Debugger Patch
interactive kernel debugger (kdb), The kdb Kernel Debugger, The kdb Kernel Debugger
interface buses, PC/104 and PC/104+, Writing a USB Driver
interface flags for net_device structure, Interface information
interface-specific data types, Interface-Specific Types
intermodule communication, Intermodule Communication, Intermodule Communication
Internet sites about Linux kernels, Sources of Further Information
interrupt handlers, Interrupt Handling, Quick Reference
using arguments with, Using Arguments
autodetecting IRQ numbers, Autodetecting the IRQ Number, Do-it-yourself probing, Installing a Shared Handler
backward compatibility issues, Backward Compatibility
BH mechanism, The BH Mechanism
bottom halves of handlers, Tasklets and Bottom-Half Processing, Writing a BH Bottom Half
enabling/disabling interrupts, Overall Control of Interrupts, Enabling and Disabling Interrupts
fast vs.slow, Fast and Slow Handlers, The internals of interrupt handling on the x86
backward compatibility issues, Further Differences in the 2.0 Kernel
implementing, Implementing a Handler, Enabling and Disabling Interrupts
installing, Installing an Interrupt Handler, The internals of interrupt handling on the x86
at device open, Installing an Interrupt Handler
shared handlers, Installing a Shared Handler
for network drivers, The Interrupt Handler
preparing parallel ports for, Preparing the Parallel Port
/proc files for, The /proc Interface
race conditions, Race Conditions, Going to Sleep Without Races
circular buffers for, Using Circular Buffers
lock variables for, Using Lock Variables, Atomic integer operations
spinlocks for, Using Spinlocks, Using Spinlocks
running shared handlers, Running the Handler
sharing interrupts, Interrupt Sharing, The /proc Interface
tasklets, Tasklets
on x86 architecture, The internals of interrupt handling on the x86
interrupt mode and asynchronous execution, How Task Queues Are Run
interrupt numbers, Installing an Interrupt Handler
used as arguments, Using Arguments
probing using kernel facility, Kernel-assisted probing
interrupt request lines (see IRQs)
Interrupt Service Routine (ISR), Time Intervals in the Kernel
interrupt-driven operation, Interrupt-Driven I/O
block drivers, Interrupt-Driven Block Drivers, Interrupt-Driven Block Drivers
interrupt.h header file, Tasklets, Quick Reference, Kernel-assisted probing, The BH Mechanism, Quick Reference
interruptible_sleep_on(), Going to Sleep and Awakening, Quick Reference
avoiding race conditions, Going to Sleep Without Races
implementation of, A Deeper Look at Wait Queues
vs. wait_event macro, A Deeper Look at Wait Queues
interruptible_sleep_on_timeout(), Going to Sleep and Awakening, Quick Reference
delaying code execution, Long Delays
interruptions, code, A Brief Introduction to Race Conditions
interrupts
PCI, PCI Interrupts
timer, Time Intervals in the Kernel
interrupts file, The /proc Interface, Quick Reference
shared interrupts and, The /proc Interface
intervals of time, Time Intervals in the Kernel, Processor-Specific Registers, Time Intervals
inter_module_get(), Intermodule Communication, Quick Reference
inter_module_get_request(), Intermodule Communication, Quick Reference
inter_module_put(), Intermodule Communication, Quick Reference
inter_module_register(), Intermodule Communication, Quick Reference
inter_module_unregister(), Intermodule Communication, Quick Reference
intptr_t type (C99 standard), Use of Standard C Types
intr_count global variable, Backward Compatibility
inw(), Using I/O Ports, Quick Reference
in_interrupt(), How Task Queues Are Run, Quick Reference
vs. intr_count global variable, Backward Compatibility
_IO() macro, Choosing the ioctl Commands, Quick Reference
io.h header file (asm), Quick Reference, Quick Reference
accessing I/O ports, Using I/O Ports
converting between bus/virtual addresses, Bus Addresses
io.h header file (linux), Quick Reference
iobuf.h header file, The kiobuf Structure, Quick Reference
_IOC() macro, Quick Reference
ioctl method, File Operations, ioctl, Device Control Without ioctl
accessing specific information for partitions, The Device Methods for spull
using bitfields to define commands, Choosing the ioctl Commands
block devices and, The ioctl Method, The ioctl Method
changing read_ahead values, Registering the Driver
command numbers, choosing, Choosing the ioctl Commands, Choosing the ioctl Commands
controlling devices without, Device Control Without ioctl
controlling I/O channel, Enhanced Char Driver Operations
customizing for networking, Custom ioctl Commands
debugging with, The ioctl Method
extra argument of, Using the ioctl Argument, The Implementation of the ioctl Commands
implementing ioctl commands, The Implementation of the ioctl Commands
network devices and, The device methods
predefined commands of, The Predefined Commands
using scalar values to define commands, Choosing the ioctl Commands
TIOCLINUX command, printk
type checking disabled, ioctl
ioctl-number.txt file, Choosing the ioctl Commands
ioctl.c file, The fs Directory
ioctl.h header file, Choosing the ioctl Commands, Quick Reference
setting up command numbers, Choosing the ioctl Commands
_IOC_TYPEBITS macro, Choosing the ioctl Commands, Quick Reference
iomem file, Memory, Quick Reference
iomem_resource structure, Resource Allocation in Linux 2.4
ioperm(), Using I/O Ports
iopl(), Using I/O Ports
ioport.h header file, Ports, Quick Reference, Using I/O Ports, Quick Reference
resource ranges and, Resource Allocation in Linux 2.4
ioports file, I/O Ports and I/O Memory, Quick Reference
ioport_resource structure, Resource Allocation in Linux 2.4
_IOR() macro, Choosing the ioctl Commands, Quick Reference
ioremap(), vmalloc and Friends, vmalloc and Friends, Quick Reference, Quick Reference
accessing I/O memory, Using I/O Memory
backward compatibility issues, Backward Compatibility
ISA memory range, ISA Memory Below 1 MB
software-mapped I/O memory and, Software-Mapped I/O Memory
ioremap_nocache(), Software-Mapped I/O Memory, Quick Reference
IORESOURCE_IO flag, PCI I/O resources in Linux 2.4
IORESOURCE_MEM flag, PCI I/O resources in Linux 2.4
IORESOURCE_PREFETCH flag, PCI I/O resources in Linux 2.4
IORESOURCE_READONLY flag, PCI I/O resources in Linux 2.4
iounmap(), vmalloc and Friends, Quick Reference, Quick Reference
backward compatibility issues, Backward Compatibility
software-mapped I/O memory and, Software-Mapped I/O Memory
iovec structures, readv and writev
io_request_lock, The I/O request lock, Quick Reference
backward compatibility issues, Backward Compatibility
multiqueue block drivers and, Multiqueue Block Drivers
performing clustered I/O, Clustered Requests
IP numbers
assigning, Assigning IP Numbers, Assigning IP Numbers
resolving to physical addresses, MAC Address Resolution, Non-Ethernet Headers
ipc directory, ipc and lib
ipv4/ipv6 subdirectories, The net directory
ip_summed field (sk_buff), Packet Reception, The Important Fields
irq argument (interrupt number), Installing an Interrupt Handler, Using Arguments
irq.h header file, Do-it-yourself probing, Enabling and Disabling Interrupts
IRQs (interrupt request lines), Installing an Interrupt Handler
autodetecting (probing) numbers for, Autodetecting the IRQ Number, Do-it-yourself probing
shared interrupts and, Installing a Shared Handler
level-triggered vs. edge-triggered, Interrupt Sharing, Hardware Resources
PCI devices and, PCI Interrupts
statistics on, The /proc Interface
IRQ_WAITING status bit, setting, The internals of interrupt handling on the x86
ISA bus master DMA, DMA for ISA Devices
ISA devices, A Look Back: ISA, The Plug-and-Play Specification
DMA for, DMA for ISA Devices, Talking to the DMA controller
EISA (Extended ISA) buses, EISA
identifying I/O regions, I/O Ports and I/O Memory
interrupt sharing and, Interrupt Sharing, Hardware Resources
pausing I/O, Pausing I/O
Plug-and-Play specification, The Plug-and-Play Specification
probing, Ports
programming techniques, ISA Programming
VLB (VESA Local Bus) devices, VLB
ISA memory
accessing, ISA Memory Below 1 MB
below 1 MB, ISA Memory Below 1 MB, ISA Memory Below 1 MB
DMA for, DMA for ISA Devices, Talking to the DMA controller
nopage method and, Mapping Memory with nopage
probing for, Probing for ISA Memory, Probing for ISA Memory
isa_readb and related functions, isa_readb and Friends
ISDN drivers and lookaside caches, Lookaside Caches, A scull Based on the Slab Caches: scullc
ISR (Interrupt Service Routine), Time Intervals in the Kernel
i_rdev field (inode structure), dev_t and kdev_t

J

jiffies value
in busy waiting implementation, Long Delays
kernel timers and, Kernel Timers
no solution for short delays, Short Delays
retrieving current time, Knowing the Current Time
at timer interrupt, Time Intervals in the Kernel
trans_start field and, Utility fields
variable syntax, Quick Reference
jiq (Just In Queue) module, How the examples work
timer usage example, Kernel Timers
jiq_print_tq(), How the examples work
jit (Just In Time) module
current time, retrieving, Knowing the Current Time
delaying code execution, Long Delays
jitbusy program, Long Delays
Just In Queue (jiq) module, How the examples work
timer usage example, Kernel Timers
Just In Time (jit) module
current time, retrieving, Knowing the Current Time
delaying code execution, Long Delays

K

kbd_mode -a command, System Hangs
kcore file, Using gdb
kdataalign program, Data Alignment
kdatasize module, Use of Standard C Types
kdb kernel debugger, The kdb Kernel Debugger, The kdb Kernel Debugger
kdev_t type, dev_t and kdev_t
extracting physical device number, The Header File blk.h
kdev_t.h header file, dev_t and kdev_t
kdev_t_no_nr(), dev_t and kdev_t
keep directive (modprobe), The User-Space Side
kernel directory, The kernel Directory
kernel headers, Kernel Modules Versus Applications
kernel I/O buffers, The kiobuf Interface, Mapping User-Space Buffers and Raw I/O
kernel I/O vectors, The kiobuf Structure
kernel lockups, detecting, The Integrated Kernel Debugger Patch
kernel logical addresses (see logical addresses)
kernel sources, Bibliography
kernel space, User Space and Kernel Space
transferring to/from user space, read and write, readv and writev
kernel stack debugger (IKD feature), The Integrated Kernel Debugger Patch
__KERNEL__ symbol, Compiling and Loading, Quick Reference
explicitly sizing data, Assigning an Explicit Size to Data Items
kernel header files and, Kernel Modules Versus Applications
kernel timers, Kernel Timers, Kernel Timers
kernel virtual addresses (see virtual addresses)
kernel.h header file, printk, I/O Registers and Conventional Memory, Quick Reference
kerneld program, backward compatibility issues for, Backward Compatibility
kerneld.h header file, backward compatibility issues for, Backward Compatibility
KERNELDIR variable and version dependency, Version Dependency
kernels
allocating memory at boot time, Boot-Time Allocation, Reserving High RAM Addresses
books about Linux, Bibliography
booting, Booting the Kernel, Booting the Kernel
with initrd, Partition Detection Using initrd
capabilities and restricted operations, Capabilities and Restricted Operations
concurrency in, Concurrency in the Kernel
connecting network drivers to, Connecting to the Kernel, Modularized and Nonmodularized Drivers
current process and, The Current Process
developmental (experimental), Version Numbering
filesystem modules, Classes of Devices and Modules
flash memory, executing from, Before Booting
handling system faults (see system faults)
IKD (integrated kernel debugger) patch, The Integrated Kernel Debugger Patch
initial boot sequence, Booting the Kernel
introduction to, An Introduction to Device Drivers, Overview of the Book
kgdb patch and, The kgdb Patch
kiobufs, The kiobuf Interface, Mapping User-Space Buffers and Raw I/O
kmod facility and, kmod and Advanced Modularization
linked lists, Linked Lists, Linked Lists
loading modules into (see loading modules)
messages (see messages)
module version control, Version Control in Modules, Exporting Versioned Symbols
multicasting support, Kernel Support for Multicasting
probing interrupt numbers with, Kernel-assisted probing
race conditions and, A Brief Introduction to Race Conditions, read and write
request queues, finding, Multiqueue Block Drivers
running task queues, How Task Queues Are Run
security (see security)
splitting role of, Splitting the Kernel, Splitting the Kernel
symbol table, The Kernel Symbol Table, The Kernel Symbol Table
klogd and, Using klogd
system hangs, System Hangs
time intervals in, Time Intervals in the Kernel, Processor-Specific Registers
tracing programs, Debugging by Watching, Debugging by Watching
using conventional data types, Assigning an Explicit Size to Data Items
version numbering, Version Numbering
web sites about, Sources of Further Information
__KERNEL_SYSCALLS__, The init Process
KERNEL_VERSION macro, Version Dependency, Backward Compatibility
kernel_version variable, Quick Reference
KERN_ALERT macro, printk
KERN_CRIT macro, printk
KERN_DEBUG macro, printk
KERN_EMERG macro, printk
KERN_ERR macro, printk
KERN_INFO macro, printk
KERN_NOTICE macro, printk
KERN_WARNING macro, printk
keventd process, Predefined Task Queues, The scheduler queue
backward compatibility issues, Backward Compatibility
call_usermodehelper and, Running User-Mode Helper Programs
keyboard, debugging when locked, System Hangs
keyboard.c file, drivers/char
kfree(), Using Resources, Quick Reference, Quick Reference
defined in slab.c file, The mm Directory
scull driver example and, scull’s Memory Usage
kfree_skb(), Functions Acting on Socket Buffers, Quick Reference
kgcc package, Compiling and Loading
kgdb patch, The kgdb Patch
khttpd subdirectory, The net directory
kill_fasync(), The Driver’s Point of View, Quick Reference
kiobufs, The kiobuf Interface, Mapping User-Space Buffers and Raw I/O
kiobuf_init(), The kiobuf Structure, Quick Reference
kiovecs, The kiobuf Structure
klogd daemon
-c flag, printk
debugging modules with, Using klogd
decoding oops messages, Using klogd
-f option, How Messages Get Logged
logging messages, How Messages Get Logged
obtaining clean oops messages, Using ksymoops
-p option, Using klogd
kmalloc(), Using Resources, Quick Reference, The Real Story of kmalloc, The Size Argument, Quick Reference
defined in slab.c file, The mm Directory
flags argument, The Flags Argument, Memory zones
limitations on memory allocation, Allocating the DMA Buffer
performance degradation issues, get_free_page and Friends
returning virtual addresses, vmalloc and Friends, vmalloc and Friends
scull driver example and, scull’s Memory Usage
size argument, The Size Argument
vs. vmalloc(), vmalloc and Friends, vmalloc and Friends
kmalloc.c file, The Size Argument, The mm Directory
kmap(), The Memory Map and struct page, Quick Reference
backward compatibility issues, Changes to Memory Management
kmem_cache_alloc, Lookaside Caches, Quick Reference
kmem_cache_create, Lookaside Caches, Quick Reference
kmem_cache_destroy, Lookaside Caches, Quick Reference
kmem_cache_free, Lookaside Caches, Quick Reference
kmem_cache_t, Lookaside Caches, Quick Reference
kmod facility, kmod and Advanced Modularization
loading modules, Module Loading Example
user-mode helper programs and, Running User-Mode Helper Programs
kmod.c file, The kernel Directory
kmod.h header file, Requesting Modules in the Kernel, Quick Reference
backward compatibility issues, Backward Compatibility
kmsg file, How Messages Get Logged
kswapd thread, The mm Directory
ksymoops utility, Using ksymoops, Using ksymoops
obtaining clean oops messages, Using ksymoops
ksyms command, The Kernel Symbol Table
ksyms file, The Kernel Symbol Table, Initialization and Shutdown, Quick Reference
ksymoops and, Using ksymoops
kunmap(), The Memory Map and struct page, Quick Reference
backward compatibility issues, Changes to Memory Management

L

layered modularization, The Kernel Symbol Table
LCRASH utility, Kernel Crash Dump Analyzers
ld -r command, Compiling and Loading
ld scripts and boot code layout, Before Booting
__le32_to_cpu macro, Byte Order, Quick Reference
least significant bit and partitionable devices, Partitionable Devices
LEDs, soldering to output pins, A Sample Driver
level-triggered vs. edge-triggered interrupt lines, Interrupt Sharing, Hardware Resources
levels
debugging, Turning the Messages On and Off
message priority (see loglevels)
levels (modalities), CPU, User Space and Kernel Space
lib directory, ipc and lib
libraries, Kernel Modules Versus Applications
license, Linux, License Terms
line disciplines, implementing, drivers/net
link state, changes in, Changes in Link State
linked lists, Linked Lists, Linked Lists
Linux
license terms, License Terms
version numbering, Version Numbering
linux directory, Kernel Modules Versus Applications
Linux Documentation Project web site, Sources of Further Information
Linux Kernel Crash Dumps (LKCD), Kernel Crash Dump Analyzers
Linux Trace Toolkit (LTT), The Linux Trace Toolkit
linux-kernel mailing list, Joining the Kernel Development Community
<linux/autoconf.h> header file, Using Version Support in Modules
<linux/blk.h> header file (see blk.h header file)
<linux/blkdev.h> header file, Registering the Driver, Quick Reference
<linux/blkpg.h> header file, The ioctl Method
<linux/bootmem.h> header file, Acquiring a Dedicated Buffer at Boot Time, Quick Reference
<linux/capability.h> header file, Capabilities and Restricted Operations, Quick Reference
<linux/config.h> header file, Using Version Support in Modules, Quick Reference, Configuration Registers and Initialization, Quick Reference
<linux/delay.h> header file, Short Delays, Quick Reference
<linux/devfs_fs_kernel.h> header file, The Device Filesystem, Quick Reference
<linux/errno.h> header file, Error Handling in init_module
<linux/etherdevice.h> header file, Quick Reference
<linux/fcntl.h> header file, Blocking and Nonblocking Operations
<linux/fs.h> header file, Quick Reference, Quick Reference, Registering the Driver, Quick Reference
asynchronous notification and, The Driver’s Point of View
block driver commands and, The ioctl Method
blocking/nonblocking operations, Blocking and Nonblocking Operations
file structure and, The file Structure
kdev_t type and, dev_t and kdev_t
register_chrdev(), Major and Minor Numbers
<linux/genhd.h> header file, The Generic Hard Disk, Quick Reference
<linux/hdreg.h> header file, The ioctl Method
<linux/highmem.h> header file, The Memory Map and struct page
<linux/if.h> header file, Interface information, Custom ioctl Commands, Quick Reference
<linux/if_ether.h> header file, Quick Reference
<linux/init.h> header file, Explicit Initialization and Cleanup Functions, Quick Reference
<linux/input.h> header file, Quick Reference
<linux/interrupt.h> header file, Tasklets, Quick Reference, Kernel-assisted probing, The BH Mechanism, Quick Reference
<linux/io.h> header file, Quick Reference
<linux/iobuf.h.h> header file, The kiobuf Structure, Quick Reference
<linux/ioctl.h> header file, Quick Reference
setting up command numbers, Choosing the ioctl Commands
<linux/ioport.h> header file, Ports, Quick Reference, Using I/O Ports, Quick Reference
resource ranges and, Resource Allocation in Linux 2.4
<linux/kdev_t.h> header file, dev_t and kdev_t
<linux/kernel.h> header file, printk, I/O Registers and Conventional Memory, Quick Reference
<linux/kerneld.h> header file
backward compatibility issues, Backward Compatibility
<linux/kmod.h> header file, Requesting Modules in the Kernel, Quick Reference
backward compatibility issues, Backward Compatibility
<linux/list.h> header file, A Deeper Look at Wait Queues, Linked Lists, Linked Lists, Quick Reference
<linux/malloc.h> header file, Quick Reference
<linux/mm.h> header file, The Flags Argument, Quick Reference, Virtual Memory Areas, Quick Reference
<linux/module.h> header file, Version Dependency, Quick Reference, File Operations
version.h header file and, Version Dependency
<linux/modversions.h> header, Using Version Support in Modules, Quick Reference
<linux/netdevice.h> header file, Module Loading, Quick Reference
<linux/param.h> header file, Time Intervals in the Kernel, Quick Reference
<linux/pci.h> header file, DMA on the PCI Bus, Quick Reference, Configuration Registers and Initialization, Quick Reference
accessing configuration space, Accessing the Configuration Space
detecting size of PCI regions, Peeking at the base address registers
pci_ops structure and, Hardware Abstractions
<linux/poll.h> header file, poll and select, Quick Reference
<linux/proc_fs.h> header file, Using the /proc Filesystem
<linux/scatterlist.h> header file, Scatter-gather mappings
<linux/sched.h> header file, Quick Reference, Quick Reference, Quick Reference, Quick Reference
interrupt request line functions, Installing an Interrupt Handler
jiffies value and, Time Intervals in the Kernel
kernel directory and, The kernel Directory
wait queue code information, A Deeper Look at Wait Queues
<linux/skbuff.h> header file, Packet Transmission, The Socket Buffers, Quick Reference
<linux/sockios.h> header file, Custom ioctl Commands, Quick Reference
<linux/spinlock.h> header file, Another Digression into Race Conditions, Quick Reference, Using Spinlocks, Quick Reference
<linux/symtab_begin.h> header file, Quick Reference
<linux/symtab_end.h> header file, Quick Reference
<linux/time.h> header file, Quick Reference
<linux/timer.h> header file, Kernel Timers, Quick Reference
<linux/tqueue.h> header file, The Nature of Task Queues, Predefined Task Queues, Quick Reference
<linux/types.h> header file, Assigning an Explicit Size to Data Items, Quick Reference
<linux/uio.h> header file, readv and writev
<linux/usb.h> header file, Quick Reference
<linux/version.h> header file, Version Dependency, Quick Reference
<linux/vmalloc.h> header file, vmalloc and Friends, Quick Reference
<linux/wait.h> header file, A Deeper Look at Wait Queues, Quick Reference
LINUX_VERSION_CODE macro, Version Dependency, Quick Reference
list.h header file, A Deeper Look at Wait Queues, Linked Lists, Linked Lists, Quick Reference
lists, linked, Linked Lists, Linked Lists
list_add(), Linked Lists, Quick Reference
list_del(), Linked Lists, Quick Reference
list_empty(), Linked Lists, Quick Reference
testing request queues with, Multiqueue Block Drivers
list_entry(), Linked Lists, Quick Reference
list_head data structure, Linked Lists, Linked Lists
list_splice(), Linked Lists, Quick Reference
little-endian byte order, Byte Order, Configuration Registers and Initialization, Accessing the Configuration Space
__LITTLE_ENDIAN symbol, Byte Order, Quick Reference
LKCD (Linux Kernel Crash Dumps), Kernel Crash Dump Analyzers
llseek method, File Operations, Changes in the File Operations Structure, The llseek Implementation
in Linux version 2.0, Seeking in Linux 2.0
ll_rw_blk.c file, drivers/block
loading block drivers, Loading Block Drivers, Extra Care
loading modules, Compiling and Loading
on demand, Loading Modules on Demand, Running User-Mode Helper Programs
slave/master modules example, Module Loading Example
dynamically assigned device numbers, Dynamic Allocation of Major Numbers
for network drivers, Module Loading
version dependency and, Version Dependency
LocalTalk devices, setting up fields for, Interface information
lock method, File Operations
lock variables, Using Lock Variables, Atomic integer operations
locked keyboard, debugging, System Hangs
lockup detector (IKD), The Integrated Kernel Debugger Patch
lock_kiovec(), The kiobuf Structure, Quick Reference
loff_t (long offset), File Operations, The file Structure, Changes in the File Operations Structure
logging messages, How Messages Get Logged
logical addresses, Address Types
loglevels (message priorities), Building and Running Modules, printk, printk
LOG_BUF_LEN circular buffer, How Messages Get Logged
long data type, Use of Standard C Types
long delays, Long Delays, Long Delays
lookaside caches, Lookaside Caches, A scull Based on the Slab Caches: scullc
backward compatibility issues, Backward Compatibility
loop.c file, drivers/block
loopback interface, How snull Is Designed
IFF_LOOPBACK flag, Interface information
loops
busy, Long Delays
endless, System Hangs
software, Short Delays
loops_per_second value, Short Delays
low memory, High and Low Memory
lp.c file, drivers/char
ls command, identifying device type, Major and Minor Numbers
lseek method, File Operations
in Linux version 2.0, Seeking in Linux 2.0
syntax in Linux 2.0, Changes in the File Operations Structure
ltalk_setup(), Interface information
LTT (Linux Trace Toolkit), The Linux Trace Toolkit
LVM (logical volume manager) drivers
drivers/md directory, drivers/md
“make request” function and, Doing Without the Request Queue

M

M68k architecture
layout of boot code, Before Booting
no support for PCI bus, How different architectures support PCI DMA
porting and, Platform Dependencies
MAC (Medium Access Control) addresses, Interface information
resolving, MAC Address Resolution, Non-Ethernet Headers
set_mac_address method and, The device methods
machine-specific registers, Processor-Specific Registers
magic SysRq key, System Hangs
mailing list, linux-kernel, Joining the Kernel Development Community
major device numbers, Major and Minor Numbers, Removing a Driver from the System
dynamic allocation of, Dynamic Allocation of Major Numbers, Dynamic Allocation of Major Numbers
MAJOR macro, dev_t and kdev_t, Quick Reference
major_name value (gendisk_struct), The Generic Hard Disk
MAJOR_NR symbol, The Header File blk.h, Quick Reference
“make request” function, Doing Without the Request Queue, Doing Without the Request Queue
make utility
building a makefile, Compiling and Loading
KERNELDIR variable and, Version Dependency
makefiles, Compiling and Loading
adding version control with, Using Version Support in Modules
exporting versioned symbols, Exporting Versioned Symbols
install rules for, Version Dependency
SPARC architecture and, Platform Dependency
__make_request(), Doing Without the Request Queue
malloc.h header file, Quick Reference
mangling symbol names, Version Control in Modules, Exporting Versioned Symbols
maplist array (kiobuf), The kiobuf Structure, Mapping User-Space Buffers and Raw I/O
mapper program, Remapping RAM
mapping memory (see memory management)
mapping registers, DMA mappings
architectures not supporting, How different architectures support PCI DMA
scatterlists and, Scatter-gather mappings
map_user_kiobuf(), Mapping User-Space Buffers and Raw I/O, Quick Reference
marking bottom halves, The BH Mechanism
mark_bh(), The BH Mechanism, Quick Reference
max_readahead global array, Registering the Driver, Quick Reference
backward compatibility issues, Backward Compatibility
max_sectors global array, Registering the Driver, Quick Reference
max_segments global array, Registering the Driver
mb(), I/O Registers and Conventional Memory, Quick Reference
MCA (Micro Channel Architecture) buses, MCA
mdelay(), Short Delays, Quick Reference
mechanism, driver
defining, The Design of scull
policy versus, The Role of the Device Driver
media, directory for, drivers/media
Medium Access Control addresses (see MAC addresses)
mem.c file, drivers/char
memcpy_fromfs(), Changes in Access to User Space, Quick Reference
memcpy_fromio(), Directly Mapped Memory, Quick Reference
memcpy_tofs(), Changes in Access to User Space, Quick Reference
memcpy_toio(), Directly Mapped Memory, Quick Reference
memory
accessing
from expansion boards, Using I/O Memory, Probing for ISA Memory
in Linux 2.0, Access to User Space in Linux 2.0, Access to User Space in Linux 2.0
in PCI buses, PCI Addressing, Accessing the I/O and Memory Spaces, Peeking at the base address registers
allocating, scull’s Memory Usage, scull’s Memory Usage
at boot time, Boot-Time Allocation, Reserving High RAM Addresses
with kmalloc, The Real Story of kmalloc, The Size Argument
by page, get_free_page and Friends, A scull Using Whole Pages: scullp
performance degradation issues, get_free_page and Friends
with vmalloc, vmalloc and Friends, A scull Using Virtual Addresses: scullv
circular buffers, Using Circular Buffers
free, information on, Playing with the New Devices
global areas, The Design of scull
high, High and Low Memory
how much to allocate, The Size Argument
ISA memory range, ISA Memory Below 1 MB, ISA Memory Below 1 MB
limitations on, High and Low Memory
lookaside caches, Lookaside Caches, A scull Based on the Slab Caches: scullc
low, High and Low Memory
managing allocation, Using Resources
page size and portability, Page Size
persistence, The Design of scull
verifying user-space addresses, Using the ioctl Argument
vs. I/O registers, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory
memory barriers, I/O Registers and Conventional Memory
backward compatibility issues, Backward Compatibility
performance issues, I/O Registers and Conventional Memory
memory management, Splitting the Kernel
accessing pages not in memory, Mapping Memory with nopage, Mapping Memory with nopage
backward compatibility issues, Changes to Memory Management, Changes to Memory Management
DMA (direct memory access), Direct Memory Access and Bus Mastering, Talking to the DMA controller
fragmentation, Do-it-yourself allocation
handling map region changes, Mapping Memory with nopage, Mapping Memory with nopage
kernel source file directory, The mm Directory
memory mapping/remapping, The Memory Map and struct page, The Memory Map and struct page
accessing pages not in memory, Mapping Memory with nopage, Mapping Memory with nopage
handling region changes, Mapping Memory with nopage, Mapping Memory with nopage
kiobufs, The kiobuf Interface, Mapping User-Space Buffers and Raw I/O
mmap method, The mmap Device Operation, Remapping Virtual Addresses
PCI regions, Peeking at the base address registers
RAM, Remapping RAM, Remapping RAM with the nopage method
specific I/O regions, Remapping Specific I/O Regions
virtual addresses, Remapping Virtual Addresses
mmap method, The mmap Device Operation, Remapping Virtual Addresses
PCI and, Accessing the I/O and Memory Spaces, Peeking at the base address registers
theory of, Memory Management in Linux, Virtual Memory Areas
VMAs (virtual memory areas), Virtual Memory Areas, Virtual Memory Areas
memory map arrays, The Memory Map and struct page
memory maps, components of, Virtual Memory Areas
memory zones, Memory zones
memory-is-prefetchable bit, Accessing the I/O and Memory Spaces
memory-mapped registers (see I/O memory)
memory.c file, The mm Directory
memset_io(), Directly Mapped Memory, Quick Reference
messages
globally enabling/disabling, Turning the Messages On and Off
logging, How Messages Get Logged
oops messages, Oops Messages, Using ksymoops
priorities (loglevels) of, Building and Running Modules, printk, printk
mice, System Hangs
asynchronous notification, Asynchronous Notification
Micro Channel Architecture (MCA) buses, MCA
minor device numbers, Major and Minor Numbers, dev_t and kdev_t, The open Method
MINOR macro, dev_t and kdev_t, Quick Reference
minor_shift value (gendisk_struct), The Generic Hard Disk
MIPS processor
directly mapped memory, Directly Mapped Memory
inline assembly code and, Processor-Specific Registers
layout of boot code, Before Booting
PCI DMA interface support, How different architectures support PCI DMA
porting and, Platform Dependencies
MIPS64 architecture, support for PCI DMA interface, How different architectures support PCI DMA
misc directory, Other Subdirectories
installing drivers in, Version Dependency
misc-modules/export.c file, Exporting Symbols in Linux 2.0
MKDEV macro, dev_t and kdev_t, Quick Reference
mknod command, Major and Minor Numbers
mlock system call, Doing It in User Space
mlock.c file, The mm Directory
mm directory, The mm Directory
mm.h header file, The Flags Argument, Quick Reference, Virtual Memory Areas, Quick Reference
mm/kmalloc.c file, The Size Argument, The mm Directory
mm/slab.c file, The Size Argument, The mm Directory
mmap method, File Operations, The mmap Device Operation, Remapping Virtual Addresses
remapping virtual addresses with, Remapping Virtual Addresses
using remap_page_range, Using remap_page_range, A Simple Implementation
scullp driver and, Remapping RAM with the nopage method, Remapping RAM with the nopage method
usage count and, Adding VMA Operations
vm_area_struct structure and, Virtual Memory Areas
mmap.c file, The mm Directory
mmap_avl.c file, The mm Directory
modalities (levels), CPU, User Space and Kernel Space
modes
device modes, Dynamic Allocation of Major Numbers
file modes, The file Structure
modprobe program, Quick Reference
assigning parameter values, Automatic and Manual Configuration
directives, The User-Space Side
insmod program vs., The Kernel Symbol Table
loading modules, The User-Space Side
request_module() and, Requesting Modules in the Kernel
security issues for module names, Module Loading and Security
version control in modules, Version Control in Modules
modularization
kmod facility, kmod and Advanced Modularization
layered, The Kernel Symbol Table
network drivers, Modularized and Nonmodularized Drivers
module parameters, Automatic and Manual Configuration
backward compatibility issues, Module Configuration Parameters
MODULE symbol, Compiling and Loading
module.c file, The kernel Directory
module.h header file, Version Dependency, Quick Reference, File Operations
version.h header file and, Version Dependency
modules, Splitting the Kernel
applications vs., Kernel Modules Versus Applications, The Current Process
classes of, Classes of Devices and Modules, Classes of Devices and Modules
communicating between, Intermodule Communication, Intermodule Communication
current process and, The Current Process
debugging, Using klogd, Using ksymoops
exporting symbols, The Kernel Symbol Table, Exporting Versioned Symbols
in Linux 2.0, Exporting Symbols in Linux 2.0, Module Configuration Parameters
filesystem, Classes of Devices and Modules
header files of, Kernel Modules Versus Applications
initializing, Initialization and Shutdown, Error Handling in init_module
explicitly naming functions for, Explicit Initialization and Cleanup Functions
interrupts (see interrupt handlers)
license terms, License Terms
loading/unloading, Kernel Modules Versus Applications, Removing a Driver from the System, Loading Modules on Demand, Running User-Mode Helper Programs
(see also cleanup_module())
with dynamically assigned device numbers, Dynamic Allocation of Major Numbers
insmod program and, Compiling and Loading
for network drivers, Module Loading, Module Unloading
slave/master modules example, Module Loading Example
usage count and, The Usage Count, Intermodule Communication
using init scripts, Dynamic Allocation of Major Numbers
version dependency and, Version Dependency
partition detection in, Partition Detection , Partition Detection
platform dependency, Platform Dependency
probing for hardware (see probing)
requesting the loading of, Requesting Modules in the Kernel
security (see security)
stacking, The Kernel Symbol Table
usage count, The Usage Count, Intermodule Communication
backward compatibility issues, The Module Usage Count
version control, Version Control in Modules, Exporting Versioned Symbols
version dependency, Version Dependency, Version Dependency
modules file, The Usage Count, Quick Reference
ksymoops and, Using ksymoops
MODULE_AUTHOR macro, Automatic and Manual Configuration, Quick Reference
MODULE_DESCRIPTION macro, Automatic and Manual Configuration, Quick Reference
module_exit(), Explicit Initialization and Cleanup Functions, Quick Reference
module_init(), Explicit Initialization and Cleanup Functions, Quick Reference
__module_kernel_version symbol, Version Dependency
MODULE_PARM macro, Automatic and Manual Configuration, Quick Reference
backward compatibility issues, Module Configuration Parameters
MODULE_PARM_DESC macro, Automatic and Manual Configuration, Quick Reference
MODULE_SUPPORTED_DEVICE macro, Automatic and Manual Configuration, Quick Reference
modutils package
exporting symbols, The Kernel Symbol Table
misc directory and, Version Dependency
MODVERSIONS, Quick Reference
modversions.h header file, Using Version Support in Modules, Quick Reference
MOD_DEC_USE_COUNT macro, The Usage Count, Quick Reference
MOD_INC_USE_COUNT macro, The Usage Count, Quick Reference
MOD_IN_USE macro, The Usage Count, Quick Reference
mod_timer(), Kernel Timers, Quick Reference
avoiding race conditions, Kernel Timers
monitoring, preprocessor for, Turning the Messages On and Off, Turning the Messages On and Off
most significant bit, Preparing the Parallel Port
partitionable devices and, Partitionable Devices
mounting block drivers, How Mounting and Unmounting Works
mremap system call, Mapping Memory with nopage
remapping specific I/O regions, Remapping Specific I/O Regions
msr.h header file, Processor-Specific Registers, Quick Reference
MTU, network devices and, The device methods
multicasting, Multicasting, A Typical Implementation
IFF_MULTICAST flag and, Interface information
multiprocessor systems
backward compatibility issues, Compiling for Multiprocessor Systems
multiqueue block drivers, Multiqueue Block Drivers, Multiqueue Block Drivers
mutex semaphores, A Brief Introduction to Race Conditions
mutual exclusion mode (semaphores), A Brief Introduction to Race Conditions

N

namei.c file, The fs Directory
names, device (see devices, names of)
namespace pollution, Kernel Modules Versus Applications
native DMA, DMA for ISA Devices, Talking to the DMA controller
natural alignment of data items, Data Alignment
nbd.c file, drivers/block
nbtest program, A Sample Implementation: scullpipe
net directory, The net directory
netdevice.h header file, Module Loading, Quick Reference
netif_carrier_off(), Changes in Link State, Quick Reference
backward compatibility issues, Differences in Linux 2.2
netif_carrier_ok(), Changes in Link State, Quick Reference
netif_carrier_on(), Changes in Link State, Quick Reference
backward compatibility issues, Differences in Linux 2.2
netif_rx(), Quick Reference
packet reception and, Packet Reception
netif_start_queue(), Opening and Closing, Quick Reference
backward compatibility issues, Differences in Linux 2.2
netif_stop_queue(), Opening and Closing, Quick Reference
backward compatibility issues, Differences in Linux 2.2
controlling transmission concurrency, Controlling Transmission Concurrency
netif_wake_queue(), Quick Reference
backward compatibility issues, Differences in Linux 2.2
restarting packet transmission, Controlling Transmission Concurrency
netsyms.c file, The net directory
network drivers, Classes of Devices and Modules, Network Drivers, Quick Reference
connecting to kernel, Connecting to the Kernel, Modularized and Nonmodularized Drivers
initializing devices, Initializing Each Device, drivers/net
interrupt handlers for, The Interrupt Handler
link state, changes in, Changes in Link State
loading/unloading modules for, Module Loading, Module Unloading
methods of, The device methods, The device methods
modularized vs. non-modularized, Modularized and Nonmodularized Drivers
opening/closing network interface, Opening and Closing, Opening and Closing
socket buffers (see socket buffers)
statistics on, Statistical Information
networking, Splitting the Kernel
backward compatibility issues, Backward Compatibility, Probing and HAVE_DEVLIST
net_device structure, Module Loading, The net_device Structure in Detail, Utility fields
device methods of, The device methods, The device methods
ether_setup and, Initializing Each Device, Interface information, Interface information
hidden fields, The Hidden Fields, Utility fields
interface flags for, Interface information
interface information, Interface information, Interface information
unusual devices, assigning fields for, Interface information
utility fields for, Utility fields
visible fields, The Visible Head
net_device_stats structure, Initializing Each Device
backward compatibility issues, Further Differences in Linux 2.0
fields in, Statistical Information
net_init.c file, Interface information
non-modularized network drivers, Modularized and Nonmodularized Drivers
nonblocking operations, Blocking and Nonblocking Operations
poll method, poll and select, The Underlying Data Structure
select method, poll and select, The Underlying Data Structure
testing, A Sample Implementation: scullpipe
nonpreemption and concurrency, Concurrency in the Kernel
nopage method, Virtual Memory Areas
backward compatibility issues, Changes to Memory Management
mapping memory with, Mapping Memory with nopage, Mapping Memory with nopage
mapping RAM to user space, Remapping RAM with the nopage method, Remapping RAM with the nopage method
mremap system call with, Mapping Memory with nopage
preventing extension of mapping, Remapping Specific I/O Regions
remapping virtual addresses with, Remapping Virtual Addresses
normal memory zone, Memory zones
__NO_VERSION__ symbol, Version Dependency, Quick Reference
NR_IRQS symbol, Do-it-yourself probing
NuBus, NuBus
NULL pointers, invalid dereferencing, Oops Messages, Oops Messages
NUM macro, splitting minor numbers, The open Method
numbering versions (see version numbering)
n_tty.c file, drivers/char

O

objdump utility, Using ksymoops
disassembling module functions, Using gdb
octets vs. bytes, Network Drivers
oops messages, Removing a Driver from the System, Oops Messages, Using ksymoops
decoding, Using klogd, Using ksymoops
resolving hex values of, Using ksymoops
open files vs. disk files, The file Structure
open method, File Operations, The open Method, The open Method
accessing data within partitions, The Device Methods for spull
adding VMA operations, Adding VMA Operations
blocking, Blocking open as an Alternative to EBUSY
checking for disk changes, Extra Care
cloning devices in response to, Cloning the Device on Open, Cloning the Device on Open
initializing file pointers, Using devfs in Practice
mounting block drivers, How Mounting and Unmounting Works
for network devices, The device methods, Opening and Closing
private_data and, The file Structure
requesting DMA channels, Registering DMA usage
restricting simultaneous users and, Restricting Access to a Single User at a Time
for single-open devices, Single-Open Devices
vm_operations_struct structure, Virtual Memory Areas
open.c file, The fs Directory
opening network interface, Opening and Closing, Opening and Closing
optimizations, compiler, I/O Registers and Conventional Memory
options directive (modprobe), The User-Space Side
outb(), Using I/O Ports, Quick Reference
outb_p(), Pausing I/O
outl(), Using I/O Ports, Quick Reference
output buffers, driver, Blocking and Nonblocking Operations
output pins, Hardware Management, Using Digital I/O Ports
soldering LEDs to, A Sample Driver
outsb(), String Operations, Quick Reference
outsl(), String Operations, Quick Reference
outsw(), String Operations, Quick Reference
outw(), Using I/O Ports, Quick Reference
overriding ARP, Overriding ARP
O_NDELAY flag (f_flags field), Blocking and Nonblocking Operations
O_NONBLOCK flag (f_flags field), The file Structure, The Predefined Commands, Blocking and Nonblocking Operations
read/write methods and, Reading data from the device
O_RDONLY flag (f_flags field), The file Structure
O_SYNC flag (f_flags field), The file Structure

P

__pa(), Address Types, Quick Reference
backward compatibility issues, Changes to Memory Management
packages, upgrading, Version Numbering
packets
multicasting, Multicasting, A Typical Implementation
transmission/reception of, The Physical Transport of Packets, Packet Transmission, Packet Reception
PACKET_BROADCAST flag, The Important Fields
PACKET_HOST flag, The Important Fields
PACKET_MULTICAST flag, The Important Fields
PACKET_OTHERHOST flag, The Important Fields
Page Directory (PGD) page table, Page Tables
page faults caused by invalid pointers, Oops Messages
Page Mid-level Directory (PMD) page table, Page Tables
page size and portability, Page Size
page tables, Page Tables, Page Tables
building
using nopage, Mapping Memory with nopage, Mapping Memory with nopage
using remap_page_range, Using remap_page_range
I/O memory and, Using I/O Memory
remapping virtual addresses, Remapping Virtual Addresses
page-oriented allocation functions, get_free_page and Friends, A scull Using Whole Pages: scullp
page.h header file, Page Size, Quick Reference, Address Types, Page Tables
page_address(), The Memory Map and struct page, Quick Reference
page_alloc.c file, The mm Directory
PAGE_SHIFT symbol, Page Size, Quick Reference
PAGE_SIZE symbol, Page Size, Quick Reference
mmap method and, The mmap Device Operation
page_table_lock, Page Tables
backward compatibility issues, Changes to Memory Management
remapping virtual addresses, Remapping Virtual Addresses
panic.c file, The kernel Directory
Parallel Line Internet Protocol (PLIP)
using Ethernet headers, Overriding ARP
interrupt handling differences, The Interrupt Handler
overriding ARP, Overriding ARP
parallel port driver modules, stacking, The Kernel Symbol Table
parallel ports, An Overview of the Parallel Port, A Sample Driver
disabling interrupts, Enabling and Disabling Interrupts
preparing for interrupt handling, Preparing the Parallel Port
running shared interrupt handlers, Running the Handler
stacking driver modules, The Kernel Symbol Table
param.h header file, Time Intervals in the Kernel, Quick Reference
parameters
assigning values, Automatic and Manual Configuration
device, Automatic and Manual Configuration
module, Automatic and Manual Configuration
backward compatibility issues, Module Configuration Parameters
parport device driver, drivers/char
parse_options(), Booting the Kernel
partial data transfers
read method, The read Method
write method, The write Method
partitionable devices, Partitionable Devices, The Device Methods for spull
accessing data within partitions, The Device Methods for spull
detecting partitions
with initrd, Partition Detection Using initrd
in modules, Partition Detection , Partition Detection
generic hard disk support for, The Generic Hard Disk
path directive (modprobe), The User-Space Side
pausing I/O, Pausing I/O
PC parallel interface, An Overview of the Parallel Port, A Sample Driver
PC/104 and PC/104+ bus architectures, PC/104 and PC/104+
PCI (Peripheral Component Interconnect)
addressing, PCI Addressing, PCI Addressing
base address registers, Peeking at the base address registers, Peeking at the base address registers
configuration registers, Configuration Registers and Initialization, Configuration Registers and Initialization
configuration space, PCI Addressing, Accessing the Configuration Space, Looking at a configuration snapshot
device configuration snapshot, Looking at a configuration snapshot
DMA and, DMA on the PCI Bus, A quick look at SBus
dealing with difficult hardware, Dealing with difficult hardware
DMA mappings (see DMA mappings)
hardware dependencies for, How different architectures support PCI DMA
simple example of, A simple PCI DMA example
drivers, alternative to, Configuration Registers and Initialization
drivers/pci directory, Bus-Specific Directories
geographical addressing, PCI Addressing
hardware abstractions, Hardware Abstractions
hot-pluggable devices, Handling Hot-Pluggable Devices, The pci_driver structure
I/O resources, PCI I/O resources in Linux 2.4
interface of, The PCI Interface, Hardware Abstractions
interrupts, PCI Interrupts
using ioremap(), vmalloc and Friends
remap_page_range and, Mapping Memory with nopage
pci.h header file, DMA on the PCI Bus, Quick Reference, Configuration Registers and Initialization, Quick Reference
accessing configuration space, Accessing the Configuration Space
detecting size of PCI regions, Peeking at the base address registers
pci_ops structure and, Hardware Abstractions
pcibios.h header file, Backward Compatibility
pcidata module, Looking at a configuration snapshot
pcidump program, Looking at a configuration snapshot
pciregions module, Peeking at the base address registers
pci_alloc_consistent(), Setting up consistent DMA mappings, Quick Reference
PCI_BASE_ADDRESS_ symbols, Accessing the I/O and Memory Spaces, Peeking at the base address registers
pci_bus structure, Hardware Abstractions, Quick Reference
pci_dev structure, DMA on the PCI Bus, Configuration Registers and Initialization, Quick Reference
backward compatibility issues, Backward Compatibility
reading configuration variables, Accessing the Configuration Space
pci_device_id structure, The pci_driver structure, Quick Reference
ID fields for, The pci_driver structure
pci_dev_driver(), Handling Hot-Pluggable Devices
PCI_DMA_BIDIRECTIONAL symbol, Setting up streaming DMA mappings, Quick Reference
PCI_DMA_FROMDEVICE symbol, Setting up streaming DMA mappings, Quick Reference
bounce buffers and, Setting up streaming DMA mappings
PCI_DMA_NONE symbol, Setting up streaming DMA mappings, Quick Reference
pci_dma_supported(), Dealing with difficult hardware, Quick Reference
pci_dma_sync_sg(), Scatter-gather mappings, Quick Reference
PCI_DMA_TODEVICE symbol, Setting up streaming DMA mappings, Quick Reference
bounce buffers and, Setting up streaming DMA mappings
pci_driver structure, The pci_driver structure, The pci_driver structure, Quick Reference
backward compatibility issues, Backward Compatibility
handling hot-pluggable devices, Handling Hot-Pluggable Devices
pci_enable_device(), Configuration Registers and Initialization
pci_find_class(), Configuration Registers and Initialization, Quick Reference
pci_find_device(), Configuration Registers and Initialization, Quick Reference
pci_find_slot(), Configuration Registers and Initialization
pci_free_consistent(), Setting up consistent DMA mappings, Quick Reference
pci_insert_device(), Handling Hot-Pluggable Devices
PCI_INTERRUPT_ symbols, PCI Interrupts
pci_map_sg(), Scatter-gather mappings, Quick Reference
pci_map_single(), Setting up streaming DMA mappings, Quick Reference
pci_module_init(), Handling Hot-Pluggable Devices, Quick Reference
pci_ops structure, Hardware Abstractions
pci_present(), Configuration Registers and Initialization, Quick Reference
pci_read_config_ functions, Accessing the Configuration Space, Quick Reference
pci_register_driver(), Handling Hot-Pluggable Devices, Quick Reference
pci_remove_device(), Handling Hot-Pluggable Devices
pci_resource_end(), PCI I/O resources in Linux 2.4
pci_resource_flags(), PCI I/O resources in Linux 2.4
pci_resource_start(), PCI I/O resources in Linux 2.4
pci_set_dma_mask(), Dealing with difficult hardware
pci_sync_single(), Setting up streaming DMA mappings, Quick Reference
pci_unmap_sg(), Scatter-gather mappings, Quick Reference
pci_unmap_single(), Setting up streaming DMA mappings, Quick Reference
pci_unregister_driver(), Handling Hot-Pluggable Devices, Quick Reference
pci_write_config_ functions, Accessing the Configuration Space, Quick Reference
PDEBUG/PDEBUGG symbols, Turning the Messages On and Off
pending output, flushing, Flushing pending output
performance
allocating socket buffers, Packet Reception
avoiding device collisions, I/O Ports and I/O Memory
clustering requests and, Clustered Requests
debugger use, Debuggers and Related Tools
degrading by allocating too much memory, get_free_page and Friends
managing system resources, Using Resources, Resource Allocation in Linux 2.4
memory barriers and, I/O Registers and Conventional Memory
mmap method, The mmap Device Operation
namespace pollution, Kernel Modules Versus Applications
output buffers and, Blocking and Nonblocking Operations
PCI vs. ISA, The PCI Interface
printk to debug, Debugging by Querying
raw I/O limitations to, Mapping User-Space Buffers and Raw I/O
using request queues (see request queues)
string operations and, String Operations
peripheral bus architecture (see bus architecture)
Peripheral Component Interconnect (see PCI)
peripheral memory, Using I/O Memory, Probing for ISA Memory
perror() vs. strace command, Debugging by Watching
persistence of memory, The Design of scull
PGD (Page Directory) page table, Page Tables
pgd_offset(), Page Tables
pgd_val(), Page Tables
pgtable.h header file, vmalloc and Friends, Page Tables
PG_locked flag, The Memory Map and struct page
PG_reserved flag, The Memory Map and struct page
physical addresses, Address Types
mapping virtual addresses to, Page Tables
pins 9/10 of parallel connector, Preparing the Parallel Port
generating interrupts, Implementing a Handler
platform dependency, Version Numbering
bit operations and, Bit operations
kmalloc flags and, The Flags Argument
for modules, Platform Dependency
porting and, Platform Dependencies, Platform Dependencies
/proc/stat file, The /proc Interface
platform-specific directories, Platform-Specific Directories
PLIP (Parallel Line Internet Protocol)
using Ethernet headers, Overriding ARP
interrupt handling differences, The Interrupt Handler
overriding ARP, Overriding ARP
Plug-and-Play (PnP) specification, The Plug-and-Play Specification
pm.c file, The kernel Directory
PMD (Page Mid-level Directory) page table, Page Tables
pmd_offset(), Page Tables
pmd_val(), Page Tables
PnP (Plug-and-Play) specification, The Plug-and-Play Specification
Point-to-Point Protocol (PPP) and interrupt handling differences, The Interrupt Handler
pointers and invalid dereferencing, Oops Messages, Using ksymoops
policy, driver, The Role of the Device Driver , The Role of the Device Driver
controlling devices by printing and, Device Control Without ioctl
poll method, File Operations, poll and select, The Underlying Data Structure
data structures of, The Underlying Data Structure
poll.h header file, poll and select, Quick Reference
POLLERR flag, poll and select
POLLHUP flag, poll and select
POLLIN flag, poll and select
POLLOUT flag, poll and select
POLLPRI flag, poll and select
POLLRDBAND flag, poll and select
POLLRDNORM flag, poll and select
POLLWRBAND flag, poll and select
POLLWRNORM flag, poll and select
poll_table structure, poll and select, The Underlying Data Structure
poll_table_entry structure, The Underlying Data Structure
poll_wait(), poll and select, Quick Reference
portability, Other Portability Issues, Linked Lists
data types and, Judicious Use of Data Types, Interface-Specific Types
devfs (device filesystem), Portability Issues and devfs
porting and, Platform Dependencies, Platform Dependencies
ports, I/O Ports and I/O Memory, Resource Allocation in Linux 2.4, Using I/O Ports, Platform Dependencies
accessing different sizes, Using I/O Ports
allocating, Ports
avoiding collisions, Ports
parallel (see parallel ports)
platform dependency and, Platform Dependencies, Platform Dependencies
post-install directive (modprobe), The User-Space Side
post-remove directive (modprobe), The User-Space Side
PowerPC architecture
page tables not used in, Page Tables
PCI DMA interface support, How different architectures support PCI DMA
porting and, Platform Dependencies
PPP (Point-to-Point Protocol) and interrupt handling differences, The Interrupt Handler
pre-install directive (modprobe), The User-Space Side
pre-remove directive (modprobe), The User-Space Side
pread method, read and write, Changes in the File Operations Structure
llseek method and, The llseek Implementation
precision, temporal, Knowing the Current Time
predefined
ioctl method commands, The Predefined Commands
task queues, Predefined Task Queues, The immediate queue
preemption and concurrency, Concurrency in the Kernel
prefetchable bit, Accessing the I/O and Memory Spaces
prefixes, Kernel Modules Versus Applications, Automatic and Manual Configuration
preprocessor, using to monitor driver, Turning the Messages On and Off, Turning the Messages On and Off
printing
controlling devices by, Device Control Without ioctl
to debug code, Debugging by Printing, Turning the Messages On and Off
from gdb debugger, Using gdb
interface-specific data, Interface-Specific Types
partition information, Partition Detection
_t data items, Interface-Specific Types
printk(), Building and Running Modules, Quick Reference
circular buffers for, How Messages Get Logged
current pointer and, The Current Process
debugging with, printk, printk, Debugging by Querying
logging messages from, How Messages Get Logged
loglevel strings for, printk
turning debug messages on/off, Turning the Messages On and Off
printk.c file, The kernel Directory
priority
asynchronous notification and, Asynchronous Notification, The Driver’s Point of View
immediate queue, Predefined Task Queues, The immediate queue
memory allocation, Using Resources, The Flags Argument
message (see loglevels)
private_data field (file structure), The file Structure, Writing Reentrant Code
privileged operations, Capabilities and Restricted Operations
probe method, The pci_driver structure
Probes, Dynamic, Dynamic Probes
probe_irq_off(), Kernel-assisted probing, Quick Reference
probe_irq_on(), Kernel-assisted probing, Quick Reference
probing, I/O Ports and I/O Memory, Resource Allocation in Linux 2.4
backward compatibility issues, Probing and HAVE_DEVLIST
for IRQ numbers, Autodetecting the IRQ Number, Do-it-yourself probing
shared interrupts and, Installing a Shared Handler
for ISA memory, Probing for ISA Memory, Probing for ISA Memory
for network devices, Initializing Each Device
/proc filesystem
creating
/proc entries, Using the /proc Filesystem
read-only /proc files, Using the /proc Filesystem
debugging with, Using the /proc Filesystem, Using the /proc Filesystem
installing an interrupt handler, The /proc Interface
removing /proc entries, Using the /proc Filesystem
shared interrupts and, The /proc Interface
vs. ioctl method, The ioctl Method
/proc/bus/pci file
backward compatibility issues, Backward Compatibility
browsing configuration space, Looking at a configuration snapshot
visibility of hardware addresses, PCI Addressing
/proc/bus/pci/devices file, Boot Time
/proc/devices file, Dynamic Allocation of Major Numbers
/proc/interrupts file, The /proc Interface, Quick Reference
shared interrupts and, The /proc Interface
/proc/iomem file, Memory, Quick Reference
/proc/ioports file, I/O Ports and I/O Memory, Quick Reference
/proc/kcore file, Using gdb
/proc/kmsg file, How Messages Get Logged
/proc/ksyms file, The Kernel Symbol Table, Quick Reference
ksymoops and, Using ksymoops
module version support and, Version Control in Modules
searching for registration functions, Initialization and Shutdown
/proc/modules file, The Usage Count, Quick Reference
ksymoops and, Using ksymoops
/proc/pci file
backward compatibility issues, Backward Compatibility
browsing configuration space, Looking at a configuration snapshot
visibility of hardware addresses, PCI Addressing
/proc/pcidata file, Looking at a configuration snapshot
/proc/pciregions file
browsing configuration space, Peeking at the base address registers
/proc/slabinfo file, Lookaside Caches
/proc/stat file, The /proc Interface, Quick Reference
/proc/sys/kernel/printk file, reading console loglevel with, printk
processes
access to multiple, Restricting Access to a Single User at a Time
avoiding race conditions with spinlocks, Another Digression into Race Conditions, Using Spinlocks, Using Spinlocks
kernel timers for, Kernel Timers, Kernel Timers
managing, Splitting the Kernel
opening devices for each process, Single-Open Devices
requeuing, How Task Queues Are Run
sleeping, Going to Sleep and Awakening, Writing Reentrant Code
race conditions and, Going to Sleep Without Races, Going to Sleep Without Races
task queues for, Task Queues, Tasklets
wait queues and, Going to Sleep and Awakening, A Deeper Look at Wait Queues
waking up (see waking up processes)
processor-specific registers, Processor-Specific Registers, Processor-Specific Registers
processor.h header file, MCA
proc_fs.h header file, Using the /proc Filesystem
proc_register(), Using the /proc Filesystem
proc_register_dynamic(), Using the /proc Filesystem
proc_dir_entry
create_proc_read_entry() and, Using the /proc Filesystem
proc_register_dynamic() and, Using the /proc Filesystem
producer/consumer algorithm, Using Circular Buffers
programmable decoders, Peeking at the base address registers
programming drivers (see writing, drivers)
programs, obtaining, License Terms
protect method, Virtual Memory Areas
proto_ops structure, The net directory
pte_offset(), Page Tables
pte_page(), Page Tables
pte_present(), Page Tables
pte_val(), Page Tables
using pte_page instead, Page Tables
PTRS_PER_PGD macro, Page Tables
PTRS_PER_PMD macro, Page Tables
PTRS_PER_PTE macro, Page Tables
put_unaligned(), Data Alignment, Quick Reference
__put_user(), Using the ioctl Argument, Quick Reference
put_user(), Using the ioctl Argument, Quick Reference
Linux 2.0 version, Access to User Space in Linux 2.0
pwrite method, read and write, Changes in the File Operations Structure
llseek method and, The llseek Implementation

Q

quantum (memory area), scull’s Memory Usage
race conditions and, A Brief Introduction to Race Conditions
reading/writing one at a time, Playing with the New Devices
querying to debug, Debugging by Querying, The ioctl Method
queue heads, active, The active queue head
queues
initializing/cleaning up, Registering the Driver
request (see request queues)
scheduler queue, Predefined Task Queues, The scheduler queue, The scheduler queue
task (see task queues)
timer (see entries under tq_; timer queues)
wait (see wait queues)
queue_task(), The Nature of Task Queues, Quick Reference
rescheduling tasks, How Task Queues Are Run
running custom task queues, Running Your Own Task Queues
scheduler queue and, The scheduler queue
timer queue and, The timer queue
vs. queue_task_irq, Backward Compatibility
queue_task_irq(), Backward Compatibility
queue_task_irq_off(), Backward Compatibility

R

race conditions, Concurrency in the Kernel
avoiding, with wait_event macros, Going to Sleep and Awakening, Quick Reference
interrupt handling and, Race Conditions, Going to Sleep Without Races
introduction to, A Brief Introduction to Race Conditions, read and write
kernel timers and, Kernel Timers
single-processor vs. SMP systems, Another Digression into Race Conditions
RAID drivers
drivers/md directory, drivers/md
“make request” function and, Doing Without the Request Queue
RAM
probing ISA memory for, Probing for ISA Memory
remapping, Remapping RAM, Remapping RAM with the nopage method
reserving high RAM addresses, Reserving High RAM Addresses
vs. I/O registers, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory
random numbers, Installing an Interrupt Handler
ranges, resource, Resource Allocation in Linux 2.4
raw I/O and user-space buffers, Mapping User-Space Buffers and Raw I/O, Mapping User-Space Buffers and Raw I/O
rd.c file, drivers/block
rdtsc/rdtscl functions, Processor-Specific Registers, Quick Reference
read method, File Operations, read and write, The read Method
arguments to, read and write
code for, The read Method
configuring DMA controller, Talking to the DMA controller
f_pos field (file structure) and, The file Structure, Changes in the File Operations Structure
get_info() and, Using the /proc Filesystem
llseek method and, The llseek Implementation
poll method and, Reading data from the device
read_proc() and, Using the /proc Filesystem
return values, rules for interpreting, The read Method
strace command and, Debugging by Watching
syntax in Linux 2.0, Changes in the File Operations Structure
read/write instructions, reordering, I/O Registers and Conventional Memory
read/write position, changing, File Operations
readb(), Directly Mapped Memory, Quick Reference
readdir method, File Operations
reader-writer spinlocks, Using Spinlocks
reading
blocking I/O, Blocking I/O, A Sample Implementation: scullpipe
blocking/nonblocking operations, Blocking and Nonblocking Operations
poll method, poll and select, The Underlying Data Structure
select method, poll and select, The Underlying Data Structure
testing, A Sample Implementation: scullpipe
from a device, read and write, The read Method
readl(), Directly Mapped Memory, Quick Reference
readq(), Directly Mapped Memory
readv method, File Operations, readv and writev
readw(), Directly Mapped Memory, Quick Reference
read_ahead global array, Registering the Driver, Quick Reference
read_lock(), Using Spinlocks, Quick Reference
read_lock_bh(), Using Spinlocks, Quick Reference
read_lock_irq(), Using Spinlocks, Quick Reference
read_lock_irqsave(), Using Spinlocks, Quick Reference
read_proc(), Using the /proc Filesystem, Using the /proc Filesystem
connecting to /proc hierarchy, Using the /proc Filesystem
read_unlock(), Using Spinlocks, Quick Reference
read_unlock_bh(), Using Spinlocks, Quick Reference
read_unlock_irq(), Using Spinlocks, Quick Reference
read_unlock_irqrestore(), Using Spinlocks, Quick Reference
read_write.c file, The fs Directory
rebuild_header method, The device methods
backward compatibility issues, Further Differences in Linux 2.0
reception of packets, The Physical Transport of Packets, Packet Reception, Packet Reception
multicasting, Multicasting, A Typical Implementation
reentrancy, Concurrency in the Kernel, System Hangs, Writing Reentrant Code
registering
block drivers, Registering the Driver, Registering the Driver
DMA usage, Registering DMA usage
facilities in init_module, Initialization and Shutdown, Error Handling in init_module
network drivers, Module Loading
ports, Ports
registers
I/O, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory
mapping, DMA mappings
scatterlists and, Scatter-gather mappings
PCI configuration, Configuration Registers and Initialization, Configuration Registers and Initialization
processor-specific, Processor-Specific Registers, Processor-Specific Registers
register_blkdev(), Registering the Driver, Quick Reference
register_cdrom(), drivers/cdrom
register_chrdev(), Major and Minor Numbers, Dynamic Allocation of Major Numbers, Quick Reference
vs. register_blkdev(), Registering the Driver
register_disk(), Quick Reference
accessing data within partitions, The Device Methods for spull
backward compatibility issues, Backward Compatibility
printing partition information, Partition Detection
reading generic disk partition table, Partition Detection
registering devices, Registering the Driver
register_framebuffer(), drivers/video
register_netdev(), Quick Reference
REGISTER_SYMTAB macro, Exporting Symbols in Linux 2.0
register_symtab(), Exporting Symbols in Linux 2.0, Quick Reference
release method, File Operations, The release Method
(see also close method)
blocking open and, Blocking open as an Alternative to EBUSY
syntax in Linux 2.0, Changes in the File Operations Structure
unmounting block devices, How Mounting and Unmounting Works
release_dma_lock(), Talking to the DMA controller, Quick Reference
release_irq(), Installing a Shared Handler
release_mem_region(), Quick Reference, Quick Reference
backward compatibility issues, Changes in Resource Management
working with I/O memory, Memory, Using I/O Memory
release_region(), Quick Reference, Quick Reference
backward compatibility issues, Changes in Resource Management
working with I/O ports, Ports, Using I/O Ports
remapping
I/O regions, Remapping Specific I/O Regions
PCI regions, Peeking at the base address registers
RAM, Remapping RAM, Remapping RAM with the nopage method
virtual addresses, Remapping Virtual Addresses
remap_page_range(), Using remap_page_range, A Simple Implementation, Quick Reference
limitations in dealing with RAM, Remapping RAM
mapping addresses returned by ioremap, Remapping Virtual Addresses
removable block devices, Removable Devices, Extra Care
remove method, The pci_driver structure
remove_proc_entry(), Using the /proc Filesystem
__remove_wait_queue, Going to Sleep Without Races, Quick Reference
remove_wait_queue(), Quick Reference, Going to Sleep Without Races, Quick Reference
reordering read/write instructions, I/O Registers and Conventional Memory
repatch program, Bibliography
request function
backward compatibility issues, Backward Compatibility
basic design of, Handling Requests: A Simple Introduction, Performing the Actual Data Transfer
buffer cache and, The request structure and the buffer cache
interrupt-driven devices and, Interrupt-Driven Block Drivers
io_request_lock and, The I/O request lock
multiqueue block drivers and, Multiqueue Block Drivers
registering block devices, Registering the Driver
register_disk and, Partition Detection
splitting up multibuffer requests, How the blk.h macros and functions work
transferring data, Performing the Actual Data Transfer
request queues, Registering the Driver
active queue heads and, The active queue head
blk.h header file and, The Header File blk.h, The Header File blk.h
block drivers not using, Doing Without the Request Queue, Doing Without the Request Queue
buffers in, The request structure and the buffer cache
defining, Multiqueue Block Drivers
I/O request locks (see io_request_lock)
initializing device-specific, Multiqueue Block Drivers
introduction to, Handling Requests: A Simple Introduction, The Request Queue
manipulating, Request queue manipulation
multiqueue block drivers and, Multiqueue Block Drivers, Multiqueue Block Drivers
request_queue structure, The I/O Request Queue
request structure, Performing the Actual Data Transfer
buffer cache and, The request structure and the buffer cache
releasing back to kernel, Request queue manipulation
requesting interrupts (see interrupt handlers)
requests, block driver, Handling Requests: A Simple Introduction, Doing Without the Request Queue
blocking, Blocking open as an Alternative to EBUSY
clustered, Clustered Requests
handling data transfer, Performing the Actual Data Transfer, Performing the Actual Data Transfer
interrupt-driven devices and, Interrupt-Driven Block Drivers
partitionable devices and, The Device Methods for spull
request_dma(), Registering DMA usage, Quick Reference
request_irq(), Installing an Interrupt Handler, Quick Reference
installing shared handlers, Installing a Shared Handler
when to call, Installing an Interrupt Handler
request_mem_region(), Quick Reference, Quick Reference
backward compatibility issues, Changes in Resource Management
working with I/O memory, Memory, Using I/O Memory
request_module(), Requesting Modules in the Kernel, Quick Reference
inter_module_get_request() and, Intermodule Communication
loading modules, The User-Space Side
modprobe program and, Requesting Modules in the Kernel
security issues for module names, Module Loading and Security
__request_region(), Resource Allocation in Linux 2.4
request_region(), Quick Reference, Quick Reference
backward compatibility issues, Changes in Resource Management
working with I/O ports, Ports, Using I/O Ports
requeuing/rescheduling tasks, How Task Queues Are Run
reserved pages, remapping, Remapping RAM, Remapping RAM with the nopage method
reserving high RAM addresses, Reserving High RAM Addresses
resetup_one_dev(), Backward Compatibility
resolution, time, Knowing the Current Time
resolving Ethernet addresses, MAC Address Resolution, Non-Ethernet Headers
resource ranges, Resource Allocation in Linux 2.4
resources
allocating in Linux 2.4, Resource Allocation in Linux 2.4
managing, Using Resources, Resource Allocation in Linux 2.4
backward compatibility for, Changes in Resource Management
PCI, PCI I/O resources in Linux 2.4
restore_flags(), Overall Control of Interrupts
restricting access (see access)
resume method, The pci_driver structure
revalidate method, Revalidation
backward compatibility issues, Backward Compatibility
register_disk and, Partition Detection
ring buffers, DMA, Overview of a DMA Data Transfer
RISC processor and inline assembly code, Processor-Specific Registers
rmb(), I/O Registers and Conventional Memory, Quick Reference
rmmod program, Splitting the Kernel, Unloading
dynamically allocating major numbers, Dynamic Allocation of Major Numbers
testing modules using, Building and Running Modules
ROM, probing ISA memory for, Probing for ISA Memory
route utility, Assigning IP Numbers
Rules.make file, Version Dependency
platform dependency and, Platform Dependency
runtime errors, strace for, Debugging by Watching
run_task_queue(), The Nature of Task Queues, Quick Reference
running custom task queues, Running Your Own Task Queues
rwlock_t type, Using Spinlocks, Quick Reference
RW_LOCK_UNLOCKED, Using Spinlocks

S

S390 architecture
no support for PCI bus, How different architectures support PCI DMA
porting and, Platform Dependencies
SAK (Secure Attention Key) function, System Hangs
sample programs, obtaining, License Terms
save_flags(), Overall Control of Interrupts
SA_INTERRUPT flag, Installing an Interrupt Handler, Quick Reference
fast vs. slow interrupt handling, Fast and Slow Handlers
SA_SAMPLE_RANDOM flag, Installing an Interrupt Handler, Quick Reference
SA_SHIRQ flag, Installing an Interrupt Handler, Quick Reference
installing shared handlers, Installing a Shared Handler
sbull driver (example), Loading Block Drivers, Quick Reference
adding raw I/O capability, Mapping User-Space Buffers and Raw I/O, Mapping User-Space Buffers and Raw I/O
sbullr driver (example), Mapping User-Space Buffers and Raw I/O, Mapping User-Space Buffers and Raw I/O
SBus (Sun-designed bus), SBus
drivers/sbus directory, Bus-Specific Directories
performing DMA mappings on, A quick look at SBus
sbus.h header file, A quick look at SBus
scatter-gather DMA mappings, Scatter-gather mappings
scatterlist structure, Scatter-gather mappings, Quick Reference
scatterlist.h header file, Scatter-gather mappings
scatterlists, mapping, Scatter-gather mappings
sched.h header file, Quick Reference, Quick Reference, Quick Reference, Quick Reference
capable() and, Capabilities and Restricted Operations
interrupt request line functions, Installing an Interrupt Handler
jiffies value and, Time Intervals in the Kernel
kernel directory and, The kernel Directory
wait queue code information, A Deeper Look at Wait Queues
schedule(), A Deeper Look at Wait Queues, Quick Reference, The kernel Directory
delaying execution of code, Long Delays
exclusive waits and, A Deeper Look at Wait Queues
preventing endless loops with, System Hangs
reentrant functions and, Writing Reentrant Code
scheduler queue (tq_scheduler), Predefined Task Queues, The scheduler queue, The scheduler queue
backward compatibility issues, Backward Compatibility
schedule_task(), Predefined Task Queues, The scheduler queue, Quick Reference
backward compatibility issues, Backward Compatibility
schedule_timeout(), Long Delays
screen layouts, kernel support for, drivers/video
SCSI drivers, Classes of Devices and Modules
drivers/scsi directory, drivers/scsi
scsi.c file, drivers/scsi
scsi_ioctl.c file, drivers/scsi
scsi_module.c file, drivers/scsi
scsi_register_module(), drivers/scsi
scull driver (example), Char Drivers, Changes in Access to User Space, Turning the Messages On and Off, Choosing the ioctl Commands, Using the ioctl Argument, The Implementation of the ioctl Commands
scullc driver (example), A scull Based on the Slab Caches: scullc
scullp driver (example), A scull Using Whole Pages: scullp
mapping RAM to user space, Remapping RAM with the nopage method, Remapping Virtual Addresses
scullpipe devices (examples), A Sample Implementation: scullpipe, A Sample Implementation: scullpipe
scullv driver (example), A scull Using Virtual Addresses: scullv, A scull Using Virtual Addresses: scullv, Remapping Virtual Addresses
Secure Attention Key (SAK) function, System Hangs
security, Security Issues
module loading and, Module Loading and Security
seeking a device, Seeking a Device
in Linux version 2.0, Seeking in Linux 2.0
segment.h header file, Quick Reference
select method, poll and select, The Underlying Data Structure
in Linux version 2.0, The Linux 2.0 select Method
poll method and, File Operations
selection.c file, drivers/char
semaphore.h header file, A Brief Introduction to Race Conditions, Quick Reference
semaphores, A Brief Introduction to Race Conditions, read and write
backward compatibility issues, Changes in Semaphore Support
detecting deadlocks with IKD, The Integrated Kernel Debugger Patch
incrementing value of, A Brief Introduction to Race Conditions
initializing, A Brief Introduction to Race Conditions
not used in interrupt handlers, Race Conditions
protecting critical code regions, A Sample Implementation: scullpipe
vs. spinlocks, Another Digression into Race Conditions
sema_init(), A Brief Introduction to Race Conditions, Quick Reference
sysdep.h header file and, Changes in Semaphore Support
setconsole program (example), printk
setterm program, Device Control Without ioctl
setup_arch(), Booting the Kernel
set_bit(), Bit operations, Quick Reference
set_config method, The device methods
set_current_state(), Going to Sleep Without Races, Quick Reference
backward compatibility issues, Differences in the 2.2 Kernel
set_dma_addr(), Talking to the DMA controller, Quick Reference
set_dma_count(), Talking to the DMA controller, Quick Reference
set_dma_mode(), Talking to the DMA controller, Quick Reference
SET_FILE_OWNER macro, The Module Usage Count
SET_INTR macro, The Header File blk.h
set_mac_address method, The device methods
set_mb(), I/O Registers and Conventional Memory
SET_MODULE_OWNER macro, File Operations, Quick Reference, Quick Reference
backward compatibility issues, Differences in Linux 2.2
net_device structure and, Initializing Each Device
set_multicast_list method, The device methods, Kernel Support for Multicasting, A Typical Implementation
interface flags and, Interface information
set_rmb(), I/O Registers and Conventional Memory
set_wmb(), I/O Registers and Conventional Memory
sg_dma_address(), Scatter-gather mappings, Quick Reference
sg_dma_len(), Scatter-gather mappings, Quick Reference
sharing interrupts, Interrupt Sharing, The /proc Interface
short delays, Short Delays, Short Delays
short driver (example), A Sample Driver
accessing I/O memory, Reusing short for I/O Memory
BH implementation, Writing a BH Bottom Half
going to sleep and avoiding race conditions, Going to Sleep Without Races
implementing
interrupt handlers, Implementing a Handler, Implementing a Handler
probing in the driver, Do-it-yourself probing
installing an interrupt handler, Installing an Interrupt Handler
shutting down modules (see unloading modules)
SIGIO signal, Asynchronous Notification
signal handling, A Sample Implementation: scullpipe
down_interruptible() and, A Brief Introduction to Race Conditions
signal.c file, The kernel Directory
single-open devices, Single-Open Devices
SIOCDEVPRIVATE commands, Custom ioctl Commands, Quick Reference
SIOCSIFADDR command, Custom ioctl Commands
SIOCSIFMAP command, Custom ioctl Commands
size of block devices, Registering the Driver
sizing data explicitly, Assigning an Explicit Size to Data Items
skbuff.h header file, Packet Transmission, The Socket Buffers, Quick Reference
skb_headroom(), Functions Acting on Socket Buffers, Quick Reference
skb_pull(), Functions Acting on Socket Buffers, Quick Reference
__skb_push(), Functions Acting on Socket Buffers, Quick Reference
backward compatibility issues, Further Differences in Linux 2.0
skb_push(), Functions Acting on Socket Buffers, Quick Reference
__skb_put(), Functions Acting on Socket Buffers, Quick Reference
skb_put(), Functions Acting on Socket Buffers, Quick Reference
skb_reserve(), Functions Acting on Socket Buffers, Quick Reference
skb_tailroom(), Functions Acting on Socket Buffers, Quick Reference
skull driver (example), Compiling and Loading, Automatic and Manual Configuration
sk_buff structure
fields for, The Important Fields
receiving packets, Packet Reception
transmitting packets, Packet Transmission
slab.c file, The Size Argument, The mm Directory
SLAB_CACHE_DMA flag, Lookaside Caches, Quick Reference
SLAB_CTOR_ATOMIC flag, Lookaside Caches, Quick Reference
SLAB_CTOR_CONSTRUCTOR flag, Lookaside Caches, Quick Reference
SLAB_HWCACHE_ALIGN flag, Lookaside Caches, Quick Reference
SLAB_NO_REAP flag, Lookaside Caches, Quick Reference
sleeping processes, Going to Sleep and Awakening, Writing Reentrant Code
avoiding race conditions, Going to Sleep Without Races, Going to Sleep Without Races
sleep_on(), Going to Sleep and Awakening, Quick Reference
avoiding race conditions, Going to Sleep Without Races
sleep_on_timeout(), Going to Sleep and Awakening, Quick Reference
delaying execution, Long Delays
slow interrupt handlers, Fast and Slow Handlers, The internals of interrupt handling on the x86
backward compatibility issues, Further Differences in the 2.0 Kernel
SLOW_DOWN_IO statement, Quick Reference
__SMP__ symbol, Compiling and Loading, Quick Reference
SMP systems
backward compatibility issues, Compiling for Multiprocessor Systems
concurrency in the kernel, Concurrency in the Kernel
kernel headers and, Compiling and Loading
module version control and, Version Control in Modules
race conditions and, A Brief Introduction to Race Conditions, read and write
running tasklets on, Tasklets, Tasklets
spinlocks to avoid race conditions, Another Digression into Race Conditions
writing reentrant code, Writing Reentrant Code
snapshot of PCI configuration, Looking at a configuration snapshot
snull driver (example), Network Drivers, Overriding ARP
socket buffers, Packet Transmission, The Socket Buffers, Functions Acting on Socket Buffers
allocating, Packet Reception, Functions Acting on Socket Buffers
functions acting on, Functions Acting on Socket Buffers
socket.c file, The net directory
sockios.h header file, Custom ioctl Commands, Quick Reference
sock_ioctl(), Custom ioctl Commands
soft lockup detector (IKD), The Integrated Kernel Debugger Patch
softirq.c file, The kernel Directory
softnet implementation and backward compatibility, Backward Compatibility
software loops, Short Delays
software memory barriers, I/O Registers and Conventional Memory, Quick Reference
software versions (see version numbering)
software-mapped I/O memory, Software-Mapped I/O Memory
sound cards, drivers for, drivers/sound
sound_install_audiodrv(), drivers/sound
SPARC architecture
defining disable_irq/enable_irq as pointers, Enabling and Disabling Interrupts
high memory, Memory zones
I/O memory management support, How different architectures support PCI DMA
platform dependency and, Platform Dependency
porting and, Platform Dependencies
SBus, SBus
performing DMA mappings on, A quick look at SBus
SPARC64 platform
data alignment, Data Alignment
directly mapped memory, Directly Mapped Memory
gdb debugger and, Using gdb
objdump utility and, Using ksymoops
oops messages and, Using ksymoops
special files, Major and Minor Numbers
spinlock.h header file, Another Digression into Race Conditions, Quick Reference, Using Spinlocks, Quick Reference
spinlocks, Using Spinlocks, Using Spinlocks
dma_spin_lock, Talking to the DMA controller
io_request_lock, The I/O request lock
page_table_lock, Page Tables
reader-writer, Using Spinlocks
vs. semaphores, Another Digression into Race Conditions
xmit_lock, Utility fields, Controlling Transmission Concurrency
spinlock_t type, Another Digression into Race Conditions, Quick Reference, Using Spinlocks, Quick Reference, Quick Reference
spin_is_locked(), Using Spinlocks, Quick Reference
spin_lock(), Another Digression into Race Conditions, Quick Reference, Using Spinlocks, Quick Reference
spin_lock_bh(), Using Spinlocks, Quick Reference
spin_lock_init(), Another Digression into Race Conditions, Quick Reference, Using Spinlocks, Quick Reference
spin_lock_irq(), Using Spinlocks, Quick Reference
spin_lock_irqsave(), Using Spinlocks, Quick Reference
avoiding deadlocks with, Using Spinlocks
spin_trylock(), Using Spinlocks, Quick Reference
spin_unlock(), Another Digression into Race Conditions, Quick Reference, Using Spinlocks, Quick Reference
spin_unlock_bh(), Using Spinlocks, Quick Reference
spin_unlock_irq(), Using Spinlocks, Quick Reference
spin_unlock_irqrestore(), Using Spinlocks, Quick Reference
spin_unlock_wait(), Using Spinlocks, Quick Reference
spull driver (example), Partitionable Devices, Interrupt-Driven Block Drivers
device methods for, The Device Methods for spull
stack meter (IKD feature), The Integrated Kernel Debugger Patch
stacking modules, The Kernel Symbol Table
standard C data types, Use of Standard C Types
start_kernel(), Booting the Kernel, Booting the Kernel
stat file, The /proc Interface, Quick Reference
static symbols, Kernel Modules Versus Applications
statistics
on caches, Lookaside Caches
on interrupts, The /proc Interface
on network interfaces, Initializing Each Device, The device methods, Statistical Information
sti(), Overall Control of Interrupts
stop method, The device methods, Opening and Closing
strace command, Debugging by Watching, Debugging by Watching
streaming DMA mappings, DMA mappings
setting up, Setting up streaming DMA mappings, Setting up streaming DMA mappings
string operations, String Operations
struct page pointer, The Memory Map and struct page, The Memory Map and struct page
backward compatibility issues, Changes to Memory Management
struct timeval pointer, Knowing the Current Time, Quick Reference
subsystem deviceID PCI register, Configuration Registers and Initialization
subsystem vendorID PCI register, Configuration Registers and Initialization
sunrpc subdirectory, The net directory
Super-H architecture
no support for PCI bus, How different architectures support PCI DMA
porting and, Platform Dependencies
supervisor mode, User Space and Kernel Space
suser(), Capabilities in 2.0
suspend method, The pci_driver structure
swapfile.c file, The mm Directory
swapout method, Virtual Memory Areas
swap_state.c file, The mm Directory
switch statement, with ioctl, ioctl, The Return Value
symbols
device-dependent, The Header File blk.h, The Header File blk.h
driver-specific, The Header File blk.h, The Header File blk.h
exporting, The Kernel Symbol Table, Exporting Versioned Symbols
in Linux 2.0, Exporting Symbols in Linux 2.0, Module Configuration Parameters
hiding global, The Kernel Symbol Table
mangling symbol names, Version Control in Modules, Exporting Versioned Symbols
static, declaring as, Kernel Modules Versus Applications
symbol table, The Kernel Symbol Table, The Kernel Symbol Table
klogd and, Using klogd
module version control and, Version Control in Modules
symtab_begin.h header file, Quick Reference
symtab_end.h header file, Quick Reference
sync method, Virtual Memory Areas
synchronization (see lock method; race conditions)
<sys/sched.h> header file
capable() and, Capabilities and Restricted Operations
sysctl_net.c file, The net directory
sysdep.h header file, Version Dependency
backward compatibility issue, Backward Compatibility, Module Configuration Parameters
sema_init() and, Changes in Semaphore Support
SET_FILE_OWNER macro and, The Module Usage Count
wait queues in Linux versions 2.0/2.2, Wait Queues in Linux 2.2 and 2.0
syslogd daemon
logging messages, How Messages Get Logged
performance problems with, Debugging by Querying
sysrq.txt file, System Hangs
system calls, Compiling and Loading
invoked by init thread, The init Process
system faults
changing message loglevels after, printk
debugging, Debugging System Faults, System Hangs
handling, kernels vs. applications, Kernel Modules Versus Applications
system hangs, System Hangs
precautions when reproducing, System Hangs
system resources
allocating in Linux 2.4, Resource Allocation in Linux 2.4
managing, Using Resources, Resource Allocation in Linux 2.4
backward compatibility for, Changes in Resource Management
system.h header file, I/O Registers and Conventional Memory, Quick Reference
System.map file
klogd and, Using klogd
ksymoops and, Using ksymoops
sys_create_module(), Compiling and Loading
sys_delete_module system call, The Usage Count
sys_syslog(), printk

T

_t data types, Interface-Specific Types
tagged initialization format, File Operations
avoiding flush method, Changes in the File Operations Structure
declaring file_operations structure, File Operations
tail pointers and circular buffers, Using Circular Buffers
take_over_console(), drivers/video
task queues, Task Queues, Tasklets
backward compatibility issues, Backward Compatibility
data structures of, The Nature of Task Queues
declaring, The Nature of Task Queues
declaring custom, Running Your Own Task Queues
driver timeline, Predefined Task Queues
predefined, Predefined Task Queues, The immediate queue
requeuing/rescheduling tasks, How Task Queues Are Run
running, How Task Queues Are Run
tasklets, Tasklets, Tasklets, Tasklets
scheduling, Tasklets
tasklet_disable(), Tasklets, Quick Reference
tasklet_enable(), Tasklets, Quick Reference
tasklet_kill(), Tasklets, Quick Reference
tasklet_schedule(), Tasklets, Quick Reference, Tasklets, Quick Reference
BH mechanism and, The BH Mechanism
TASK_EXCLUSIVE flag, A Deeper Look at Wait Queues
TASK_INTERRUPTIBLE flag, A Deeper Look at Wait Queues, Going to Sleep Without Races, Quick Reference
task_queue, The Nature of Task Queues, Quick Reference
TASK_RUNNING flag, A Deeper Look at Wait Queues, Going to Sleep Without Races, Quick Reference
TASK_UNINTERRUPTIBLE flag, Quick Reference
tcpdump program, The Physical Transport of Packets
terminals, selecting for messages, printk
testing (non)blocking operations, A Sample Implementation: scullpipe
test_and_change_bit(), Bit operations, Quick Reference
test_and_clear_bit(), Bit operations, Quick Reference
test_and_set_bit(), Bit operations, Quick Reference
test_bit(), Bit operations, Quick Reference
“thundering herd” problem, A Deeper Look at Wait Queues
time, Flow of Time, Quick Reference
delaying execution of code, Delaying Execution, Short Delays
HZ (time frequency), Time Intervals in the Kernel, Time Intervals
kernel timers, Kernel Timers, Kernel Timers
sleeping processes, Going to Sleep Without Races, Going to Sleep Without Races
time intervals in the kernel, Time Intervals in the Kernel, Processor-Specific Registers, Time Intervals
time.c/timer.c files, The kernel Directory
time.h header file, Quick Reference
timeouts
backward compatibility issues, Backward Compatibility
of kernel timers, Kernel Timers
scheduling, Long Delays
setting up short-term, Long Delays
transmission (see transmission timeouts)
timer interrupts, Time Intervals in the Kernel
timer queue (tq_timer), Predefined Task Queues, The timer queue, Quick Reference
BH mechanism and, The BH Mechanism
timer queue element structure, The Nature of Task Queues
timer.h header file, Kernel Timers, Quick Reference
timers, Kernel Timers, Kernel Timers
TIMER_BH bottom half, The BH Mechanism
timer_list structure, Kernel Timers
timestamp counter (TSC), Processor-Specific Registers
TIOCLINUX command, printk
token ring networks, setting up interfaces for, Interface information
top-half vs. bottom-half handlers, Tasklets and Bottom-Half Processing
to_kdev_t(), dev_t and kdev_t
tqueue.h header file, The Nature of Task Queues, Predefined Task Queues, Quick Reference
TQUEUE_BH bottom half, The BH Mechanism
tq_immediate queue, Predefined Task Queues, The immediate queue, Quick Reference
BH mechanism and, The BH Mechanism
writing a BH bottom half, Writing a BH Bottom Half
tq_scheduler queue, Predefined Task Queues, The scheduler queue, The scheduler queue
backward compatibility issues, Backward Compatibility
tq_struct structure, The Nature of Task Queues
tq_timer(), Predefined Task Queues, The timer queue, Quick Reference
BH mechanism and, The BH Mechanism
tracing programs, Debugging by Watching, Debugging by Watching
Linux Trace Toolkit (LTT), The Linux Trace Toolkit
transistor-transistor logic (TTL) levels, An Overview of the Parallel Port
transmission concurrency, controlling, Controlling Transmission Concurrency
transmission of packets, The Physical Transport of Packets, Packet Transmission, Transmission Timeouts
multicasting, Multicasting, A Typical Implementation
transmission timeouts, Initializing Each Device, Transmission Timeouts
tx_timeout method and, The device methods
watchdog_timeo field and, Utility fields
traversal of linked lists, Linked Lists
troubleshooting, Debugging Techniques
(see also debugging)
porting problems, Platform Dependencies, Platform Dependencies
race conditions, Race Conditions, Going to Sleep Without Races
system hangs, System Hangs
wrong font on console, Device Control Without ioctl
truncating devices on open, The open Method
tr_configure(), Interface information
TSC (timestamp counter), Processor-Specific Registers
TTL (transistor-transistor logic) levels, An Overview of the Parallel Port
tunelp program, The Role of the Device Driver
tx_timeout method, The device methods, Transmission Timeouts
TYPE macro, splitting minor numbers, The open Method
types.h header file (asm), Assigning an Explicit Size to Data Items
types.h header file (linux), Assigning an Explicit Size to Data Items, Quick Reference

U

u8, u16, u32, u64 data types, Assigning an Explicit Size to Data Items, Quick Reference
uaccess.h header file, read and write, Quick Reference, Using the ioctl Argument, Quick Reference
uClinux port
different ld scripts needed for, Before Booting
mmnommu directory, The mm Directory
udelay(), Short Delays, Quick Reference
uint8_t/uint32_t types, Assigning an Explicit Size to Data Items
uintptr_t type (C99 standard), Use of Standard C Types
uio.h header file, readv and writev
unaligned data, Data Alignment
unaligned.h header file, Data Alignment, Quick Reference
uniqueness of ioctl command numbers, Choosing the ioctl Commands
universal serial bus drivers (see USB drivers)
Unix design books, Bibliography
unix subdirectory, The net directory
unloading modules, Kernel Modules Versus Applications, Unloading, Removing a Driver from the System
(see also cleanup_module())
on demand, Loading Modules on Demand, Running User-Mode Helper Programs
for network drivers, Module Unloading
usage count and, The Usage Count, Intermodule Communication
unlock_kiovec(), The kiobuf Structure, Quick Reference
unmap method, Virtual Memory Areas
unmap_kiobuf(), Mapping User-Space Buffers and Raw I/O, Quick Reference
unregistering
block drivers, Registering the Driver, Registering the Driver
facilities, Error Handling in init_module
unregister_blkdev(), Registering the Driver, Quick Reference
unregister_cdrom(), drivers/cdrom
unregister_chrdev(), Removing a Driver from the System, Quick Reference
unregister_netdev(), Quick Reference
unsigned type, Using I/O Ports
platform dependencies and, Platform Dependencies
up(), A Brief Introduction to Race Conditions, Quick Reference
urandom device, Installing an Interrupt Handler
usage count, Adding VMA Operations
accessing data within partitions, The Device Methods for spull
decremented by release method, The release Method
incremented by open method, The open Method
maintained by block drivers, Registering the Driver
maintaining via owner field, The open Method
modules, The Usage Count, Intermodule Communication
backward compatibility issues, The Module Usage Count
nopage method and, Remapping RAM with the nopage method
USB (universal serial bus) drivers, Classes of Devices and Modules, USB
call_usermodehelper and, Running User-Mode Helper Programs
directory for, Bus-Specific Directories
lookaside caches, Lookaside Caches, A scull Based on the Slab Caches: scullc
stacking on usbcore/input modules, The Kernel Symbol Table
writing, Writing a USB Driver, Writing a USB Driver
usb.h header file, Quick Reference
usbcore module, The Kernel Symbol Table
usb_deregister(), Writing a USB Driver, Quick Reference
usb_driver structure, Writing a USB Driver, Quick Reference
usb_register(), Writing a USB Driver, Quick Reference
user mode, User Space and Kernel Space
helper programs, running, Running User-Mode Helper Programs
user space, User Space and Kernel Space
access to, in Linux 2.0, Access to User Space in Linux 2.0, Access to User Space in Linux 2.0
accessing I/O ports from, Using I/O Ports
capabilities/restrictions in, Capabilities and Restricted Operations
changes in access to, Changes in Access to User Space
entering via init process, The init Process
explicitly sizing data in, Assigning an Explicit Size to Data Items
mapping RAM to, Remapping RAM, Remapping RAM with the nopage method
reentrant functions and, Writing Reentrant Code
retrieving datum from, Using the ioctl Argument
transferring to/from kernel space, read and write, readv and writev
watching programs run in, Debugging by Watching, Debugging by Watching
writing drivers in, Doing It in User Space
user virtual addresses, Address Types
User-Mode Linux, The User-Mode Linux Port
users, restricting access to simultaneous, Restricting Access to a Single User at a Time
__USE_OLD_SELECT__ preprocessor symbol, The Linux 2.0 select Method
__USE_OLD_SYMTAB__, Exporting Symbols in Linux 2.0
UTS_RELEASE macro, Version Dependency

V

__va(), Address Types, Quick Reference
backward compatibility issues, Changes to Memory Management
validating
block driver requests, The Request Queue
disk changes, Revalidation
variables, declaring as volatile, Race Conditions
vector operations (readv/writev), readv and writev
vendorID PCI register, Configuration Registers and Initialization
VERIFY_ symbols, Using the ioctl Argument, Quick Reference
verify_area(), Access to User Space in Linux 2.0, Access to User Space in Linux 2.0
version dependency, Version Dependency, Version Dependency
module version control, Version Control in Modules, Exporting Versioned Symbols
version numbering, Version Numbering
char drivers, Major and Minor Numbers, dev_t and kdev_t
major device numbers, Major and Minor Numbers, Removing a Driver from the System
minor device numbers, Major and Minor Numbers, dev_t and kdev_t, The open Method
version.h header file, Version Dependency, Quick Reference
versioned symbols, Using Version Support in Modules
enabling module version control, Using Version Support in Modules
exporting, Exporting Versioned Symbols
VESA Local Bus (VLB) devices, VLB
vfree(), vmalloc and Friends, Quick Reference
backward compatibility issues, Backward Compatibility
video devices, directory for, drivers/video
video/videodev.c file, drivers/media
video_device structure, drivers/media
video_register_device(), drivers/media
virtual addresses, Address Types
assigning to devices, Software-Mapped I/O Memory
mapping to physical addresses, Page Tables
remapping, Remapping Virtual Addresses
Sbus peripherals and, SBus
vmalloc and related functions, vmalloc and Friends, A scull Using Virtual Addresses: scullv
virtual memory areas (VMAs), Virtual Memory Areas, Virtual Memory Areas
main fields in vm_area_struct, Virtual Memory Areas
virt_to_bus(), Bus Addresses, Quick Reference
backward compatibility issues, Changes to DMA
virt_to_page(), The Memory Map and struct page, Quick Reference
backward compatibility issues, Changes to Memory Management
mapping memory with nopage, Mapping Memory with nopage
VLB (VESA Local Bus) devices, VLB
vmalloc(), vmalloc and Friends, A scull Using Virtual Addresses: scullv, Quick Reference, Remapping Virtual Addresses
vs. kmalloc(), vmalloc and Friends, vmalloc and Friends
vmalloc.c file, The mm Directory
vmalloc.h header file, vmalloc and Friends, Quick Reference
VMALLOC_VMADDR(), Remapping Virtual Addresses
VMAs (virtual memory areas), Virtual Memory Areas, Virtual Memory Areas
main fields in vm_area_struct, Virtual Memory Areas
VMA_OFFSET macro, Adding VMA Operations
vmlinux kernel image, Before Booting
vmscan.c file, The mm Directory
vm_area_struct structure, Virtual Memory Areas
backward compatibility issues, Changes to Memory Management
VM_IO flag, Virtual Memory Areas
vm_operations_struct structure, Virtual Memory Areas
vm_private_data field (vm_area_struct), Remapping RAM with the nopage method
backward compatibility issues, Changes to Memory Management
VM_RESERVED flag, Virtual Memory Areas
volatile, declaring variables as, Race Conditions
vremap() in Linux 2.x only, Backward Compatibility, Backward Compatibility
vsprintf.c file, ipc and lib
vt.c file, drivers/char

W

wait queues, Going to Sleep and Awakening, A Deeper Look at Wait Queues
avoiding race conditions, Going to Sleep Without Races
defined type for, Quick Reference
delaying code execution, Long Delays
in Linux versions 2.0/2.2, Wait Queues in Linux 2.2 and 2.0
manipulating, A Deeper Look at Wait Queues
poll table entries and, The Underlying Data Structure
putting processes into, Quick Reference
wait.h header file, A Deeper Look at Wait Queues, Quick Reference
wait_event(), Going to Sleep and Awakening, Quick Reference, Going to Sleep Without Races, Quick Reference
vs. interruptible_sleep_on(), A Deeper Look at Wait Queues
wait_event_interruptible(), Going to Sleep and Awakening, Quick Reference, Going to Sleep Without Races, Quick Reference
wait_queue_head_t, Quick Reference
new in Linux version 2.3.1, Wait Queues in Linux 2.2 and 2.0
poll table entries and, The Underlying Data Structure
sleeping/waking up processes, Going to Sleep and Awakening, Going to Sleep and Awakening
working with advanced applications, A Deeper Look at Wait Queues
wait_queue_t type, A Deeper Look at Wait Queues, Quick Reference
poll table entries and, The Underlying Data Structure
wake_up(), Going to Sleep and Awakening, Quick Reference
resuming execution of code, Long Delays
wake_up_interruptible(), Going to Sleep and Awakening, Quick Reference
wake_up_interruptible_sync(), Going to Sleep and Awakening, Quick Reference
wake_up_sync(), Going to Sleep and Awakening, Quick Reference
waking up processes, Going to Sleep and Awakening
exclusive waits and, A Deeper Look at Wait Queues
functions used for, Quick Reference
release method and, Blocking open as an Alternative to EBUSY
-Wall flag (gcc), Compiling and Loading, Interface-Specific Types
watchdog_timeo field (net_device structure), Utility fields, Transmission Timeouts
watching programs in user space, Debugging by Watching, Debugging by Watching
web sites related to Linux kernels, Sources of Further Information
wmb(), I/O Registers and Conventional Memory, Quick Reference
wppage method, Virtual Memory Areas
backward compatibility issues, Changes to Memory Management
wrapper functions, compiling under 2.0 headers, Changes in the File Operations Structure
write method, File Operations, read and write, read and write
code for, The write Method
configuring DMA controller, Talking to the DMA controller
f_pos field (file structure) and, The file Structure, Changes in the File Operations Structure
input/output buffers and, Blocking and Nonblocking Operations
llseek method and, The llseek Implementation
poll method and, Writing to the device
return values, rules for interpreting, The write Method
select method and, Writing to the device
strace command and, Debugging by Watching
syntax in Linux 2.0, Changes in the File Operations Structure
writeb(), Directly Mapped Memory, Quick Reference
writel(), Directly Mapped Memory, Quick Reference
writeq(), Directly Mapped Memory
writev method, File Operations, readv and writev
writew(), Directly Mapped Memory, Quick Reference
write_lock(), Using Spinlocks, Quick Reference
write_lock_bh(), Using Spinlocks, Quick Reference
write_lock_irq(), Using Spinlocks, Quick Reference
write_lock_irqsave(), Using Spinlocks, Quick Reference
write_unlock(), Using Spinlocks, Quick Reference
write_unlock_bh(), Using Spinlocks, Quick Reference
write_unlock_irq(), Using Spinlocks, Quick Reference
write_unlock_irqrestore(), Using Spinlocks, Quick Reference
writing, Debugging Techniques
(see also debugging)
blocking I/O, Blocking I/O, Blocking and Nonblocking Operations
blocking/nonblocking operations, Blocking and Nonblocking Operations
control sequences to devices, Device Control Without ioctl
to a device, read and write, read and write, The write Method, readv and writev
drivers
using devfs, The Device Filesystem, Portability Issues and devfs
reentrant code, Writing Reentrant Code
in user space, Doing It in User Space
version numbering, Version Numbering
watching user-space programs run, Debugging by Watching, Debugging by Watching
writer’s role in, The Role of the Device Driver , The Role of the Device Driver
interrupt handler bottom halves, Writing a BH Bottom Half
interrupt handlers, Implementing a Handler, Enabling and Disabling Interrupts
makefiles, Compiling and Loading

X

x/i (examine instructions) command, Using gdb
x86 architecture
interrupt handling on, The internals of interrupt handling on the x86
limitations of platform, Before Booting
PCI DMA interface support, How different architectures support PCI DMA
porting and, Platform Dependencies
xtime variable, Knowing the Current Time

Z

zImage file, Before Booting

Get Linux Device Drivers, Second Edition now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.