A
- access
- blocking open requests, Blocking Open as an Alternative to EBUSY, Blocking Open as an Alternative to EBUSY
- cloning devices on open, Cloning the Device on Open
- concurrent (see race conditions)
- to device files, Access Control on a Device File
- to expansion board memory, Accessing Memory on Device Boards, High PCI Memory
- ISA memory, ISA Memory Below 1M, ISA Memory Above 1M
- PCI configuration space, Accessing the Configuration Space, Looking at a configuration snapshot
- PCI memory, High PCI Memory
- restricting to simultaneous users, Restricting Access to a Single User at a Time, Restricting Access to a Single User at a Time
- text-mode video buffer, Accessing the Text-Mode Video Buffer
- to user space in Linux 2.1, Accessing User Space, Using the New Interface
- access to drivers, Dynamic Allocation of Major Numbers
- access_ok(), Accessing User Space
- add-symbol-file (gdb command), Remote Debugging
- Address Resolution Protocol (ARP), Initializing Each Device
- using with Ethernet, Using ARP with Ethernet
- addresses
- for peripheral boards, PCI Addressing
- Plug and Play, The ``Plug and Play'' Specification
- resolving (Ethernet), Address Resolution, Non-Ethernet Headers
- verifying in user space, Using the ioctl Argument
- add_timer(), The New Timer List
- add_wait_queue(), Going to Sleep Without Races
- __add_wait_queue(), Going to Sleep Without Races
- advise method, Virtual Memory Areas
- aliases for device names, The open Method
- allocating
- major device numbers, Dynamic Allocation of Major Numbers
- memory, Using Resources, Scull’s Memory Usage
- at boot time, Playing Dirty, Playing Dirty
- determining how much, The Size Argument
- function definitions for, Allocation and Deallocation
- on ISA boards, ISA Memory, ISA Memory, ISA Memory Below 1M, ISA Memory Above 1M
- kmalloc for, The Real Story of kmalloc, The Size Argument
- by page, get_free_page and Friends, A scull Using Whole Pages: scullp
- page clusters for, The Size Argument
- vmalloc for, vmalloc and Friends, A scull Using Virtual Addresses: scullv
- ports, Ports, Ports
- alloc_skb(), Functions Acting on Socket Buffers
- Alpha architecture
- memory mapping, The mmap Device Operation
- porting and, Platform Dependencies
- setting up processors, Setting Up Alpha Processors
- Alt-PrScr key, System Hangs
- applications versus modules, Modules Versus Applications, Concurrency in the Kernel
- arch directory, Architecture Dependencies
- architecture dependency (see platform dependency)
- ARP (Address Resolution Protocol), Initializing Each Device
- overriding, Overriding ARP
- using with Ethernet, Using ARP with Ethernet
- asm directory, Modules Versus Applications
- <asm/atomic.h> header, Atomic integer operations
- <asm/bitops.h> header, Bit Operations
- <asm/byteorder.h> header, Conversion Functions
- <asm/dma.h> header, Talking to the DMA controller
- <asm/io.h> header, Using I/O Ports, Other Portability Issues
- <asm/ioctl.h> header, Choosing the ioctl Commands
- <asm/irq.h> header, Enabling and Disabling Interrupts
- <asm/page.h> header, Other Portability Issues, Page Tables
- <asm/segment.h> header, Quick Reference
- <asm/system.h> header, Quick Reference
- <asm/uaccess.h> header, Accessing User Space
- asynchronous DMA, Overview of a DMA Data Transfer
- asynchronous events, timer queues and, The Nature of Task Queues
- asynchronous notification, Asynchronous Notification, The Driver’s Point of View
- asynchronous notification, drivers and, The Driver’s Point of View, The Driver’s Point of View
- asynctest program, Asynchronous Notification
- atomic bit operations, Bit operations, Bit operations
- atomic integer operations, Atomic integer operations
- atomic.h header, Atomic integer operations
- atomic_add(), Atomic integer operations
- atomic_dec(), Atomic integer operations
- atomic_dec_and_test(), Atomic integer operations
- atomic_inc(), Atomic integer operations
- atomic_sub(), Atomic integer operations
- atomic_t data type, Atomic integer operations
- 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, Probing the IRQ Line
- shared interrupts and, Installing a Shared Handler
- module loading/unloading, Loading Modules on Demand
- awakening processes, Going to Sleep and Awakening
B
- bad_user_access_length(), Using the ioctl Argument
- base name, device, The Generic Hard Disk
- be16_to_cpu(), be32_to_cpu(), Conversion Functions
- big-endian byte order, Other Portability Issues
- binary formats, Initialization and Shutdown, Exec and Binary Formats
- binfmts.h header, Exec and Binary Formats
- bios32.h header, Detecting the Device
- bit operations, Bit operations, Bit operations, Bit Operations
- bit-splitting, The open Method
- bitops.h header, Bit Operations
- blk.h header, The Header File blk.h, The Header File blk.h
- blkdev.h header, Registering the Driver
- BLKFLSBUF command, The ioctl Method
- BLKGETSIZE command, The ioctl Method, The Device Methods for spull
- 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
- blksize_size array, Registering the Driver
- blk_dev_struct structure, Registering the Driver
- blk_size array, Registering the Driver
- block drivers, Classes of Devices and Modules
- arrays for information about, Registering the Driver
- function definitions for, devices.c and block_dev.c, Char, Block, and Network Drivers
- generic hard disk support, The Generic Hard Disk, The Generic Hard Disk
- handling requests, Handling Requests, Clustered Requests
- interrupt-driven, Interrupt-Driven Block Drivers, Interrupt-Driven Block Drivers
- ioctl method and, The ioctl Method, The ioctl Method
- <linux/blk.h> header, The Header File blk.h, The Header File blk.h
- loading/unloading, Loading Block Drivers, Extra Care
- mounting device, How Mounting Works, How Mounting Works
- partionable devices and, Partitionable Devices, The Device Methods for spull
- registering/unregistering, Registering the Driver, Registering the Driver
- removable block devices, Removable Devices, Extra Care
- blocking I/O operations, Blocking I/O
- blocking open requests, Blocking Open as an Alternative to EBUSY, Blocking Open as an Alternative to EBUSY
- testing, A Sample Implementation: scullpipe
- block_dev file, devices.c and block_dev.c
- block_fsync(), Registering the Driver
- block_read(), Registering the Driver
- block_write(), Registering the Driver
- BogoMips value, Short Delays
- booting
- allocating memory while, Playing Dirty, Playing Dirty
- bzImage kernel, Booting a bare-bones bzImage kernel
- kernels, Booting the Kernel, Booting the Kernel
- Linux, Setting Up the X86 Processors, Other booters
- (non)modularized drivers and, Modularized and Non-Modularized Drivers
- Alpha processors, Setting Up Alpha Processors
- PCI and, Boot Time
- Sparc computers, Setting Up Sparc Processors
- zImage kernel, Booting a bare-bones zImage kernel
- bottom halves
- of interrupt handlers, Bottom Halves
- tasks queues, The Nature of Task Queues, The immediate queue
- bridge directory, Networking
- BSS segments, Virtual Memory Areas
- buffer cache, Inodes and Caching Techniques
- buffer for printk(), How Messages Get Logged
- buffer, DMA, Allocating the DMA Buffer, Do-it-yourself allocation
- buffer_head structure, Performing the Actual Data Transfer, Clustered Requests
- bugs (see debugging; troubleshooting)
- bus addresses, Bus Addresses
- bus architecture, Overview of Peripheral Buses, Quick Reference
- bus_to_virt(), Bus Addresses
- byte order and portability, Other Portability Issues
- byteorder.h header, Other Portability Issues, Conversion Functions
- bzImage kernel, booting, Booting a bare-bones bzImage kernel
C
- caching techniques, Inodes and Caching Techniques
- cancel_release_module(), The Kernel-Level Side
- Card Select Number (CSN), The ``Plug and Play'' Specification
- cdrom directory, Other Subdirectories
- centralized symbol table, Registering Symbol Tables, Registering Symbol Tables
- CFLAGS variable (make), Compiling and Loading
- change_bit(), Bit operations, Bit Operations
- change_mtu method, The device methods
- channels, DMA, DMA for ISA devices, Registering DMA usage
- char drivers, Classes of Devices and Modules, Char Drivers
- defining mechanism of, The Design of scull, The Design of scull
- function definitions for, Char, Block, and Network Drivers
- version numbers, Major and Minor Numbers, dev_t and kdev_t
- CHECKSUM_ symbols, Packet Reception
- check_media_charge method, Overview of the Different Operations, check_media_change
- check_region(), Ports
- circular buffers, Using Circular Buffers, Using Circular Buffers
- class PCI register, Detecting the Device
- classes, module, Splitting the Kernel, Classes of Devices and Modules
- cleanup_module(), Modules Versus Applications, Error Handling in init_module
- network drivers and, Module Unloading
- releasing ports, Ports
- clear_bit(), Bit operations, Bit Operations
- clear_dma_ff(), Talking to the DMA controller
- cli(), ISA Memory
- clock ticks (see jiffies value)
- clone system call, Process Control
- cloning devices on open requests, Cloning the Device on Open
- close method, The release Method, Virtual Memory Areas
- (see also release method)
- after cloning devices on open, Cloning the Device on Open
- partitionable devices and, The Device Methods for spull
- for single-open devices, Single-Open Devices
- closing network interface, Opening and Closing
- clustered requests, Clustered Requests, Clustered Requests
- code, delaying, Delaying Execution, Short Delays
- collisions, device, Ports
- command-oriented drivers, Device Control Without ioctl, Device Control Without ioctl
- compiling, ELF binary formats for, Declaring Parameters
- concurrency, Concurrency in the Kernel, Race Conditions, Going to Sleep Without Races
- concurrent access (see race conditions)
- conf.modules file, The User-Level Side
- config.h header, Detecting the Device
- configuration space, PCI, PCI Addressing, Accessing the Configuration Space, Looking at a configuration snapshot
- configuring, Automatic and Manual Configuration, Automatic and Manual Configuration
- Alpha processors, Setting Up Alpha Processors
- DMA controller, Talking to the DMA controller, Talking to the DMA controller
- network devices, The device methods
- at load time, Load-Time Configuration, Load-Time Configuration
- at run time, Run-Time Configuration
- PCI registers, Detecting the Device, Detecting the Device
- persistent data storage vs., Persistent Storage Across Unload/Load, Persistent Storage Across Unload/Load
- Sparc computers, Setting Up Sparc Processors
- X86 processors, Setting Up the X86 Processors, Other booters
- CONFIG_MODVERSIONS(), Using Version Support in Modules
- CONFIG_PCI(), Detecting the Device
- consoles
- selecting for messages, Printk
- wrong font on, Device Control Without ioctl
- CONSOLE_BH bottom half, The Design of Bottom Halves
- console_loglevel variable, Printk
- control functions, Control Functions
- Control-PrScr key, System Hangs
- controlling access (see access)
- controlling-by-write, Device Control Without ioctl, Device Control Without ioctl
- converting
- Linux 2.1 functions for, Conversion Functions
- virtual addresses, Bus Addresses
- copy-on-write pages, Using the ioctl Argument
- copying, cross-space, Read and Write
- copy_from_user(), Accessing User Space
- __copy_from_user(), Accessing User Space
- copy_from_user_ret(), Accessing User Space
- copy_to_user(), Accessing User Space
- copy_to_user_ret(), Accessing User Space
- __copy_to_user(), Accessing User Space
- core directory, Networking
- core files, Using gdb
- core-file (gdb command), Using gdb
- cp command, The write Method
- CPU modalities (levels), User Space and Kernel Space
- cpu_idle(), Booting the Kernel
- cpu_to_ convertion functions, Conversion Functions
- create_module system call, Security Issues
- cross-space copying, Read and Write
- CSN (Card Select Number), The ``Plug and Play'' Specification
- cua’s (callout devices), The open Method
- current pointer, Concurrency in the Kernel, Other Changes
- timeout field, Long Delays
- current time, Knowing the Current Time
- CURRENT(), Handling Requests, Performing the Actual Data Transfer
- currenttime file (jit module), Knowing the Current Time
- current_set array, Concurrency in the Kernel
- custom
- data types, Interface-Specific Types, Interface-Specific Types
- ioctl methods for networking, Custom ioctl Commands, Custom ioctl Commands
- modules package, The User-Level Side
- task queues, Running Your Own Task Queues
- cx_interrupt() (example), Using Arguments
- cx_open() (example), Using Arguments
D
- data
- misaligned, Using the /proc Filesystem
- physical packet transport, The Physical Transport of Packets, Packet Transmission, Packet Reception
- protecting from race conditions, Race Conditions
- reading (see reading)
- sizing explicitly, Assigning an Explicit Size to Data Items, Assigning an Explicit Size to Data Items
- transfering for block driver requests, Performing the Actual Data Transfer, Performing the Actual Data Transfer
- transfering with DMA, Direct Memory Access
- unaligned, portability and, Other Portability Issues
- writing (see writing)
- data types
- for explicitly sizing data, Assigning an Explicit Size to Data Items, Assigning an Explicit Size to Data Items
- interface-specific, Interface-Specific Types, Interface-Specific Types
- portability and, Judicious Use of Data Types, Interface-Specific Types
- standard C types, Use of Standard C Types, Use of Standard C Types
- datasize program, Use of Standard C Types
- dd command, The write Method
- deallocating (see allocating)
- debugging, Debugging Techniques, Remote Debugging
- (see also troubleshooting)
- implementing debug levels, Using the Preprocessor to Ease Monitoring
- interrupt handling, Using Arguments
- with ioctl method, The ioctl Method, The ioctl Method
- locked keyboard, System Hangs
- module loading, Version Dependency
- modules, Using klogd, Remote Debugging
- by printing, Debugging by Printing, Using the Preprocessor to Ease Monitoring
- by querying, Debugging by Querying, The ioctl Method
- race conditions, Race Conditions, Going to Sleep Without Races
- remote debugging, Remote Debugging, Remote Debugging
- system faults, Debugging System Faults, System Hangs
- system hangs, System Hangs, System Hangs
- using a debugger, Using a Debugger, Remote Debugging
- by watching in user space, Debugging by Watching, Debugging by Watching
- DECLARE_TASK_QUEUE(), Running Your Own Task Queues
- declaring device parameters, Declaring Parameters
- decoding oops messages, Using ksymoops, Using klogd
- DEFAULT_CONSOLE_LOGLEVEL priority, Printk
- DEFAULT_MESSAGE_LOGLEVEL priority, Printk
- delayed_release_module(), The Kernel-Level Side
- delaying execution, Delaying Execution, Long Delays, Short Delays, Short Delays
- delete_module(), Unloading
- deleting device nodes, Removing a Driver from the System
- del_timer(), The New Timer List
- demand-loading modules, Loading Modules on Demand
- depmod utility, The User-Level Side
- dereferencing invalid pointers, Oops Messages, Using klogd
- /dev nodes
- assigning, Major and Minor Numbers
- /dev/random device, Installing an Interrupt Handler
- /dev/urandom device, Installing an Interrupt Handler
- dynamic major number allocation and, Dynamic Allocation of Major Numbers
- removing, Removing a Driver from the System
- development kernels, Version Numbering
- device control operations, Splitting the Kernel
- device files, Major and Minor Numbers, Access Control on a Device File
- device structure, Module Loading, The device Structure in Detail, Utility fields
- deviceID PCI register, Detecting the Device
- devices
- autodetecting parameters of, Automatic and Manual Configuration
- base name of, The Generic Hard Disk
- block (see block drivers)
- 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
- collisions between, Ports
- controlling with ioctl, ioctl, Device Control Without ioctl
- declaring parameters for, Declaring Parameters
- detecting newly added, Persistent Storage Across Unload/Load
- DMA and, Direct Memory Access
- file operations on, File Operations, Overview of the Different Operations
- hardware management, Hardware Management
- identifying type with ls command, Major and Minor Numbers
- interrupts (see interrupt handlers)
- miscellaneous, Initialization and Shutdown
- names of, Major and Minor Numbers
- aliases for, The open Method
- dynamic major number allocation and, Dynamic Allocation of Major Numbers
- removing, Removing a Driver from the System
- network (see network drivers)
- partitionable, Partitionable Devices, The Device Methods for spull, The Device Methods for spull
- PCI (see PCI)
- probing (see probing)
- reading and writing, Read and Write
- removable, Removable Devices, Extra Care
- seeking, Seeking a Device, The lseek Implementation
- single-open, Single-Open Devices, Single-Open Devices
- single-user access to, Restricting Access to a Single User at a Time, 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, Device Control Without ioctl
- devices file, devices.c and block_dev.c
- DEVICE_INTR symbol, The Header File blk.h
- DEVICE_NAME symbol, The Header File blk.h
- DEVICE_NO_RANDOM symbol, The Header File blk.h
- DEVICE_NR symbol, The Header File blk.h
- DEVICE_OFF symbol, The Header File blk.h
- DEVICE_ON symbol, The Header File blk.h
- DEVICE_REQUEST symbol, The Header File blk.h
- DEVICE_TIMEOUT symbol, The Header File blk.h
- dev_alloc_skb(), Functions Acting on Socket Buffers
- dev_id pointer, Installing an Interrupt Handler, Using Arguments, Installing a Shared Handler
- dev_kfree_skb(), Functions Acting on Socket Buffers
- dev_mc_list structure, Kernel Support for Multicasting
- dev_t type (Unix), dev_t and kdev_t
- direct memory access (DMA), Direct Memory Access
- directories of kernel headers, Modules Versus Applications
- directory cache, Inodes and Caching Techniques
- disable_dma(), Talking to the DMA controller
- disable_irq(), Enabling and Disabling Interrupts
- disabling interrupts, Enabling and Disabling Interrupts, Enabling and Disabling Interrupts, Disabling Interrupts
- disassemble command (gdb), Using gdb
- disk changes (see removable block devices)
- disk geometry, retrieving, The ioctl Method
- DMA (direct memory access), Direct Memory Access
- allocating buffer for, Allocating the DMA Buffer, Do-it-yourself allocation
- configuring controller, Talking to the DMA controller, Talking to the DMA controller
- for ISA memory, DMA for ISA devices, Talking to the DMA controller
- PCI devices and, DMA and PCI Devices
- registering usage, Registering DMA usage
- dma file, Other Operations
- dma.h header, Talking to the DMA controller
- DMAC (DMA controller), DMA for ISA devices
- documentation for futher information, Sources for Further Information
- do_bottom_half(), The Design of Bottom Halves
- do_gettimeofday(), Knowing the Current Time
- do_ioctl method, The device methods
- do_IRQ(), The internals of interrupt handling on the x86
- do_no_page(), Other Interfaces
- do_timer(), Predefined Task Queues, The Design of Bottom Halves
- do_wp_page(), Other Interfaces
- dquot file, Minor Files
- drivers
- adding new, Major and Minor Numbers, Removing a Driver from the System
- asynchronous notification and, The Driver’s Point of View, The Driver’s Point of View
- callout (cua’s), The open Method
- character (see char drivers)
- choosing ioctl numbers for, Choosing the ioctl Commands
- command-oriented, Device Control Without ioctl, Device Control Without ioctl
- configuring, Automatic and Manual Configuration, Automatic and Manual Configuration
- device names (see devices, names of)
- file operations, File Operations, Overview of the Different Operations
- input and output buffers, Blocking and Nonblocking Operations
- interrupt-driven, Interrupt-Driven Block Drivers, Interrupt-Driven Block Drivers
- mechanism of (see mechanism, driver)
- monitoring with preprocessor, Using the Preprocessor to Ease Monitoring, Using the Preprocessor to Ease Monitoring
- network drivers, Network Drivers, Quick Reference
- network, bottom half for, The Design of Bottom Halves
- probing for IRQ numbers, Do-it-yourself probing, Do-it-yourself probing
- recent developments, Recent Developments, Other Changes
- removing (see unloading modules)
- SCSI, Classes of Devices and Modules
- serial, Initialization and Shutdown
- tty, Initialization and Shutdown, The open Method
- user-space, Doing It in User Space, Doing It in User Space
- version (see version numbering)
- drivers directory, Drivers, Other Subdirectories
E
- EBUSY error, Blocking Open as an Alternative to EBUSY, Blocking Open as an Alternative to EBUSY
- EISA buses, EISA
- ELF binary formats, Declaring Parameters
- enable_dma(), Talking to the DMA controller
- enable_irq(), Enabling and Disabling Interrupts
- enabling interrupts, Enabling and Disabling Interrupts, Enabling and Disabling Interrupts
- end-of-file
- seeking relative to, The lseek Implementation
- select system call and, Select
- endless loops, preventing, System Hangs
- end_request(), Handling Requests, Clustered Requests
- interrupt-driven block drivers and, Interrupt-Driven Block Drivers
- enet_statistics structure, The device methods, Statistical Information, Other Changes
- errno.h file, Error Handling in init_module
- error codes, Error Handling in init_module
- errors
- handling in init_module(), Error Handling in init_module
- with partial data transfers, The write Method
- PCI device, Detecting the Device
- read/write, Read and Write
- strace command to debug, Debugging by Watching
- /etc/conf.modules file, The User-Level Side
- /etc/modules.conf file, The User-Level Side
- Ethernet, The Physical Transport of Packets
- address resolution, Address Resolution, Non-Ethernet Headers
- function definitions, Networking
- non-Ethernet headers, Non-Ethernet Headers
- ether_setup(), Interface information
- eth_header method, The device methods
- exceptions
- handling, Handling Kernel-Space Faults, Handling Kernel-Space Faults
- selecting for, Select
- exec(), Exec and Binary Formats
- execution (exec) domains, Initialization and Shutdown
- execution modes, User Space and Kernel Space
- exec_domain file, Other Operations
- exit system call, Process Control
- expansion board memory, Accessing Memory on Device Boards, High PCI Memory
- experimental kernels, Version Numbering
- expires field (timer_list structure), The New Timer List
- exporting symbols, Exporting Versioned Symbols, Exporting Symbols, Exporting Symbols
- EXPORT_ macros, Exporting Symbols
- EXPORT_SYMTAB(), Exporting Versioned Symbols
- Extended ISA buses, EISA
- __ex_table section, Handling Kernel-Space Faults
F
- facilities, (un)registering in init_module(), Initialization and Shutdown, Initialization and Shutdown, Error Handling in init_module
- fast interrupt handlers, Fast and Slow Handlers, The internals of interrupt handling on the x86, Installing a Shared Handler
- fasync method, Overview of the Different Operations
- fasync_helper(), The Driver’s Point of View, Quick Reference
- fasync_struct structure, The Driver’s Point of View
- faults (see system faults)
- fcntl file, Control Functions
- fcntl system call, The Predefined Commands
- fddi_setp(), Interface information
- fdisk program, Partitionable Devices, The Device Methods for spull
- file flags, The file Structure
- file handling, function definitions for, The fs Directory, Minor Files
- file locks, File Locks
- file modes, The file Structure
- file operations, File Operations, Overview of the Different Operations
- Linux 2.1 and, File Operations, The poll Method
- file structure, File Operations, The file Structure, The file Structure
- File System header (fs.h), Quick Reference
- filemap file, Other Interfaces
- filesystem nodes, Splitting the Kernel, Classes of Devices and Modules
- creating within /proc, Using the /proc Filesystem
- names, device (see devices, names of)
- filesystems file, The VFS: Superblocks
- file_operations structure, File Operations, Overview of the Different Operations, The file Structure, Pipes and fifos
- filp pointer, The file Structure, ioctl, How Mounting Works
- FIOASYNC command, The Predefined Commands
- FIOCLEX command, The Predefined Commands
- FIONBIO command, The Predefined Commands
- FIONCLEX command, The Predefined Commands
- firmware, PCI-aware, Boot Time
- .fixup section, Handling Kernel-Space Faults
- flags, file, The file Structure
- flock system call, File Locks
- flushing pending output, Flushing pending output
- font, incorrect on console, Device Control Without ioctl
- fops pointer, Major and Minor Numbers, File Operations, The open Method, Registering the Driver
- forcing module load, Version Dependency
- fork system call, Process Control
- fragmentation, Do-it-yourself allocation
- free command, Playing with the New Devices
- free_dma(), Registering DMA usage
- free_irq(), Installing an Interrupt Handler
- when to call, Installing an Interrupt Handler
- free_page(), get_free_page and Friends
- free_pages(), get_free_page and Friends
- free_wait(), The Underlying Data Structure
- fs directory, The fs Directory, Minor Files
- fs.h header, Quick Reference, The ioctl Method
- fsync method, Overview of the Different Operations, Flushing pending output
- functions, Registering Symbol Tables
- (see also symbols)
- calling from modules/applications, Modules Versus Applications
- disassembling with gdb, Using gdb
- inserting schedule() calls in, System Hangs
- multitasking and, Concurrency in the Kernel
- f_flags field (file structure), The file Structure
- f_op pointer, The file Structure
- f_pos pointer, The lseek Implementation
- F_SETFL command, The Predefined Commands, The Driver’s Point of View
- F_SETOWN command, Asynchronous Notification, The Driver’s Point of View
G
- gcc compiler
- -g flag, Using gdb
- -O flag, Compiling and Loading
- -Wall flag, Compiling and Loading
- gdb debugger, Using gdb, Remote Debugging
- gendisk_struct structure, The Generic Hard Disk
- General Public License (GPL), License Terms
- generic hard disk support, The Generic Hard Disk, The Generic Hard Disk
- genhd.h header, The Generic Hard Disk
- genhd_struct structure
- declaring for partitionable drivers, Partition Detection in the Kernel
- __GENKSYMS__(), Quick Reference
- genksyms program, Exporting Versioned Symbols
- geometry, disk, The ioctl Method
- __get_dma_pages(), get_free_page and Friends
- get_dma_residue(), Talking to the DMA controller
- get_free_page(), The Priority Argument, get_free_page and Friends
- __get_free_page(), get_free_page and Friends
- __get_free_pages(), get_free_page and Friends
- get_persist(), Persistent Storage Across Unload/Load
- get_stats method, Statistical Information
- get_user(), Using the ioctl Argument, Quick Reference, Accessing User Space
- __get_user(), Accessing User Space
- get_user_byte(), Quick Reference
- get_user_ret(), Accessing User Space
- GFP_ATOMIC priority, The Priority Argument, get_free_page and Friends
- GFP_DMA priority, Allocating the DMA Buffer
- GFP_DMA symbol, The Priority Argument
- GFP_KERNEL priority, Using Resources, The Priority Argument
- GFP_NFS priority, The Priority Argument
- global
- memory areas, The Design of scull
- message enabling/disabling, Using the Preprocessor to Ease Monitoring
- symbols, The Kernel Symbol Table, Registering Symbol Tables
- goodness(), sched.c
- goto statement, Error Handling in init_module
- GPL (General Public License), License Terms
- gpm-root daemon, System Hangs
- group, device, Dynamic Allocation of Major Numbers
H
- HARDRESET command, Choosing the ioctl Commands
- hardsect_size array, Registering the Driver
- hardware (see devices)
- hard_header method, The device methods, Non-Ethernet Headers
- hard_start_transmit method, Packet Transmission
- hard_start_xmit method, The device methods, Packet Transmission
- HAVE_CHANGE_MTU(), The device methods
- HAVE_HEADER_CACHE(), The device methods
- HDIO_GETGEO command, The ioctl Method
- head pointer, Using Circular Buffers
- header files, Modules Versus Applications
- headers, Ethernet (see Ethernet)
- headers, non-Ethernet, Non-Ethernet Headers
- header_cache_bind method, The device methods
- header_cache_update method, The device methods
- hiding global symbols, Registering Symbol Tables
- htonl(), Other Portability Issues
- htons(), Other Portability Issues
- hung system, System Hangs, System Hangs
- HZ (time frequency) symbol, Time Intervals in the Kernel, Other Portability Issues
I
- I/O, Flushing pending output
- (see also reading; writing)
- accessing, PCI and, Accessing the I/O and Memory Spaces, Accessing the I/O and Memory Spaces
- asynchronous notification, Asynchronous Notification, The Driver’s Point of View
- blocking, Blocking I/O
- blocking/nonblocking, Blocking and Nonblocking Operations, Blocking and Nonblocking Operations
- buffers for, Blocking and Nonblocking Operations
- flushing pending, Flushing pending output
- interrupt-driven, Interrupt-Driven I/O, Interrupt-Driven I/O
- ISA devices and, Hardware Resources
- pausing, Pausing I/O, Pausing I/O
- remapping specific regions of, Remapping Specific I/O Regions, Remapping Specific I/O Regions
- space for, in PCI buses, PCI Addressing
- string operations, String Operations
- transfering data with DMA, Direct Memory Access
- I/O ports, Using I/O Ports
- parallel ports, Using the Parallel Port, A Sample Driver, Preparing the Parallel Port
- I/O typing, Platform Dependencies
- if.h header, Custom ioctl Commands
- ifconfig command, Opening and Closing
- IFF_ symbols, Interface information, Interface information, Kernel Support for Multicasting
- IFF_NOARP symbol, Initializing Each Device
- ifreq structure, Custom ioctl Commands
- immediate queue, Predefined Task Queues, The immediate queue, The Design of Bottom Halves, Writing a Bottom Half
- IMMEDIATE_BH bottom half, The Design of Bottom Halves
- inb(), Using I/O Ports
- include/asm directory (see entries under <asm/>)
- infinite loops, preventing, System Hangs
- inflate file, IPC and lib Functions
- info file, Other Operations
- init process, The Init Process
- initializing
- kernel data structures, Booting the Kernel
- modules, Initialization and Shutdown
- network devices, Initializing Each Device
- PCI drivers, Detecting the Device
- initrd utility, Partition Detection Using Initrd, The Init Process
- init_mm, accessing, Remapping Virtual Addresses
- init_module(), Modules Versus Applications, Initialization and Shutdown, Module Loading
- error handling in, Error Handling in init_module
- installing interrupt handler within, Installing an Interrupt Handler
- unregistering facilties from, Error Handling in init_module
- INIT_REQUEST(), Handling Requests
- init_timer(), The New Timer List
- inl(), Using I/O Ports
- inline functions, Using I/O Ports
- inode field (file structure), The file Structure
- inode pointer, ioctl
- inodes, Inodes and Caching Techniques
- insb(), String Operations
- insl(), String Operations
- insmod program, Splitting the Kernel, Compiling and Loading
- assigning parameter values, Automatic and Manual Configuration
- -f flag, Version Dependency
- modprobe program vs., The User-Level Side
- installing
- interrupt handlers, Installing an Interrupt Handler, The internals of interrupt handling on the x86
- insw(), String Operations
- int data type, Use of Standard C Types
- interface-specific data types, Interface-Specific Types, Interface-Specific Types
- interrupt handlers, Interrupt Handling
- autodetecting IRQ numbers, Autodetecting the IRQ Number, Do-it-yourself probing, Installing a Shared Handler
- version dependency, Probing the IRQ Line
- enabling parallel ports for, Preparing the Parallel Port
- enabling/disabling interrupts, Disabling Interrupts
- implementing, Implementing a Handler, Enabling and Disabling Interrupts
- installing, Installing an Interrupt Handler, The internals of interrupt handling on the x86
- Linux 2.1 and, Interrupt Management
- /proc files for, The /proc Interface, The /proc Interface
- race conditions, Race Conditions, Going to Sleep Without Races
- circular buffers for, Using Circular Buffers, Using Circular Buffers
- circular locak variables for, Using Lock Variables, Atomic integer operations
- slow vs. fast, Fast and Slow Handlers, The internals of interrupt handling on the x86, Installing a Shared Handler
- version dependency, Version Dependencies of IRQ Handling, Probing the IRQ Line
- interrupt handling
- bottom halves of handlers, Bottom Halves
- sharing interrupts, Interrupt Sharing, The /proc Interface
- on x86 architecture, The internals of interrupt handling on the x86, The internals of interrupt handling on the x86
- interrupt handlnig
- enabling/disabling interrupts, Enabling and Disabling Interrupts, Enabling and Disabling Interrupts
- interrupt numbers, Installing an Interrupt Handler, Using Arguments
- interrupt reporting, Fast and Slow Handlers
- interrupt time, The Nature of Task Queues
- interrupt-driven operation, Interrupt-Driven I/O, Interrupt-Driven I/O
- block drivers, Interrupt-Driven Block Drivers, Interrupt-Driven Block Drivers
- network drivers, Interrupt-Driven Operation, Interrupt-Driven Operation
- interrupt.h header, Kernel-helped probing
- interruptible_sleep_on(), Going to Sleep and Awakening, Long Delays, Going to Sleep Without Races
- interrupts file, The /proc Interface
- shared interrupts and, The /proc Interface
- interrupts, PCI, PCI Interrupts, PCI Interrupts
- intervals of time, Time Intervals in the Kernel, Time Intervals in the Kernel, Other Portability Issues
- intr_count variable, The Nature of Task Queues, Interrupt Management
- immediate queue and, The immediate queue
- inw(), Using I/O Ports
- in_interrupt(), Interrupt Management
- io.h header, Using I/O Ports
- _IOC symbols/macros, Quick Reference
- ioctl file, Control Functions
- ioctl method, Overview of the Different Operations, ioctl, Device Control Without ioctl
- block devices and, The ioctl Method, The ioctl Method
- command numbers, Choosing the ioctl Commands, Choosing the ioctl Commands
- controlling devices without, Device Control Without ioctl, Device Control Without ioctl
- customizing for networking, Custom ioctl Commands, Custom ioctl Commands
- debugging with, The ioctl Method, The ioctl Method
- extra argument of, Using the ioctl Argument, Using the ioctl Argument
- Linux 2.1 implementation, Using the New Interface
- network devices and, The device methods
- partitionable devices and, The Device Methods for spull
- TIOCLINUX command, Printk
- ioctl()
- predefined commands of, The Predefined Commands, The Predefined Commands
- ioctl-number.txt file, Choosing the ioctl Commands
- ioctl.h header, Choosing the ioctl Commands, Quick Reference
- ioperm(), Using I/O Ports
- iopl(), Using I/O Ports
- ioports file, Ports
- ioremap(), vmalloc and Friends
- IP numbers, assigning, Assigning IP Numbers, Assigning IP Numbers
- IPC (Inter-Process Communication)
- function definitions, IPC and lib Functions
- ipc directory, IPC and lib Functions
- ip_summed field (sk_buff), Packet Reception, The Important Fields
- IRQ (interrupt request lines)
- autodetecting (probing) numbers for, Autodetecting the IRQ Number, Do-it-yourself probing
- shared interrupts and, Installing a Shared Handler
- version dependency, Probing the IRQ Line
- irq argument (interrupt number), Installing an Interrupt Handler, Using Arguments
- irq.h header, Enabling and Disabling Interrupts
- IRQs (interrupt request lines), Installing an Interrupt Handler
- statistics on, The /proc Interface
- ISA devices, A Look Back: ISA, The ``Plug and Play'' Specification
- allocating memory, ISA Memory, ISA Memory
- DMA for, DMA for ISA devices, Talking to the DMA controller
- Extended ISA (EISA) buses, EISA
- interface to memory, ISA Memory Below 1M, ISA Memory Above 1M
- probing, ISA Memory
- probing for, Initializing Each Device
- ISA-busmaster DMA, DMA for ISA devices
- isdn directory, Other Subdirectories
- i_rdev field (inode structure), dev_t and kdev_t
J
- jiffies value, Time Intervals in the Kernel
- for current time, Knowing the Current Time
- timeout field and, Long Delays
- at timer interrupt, Time Intervals in the Kernel
- jiq module, How the examples work
- jiq_print(), How the examples work
- jit module, Knowing the Current Time
- jitbusy program, Long Delays
- jitimer module, The New Timer List
- joysticks, System Hangs
K
- kbd_mode -a command, System Hangs
- kcore file, Using gdb
- kdebug utility, Using kdebug, Using kdebug
- kdev_t type, dev_t and kdev_t, dev_t and kdev_t
- extracting physical device number from, The Header File blk.h
- kdev_t.h header, dev_t and kdev_t
- kdev_t_no_nr(), dev_t and kdev_t
- kernel directory, The kernel Directory, Other Operations
- kernel headers, Modules Versus Applications
- kernel_send(), The Kernel-Level Side
- kernel space, User Space and Kernel Space
- handling faults in, Handling Kernel-Space Faults, Handling Kernel-Space Faults
- kerlend program and, The Kernel-Level Side
- transfering to/from user space, Read and Write
- __KERNEL__ symbol, Compiling and Loading
- kernel timers, Kernel Timers, The New Timer List
- kerneld program, Loading Modules on Demand
- mmap method and, Maintaining the Usage Count
- kerneld.h header, The Kernel-Level Side
- persistent storage capability, Persistent Storage Across Unload/Load
- kernels
- allocating memory at boot time, Playing Dirty, Playing Dirty
- booting, Booting the Kernel, Booting the Kernel
- booting with initrd, Partition Detection Using Initrd
- bzImage, booting, Booting a bare-bones bzImage kernel
- connecting network drivers to, Connecting to the Kernel, Modularized and Non-Modularized Drivers
- developmental (experimental), Version Numbering
- handling system faults (see system faults)
- loading modules into (see loading modules)
- messages (see messages)
- module version control, Version Control in Modules
- multicasting support, Kernel Support for Multicasting
- multitasking in, Concurrency in the Kernel
- partition detection in, Partition Detection in the Kernel, Partition Detection in the Kernel
- probing interrupt numbers with, Kernel-helped probing, Kernel-helped probing
- remote debugging enabled on, Remote Debugging, Remote Debugging
- security (see security)
- splitting role of, Splitting the Kernel, Splitting the Kernel
- symbol table, Modules Versus Applications, The Kernel Symbol Table, Registering Symbol Tables
- time intervals in, Time Intervals in the Kernel, Time Intervals in the Kernel
- version 2.1, Recent Developments, Other Changes
- version numbering, Version Numbering, Version Numbering
- zImage, booting, Booting a bare-bones zImage kernel
- kernel_version symbol, Version Dependency
- keyboard, debugging when locked, System Hangs
- kfree(), Using Resources
- kfree_skb(), Functions Acting on Socket Buffers
- kgdb script, Using kdebug
- kill_fasync(), The Driver’s Point of View, Quick Reference
- klogd daemon
- -c flag, Printk
- debugging modules with, Using klogd
- decoding oops messages, Using klogd, Using klogd
- -f flag, How Messages Get Logged
- -k flag, Using klogd
- kmalloc command, The Real Story of kmalloc, The Size Argument
- kmalloc file, Allocation and Deallocation
- kmalloc(), Using Resources
- kmouse module, Cloning the Device on Open
- ksymoops utility, Using ksymoops, Using ksymoops
- ksyms command
- -m flag, Using ksymoops
- ksyms file, The Kernel Symbol Table, Modularization
L
- layered modularization (stacking modules), The Kernel Symbol Table
- ld -r command, Compiling and Loading
- le16_to_cpu(), le32_to_cpu(), Conversion Functions
- le16_to_cpup(), le16_to_cpus(), Conversion Functions
- levels
- debugging, Using the Preprocessor to Ease Monitoring
- message priority (see loglevels)
- levels (modalities), CPU, User Space and Kernel Space
- libraries, Modules Versus Applications
- library functions, IPC and lib Functions
- license, Linux, License Terms
- lilo program (Linux Loader), Using lilo
- line disciplines, Initialization and Shutdown
- lines, interrupt (see IRQs)
- Linux
- license terms, License Terms
- version numbering, Version Numbering, Version Numbering
- linux directory, Modules Versus Applications
- Linux, loading, Setting Up the X86 Processors, Other booters
- <linux/binfmts.h> header, Exec and Binary Formats
- <linux/bios32.h> header, Detecting the Device
- <linux/blk.h> header, The Header File blk.h, The Header File blk.h
- <linux/blkdev.h> header, Registering the Driver
- <linux/config.h> header, Detecting the Device
- <linux/fs.h> header, The ioctl Method
- <linux/fs.h> header, Quick Reference
- <linux/genhd.h> header, The Generic Hard Disk
- <linux/if.h> header, Custom ioctl Commands
- <linux/interrupt.h> header, Kernel-helped probing
- <linux/ioctl.h> header, Quick Reference
- <linux/kdev_t.h> header, dev_t and kdev_t
- <linux/kerneld.h> header, The Kernel-Level Side, Persistent Storage Across Unload/Load
- <linux/mm.h> header, The Memory Map
- <linux/module.h> header, Quick Reference
- <linux/modversions.h> header, Using Version Support in Modules
- <linux/net.h> header, Networking
- <linux/pci.h> header, Detecting the Device
- <linux/sched.h> header, Quick Reference
- <linux/skbuff.h> header, The Socket Buffers
- <linux/symtab_begin.h> header, Registering Symbol Tables, Quick Reference
- <linux/symtab_end.h> header, Quick Reference
- <linux/timer.h> header, The New Timer List
- <linux/tqueue.h> header, Predefined Task Queues
- <linux/types.h> header, Interface-Specific Types
- <linux/version.h> header, Version Dependency, Quick Reference
- <linux/vmalloc.h> header, vmalloc and Friends
- LINUX_VERSION_CODE(), Version Dependency
- little-endian byte order, Other Portability Issues
- llseek method, Prototype Differences
- load-time network interface configuration, Load-Time Configuration, Load-Time Configuration
- load50 program, The scheduler queue
- loading block drivers, Loading Block Drivers, Extra Care
- loading Linux, Setting Up the X86 Processors, Other booters
- loading modules, Compiling and Loading
- on demand, Loading Modules on Demand
- dynamically assigned device numbers, Dynamic Allocation of Major Numbers
- for network drivers, Module Loading
- persistent storage across, Persistent Storage Across Unload/Load, Persistent Storage Across Unload/Load
- version dependency and, Version Dependency
- loadlin program, Using loadlin
- lock variables, Using Lock Variables, Atomic integer operations
- locked keyboard, debugging, System Hangs
- locks file, File Locks
- loff_t field (file structure), The file Structure
- logging messages, How Messages Get Logged, How Messages Get Logged
- loglevels (message priorities), Printk, Printk, System Hangs
- long data type, Use of Standard C Types
- long delays, Long Delays, Long Delays
- loops, endless, System Hangs
- ls command, identifying device type with, Major and Minor Numbers
- lseek method, Overview of the Different Operations, The lseek Implementation, The lseek Implementation, Prototype Differences
- lseek_off_t(), Prototype Differences
- lseek_t(), Prototype Differences
M
- M68k architecture, porting and, Platform Dependencies
- Magic System Request Key, System Hangs
- MAJOR(), dev_t and kdev_t
- major device numbers, Major and Minor Numbers, Removing a Driver from the System
- dynamic allocation of, Dynamic Allocation of Major Numbers
- major_name value (gendisk_struct), The Generic Hard Disk
- MAJOR_NR symbol, The Header File blk.h
- Makefile, Compiling and Loading, Compiling and Loading, Using Version Support in Modules
- make_request(), Clustered Requests
- mapper program, Remapping RAM
- mapping memory (see memory management)
- MAP_NR(), The Memory Map
- marking bottom halves, The Design of Bottom Halves
- mark_bh(), The Design of Bottom Halves
- master module, Using Version Support in Modules
- MAX_DMA_ADDRESS(), Allocating the DMA Buffer
- MCA buses, MCA
- mechanism, driver
- defining, The Design of scull, The Design of scull
- policy versus, The Role of the Driver Writer
- memcpy_fromfs(), Read and Write
- memcpy_fromio(), ISA Memory Below 1M
- memcpy_tofs(), Read and Write
- put_user() instead of, Using the ioctl Argument
- memcpy_toio(), ISA Memory Below 1M
- memory
- accessing from expansion boards, Accessing Memory on Device Boards, High PCI Memory
- allocating, Scull’s Memory Usage
- at boot time, Playing Dirty, Playing Dirty
- function definitions for, Allocation and Deallocation
- on ISA boards, ISA Memory, ISA Memory, ISA Memory Below 1M, ISA Memory Above 1M
- with kmalloc, The Real Story of kmalloc, The Size Argument
- by page, get_free_page and Friends, A scull Using Whole Pages: scullp
- with vmalloc, vmalloc and Friends, A scull Using Virtual Addresses: scullv
- circular buffers, Using Circular Buffers, Using Circular Buffers
- free, information on, Playing with the New Devices
- global areas, The Design of scull
- how much to allocate, The Size Argument
- managing allocation, Using Resources
- page clusters, The Size Argument
- page size and portability, Other Portability Issues
- on PCI boards, High PCI Memory
- persistence, The Design of scull
- on text-mode VGA boards, Accessing the Text-Mode Video Buffer
- verifying user-space addresses, Using the ioctl Argument
- virtual, Linux 2.1 and, Virtual Memory
- memory file, Other Interfaces
- memory management, Splitting the Kernel
- DMA (direct memory access), Direct Memory Access
- fragmentation, Do-it-yourself allocation
- handling map region changes, Supporting the mremap System Call, Supporting the mremap System Call
- memory mapping/remapping, The Memory Map
- Alpha architecture, The mmap Device Operation
- function definitions for, Other Interfaces
- handling region changes, Supporting the mremap System Call, Supporting the mremap System Call
- mmap method, The mmap Device Operation, Remapping Virtual Addresses
- PCI regions, Accessing the I/O and Memory Spaces
- RAM, Remapping RAM, Implementing the nopage method
- specific I/O regions, Remapping Specific I/O Regions, Remapping Specific I/O Regions
- virtual addresses, Remapping Virtual Addresses, Remapping Virtual Addresses
- mmap method, The mmap Device Operation, Remapping Virtual Addresses
- PCI and, Accessing the Configuration Space, Accessing the I/O and Memory Spaces
- theory of, Memory Management in Linux, The Memory Map
- VMAs (virtual memory areas), Virtual Memory Areas, Virtual Memory Areas
- memory-is-prefetchable bit, Accessing the I/O and Memory Spaces
- memset_io(), ISA Memory Below 1M
- mem_map_t type, The Memory Map
- messages
- globally enabling/disabling, Using the Preprocessor to Ease Monitoring
- logging, How Messages Get Logged, How Messages Get Logged
- oops messages, Oops Messages, Using klogd
- priorities (loglevels) of, Printk, Printk
- priority of, Building and Running Modules
- from PrScr key, System Hangs
- methods (see file operations)
- mice, System Hangs
- asynchronous notification, Asynchronous Notification
- cloning devices (kmouse module), Cloning the Device on Open
- Micro Channel Architecture (MCA), MCA
- milo program, Setting Up Alpha Processors
- MINIMUM_CONSOLE_LOGLEVEL priority, Printk
- minor device numbers, Major and Minor Numbers, dev_t and kdev_t, dev_t and kdev_t
- MINOR(), dev_t and kdev_t
- minor_shift value (gendisk_struct), The Generic Hard Disk
- Mips architecture, porting and, Platform Dependencies
- misaligned data, Using the /proc Filesystem
- misc devices, Char, Block, and Network Drivers
- miscellaneous devices, Initialization and Shutdown
- MKDEV(), dev_t and kdev_t
- mknod command, Major and Minor Numbers
- mlock file, Other Interfaces
- mm directory, The mm Directory, Other Interfaces
- mm.h header, The Memory Map
- mmap file, Other Interfaces
- mmap method, Overview of the Different Operations, The mmap Device Operation, Remapping Virtual Addresses
- remapping virtual addresses with, Remapping Virtual Addresses, Remapping Virtual Addresses
- usage count and, Maintaining the Usage Count, Maintaining the Usage Count
- modalities (levels), CPU, User Space and Kernel Space
- modes
- device modes, Dynamic Allocation of Major Numbers
- file modes, The file Structure
- mode_t field (file structure), The file Structure
- modprobe program, The User-Level Side
- modularization, Modularization, /proc/modules
- layered (see stacking modules)
- network drivers, Modularized and Non-Modularized Drivers
- module file, Modularization
- MODULE symbol, Compiling and Loading
- module.h header, Quick Reference
- modules, Audience of This Book , Splitting the Kernel
- addresses for, adding to system map, Using ksymoops
- applications versus, Modules Versus Applications, Concurrency in the Kernel
- classes of, Classes of Devices and Modules, Classes of Devices and Modules
- debugging, Using klogd, Remote Debugging
- exporting symbols, Exporting Versioned Symbols, Exporting Symbols, Exporting Symbols
- filesystem (see filesystem nodes)
- header files of, Modules Versus Applications
- HZ (time frequency) and, Time Intervals in the Kernel
- initializing, Initialization and Shutdown
- interrupts (see interrupt handlers)
- license terms, License Terms
- loading/unloading, Modules Versus Applications, Compiling and Loading, Unloading, Removing a Driver from the System, Removing a Driver from the System, Loading Modules on Demand
- (see also cleanup_module())
- with dynamically assigned device numbers, Dynamic Allocation of Major Numbers
- for network drivers, Module Loading, Module Unloading
- usage count and, The Usage Count, The Usage Count
- version dependency and, Version Dependency
- partition detection in, Partition Detection in Modules
- partitionable, portability and, Partitionable Devices
- persistent storage, Persistent Storage Across Unload/Load, Persistent Storage Across Unload/Load
- probing for hardware (see probing)
- security (see security)
- stacking, The Kernel Symbol Table
- usage count (see usage count)
- version dependency, Version Dependency
- version support, Version Control in Modules
- modules file, The Usage Count, /proc/modules
- modules package
- customizing, The User-Level Side
- persistent storage capability, Persistent Storage Across Unload/Load
- modules.conf file, The User-Level Side
- MODULE_PARM(), Declaring Parameters
- __MODULE_STRING symmbol, Declaring Parameters
- MOD_DEC_USE_COUNT macro, The Usage Count
- MOD_INC_USE_COUNT macro, The Usage Count
- MOD_IN_USE macro, The Usage Count
- monitoring, preprocessor for, Using the Preprocessor to Ease Monitoring, Using the Preprocessor to Ease Monitoring
- mounting block devices, How Mounting Works, How Mounting Works
- mouse (see mice)
- mremap file, Other Interfaces
- mremap system call, Supporting the mremap System Call, Supporting the mremap System Call
- msg file, IPC and lib Functions
- MTU, network devices and, The device methods
- multicasting, Multicasting, A Typical Implementation
- multitasking, Concurrency in the Kernel
N
- name cache, Inodes and Caching Techniques
- names, device (see devices, names of)
- namespace pollution, Modules Versus Applications
- native DMA, DMA for ISA devices, Talking to the DMA controller
- nbtest program, A Sample Implementation: scullpipe
- net directory, Modules Versus Applications, Networking
- net.h header, Networking
- network drivers, Classes of Devices and Modules, Network Drivers, Quick Reference
- configuring, Load-Time Configuration
- connecting to kernel, Connecting to the Kernel, Modularized and Non-Modularized Drivers
- function definitions for, Char, Block, and Network Drivers
- initializing device, Initializing Each Device
- interrupt-driven operation, Interrupt-Driven Operation, Interrupt-Driven Operation
- loading/unloading modules for, Module Loading, Module Unloading
- methods of, The device methods, The device methods
- modularized vs. non-modularized, Modularized and Non-Modularized Drivers
- opening/closing network interface, Opening and Closing
- socket buffers, Packet Transmission, The Socket Buffers, Functions Acting on Socket Buffers
- statistics on, Statistical Information
- networking, Splitting the Kernel
- NET_BH bottom half, The Design of Bottom Halves
- net_init file, Char, Block, and Network Drivers
- new timers, The New Timer List, The New Timer List
- nice system call, sched.c
- nodes
- creating within /proc, Using the /proc Filesystem
- names, device (see devices, names of)
- read-only, Using the /proc Filesystem
- non-modularized network drivers, Modularized and Non-Modularized Drivers
- nonblocking operations, Blocking and Nonblocking Operations, Blocking and Nonblocking Operations
- select method, Select, The Underlying Data Structure
- testing, A Sample Implementation: scullpipe
- nopage method, Virtual Memory Areas
- mapping RAM to user space, Implementing the nopage method, Implementing the nopage method
- mremap method with, Supporting the mremap System Call, Supporting the mremap System Call
- remapping virtual addresses with, Remapping Virtual Addresses
- noquot file, Minor Files
- __NO_VERSION__ symbol, Version Dependency
- NR_IRQS symbol, Do-it-yourself probing
- ntohl(), Other Portability Issues
- ntohs(), Other Portability Issues
- numbering versions (see version numbering)
O
- objdump utility, Using gdb
- obtaining sample programs, License Terms
- old timers, Kernel Timers
- oops messages, Oops Messages, Using klogd
- resolving hex values of, Using ksymoops, Using ksymoops
- oops program, Using oops, Using oops
- open file, open.c
- open method, Overview of the Different Operations, The open Method, The open Method, Virtual Memory Areas
- blocking, Blocking Open as an Alternative to EBUSY, Blocking Open as an Alternative to EBUSY
- checking for disk changes, Extra Care
- cloning devices in response to, Cloning the Device on Open
- for network devices, The device methods, Opening and Closing
- partitionable devices and, The Device Methods for spull
- private_data and, The file Structure
- restricting simultaneous users and, Restricting Access to a Single User at a Time
- for single-open devices, Single-Open Devices
- opening network interface, Opening and Closing
- outb(), Using I/O Ports
- outl(), Using I/O Ports
- output buffer, driver, Blocking and Nonblocking Operations
- outsb(), String Operations
- outsl(), String Operations
- outsw(), String Operations
- outw(), Using I/O Ports
- overriding ARP, Overriding ARP
- O_NONBLOCK flag (f_flags field), The Predefined Commands, Blocking and Nonblocking Operations, Blocking and Nonblocking Operations
P
- packets
- muticasting, Multicasting, A Typical Implementation
- transmission/reception of, The Physical Transport of Packets, Packet Transmission, Packet Reception
- page size and portability, Other Portability Issues
- page tables, Page Tables, Page Tables
- page-oriented allocation functions, get_free_page and Friends, A scull Using Whole Pages: scullp
- page.h header, Other Portability Issues, Page Tables
- page_alloc file, Allocation and Deallocation
- page_io file, Paging and Swapping
- PAGE_OFFSET(), The Memory Map
- PAGE_SHIFT symbol, Other Portability Issues
- PAGE_SIZE symbol, Other Portability Issues, The mmap Device Operation
- paging, Paging and Swapping
- panic file, Other Operations
- parallel ports, Using the Parallel Port, A Sample Driver, Preparing the Parallel Port
- parameters, device, Automatic and Manual Configuration, Declaring Parameters
- partial data transfers, The read Method, The write Method
- partitionable devices, Partitionable Devices, The Device Methods for spull
- detecting partitions in kernel, Partition Detection in the Kernel, Partition Detection in the Kernel
- detecting partitions in modules, Partition Detection in Modules
- detecting partitions with initrd, Partition Detection Using Initrd
- generic hard disk support for, The Generic Hard Disk, The Generic Hard Disk
- non-partitionable devices vs., The Device Methods for spull
- pausing I/O, Pausing I/O, Pausing I/O
- PCI (Peripheral Component Interconnect)
- addressing, PCI Addressing
- configuration registers, Detecting the Device, Detecting the Device
- configuration space, PCI Addressing, Accessing the Configuration Space, Looking at a configuration snapshot
- device configuration snapshot, Looking at a configuration snapshot
- DMA and, DMA and PCI Devices
- interface of, The PCI Interface, PCI Interrupts
- interrupts, PCI Interrupts, PCI Interrupts
- memory, High PCI Memory
- pci directory, Other Subdirectories
- pci file, Boot Time
- pci.h header, Detecting the Device
- pcibios_find_class(), Detecting the Device
- pcibios_find_device(), Detecting the Device
- pcibios_present(), Detecting the Device
- pcibios_read_config_ functions, Accessing the Configuration Space
- pcibios_strerror(), Detecting the Device
- pcibios_write_config_ functions, Accessing the Configuration Space
- pcidata module, Looking at a configuration snapshot
- pcidump program, Looking at a configuration snapshot
- pciregions module, Accessing the I/O and Memory Spaces
- PCI_BASE_ADDRESS_ symbols, Accessing the I/O and Memory Spaces, Accessing the I/O and Memory Spaces
- PCI_INTERRUPT_ symbols, PCI Interrupts
- pending output, flushing, Flushing pending output
- performance
- avoiding device collisions, Ports
- clustering requests and, Clustered Requests
- debugger use, Using a Debugger
- managing system resources, Using Resources, ISA Memory
- mmap method, The mmap Device Operation
- namespace pollution, Modules Versus Applications
- output buffer and, Blocking and Nonblocking Operations
- printk to debug, Debugging by Querying
- probing for IRQ numbers, Kernel-helped probing
- reading from /proc files, Using the /proc Filesystem
- string operations and, String Operations
- peripheral bus architecture, Overview of Peripheral Buses, Quick Reference
- Peripheral Component Interconnect (see PCI)
- peripheral memory, Accessing Memory on Device Boards, High PCI Memory
- perror() vs. strace command, Debugging by Watching
- persistence of memory, The Design of scull
- persistent storage, Persistent Storage Across Unload/Load, Persistent Storage Across Unload/Load
- PGD (Page Directory), Page Tables
- pgd_offset(), Page Tables
- pgd_val(), Page Tables
- PG_reserved bit, setting to remap RAM, Playing with the reserved bit
- phys_to_virt(), Bus Addresses
- pipe.c file, Pipes and fifos
- platform dependency, Version Numbering, Architecture Dependencies
- porting and, Platform Dependencies, Platform Dependencies
- read/write methods and, Read and Write
- Plug and Play specification, The ``Plug and Play'' Specification
- PMD (Page Mid-level Directory), Page Tables
- pmd_offset(), Page Tables
- pmd_val(), Page Tables
- PnP specification, The ``Plug and Play'' Specification
- pointers
- invalid dereferencing, Oops Messages, Using klogd
- to user space, verifying, Using the ioctl Argument
- policy, driver, The Role of the Driver Writer, The Role of the Driver Writer
- controlling devices by printing and, Device Control Without ioctl
- POLL... bits, The poll Method
- poll method, The poll Method, The poll Method
- portability, Other Portability Issues, Other Portability Issues
- data types and, Judicious Use of Data Types, Interface-Specific Types
- interrupt handlers, Version Dependencies of IRQ Handling, Probing the IRQ Line
- obtaining current time and, Knowing the Current Time
- partitionable modules and, Partitionable Devices
- porting and, Platform Dependencies, Platform Dependencies
- read/write methods and, Read and Write
- ports, Ports, Ports, Using I/O Ports
- parallel, Using the Parallel Port, A Sample Driver, Preparing the Parallel Port
- platform dependency and, Platform Dependencies, Platform Dependencies
- PowerPC architecture, porting and, Platform Dependencies
- precision, temporal, Time Intervals in the Kernel, Knowing the Current Time
- predefined task queues, Predefined Task Queues, The immediate queue
- prefetchable bit, Accessing the I/O and Memory Spaces
- prefixes, Modules Versus Applications, Automatic and Manual Configuration
- preprocessor, using to monitor driver, Using the Preprocessor to Ease Monitoring, Using the Preprocessor to Ease Monitoring
- printing
- controlling devices by, Device Control Without ioctl
- to debug code, Debugging by Printing, Using the Preprocessor to Ease Monitoring
- from gdb debugger, Using gdb
- interface-specific data, Interface-Specific Types
- printk(), Building and Running Modules
- circular buffer for, How Messages Get Logged
- debugging with, Printk, Printk, Debugging by Querying
- logging messages from, How Messages Get Logged, How Messages Get Logged
- 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 Priority Argument
- message (see loglevels)
- private_data field (file structure), The file Structure, Writing Reentrant Code
- probe_irq_off(), Kernel-helped probing
- probe_irq_on(), Kernel-helped probing
- probing, Ports, ISA Memory
- for IRQ numbers, Autodetecting the IRQ Number, Do-it-yourself probing
- for ISA devices, Initializing Each Device
- for ISA memory, ISA Memory
- for network devices, Initializing Each Device
- persistent storage to avoid, Persistent Storage Across Unload/Load
- probing devices
- for IRQ numbers
- shared interrupts and, Installing a Shared Handler
- version dependency, Probing the IRQ Line
- /proc files, Initialization and Shutdown
- /proc/interrupts, The /proc Interface
- shared interrupts and, The /proc Interface
- /proc/stat, The /proc Interface
- /proc filesystem, Using the /proc Filesystem, Using the /proc Filesystem
- /proc/modules (see modules file)
- /proc/pci file, Boot Time
- processes
- access to multiple, Restricting Access to a Single User at a Time, Restricting Access to a Single User at a Time
- kernel timers for, Kernel Timers, The New Timer List
- managing, Splitting the Kernel, Process Control
- opening devices for each process, Single-Open Devices, Single-Open Devices
- putting to sleep and awakening, Going to Sleep and Awakening, Going to Sleep and Awakening
- race conditions and, Going to Sleep Without Races, Going to Sleep Without Races
- requeuing, The timer queue
- sleeping during wait queues, Long Delays, Going to Sleep Without Races
- task queues for, Task Queues, Running Your Own Task Queues
- proc_register_dynamic(), Other Changes
- program, obtaining, License Terms
- programming drivers (see writing drivers)
- protect method, Virtual Memory Areas
- PrScr key, System Hangs
- pte_offset(), Page Tables
- pte_page(), Page Tables
- pte_present(), Page Tables
- pte_val(), Page Tables
- PTRS_PER_ symbols, Page Tables
- putting processes to sleep, Going to Sleep and Awakening, Going to Sleep and Awakening
- put_user(), Quick Reference, Accessing User Space
- put_user(), Using the ioctl Argument
- __put_user(), Accessing User Space
- put_user_byte(), Quick Reference
- put_user_ret(), Accessing User Space
Q
- querying to debug, Debugging by Querying, The ioctl Method
- queues
- scheduler queue, Predefined Task Queues, The scheduler queue, The scheduler queue
- queue_task(), The Nature of Task Queues, Running Your Own Task Queues
- queue_task_irq(), The Nature of Task Queues, Task Queues
- queue_task_irq_off(), The Nature of Task Queues, Task Queues
R
- race conditions, Race Conditions, Going to Sleep Without Races
- RAM
- probing ISA memory for, ISA Memory
- remapping, Remapping RAM, Implementing the nopage method
- random numbers, Installing an Interrupt Handler
- read method, Overview of the Different Operations, Read and Write
- Linux 2.1 and, Prototype Differences
- Linux 2.1 implementation, Using the New Interface
- select system call with, Reading data from the device
- read-only /proc nodes, Using the /proc Filesystem
- read/write position, Overview of the Different Operations, The file Structure
- readb(), ISA Memory Below 1M
- readdir file, read_write.c and readdir.c
- readdir method, Overview of the Different Operations
- reading
- blocking I/O, Blocking I/O
- blocking/nonblocking operations, Blocking and Nonblocking Operations, Blocking and Nonblocking Operations
- select method, Select, The Underlying Data Structure
- testing, A Sample Implementation: scullpipe
- from a device, Read and Write
- from /proc files, Using the /proc Filesystem
- verifying memory address for, Using the ioctl Argument
- readl(), ISA Memory Below 1M
- readw(), ISA Memory Below 1M
- read_ahead array, Registering the Driver
- read_write file, read_write.c and readdir.c
- REALLY_SHOW_IO symbol, Pausing I/O
- rebuild_header method, The device methods, Overriding ARP, Other Changes
- reception of packets, The Physical Transport of Packets, Packet Reception, Packet Reception, Multicasting, A Typical Implementation
- reductions in memory map region, Supporting the mremap System Call, Supporting the mremap System Call
- reentrancy, System Hangs, Writing Reentrant Code, Writing Reentrant Code
- registering
- block drivers, Registering the Driver, Registering the Driver
- DMA usage, Registering DMA usage
- facilities in init_module(), Initialization and Shutdown, Initialization and Shutdown
- function definitions for, devices.c and block_dev.c
- network drivers, Module Loading
- ports, Ports
- symbol tables, Registering Symbol Tables, Registering Symbol Tables
- registers, PCI configuration, Detecting the Device, Detecting the Device
- register_blkdev(), Registering the Driver
- register_chrdev(), Major and Minor Numbers, Dynamic Allocation of Major Numbers
- register_symtab(), Registering Symbol Tables, Registering Symbol Tables
- register_symtab_from(), Quick Reference
- release method, Overview of the Different Operations, The release Method, The release Method
- (see also close method)
- block devices and, How Mounting Works
- blocking open and, Blocking Open as an Alternative to EBUSY
- Linux 2.1 and, Prototype Differences
- release_module(), The Kernel-Level Side
- release_region(), Ports
- release_return(), Prototype Differences
- release_t(), Prototype Differences
- remapping
- I/O regions, Remapping Specific I/O Regions, Remapping Specific I/O Regions
- PCI regions, Accessing the I/O and Memory Spaces
- RAM, Remapping RAM, Implementing the nopage method
- virtual addresses, Remapping Virtual Addresses, Remapping Virtual Addresses
- remap_page_range(), A Simple Implementation, Playing with the reserved bit
- remote debugging, Remote Debugging, Remote Debugging
- removable block devices, Removable Devices, Extra Care
- remove_wait_queue(), Going to Sleep Without Races
- _remove_wait_queue(), Going to Sleep Without Races
- request_fn(), Clustered Requests
- request_struct structure, Performing the Actual Data Transfer
- clustered requests and, Clustered Requests
- requesting interrupts (see interrupt handlers)
- requests, block driver, Handling Requests, Clustered Requests
- blocking, Blocking Open as an Alternative to EBUSY, Blocking Open as an Alternative to EBUSY
- clustered, Clustered Requests, 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
- request_irq(), Installing an Interrupt Handler
- for shared interrupts, Installing a Shared Handler
- version dependency of, Different Prototypes for request_irq
- when to call, Installing an Interrupt Handler
- request_module(), The Kernel-Level Side
- request_region(), Ports
- requeuing/rescheduling tasks, The timer queue
- reserved bit, setting to remap RAM, Playing with the reserved bit
- reserved pages, remapping, Remapping RAM, Implementing the nopage method
- resetup_one_dev(), Partitionable Devices, Partition Detection in Modules
- resolution, time, Time Intervals in the Kernel, Knowing the Current Time
- resolving Ethernet addresses, Address Resolution, Non-Ethernet Headers
- resource file, Other Operations
- resources for further reading, Sources for Further Information
- resources, managing, Using Resources, ISA Memory
- restore_flags(:), ISA Memory
- restricting access (see access)
- return_from_sys_call(), The Design of Bottom Halves
- ret_from_sys_call, The Design of Bottom Halves
- ret_from_sys_call(), The internals of interrupt handling on the x86
- revalidate method, Overview of the Different Operations, revalidate
- RightAlt-PrScr key, System Hangs
- rmmod command, Splitting the Kernel, Unloading
- ROM, probing ISA memory for, ISA Memory
- run-time errors, strace for, Debugging by Watching
- run-time network interface configuration, Run-Time Configuration
- run_task_queue(), The Nature of Task Queues, Running Your Own Task Queues
S
- safe time, The Nature of Task Queues
- SAK (Secure Attention Key), System Hangs
- save_flags(), ISA Memory
- saving across loading/unloading, Persistent Storage Across Unload/Load, Persistent Storage Across Unload/Load
- SA_INTERRUPT symbol, Installing an Interrupt Handler
- SA_SAMPLE_RANDOM symbol, Installing an Interrupt Handler
- SA_SHIRQ symbol, Installing an Interrupt Handler, Installing a Shared Handler
- sbull driver (example), Loading Block Drivers, Interrupt-Driven Block Drivers
- Sbus peripherals, Sbus
- sched file, sched.c
- sched.h header, Quick Reference
- schedule(), Quick Reference, sched.c
- called during interrupt time, The Nature of Task Queues
- preventing endless loops with, System Hangs
- scheduler queue (tq_scheduler), Predefined Task Queues, The scheduler queue, The scheduler queue
- scheduling functions, Concurrency in the Kernel
- scsi directory, Modules Versus Applications, SCSI Drivers
- SCSI drivers, Classes of Devices and Modules, SCSI Drivers
- scull driver (example), Char Drivers, Playing with the New Devices, Using the Preprocessor to Ease Monitoring, Using oops, Choosing the ioctl Commands, Using the ioctl Argument, Using the ioctl Argument
- scullp driver (example), A scull Using Whole Pages: scullp, A scull Using Virtual Addresses: scullv, Implementing the nopage method, Remapping Virtual Addresses
- scullpipe devices (examples), A Sample Implementation: scullpipe
- scullv driver (example), A scull Using Virtual Addresses: scullv, A scull Using Virtual Addresses: scullv, Remapping Virtual Addresses, Remapping Virtual Addresses
- Secure Attention Key (SAK), System Hangs
- securelevel variable, Security Issues
- security, Security Issues, Security Issues
- seeking a device, Seeking a Device, The lseek Implementation
- segment.h header, Quick Reference
- segmentation faults, handling, Handling Kernel-Space Faults, Handling Kernel-Space Faults
- select file, select.c
- select method, Overview of the Different Operations, Select, The Underlying Data Structure
- poll method vs., The poll Method, The poll Method
- select_table structure, Select, The Underlying Data Structure
- select_table_entry structure, The Underlying Data Structure
- select_wait(), The Underlying Data Structure, Quick Reference
- SEL_ symbols, Select, Quick Reference
- serial ports, Initialization and Shutdown
- setconsole program (example), Printk
- setterm program, Device Control Without ioctl
- set_bit(), Bit operations, Bit Operations
- set_config method, The device methods
- configuring network interface, Run-Time Configuration
- set_dma_addr(), Talking to the DMA controller
- set_dma_count(), Talking to the DMA controller
- set_dma_mode(), Talking to the DMA controller
- set_mac_address method, The device methods
- set_multicast_list method, The device methods, Kernel Support for Multicasting, A Typical Implementation
- set_persist(), Persistent Storage Across Unload/Load
- sharing interrupts, Interrupt Sharing, The /proc Interface
- Shift-PrScr key, System Hangs
- short delays, Short Delays, Short Delays
- short driver (example), A Sample Driver, A Sample Driver, Preparing the Parallel Port, Using Circular Buffers
- shutting down modules (see unloading modules)
- SIGIO signal, Asynchronous Notification
- signal handling, A Sample Implementation: scullpipe
- silo program, Setting Up Sparc Processors
- single-open devices, Single-Open Devices, Single-Open Devices
- SIOCDEVPRIVATE commands, Custom ioctl Commands
- size of block devices, Registering the Driver
- sizing data explicitly, Assigning an Explicit Size to Data Items, Assigning an Explicit Size to Data Items
- skbuff.h header, The Socket Buffers
- skb_headroom(), Functions Acting on Socket Buffers
- skb_pull(), Functions Acting on Socket Buffers
- skb_push(), Functions Acting on Socket Buffers
- skb_put(), Functions Acting on Socket Buffers
- skb_reserve(), Functions Acting on Socket Buffers
- skb_tailroom(), Functions Acting on Socket Buffers
- skull driver (example), Compiling and Loading, Automatic and Manual Configuration
- sk_buff structure, Packet Transmission, The Socket Buffers, Functions Acting on Socket Buffers
- sleeping processes, Going to Sleep and Awakening, Going to Sleep and Awakening, Going to Sleep Without Races, Going to Sleep Without Races
- sleep_on(), Going to Sleep and Awakening, Long Delays, Going to Sleep Without Races
- slow interrupt handlers, Fast and Slow Handlers, The internals of interrupt handling on the x86, Installing a Shared Handler
- SLOW_DOWN_IO(), Pausing I/O
- SLOW_IO_BY_JUMPING symbol, Pausing I/O
- SMP machines, kernel headers and, Compiling and Loading
- __SMP__ symbol, Compiling and Loading
- 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
- functions on, Functions Acting on Socket Buffers
- socket structure, Networking
- softirq file, Other Operations
- software versions (see version numbering)
- sound directory, Other Subdirectories
- Space file, Char, Block, and Network Drivers
- Sparc architecture, porting and, Platform Dependencies
- Sparc computers, setting up, Setting Up Sparc Processors
- spull driver (example), Partitionable Devices, Interrupt-Driven Block Drivers
- stacking modules, The Kernel Symbol Table
- standard C data types, Use of Standard C Types, Use of Standard C Types
- start_kernel(), Booting the Kernel, Booting the Kernel
- stat file, The /proc Interface, Minor Files
- state field (current), Going to Sleep Without Races
- static symbols, Modules Versus Applications
- statistics
- on interrupts, The /proc Interface
- on network interfaces, The device methods, Statistical Information
- sti(), ISA Memory, Fast and Slow Handlers
- stop method, The device methods, Opening and Closing
- strace command, Debugging by Watching
- string file, IPC and lib Functions
- string operations, String Operations
- super file, The VFS: Superblocks
- superblocks, The VFS: Superblocks
- supervisor mode, User Space and Kernel Space
- swap file, Paging and Swapping
- swapfile file, Paging and Swapping
- swapon/swapoff system calls, Paging and Swapping
- swapping, Paging and Swapping
- swap_state file, Paging and Swapping
- switch statement, with ioctl, ioctl, The Return Value
- symbols, Registering Symbol Tables
- (see also functions; variables)
- adding to modifying system map, Using ksymoops
- declaring as static, Modules Versus Applications
- exporting, Exporting Versioned Symbols, Exporting Symbols, Exporting Symbols
- global, The Kernel Symbol Table
- registering symbol table, Registering Symbol Tables, Registering Symbol Tables
- symbol table, Modules Versus Applications, The Kernel Symbol Table, Registering Symbol Tables
- symtab_begin.h header, Registering Symbol Tables, Quick Reference
- symtab_end.h header, Quick Reference
- sync method, Virtual Memory Areas
- synchronous writes, The Predefined Commands
- sys file, Other Operations
- system faults
- changing message loglevels after, Printk
- debugging, Debugging System Faults, System Hangs
- handling, kernels versus applications, Modules Versus Applications
- kernel-space, Handling Kernel-Space Faults, Handling Kernel-Space Faults
- system hangs, System Hangs, System Hangs
- system map, modifying, Using ksymoops
- system resources, managing, Using Resources, ISA Memory
- system.h header, Quick Reference
- sys_syslog(), Printk
T
- _t data types, Interface-Specific Types, Interface-Specific Types
- tail pointer, Using Circular Buffers
- task queues, Task Queues, Running Your Own Task Queues
- declaring custom, Running Your Own Task Queues
- Linux 2.1 and, Task Queues
- predefined, Predefined Task Queues, The immediate queue
- TASK_ symbols, Going to Sleep Without Races
- task_queue pointer, The Nature of Task Queues
- tcpdump program, The Physical Transport of Packets
- terminals, selecting for messages, Printk
- test_..._bit functions, Bit Operations
- test_bit(), Bit operations, Bit Operations
- testing (non)blocking operations, A Sample Implementation: scullpipe
- text-mode VGA boards, Hardware Management, Accessing the Text-Mode Video Buffer
- time, Flow of Time, Quick Reference
- current time, Knowing the Current Time
- delaying execution, Delaying Execution, Short Delays
- HZ (time frequency), Time Intervals in the Kernel, Other Portability Issues
- interrupt time, The Nature of Task Queues
- kernel timers, Kernel Timers, The New Timer List
- safe time, The Nature of Task Queues
- sleeping processes, Going to Sleep and Awakening, Going to Sleep and Awakening, Going to Sleep Without Races, Going to Sleep Without Races
- time intervals, Time Intervals in the Kernel, Time Intervals in the Kernel, Other Portability Issues
- time file, Other Operations
- timeout field (current), Long Delays
- timeouts, Long Delays, The Header File blk.h
- TIMEOUT_VALUE symbol, The Header File blk.h
- timer interrupt, Time Intervals in the Kernel
- timer queue (tq_timer), Predefined Task Queues, The timer queue, The Design of Bottom Halves
- timer queue element structure, The Nature of Task Queues
- timer.h header, The New Timer List
- timers (see kernel timers)
- TIMER_BH bottom half, The Design of Bottom Halves
- timer_list structure, The New Timer List
- TIOCLINUX command, Printk
- to_kdev_t(), dev_t and kdev_t
- tqueue.h header, Predefined Task Queues
- TQUEUE_BH bottom half, The Design of Bottom Halves
- tq_disk queue, Predefined Task Queues
- tq_immediate queue, Predefined Task Queues, The immediate queue
- tq_scheduler queue, Predefined Task Queues, The scheduler queue, The scheduler queue
- tq_struct structure, The Nature of Task Queues
- tq_timer(), Predefined Task Queues, The timer queue, The Design of Bottom Halves
- tracing programs, Debugging by Watching
- transmission of packets, The Physical Transport of Packets, Packet Transmission, Packet Transmission, Multicasting, A Typical Implementation
- troubleshooting, Debugging Techniques
- (see also debugging)
- handling kernel-space faults, Handling Kernel-Space Faults, Handling Kernel-Space Faults
- misaligned data, Using the /proc Filesystem
- porting problems, Platform Dependencies, Platform Dependencies
- race conditions, Race Conditions, Going to Sleep Without Races
- system hangs, System Hangs, System Hangs
- wrong font on console, Device Control Without ioctl
- truncating devices on open, The open Method
- tr_setp(), Interface information
- tty
- cua versus, The open Method
- drivers for, Initialization and Shutdown
- line disciplines, Initialization and Shutdown
- switching, The Design of Bottom Halves
- types.h header, Interface-Specific Types
U
- u8, u16, u32, u64 data types, Assigning an Explicit Size to Data Items, Conversion Functions
- uaccess.h header, Accessing User Space
- udelay(), Short Delays
- unaligned data, Other Portability Issues
- uniqueness of ioctl command numbers, Choosing the ioctl Commands
- unloading modules, Modules Versus Applications, Unloading, Removing a Driver from the System, Removing a Driver from the System
- (see also cleanup_module())
- on demand, Loading Modules on Demand
- for network drivers, Module Unloading
- usage count and, The Usage Count, The Usage Count
- unmap method, Virtual Memory Areas
- unregistering
- block drivers, Registering the Driver, Registering the Driver
- facilities, Error Handling in init_module
- /proc nodes, Using the /proc Filesystem
- unregister_blkdev(), Registering the Driver
- unregister_chrdev(), Removing a Driver from the System
- urandom device, Installing an Interrupt Handler
- usage count, The Usage Count, The Usage Count
- mmap method and, Maintaining the Usage Count, Maintaining the Usage Count
- open method and, The open Method
- partitionable devices and, The Device Methods for spull
- release method and, The release Method
- resetting to zero, Choosing the ioctl Commands
- user mode, User Space and Kernel Space
- user space, User Space and Kernel Space
- accessing in Linux 2.1, Accessing User Space, Using the New Interface
- explicitly sizing data in, Assigning an Explicit Size to Data Items
- HZ (time frequency) and, Time Intervals in the Kernel
- kerneld program and, The User-Level Side, The User-Level Side
- mapping RAM to, Remapping RAM, Implementing the nopage method
- retrieving datum from, Using the ioctl Argument
- transfering to/from kernel space, Read and Write
- verifying addresses, Using the ioctl Argument
- watching programs run in, Debugging by Watching, Debugging by Watching
- writing drivers in, Doing It in User Space, Doing It in User Space
- users, restricting access to simultaneous, Restricting Access to a Single User at a Time, Restricting Access to a Single User at a Time
- /usr/include/asm directory (see entries under <asm/>)
- /usr/include/linux directory (see entries under <linux/>)
- /usr/include/net directory, Modules Versus Applications
- /usr/include/scsi directory, Modules Versus Applications
- util file, IPC and lib Functions
V
- validating
- block driver requests, Handling Requests
- disk changes, revalidate
- variables, Registering Symbol Tables
- (see also symbols)
- vendor PCI register, Detecting the Device
- VERIFY_ symbols, Using the ioctl Argument, Quick Reference
- verifying user-space addresses, Using the ioctl Argument
- verify_area(), Using the ioctl Argument, Quick Reference, Accessing User Space, Handling Kernel-Space Faults
- version dependency, Version Dependency, Architecture Dependencies
- interrupt handlers, Version Dependencies of IRQ Handling, Probing the IRQ Line
- module version support, Version Control in Modules
- version numbering, 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, dev_t and kdev_t
- version.h header, Version Dependency, Quick Reference
- VESA Local Bus devices, VLB
- vfree(), vmalloc and Friends, vmalloc and Friends
- VFS (Virtual File System), The VFS: Superblocks
- VGA boards, Hardware Management, Accessing the Text-Mode Video Buffer
- virtual addresses
- Sbus peripherals and, Sbus
- virtual addresses, remapping, Remapping Virtual Addresses, Remapping Virtual Addresses
- virtual memory
- Linux 2.1 and, Virtual Memory
- virtual memory areas (VMAs), Virtual Memory Areas, Virtual Memory Areas
- virt_to_bus(), Bus Addresses
- virt_to_phys(), Bus Addresses
- VLB (VESA Local Bus) devices, VLB
- vmalloc file, Allocation and Deallocation
- vmalloc(), vmalloc and Friends, A scull Using Virtual Addresses: scullv, Remapping Virtual Addresses
- vmalloc.h header, vmalloc and Friends
- VMALLOC_VMADDR(), Remapping Virtual Addresses
- VMAs (virtual memory areas), Virtual Memory Areas, Virtual Memory Areas
- vmlinux and vmlinuz files, Using gdb, Using gdb
- vmscan file, Paging and Swapping
- vm_area_struct structure, Virtual Memory Areas
- vm_operations_struct structure, Virtual Memory Areas
- void(), The Generic Hard Disk
- vremap(), vmalloc and Friends, vmalloc and Friends, vremap
W
- wait queues, Going to Sleep and Awakening, Wait Queues, Wait Queues
- performing jobs from within, Going to Sleep Without Races
- processes sleeping during, Long Delays
- wake_up(), Going to Sleep and Awakening, Going to Sleep Without Races
- wake_up_interruptible(), Going to Sleep and Awakening, Going to Sleep Without Races
- waking up processes, Going to Sleep and Awakening
- -Wall flag (gcc), Compiling and Loading
- watching programs in user space, Debugging by Watching, Debugging by Watching
- wppage method, Virtual Memory Areas
- write method, Overview of the Different Operations, Read and Write, Read and Write
- Linux 2.1 and, Prototype Differences
- select system call with, Writing to the device
- writeb(), ISA Memory Below 1M
- writel(), ISA Memory Below 1M
- writew(), ISA Memory Below 1M
- writing, Debugging Techniques
- (see also debugging)
- blocking I/O, Blocking I/O, Blocking and Nonblocking Operations
- control sequences to devices, Device Control Without ioctl, Device Control Without ioctl
- to a device, Read and Write, Read and Write, The write Method
- drivers
- reentrant code, Writing Reentrant Code, Writing Reentrant Code
- in user space, Doing It in User Space, Doing It in User Space
- version numbering, Version Numbering, Version Numbering
- watching user-space programs run, Debugging by Watching, Debugging by Watching
- writer’s role in, The Role of the Driver Writer, The Role of the Driver Writer
- implement handlers, Implementing a Handler, Enabling and Disabling Interrupts
- interrupt handler bottom halves, Writing a Bottom Half
- Makefile, Compiling and Loading, Compiling and Loading
- to /proc file, Using the /proc Filesystem
- synchronously, The Predefined Commands
- verifying memory address for, Using the ioctl Argument
X
- x86 architecture
- interrupt handling on, The internals of interrupt handling on the x86, The internals of interrupt handling on the x86
- porting and, Platform Dependencies
- X86 architecture
- setting up, Setting Up the X86 Processors, Other booters
- xtime variable, Knowing the Current Time
Z
- zImage kernel, booting, Booting a bare-bones zImage kernel
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.