C

caches, Lookaside Caches–The alloc_pages Interface, Lookaside Caches, Quick Reference, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, Using remap_pfn_range, DMA mappings

argument, Lookaside Caches

coherency issues, DMA mappings

lookaside, Lookaside Caches–The alloc_pages Interface, Quick Reference

troubleshooting, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, Using remap_pfn_range

calling, The Current Process, Debugging by Watching, ioctl, Single-Open Devices, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory, Using I/O Memory, How It Works, Command Pre-Preparation

current process, The Current Process

firmware, How It Works

ioctl method, ioctl

ioremap function, Using I/O Memory

memory barriers, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory

perror calls, Debugging by Watching

preparation functions, Command Pre-Preparation

release, Single-Open Devices

cancellation of urbs, Canceling Urbs

capabilities, restricted operations and, Capabilities and Restricted Operations

capability.h header file, Capabilities and Restricted Operations, Quick Reference

capable function, Capabilities and Restricted Operations, Quick Reference

CAP_DAC_OVERRIDE capability, Capabilities and Restricted Operations, Restricting Access to a Single User at a Time

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 utility, The Role of the Device Driver

carrier signals, Changes in Link State

cdev structure, Char Device Registration

change_bit operation, Bit Operations

change_mtu method, The Device Methods, Packet Reception

improving performance using socket buffers, Packet Reception

char (character) drivers, Classes of Devices and Modules, The Design of scull, The Design of scull, Major and Minor Numbers, Major and Minor Numbers–Dynamic Allocation of Major Numbers, File Operations–File Operations, The file Structure, The inode Structure, Char Device Registration–The Older Way, The open Method–The open Method, The release Method, scull's Memory Usage–scull's Memory Usage, read and write, read and write, readv and writev, readv and writev, Playing with the New Devices, ioctl–Device Control Without ioctl, Blocking I/O–Testing the Scullpipe Driver, poll and select–The Underlying Data Structure, poll and select–The Underlying Data Structure, Asynchronous Notification–The Driver's Point of View, Seeking a Device, Access Control on a Device File

access, Major and Minor Numbers–Dynamic Allocation of Major Numbers

asynchronous notification, Asynchronous Notification–The Driver's Point of View

defining mechanism of, The Design of scull

files, File Operations–File Operations, The file Structure, Access Control on a Device File

access to, Access Control on a Device File

operations, File Operations–File Operations

structures, The file Structure

I/O, Blocking I/O–Testing the Scullpipe Driver

inode structure, The inode Structure

ioctl method, ioctl–Device Control Without ioctl

llseek method, Seeking a Device

memory usage (scull), scull's Memory Usage–scull's Memory Usage

open method, The open Method–The open Method

poll method, poll and select–The Underlying Data Structure

read method, read and write

readv calls, readv and writev

registration, Char Device Registration–The Older Way

release method, The release Method

scull (design of), The Design of scull

select method, poll and select–The Underlying Data Structure

testing, Playing with the New Devices

version numbers, Major and Minor Numbers

write method, read and write

writev calls, readv and writev

char *buffer field (request structure), A Simple request Method

char *name variable (USB), probe and disconnect in Detail

char bus_id field, Devices

char disk_name field (gendisk), The gendisk structure

char name field (net_device structure), Global Information

character drivers, Classes of Devices and Modules (see char drivers)

chars_in_buffer function, Other Buffering Functions

CHECKSUM_ symbols, Packet Reception

check_flags method, File Operations

circular buffers, How Messages Get Logged, Lock-Free Algorithms, Implementing a Handler, Overview of a DMA Data Transfer

DMA ring buffers, Overview of a DMA Data Transfer

implementing interrupt handlers, Implementing a Handler

for printk function, How Messages Get Logged

claim_dma_lock function, Talking to the DMA controller

class register (PCI), Configuration Registers and Initialization

classes, Classes of Devices and Modules–Classes of Devices and Modules, Classes of Devices and Modules, The Linux Device Model, Classes–Class interfaces, Managing classes, Class devices, Class interfaces, Classes

devices, Classes of Devices and Modules, The Linux Device Model, Class devices

functions, Classes

interfaces, Class interfaces

Linux device model, Classes–Class interfaces

management, Managing classes

modules, Classes of Devices and Modules–Classes of Devices and Modules

class_id field, Class devices

class_simple interface, The class_simple Interface

class_simple_create function, udev

class_simple_device_add function, udev

class_simple_device_remove function, udev

cleanup function, The Cleanup Function

clearing bits on interface boards, Implementing a Handler

clear_bit operation, Bit Operations

clear_dma_ff function, Talking to the DMA controller

clocks, Processor-Specific Registers, Timekeeping, Timekeeping

(see also time)

cycles (counting), Processor-Specific Registers

cloning devices, Cloning the Device on open

close function (tty drivers), open and close–open and close

close method, The release Method, The vm_area_struct structure

vm_operations_struct structure, The vm_area_struct structure

cmd field (request structure), Command Pre-Preparation

coarse-grained locking, Fine- Versus Coarse-Grained Locking

code, Loadable Modules, Setting Up Your Test System, The Hello World Module–The Hello World Module, User Space and Kernel Space, Concurrency in the Kernel, Preliminaries, Doing It in User Space–Doing It in User Space, Debugging by Printing, Pitfalls in scull, Manual sleeps, Restricting Access to a Single User at a Time, Processor-Specific Registers, Delaying Execution–Short Delays, Short Delays, Delays, ISA Programming

concurrency in, Concurrency in the Kernel

delaying execution of, Short Delays

execution, Delaying Execution–Short Delays, Delays

hello world module, The Hello World Module–The Hello World Module

inline assembly (example), Processor-Specific Registers

ISA, ISA Programming

kernels, Debugging by Printing (see kernels)

memory (scull), Pitfalls in scull

module requirements, Preliminaries

runtime, Loadable Modules

scilluid, Restricting Access to a Single User at a Time

sleeps, Manual sleeps

test system setup, Setting Up Your Test System

user space programming, User Space and Kernel Space, Doing It in User Space–Doing It in User Space

coherency, DMA mappings, Setting up coherent DMA mappings

caches, DMA mappings

DMA, Setting up coherent DMA mappings

command pre-preparation (block drivers), Command Pre-Preparation

command-oriented drivers, Device Control Without ioctl

commands, printk, printk, Debugging by Watching, Debugging by Watching, Using gdb, Choosing the ioctl Commands, The Predefined Commands, The Predefined Commands, The Predefined Commands, The Predefined Commands, The Predefined Commands, The Predefined Commands, The Implementation of the ioctl Commands, Asynchronous Notification, Asynchronous Notification, Asynchronous Notification, Quick Reference, Hardware Information, Opening and Closing–Opening and Closing, Custom ioctl Commands, Custom ioctl Commands

(see also functions)

dmesg, printk

FIOASYNC, The Predefined Commands

FIOCLEX, The Predefined Commands

FIONBIO, The Predefined Commands

FIONCLEX, The Predefined Commands

FIOQSIZE, The Predefined Commands

F_SETFL fcntl, Asynchronous Notification

F_SETOWN, Asynchronous Notification

gdb, Using gdb

ifconfig, Hardware Information, Opening and Closing–Opening and Closing

net_device structure and, Hardware Information

opening network drivers, Opening and Closing–Opening and Closing

ioctl, Choosing the ioctl Commands, The Predefined Commands, The Implementation of the ioctl Commands, Quick Reference, Custom ioctl Commands

creating, Quick Reference

customizing for networking, Custom ioctl Commands

implementation, The Implementation of the ioctl Commands

printk, printk (see printk function)

SIOCDEVPRIVATE, Custom ioctl Commands

strace, Debugging by Watching

wc, Debugging by Watching

communication with user space, The Linux Device Model

compilers, Processor-Specific Registers, I/O Registers and Conventional Memory

gcc, Processor-Specific Registers

optimizations, I/O Registers and Conventional Memory

compiling, Compiling Modules–Compiling Modules, Playing with the New Devices

char drivers, Playing with the New Devices

modules, Compiling Modules–Compiling Modules

complete function (urbs), Completing Urbs: The Completion Callback Handler

complete module, Completions

completion, Completions–Completions, Completing Urbs: The Completion Callback Handler, Talking to the DMA controller, Request Completion Functions

of DMA, Talking to the DMA controller

request functions, Request Completion Functions

semaphores, Completions–Completions

urbs, Completing Urbs: The Completion Callback Handler

concurrency, Concurrency in the Kernel, Concurrency in the Kernel, Pitfalls in scull, Concurrency and Its Management–Concurrency and Its Management, Semaphores and Mutexes, The Linux Semaphore Implementation–Reader/Writer Semaphores, Completions–Completions, Spinlocks–Reader/Writer Spinlocks, Locking Traps–Fine- Versus Coarse-Grained Locking, Alternatives to Locking–Read-Copy-Update, Controlling Transmission Concurrency, Controlling Transmission Concurrency

alternatives to locking, Alternatives to Locking–Read-Copy-Update

controlling transmission, Controlling Transmission Concurrency

debugging, Concurrency in the Kernel

in kernel programming, Concurrency in the Kernel

locking, Semaphores and Mutexes, Locking Traps–Fine- Versus Coarse-Grained Locking

adding, Semaphores and Mutexes

traps, Locking Traps–Fine- Versus Coarse-Grained Locking

management, Concurrency and Its Management–Concurrency and Its Management

scull (troubleshooting memory), Pitfalls in scull

semaphores, The Linux Semaphore Implementation–Reader/Writer Semaphores, Completions–Completions

completion, Completions–Completions

implementation, The Linux Semaphore Implementation–Reader/Writer Semaphores

spinlocks, Spinlocks–Reader/Writer Spinlocks

transmission, Controlling Transmission Concurrency

configuration, Setting Up Your Test System, Version Dependency, Module Parameters–Module Parameters, Major and Minor Numbers, The Internal Representation of Device Numbers, Allocating and Freeing Device Numbers, Allocating and Freeing Device Numbers, Dynamic Allocation of Major Numbers, Char Device Registration, Debugging Support in the Kernel–Debugging Support in the Kernel, Semaphores and Mutexes, Timeouts, Installing an Interrupt Handler–The internals of interrupt handling on the x86, PCI Addressing, Configuration Registers and Initialization, Accessing the Configuration Space, Configurations, Setting up coherent DMA mappings, Setting up streaming DMA mappings, Single-page streaming mappings, How snull Is Designed–The Physical Transport of Packets, Device Registration, Interface Information–The Device Methods, The Device Methods, A Typical Implementation, TTY Line Settings, ioctls

cdev structure, Char Device Registration

char drivers, Allocating and Freeing Device Numbers

character (char) drivers, Major and Minor Numbers, The Internal Representation of Device Numbers, Allocating and Freeing Device Numbers, Dynamic Allocation of Major Numbers

(see also char drivers)

dynamic allocation of major numbers, Dynamic Allocation of Major Numbers

internal representation of device numbers, The Internal Representation of Device Numbers

major/minor numbers, Major and Minor Numbers

coherent DMA mappings, Setting up coherent DMA mappings

critical sections, Semaphores and Mutexes

ether_setup function, Interface Information–The Device Methods

interrupt handlers, Installing an Interrupt Handler–The internals of interrupt handling on the x86

kernels, Debugging Support in the Kernel–Debugging Support in the Kernel

line settings (tty drivers), TTY Line Settings

multicasting, A Typical Implementation

network devices, The Device Methods

net_device structure, Device Registration

parameter assignment, Module Parameters–Module Parameters

PCI, PCI Addressing, Configuration Registers and Initialization, Accessing the Configuration Space

accessing configuration space, Accessing the Configuration Space

registers, Configuration Registers and Initialization

serial lines, ioctls

single-page streaming mappings, Single-page streaming mappings

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

streaming DMA mappings, Setting up streaming DMA mappings

test system setup, Setting Up Your Test System

timeouts, Timeouts

USB interfaces, Configurations

version dependency, Version Dependency

CONFIG_ACPI_DEBUG option, Debugging Support in the Kernel

CONFIG_DEBUG_DRIVER option, Debugging Support in the Kernel

CONFIG_DEBUG_INFO option, Debugging Support in the Kernel

CONFIG_DEBUG_KERNEL option, Debugging Support in the Kernel

CONFIG_DEBUG_PAGEALLOC option, Debugging Support in the Kernel

CONFIG_DEBUG_SLAB option, Debugging Support in the Kernel

CONFIG_DEBUG_SPINLOCK option, Debugging Support in the Kernel

CONFIG_DEBUG_SPINLOCK_SLEEP option, Debugging Support in the Kernel

CONFIG_DEBUG_STACKOVERFLOW option, Debugging Support in the Kernel

CONFIG_DEBUG_STACK_USAGE option, Debugging Support in the Kernel

CONFIG_IKCONFIG option, Debugging Support in the Kernel

CONFIG_IKCONFIG_PROC option, Debugging Support in the Kernel

CONFIG_INIT_DEBUG option, Debugging Support in the Kernel

CONFIG_INPUT_EVBUG option, Debugging Support in the Kernel

CONFIG_KALLSYMS option, Debugging Support in the Kernel

CONFIG_MAGIC_SYSRQ option, Debugging Support in the Kernel

CONFIG_PROFILING option, Debugging Support in the Kernel

CONFIG_SCSI_CONSTANTS option, Debugging Support in the Kernel

CONFIG_USB_DYNAMIC_MINORS configuration option, probe and disconnect in Detail

connections, Creating your /proc file, PCI Drivers, USB Drivers, IEEE1394 (FireWire), USB, Assigning IP Numbers, Connecting to the Kernel–Utility Fields

(see also hotplugs)

Firewire, IEEE1394 (FireWire)

IP numbers, Assigning IP Numbers

network drivers to kernels, Connecting to the Kernel–Utility Fields

PCI, PCI Drivers (see PCI)

/proc file hierarchies, Creating your /proc file

USB, USB Drivers (see USB)

connectors (ISA), VLB

consoles, Redirecting Console Messages, Device Control Without ioctl

messages (redirecting), Redirecting Console Messages

wrong font on, Device Control Without ioctl

console_loglevel variable, printk, System Hangs

debugging system hangs, System Hangs

const char *dev_name functions, Installing an Interrupt Handler

const char *name field (PCI registration), Registering a PCI Driver

const char *name function, Registering a USB Driver

const struct pci_device_id *id_table field (PCI registration), Registering a PCI Driver

const struct usb_device_id *id_table function, Registering a USB Driver

constructor function (kmem_cache_create), Lookaside Caches

CONTROL endpoints (USB), Endpoints

control functions (queues), Queue control functions

control urbs (USB), Control urbs

controllers (PCI), Hardware Abstractions

controlling, Device Control Without ioctl, Submitting and Controlling a Urb, Controlling Transmission Concurrency

transmission concurrency, Controlling Transmission Concurrency

urbs (USB), Submitting and Controlling a Urb

by writing control sequences, Device Control Without ioctl

conventional memory I/O registers, I/O Registers and Conventional Memory, I/O Registers and Conventional Memory

(see also memory)

conversion (virtual addresses), Bus Addresses

copying (cross-space), read and write

core files, Using gdb

counters, Measuring Time Lapses, Processor-Specific Registers, Processor-Specific Registers, Reference count manipulation

jiffies, Measuring Time Lapses

reference (kobjects), Reference count manipulation

registers, Processor-Specific Registers

TSC, Processor-Specific Registers

counts (interrupts), ioctls

CPU modalities (levels), User Space and Kernel Space

create_module system call, vmalloc and Friends

create_proc_read_entry function, Creating your /proc file

creating, Creating and Destroying Urbs, Queue creation and deletion

queues, Queue creation and deletion

urbs (USB), Creating and Destroying Urbs

critical sections, Semaphores and Mutexes

cross-space copying, read and write

CRTSCTS bitmask, set_termios

CSIZE bitmask, set_termios

CSN (card select number), The Plug-and-Play Specification

CSTOPB bitmask, set_termios

current process, The Current Process, The Current Process, Quick Reference

current time, retrieving, Knowing the Current Time–Knowing the Current Time

current.h header file, The Current Process

currentime file (jit module), Knowing the Current Time

custom, Interface-Specific Types, Custom ioctl Commands

data types, Interface-Specific Types

ioctl methods for networking, Custom ioctl Commands

cycles_t type, Processor-Specific Registers