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
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.