Index

Symbols

. (period) and ..(double period) notation, Files
80 x 86 processors, Organization of the Material
clocks, Hardware Clocks
exceptions, Exceptions
I/O architecture, I/O Architecture, Putting DMA to work
memory, Non-Uniform Memory Access (NUMA)
Task State Segment, Task State Segment
802.3 standard, The neighbor cache

A

aborts, Interrupts and Exceptions
absolute pathnames, Files
Accelerated Graphics Port (AGP), Mapping addresses of I/O shared memory
access rights, Access Rights and File Mode
ACLs (access control lists), General Characteristics of Ext2
active lists, The Least Recently Used (LRU) Lists
active swap areas, Swap Area
active transactions, Transactions
address buses, I/O Architecture
address resolution, Libraries
Address Resolution Protocol (ARP), The neighbor cache
address spaces, Processes, The Process’s Address Space
creating, Creating and Deleting a Process Address Space
deleting, Deleting a Process Address Space
addresses, Memory Addresses
address_space objects, The address_space Object, The address_space Object
page descriptors, The lists of page descriptors in the address_space object
adjacent bytes, Block Device Drivers
Advanced Power Management (APM), Segmentation in Linux
Advanced Programmable Interrupt Controllers (see APICs)
advisory file locks, File Locking
AGP (Accelerated Graphics Port), Mapping addresses of I/O shared memory
alignment factors, Aligning Objects in Memory
anonymous mapping, Demand Paging
APICs (Advanced Programmable Interrupt Controllers), The Advanced Programmable Interrupt Controller (APIC)
CPU local timer, CPU Local Timers
local, interrupt handlers for, The local timer interrupt handler
timers, synchronization, Initialization of the timekeeping architecture
APM (Advanced Power Management), Segmentation in Linux
arch directory, Hardware Dependency
ARP (Address Resolution Protocol), The neighbor cache
arp cache, The neighbor cache
Assembler OUTput executable format (a.out), Executable Formats
asynchronous buffer heads, Buffer Head Data Structures
asynchronous interrupts, Interrupts and Exceptions
asynchronous notifications, Signals and Interprocess Communication
asynchronous read-ahead operations, Read-Ahead of Files, The accessed page is unlocked (asynchronous read-ahead)
atomic operation handles, Atomic operation handles
atomic operations, Synchronization and Critical Regions, Atomic Operations, Atomic Operations
AVL tree, Memory Region Data Structures

B

base priority, The Scheduling Algorithm
base time quanta, The Scheduling Algorithm
batch processes, Scheduling Policy
bdflush kernel thread, The bdflush kernel thread, The bdflush kernel thread
big kernel locks (BKLs), The Global Kernel Lock
big reader read/write spin locks, The Big Reader Lock
BIOS, Prehistoric Age: The BIOS
bootstrap process, Prehistoric Age: The BIOS
Real Mode addressing, usage of, Prehistoric Age: The BIOS
bitmap, Data structures
bitmap caches, Bitmap Caches
block clustering, Extending the request queue
block device descriptors, Keeping Track of Block Device Drivers
block device drivers, Block Device Drivers, Page I/O operations, Character Device Drivers
(see also I/O devices)
architecture, An Overview of Block Device Driver Architecture, Block device low-level driver descriptor
low-level driver descriptors, Block device low-level driver descriptor
request descriptors, Request descriptors
request queue descriptors, Request queue descriptors
block I/O operations, Block I/O operations
blocks, Sectors, Blocks, and Buffers
buffers, Sectors, Blocks, and Buffers
buffer heads, Buffer Heads, Buffer Heads
data structures for, Keeping Track of Block Device Drivers
default file operation methods, Initializing a Block Device Driver
initializing, Initializing a Block Device Driver
kernel, monitoring by, Keeping Track of Block Device Drivers
low-level request handling, Low-Level Request Handling, Low-Level Request Handling
page I/O operations, Page I/O operations, Page I/O operations
requesting function, The ll_rw_block( ) Function, Extending the request queue
sectors, Sectors, Blocks, and Buffers
block device files, Device Files
prepare_write and commit_write methods, The prepare_write and commit_write methods for block device files
block device inode, Keeping Track of Block Device Drivers
block device request, An Overview of Block Device Driver Architecture
block fragmentation, General Characteristics of Ext2
block group, Ext2 Disk Data Structures
block I/O operation, Block and Page I/O Operations
blocked signals, The Role of Signals
modifying, Modifying the Set of Blocked Signals
blocks, Sectors, Blocks, and Buffers
filetypes, usage by, How Various File Types Use Disk Blocks, Device file, pipe, and socket
preallocation, General Characteristics of Ext2
bootstrap, System Startup
bottom halves, The Role of Interrupt Signals, Softirqs, Tasklets, and Bottom Halves, Bottom Halves, Extending a bottom half
imminent obsolescence of, Softirqs, Tasklets, and Bottom Halves
TIMER_BH bottom half, The TIMER_BH bottom half
BSD sockets, BSD Sockets
methods, BSD Sockets
bss segments, Program Segments and Process Memory Regions
buddy system algorithm, The Buddy System Algorithm, Freeing a block
blocks, allocation of, Allocating a block
freeing of, Freeing a block
data structures, Data structures
example, The Buddy System Algorithm
slab allocator and, Interfacing the Slab Allocator with the Buddy System
buffer caches, Disk Caches, The Buffer Cache, The sync( ), fsync( ), and fdatasync( ) system calls
bdflush kernel thread, The bdflush kernel thread, The bdflush kernel thread
buffer head data structures, Buffer Head Data Structures, Buffer usage counter
buffer pages, Buffer Pages, Allocating buffer pages
dirty buffers, flushing to disk, The sync( ), fsync( ), and fdatasync( ) system calls
dirty buffers, writing to disk, Writing Dirty Buffers to Disk
get_blk function, The getblk( ) Function
I/O operations, usage by, Disk Caches
kupdate kernel thread, The kupdate kernel thread, The kupdate kernel thread
buffer heads, Buffer Heads
for cached buffers, Buffer Head Data Structures
unused buffer heads, Buffer Head Data Structures
buffer pages, Buffer Pages, Allocating buffer pages
buffers, Sectors, Blocks, and Buffers
bus addresses, Direct Memory Access (DMA)
bus mouse interface, Custom I/O interfaces
buses, I/O Architecture
Busy bit, Task State Segment

C

cache controllers, Hardware Cache
write-through and write-back, Hardware Cache
cache descriptors, Cache Descriptor
cache entry tags, Hardware Cache
cache hits, Hardware Cache
cache lines, Hardware Cache
cache misses, Hardware Cache
cache snooping, Hardware Cache
caches, Hardware Cache, Hardware Cache, The Slab Allocator
allocating slabs to, Allocating a Slab to a Cache
slabs, releasing from, Releasing a Slab from a Cache
types of, General and Specific Caches
character device drivers, Character Device Drivers, Character Device Drivers
character device files, Device Files
child filesystems, Filesystem Mounting
clocks, Hardware Clocks, The local timer interrupt handler
Code Segment Descriptors, Segment Descriptors
code segment registers, Segmentation Registers
Columbus Unix, System V IPC
command-line arguments, Program Execution, Command-Line Arguments and Shell Environment
commit_write method, The prepare_write and commit_write methods for regular files, The prepare_write and commit_write methods for block device files
common file model, The Common File Model, The Common File Model
object types, The Common File Model
completions, Completions
concurrency level, Synchronizing Accesses to Kernel Data Structures
context switch, Process Switch
control buses, I/O Architecture
control registers, Paging in Hardware, I/O Ports
Copy On Write (see COW)
core dump, Signals and Interprocess Communication
COW (Copy On Write), Copy On Write, Copy On Write
CPL (Current Privilege Level), Segmentation Registers, Hardware Handling of Interrupts and Exceptions
segment updating and, Segmentation in Linux
CPU local timer, CPU Local Timers
CPU resource limit, Checking the Current Process CPU Resource Limit
CPU-bound processes, Scheduling Policy
cr0 control register, Paging in Hardware
cr3 control register, Regular Paging
critical regions, Synchronization and Critical Regions, Synchronization Primitives
current macro, The current macro
Current Privilege Level (see CPL)
current working directory, Files
custom I/O interfaces, I/O Interfaces, Custom I/O interfaces

D

data buses, I/O Architecture
Data Segment Descriptors, Segment Descriptors
data segment registers, Segmentation Registers
dates, updating by the kernel, Updating the Time and Date
deadlocked state, Avoiding deadlocks
default routers, Routing Data Structures
defective page slots, Swap Area Descriptor
deferrable functions, Softirqs, Tasklets, and Bottom Halves
activation of, Softirqs, Tasklets, and Bottom Halves
disabling, Disabling Deferrable Functions
execution of, Softirqs, Tasklets, and Bottom Halves
initialization of, Softirqs, Tasklets, and Bottom Halves
operations performed on, Softirqs, Tasklets, and Bottom Halves
demand paging, Process virtual address space handling, Demand Paging, Demand Paging
limitations, Reclaiming Page Frame
for memory mapping, Demand Paging for Memory Mapping, Demand Paging for Memory Mapping
dentry
caches, The Common File Model
objects, The Common File Model, dentry Objects, The dentry Cache
operations, The dentry Cache
dependencies, Module Dependency
Descriptor Privilege Level (DPL), Segment Descriptors, Hardware Handling of Interrupts and Exceptions
destination caches, The Destination Cache
devfs device files, Device Files, Devfs Device Files
device controllers, Device Controllers, Accessing the I/O shared memory
device drivers, Device Drivers, Device Drivers, Interrupt mode, Character Device Drivers
(see also I/O devices)
buffering strategies, Buffering Strategies of Device Drivers
IRQ-configuration, Interrupt vectors
registering, Registering a Device Driver
resource functions, Accessing I/O ports
device files, Device Files, VFS Handling of Device Files
examples, Old-Style Device Files
Virtual Filesystem, handling by, VFS Handling of Device Files
device plugging, Scheduling the activation of the strategy routine
device unplugging, Scheduling the activation of the strategy routine
direct access buffers, Direct I/O Transfers
direct I/O transfers, Direct I/O Transfers, Direct I/O Transfers
direct access buffers, Direct I/O Transfers
direct mapped caches, Hardware Cache
Direct Memory Access Controller (see DMAC)
directories, Directory
dirty buffers, writing to disk, Writing Dirty Buffers to Disk
disk caches, The Common File Model, Disk Caches, The sync( ), fsync( ), and fdatasync( ) system calls
buffer caches (see buffer caches)
page caches (see page caches)
disk controllers, Device Controllers
disk interface, Custom I/O interfaces
disk-based filesystems, The Role of the Virtual Filesystem (VFS)
write methods of, Writing to a File, Writing to a File
displacement of a logical address, Memory Addresses
DMAC (Direct Memory Access Controller), Direct Memory Access (DMA), Putting DMA to work
doubly linked lists, Doubly linked lists
runqueues, The list of TASK_RUNNING processes
wait queues, Wait queues
DPL (Descriptor Privilege Level), Segment Descriptors, Hardware Handling of Interrupts and Exceptions
dynamic address checking, exception tables, The exception tables, Generating the exception tables and the fixup code
generating, Generating the exception tables and the fixup code
dynamic caching mode, Ext2 Memory Data Structures
dynamic distribution of IRQs, The Advanced Programmable Interrupt Controller (APIC)
dynamic memory, Memory Management
dynamic priority, The Scheduling Algorithm
dynamic timers, Dynamic Timers, An Application of Dynamic Timers
example, An Application of Dynamic Timers
handling, Dynamic timers handling
race conditions and, Dynamic timers and race conditions

E

e2fsck external program, General Characteristics of Ext2
elevator algorithm, Extending the request queue
ELF (Executable and Linking Format), Executable Formats
emulation, Execution Domains
environment variables, Program Execution, Command-Line Arguments and Shell Environment
epochs, The Scheduling Algorithm
errno variable, POSIX APIs and System Calls
ESCAPE instructions, Saving the FPU, MMX, and XMM Registers
esp registers, Processor descriptors handling
Ethernet, The neighbor cache
exception handling, Exception Handling, Interrupt Handling
exception handlers, Saving the Registers for the Exception Handler
down( ) and, Getting and releasing semaphores
entering and leaving, Entering and Leaving the Exception Handler
nested execution of, Nested Execution of Exception and Interrupt Handlers
exception tables, The exception tables, Generating the exception tables and the fixup code
generating, Generating the exception tables and the fixup code
exceptions, The Process/Kernel Model, Interrupts and Exceptions, Exceptions, Exceptions
hardware handling of, Hardware Handling of Interrupts and Exceptions
process switching, contrasted with, The Role of Interrupt Signals
termination phase, Returning from Interrupts and Exceptions, The ret_ from_ fork( ) Function
types of, Interrupts and Exceptions
exclusive processes, Wait queues
Executable and Linking Format (ELF), Executable Formats
executable files, Program Execution, Executable Files, Execution Tracing
Execute access rights, Access Rights and File Mode
execution context, Executable Files
execution domain descriptors, Execution Domains
exit() library function, Destroying Processes
Ext FS (Extended Filesystem), General Characteristics of Ext2
Ext2 (Second Extended Filesystem), General Characteristics of Ext2, Releasing a Data Block
bitmap, Group Descriptor and Bitmap
bitmap caches, Bitmap Caches
block groups, Ext2 Disk Data Structures
blocks, usage by file types, How Various File Types Use Disk Blocks, Device file, pipe, and socket
creating, Creating the Ext2 Filesystem, Creating the Ext2 Filesystem
data blocks, Data Blocks Addressing, Releasing a Data Block
addressing, Data Blocks Addressing, Data Blocks Addressing
allocating, Allocating a Data Block
file holes, File Holes
releasing, Releasing a Data Block
device files, pipes, and sockets, Device file, pipe, and socket
directories, Directory
disk data structures, Ext2 Disk Data Structures, Device file, pipe, and socket
disk space management, Managing Ext2 Disk Space, Releasing a Data Block
features, General Characteristics of Ext2
group descriptors, Ext2 Disk Data Structures, Group Descriptor and Bitmap
inode tables, Inode Table, Inode Table
inodes, Creating Inodes, Deleting Inodes
creating, Creating Inodes, Creating Inodes
deleting, Deleting Inodes, Deleting Inodes
memory data structures, Ext2 Memory Data Structures
filesystem images, Ext2 Memory Data Structures
RAM copy, Ext2 Memory Data Structures
methods, Ext2 Methods, Ext2 File Operations
file operations, Ext2 File Operations
inode operations, Ext2 Inode Operations
superblock operations, Ext2 Superblock Operations
partition boot sector, Ext2 Disk Data Structures
preallocation of blocks, General Characteristics of Ext2
regular files, Regular file
superblocks, Ext2 Disk Data Structures, Superblock
symbolic links, Symbolic link
VFS superblock data, The ext2_sb_info and ext2_inode_info Structures
Ext3 filesystem, The Ext3 Filesystem, How Journaling Works
atomic operation handles, Atomic operation handles
journaling, How Journaling Works, How Journaling Works
journaling block device layer, The Journaling Block Device Layer, Transactions
journaling filesystem, The Ext3 Journaling Filesystem
logging, The Ext3 Journaling Filesystem
metadata, The Ext3 Journaling Filesystem
transactions, Transactions
Extended Filesystem (Ext FS), General Characteristics of Ext2
extended frames, Setting up the frame
extended paging, Extended Paging
external device, I/O Interfaces
external fragmentation, The Buddy System Algorithm
external object descriptors, Object Descriptor
external slab descriptors, Slab Descriptor

F

f00f bug, Preliminary Initialization of the IDT
faults, Interrupts and Exceptions
FIB (Forwarding Information Base), The Forwarding Information Base (FIB)
FIFOs, FIFOs, Creating and Opening a FIFO
creating and opening, Creating and Opening a FIFO
file operations, Creating and Opening a FIFO
pipes, contrasted with, FIFOs
file block numbers, Data Blocks Addressing
file control blocks, The Common File Model
file descriptors, Opening a file, Files Associated with a Process
file handles, Superblock Objects
file hard links, Hard and Soft Links
file holes, File Holes
file locking, File Locking, FL_POSIX Locks
file modes, Access Rights and File Mode
file objects, The Common File Model, File Objects, File Objects
file operations, File Objects
file pointers, Opening a file, File Objects
file soft links, Hard and Soft Links
files, Files
accesses and memory-mapping, Disk Caches
accessing, Accessing an opened file, Accessing Files, Direct I/O Transfers
direct I/O transfers (see direct I/O transfers)
memory mapping (see memory mapping)
addressing of, Accessing an opened file
closing, Closing a file
deleting, Renaming and deleting a file
device files, Device Files
filename length, Files
fragmentation, Managing Ext2 Disk Space
opening, Opening a file
reading from, Reading from a File, The accessed page is unlocked (asynchronous read-ahead)
page basis of, Reading and Writing a File
read operation descriptors, Reading from a File
read-ahead technique (see read-ahead of files)
renaming, Renaming and deleting a file
undeletion of, General Characteristics of Ext2
writing to, Reading and Writing a File, Writing to a File, The prepare_write and commit_write methods for block device files
prepare_write and commit_write methods, The prepare_write and commit_write methods for regular files, The prepare_write and commit_write methods for block device files
write methods, disk-based filesystems, Writing to a File, Writing to a File
filesystem control blocks, The Common File Model
filesystem type registration, Filesystem Type Registration
filesystems, Linux Versus Other Unix-Like Kernels, The Role of the Virtual Filesystem (VFS), The Common File Model
(see also Virtual Filesystem)
Ext2 (see Ext2)
Ext3 (see Ext3 filesystem)
mounting, Filesystem Mounting, Mounting a Generic Filesystem
generic filesystems, Mounting a Generic Filesystem, Mounting a Generic Filesystem
root filesystem, Mounting the Root Filesystem, Mounting the Root Filesystem
special filesystems, Special Filesystems
types, Filesystem Types, Filesystem Type Registration
Unix filesystem, An Overview of the Unix Filesystem, Renaming and deleting a file
unmounting, Unmounting a Filesystem
filetypes, File Types
fix-mapped linear addresses, Fix-Mapped Linear Addresses
fixed preemption point, Linux Versus Other Unix-Like Kernels
fixed-limit caching mode, Ext2 Memory Data Structures
floating-point unit (FPU), Saving the FPU, MMX, and XMM Registers
floppy disks, formatting for Linux, Creating the Ext2 Filesystem
flushing dirty buffers, Writing Dirty Buffers to Disk
system calls for, The sync( ), fsync( ), and fdatasync( ) system calls
focus processors, IRQ distribution in multiprocessor systems
Forwarding Information Base (FIB), The Forwarding Information Base (FIB)
FPU (floating-point unit), Saving the FPU, MMX, and XMM Registers
frame buffer, Custom I/O interfaces
frames, Setting up the frame, The neighbor cache
extended frames, Setting up the frame
free page frame, Page Descriptors
full-duplex pipe, Using a Pipe
fully associative caches, Hardware Cache
function footprints, The Slab Allocator

G

G granularity flags, Segment Descriptors
GART (Graphics Address Remapping Table), Mapping addresses of I/O shared memory
GDT (Global Descriptor Table), Segment Descriptors
general caches, General and Specific Caches
general-purpose I/O interfaces, I/O Interfaces, General-purpose I/O interfaces
GID (Group ID), Access Rights and File Mode
Global Descriptor Table (GDT), Segment Descriptors
global interrupt disabling, Global Interrupt Disabling, Global Interrupt Disabling
concurrency and, Choosing Among Spin Locks, Semaphores, and Interrupt Disabling
global kernel locks, The Global Kernel Lock
GNU/Linux kernel vs. commercial distributions, Level of Description
goal, Allocating a Data Block
graphic interface, Custom I/O interfaces
Graphics Address Remapping Table (GART), Mapping addresses of I/O shared memory
Group ID (GID), Users and Groups, Access Rights and File Mode
group leader, Process groups and login sessions

H

half-duplex pipes, Using a Pipe
hardware cache memory, Hardware Cache
hardware caches, Hardware Cache, Hardware Cache
handling, Handling the Hardware Cache and the TLB
lines, Hardware Cache
hardware clocks, Hardware Clocks, CPU Local Timers
hardware context, Hardware Context
hardware context switches, Hardware Context
hardware error codes, Exceptions
hardware header cache, The neighbor cache
hash chaining, The pidhash table and chained lists
hash collision, The pidhash table and chained lists
heaps, Managing the Heap, Program Segments and Process Memory Regions
managing, Managing the Heap, Managing the Heap
hidden scheduling, Support for real-time applications is weak
high-level driver, An Overview of Block Device Driver Architecture
host identifiers, Routing Data Structures
hot spot, Profiling the Kernel Code
hyper-threaded microprocessors, Scheduling on multiprocessor systems

I

I/O APIC (Advanced Programmable Interrupt Controller), The Advanced Programmable Interrupt Controller (APIC)
initialization at bootstrap, IRQ distribution in multiprocessor systems
I/O architecture, I/O Architecture, Putting DMA to work
I/O buses, I/O Architecture
I/O devices, Managing I/O Devices, Character Device Drivers
block device drivers (see block device drivers)
character device drivers, Character Device Drivers, Character Device Drivers
device controllers, Device Controllers, Accessing the I/O shared memory
device drivers, Device Drivers, Interrupt mode
buffering strategies, Buffering Strategies of Device Drivers
registering, Registering a Device Driver
resources, Accessing I/O ports
device files, Device Files, VFS Handling of Device Files
DMAC (Direct Memory Access Controller), Direct Memory Access (DMA), Putting DMA to work
I/O interfaces, I/O Interfaces, General-purpose I/O interfaces
I/O operations, monitoring, Monitoring I/O Operations, Interrupt mode
I/O ports, I/O Ports, Accessing I/O ports
I/O shared memory, Device Controllers
accessing, Accessing the I/O shared memory, Accessing the I/O shared memory
address mapping, Mapping addresses of I/O shared memory
kernel, levels of support by, Levels of Kernel Support
I/O interrupt handlers, I/O Interrupt Handling
I/O interrupt handling, I/O Interrupt Handling, Dynamic allocation of IRQ lines
I/O-bound processes, Scheduling Policy
idtr CPU registers, Interrupt Descriptor Table
IDTs (Interrupt Descriptor Tables), Interrupt Descriptor Table
initializing, Initializing the Interrupt Descriptor Table, Preliminary Initialization of the IDT
preliminary initialization, Preliminary Initialization of the IDT
IEEE 802 standards, The neighbor cache
immutable files, General Characteristics of Ext2
inactive lists, The Least Recently Used (LRU) Lists
include directory, Hardware Dependency
INET sockets, INET Sockets
methods, INET Sockets
info structure, Swap Area
init process, Zombie processes, Process 0
initialized data segments, Program Segments and Process Memory Regions
inode objects, The Common File Model, Inode Objects, Inode Objects
inode operations, Inode Objects
inode semaphores, Inode Semaphore
inode tables, Inode Table, Inode Table
inodes, File Descriptor and Inode
caches, The dentry Cache
numbers, The Common File Model
input registers, I/O Ports
insmod program, Linking and Unlinking Modules
int instruction, Initializing the Interrupt Descriptor Table
interactive processes, Scheduling Policy
internal device, I/O Interfaces
internal fragmentation, Memory Area Management
internal object descriptors, Object Descriptor
internal slab descriptors, Slab Descriptor
Internet, Network Architectures
Internet Protocol Suite (IPS) network architecture, Network Architectures
interpreted scripts, Executable Formats
interprocess communications, Signals and Interprocess Communication, Process Communication, Demand paging for IPC shared memory regions
FIFOs, FIFOs, Creating and Opening a FIFO
creating and opening, Creating and Opening a FIFO
file operations, Creating and Opening a FIFO
pipes, Pipes, Writing into a Pipe
creating and destroying, Creating and Destroying a Pipe
data structures, Pipe Data Structures, The pipefs special filesystem
limitations of, FIFOs
read and write channels, Using a Pipe
reading from, Reading from a Pipe
writing into, Writing into a Pipe
System V IPC (see System V IPC)
Unix, mechanisms available in, Process Communication
interprocessor interrupts, The Advanced Programmable Interrupt Controller (APIC)
Interrupt Controllers, IRQs and Interrupts
Interrupt Descriptor Tables (see IDTs)
interrupt descriptors, Interrupt, Trap, and System Gates
interrupt gates, Interrupt Descriptor Table, Interrupt, Trap, and System Gates, IRQ data structures
interrupt handling, Interrupt Handling, Interprocessor Interrupt Handling
interrupt handlers, The Process/Kernel Model
for local timers, The local timer interrupt handler
nested execution of, Nested Execution of Exception and Interrupt Handlers
registers, saving, Saving the registers for the interrupt handler
vs exception handlers, Nested Execution of Exception and Interrupt Handlers
interrupt mode, Interrupt mode
Interrupt Redirection Tables, The Advanced Programmable Interrupt Controller (APIC)
Interrupt ReQuests (see IRQs)
interrupt service routines (ISRs), I/O Interrupt Handling, Interrupt service routines
interrupt signals, The Process/Kernel Model, Interrupts and Exceptions
interrupt vectors, Interrupt vectors
interrupts, Interrupts and Exceptions, The Advanced Programmable Interrupt Controller (APIC)
actions following, I/O Interrupt Handling
bottom halves, The Role of Interrupt Signals
disabling, Interrupt disabling, Local Interrupt Disabling, Global Interrupt Disabling
hardware handling of, Hardware Handling of Interrupts and Exceptions
IRQs (Interrupt ReQuests) and, IRQs and Interrupts, The Advanced Programmable Interrupt Controller (APIC)
laptops and, Interrupts and Exceptions
multiprocessor systems, handling on, Interprocessor Interrupt Handling
numerical identification, Interrupts and Exceptions
process switching, contrasted with, The Role of Interrupt Signals
termination phase, Returning from Interrupts and Exceptions, The ret_ from_ fork( ) Function
top halves, The Role of Interrupt Signals
types of, Interrupts and Exceptions
vectors, Interrupts and Exceptions
interval timers, The setitimer( ) and alarm( ) System Calls
IPC, System V IPC (see System V IPC)
(see also interprocess communications)
(see also System V IPC)
IPS (Internet Protocol Suite) network architecture, Network Architectures
IRQs (Interrupt ReQuests), IRQs and Interrupts, The Advanced Programmable Interrupt Controller (APIC)
allocation of IRQ lines, Dynamic allocation of IRQ lines, Dynamic allocation of IRQ lines
data structures, IRQ data structures
I/O APIC and, The Advanced Programmable Interrupt Controller (APIC)
line selection, IRQ configurable devices, Interrupt vectors
ISA buses, memory mapping, Mapping addresses of I/O shared memory
ISRs (interrupt service routines), I/O Interrupt Handling, Interrupt service routines

J

JBD (Journaling Block Device), The Journaling Block Device Layer
jiffies, PIT’s interrupt service routine
timer implementation and, Software Timers
journal, Journaling Filesystems
journaling, General Characteristics of Ext2, How Journaling Works, How Journaling Works
Journaling Block Device (JBD), The Journaling Block Device Layer
journaling block device layer, The Journaling Block Device Layer, Transactions
journaling filesystems, Journaling Filesystems

K

kapm, Other kernel threads
kernel code segment, Segmentation in Linux
kernel control paths, Reentrant Kernels, Nested Execution of Exception and Interrupt Handlers, Kernel Control Paths, Synchronization Primitives
interleaving conditions, Kernel Control Paths
Linux, interleaving in, Nested Execution of Exception and Interrupt Handlers
race conditions and, Synchronization Primitives
kernel data segment, Segmentation in Linux
kernel master Page Global Directory, Final kernel Page Table when RAM size is less than 896 MB
Kernel Memory Allocator (KMA), Kernel Memory Allocator
Kernel Mode, Basic Operating System Concepts, The Process/Kernel Model, When Synchronization Is Not Necessary
exceptions in, Nested Execution of Exception and Interrupt Handlers
User Mode, contrasted with, Process Address Space
kernel oops, Entering and Leaving the Exception Handler, Handling a Faulty Address Outside the Address Space
kernel page cache
self-caching applications and, Direct I/O Transfers
kernel page tables, Kernel Page Tables
kernel requests, issuing of, Kernel Control Paths
kernel semaphores, Semaphores, Read/Write Semaphores
acquiring, Getting and releasing semaphores, Getting and releasing semaphores
releasing, Getting and releasing semaphores
kernel symbol table, Exporting Symbols
kernel threads, The Process/Kernel Model, Kernel Threads, Other kernel threads
kernel wrapper routines, POSIX APIs and System Calls, Kernel Wrapper Routines, Kernel Wrapper Routines
kernels, Linux Versus Other Unix-Like Kernels, Basic Operating System Concepts, Kernel Synchronization
code profilers, Profiling the Kernel Code
concurrency and global interrupt disabling, Choosing Among Spin Locks, Semaphores, and Interrupt Disabling
concurrency level, Synchronizing Accesses to Kernel Data Structures
CPU activity, tracking by, Keeping Track of System Load
data structures, synchronization of access, Synchronizing Accesses to Kernel Data Structures, Protecting a data structure accessed by exceptions, interrupts, and deferrable functions
destination caches, The Destination Cache
GNU/Linux vs. commercial distributions, Level of Description
interprocess communications, Signals and Interprocess Communication
(see also interprocess communications)
interrupt handling, The Role of Interrupt Signals
kernel threads, Linux Versus Other Unix-Like Kernels
Linux compared to Unix, Linux Versus Other Unix-Like Kernels
loading and execution, System Startup, Modern Age: The start_kernel( ) Function
mappings, high-memory page frames, Kernel Mappings of High-Memory Page Frames, Temporary kernel mappings
modules, Kernel Architecture
nonpreemptive, Nonpreemptive kernels
preemptive, Process Preemption
vs. nonpreemptive, Linux Versus Other Unix-Like Kernels
priority of, Process Address Space
process management, Process Descriptor
processes, contrasted with, The Process/Kernel Model
read/write semaphores, handling of, Read/Write Semaphores
signals, Signals and Interprocess Communication
usage of, Signals
source code and instruction order, Memory Barriers
source code directory tree (Linux), Source Code Structure, Source Code Structure
synchronization, Kernel Synchronization, Inode Semaphore
conditions not requiring, When Synchronization Is Not Necessary
techniques (see synchronization primitives)
threads, memory descriptors of, Memory Descriptor of Kernel Threads
timekeeping, Timing Measurements, The local timer interrupt handler
Unix kernels, An Overview of Unix Kernels, Device Drivers
demand paging, Process virtual address space handling
device drivers, Device Drivers
reentrant kernels, Reentrant Kernels, Synchronization and Critical Regions
keyboard interface, Custom I/O interfaces
KMA (Kernel Memory Allocator), Kernel Memory Allocator
kswapd kernel threads, When to Perform Page Swap Out, The kswapd Kernel Thread, The kswapd Kernel Thread
kupdate kernel threads, The kupdate kernel thread, The kupdate kernel thread

L

L1-caches, Hardware Cache
L2-caches, Hardware Cache
lazy TLB mode, Handling the TLB
ld.so, Libraries
LDTDs (Local Descriptor Table Descriptors), Segment Descriptors
LDTs (Local Descriptor Tables), Segment Descriptors, Segmentation in Linux
lease locks, Linux File Locking
Least Recently Used (LRU) lists (see LRU lists)
left children, red-black trees, Memory Region Data Structures
lightweight processes, Linux Versus Other Unix-Like Kernels, Processes, Lightweight Processes, and Threads
creation in Linux, The clone( ), fork( ), and vfork( ) System Calls
linear address fields, The Linear Address Fields
linear address intervals, Allocating a Linear Address Interval, Second phase: updating the Page Tables
allocating, Allocating a Linear Address Interval, Allocating a Linear Address Interval
releasing, Releasing a Linear Address Interval, Second phase: updating the Page Tables
memory regions, scanning, First phase: scanning the memory regions
Page Tables, updating, Second phase: updating the Page Tables
linear addresses, Memory Addresses
and noncontiguous memory areas, Linear Addresses of Noncontiguous Memory Areas
links, Hard and Soft Links
Linux, Introduction
advantages, Linux Versus Other Unix-Like Kernels
emulation of other operating systems, Execution Domains
filesystems, Linux Versus Other Unix-Like Kernels
Unix filesystem and, An Overview of the Unix Filesystem, Renaming and deleting a file
hardware dependency, Hardware Dependency
kernel, Linux Versus Other Unix-Like Kernels
kernel control paths, interleaving, Nested Execution of Exception and Interrupt Handlers
kernel threading, Linux Versus Other Unix-Like Kernels
lightweight processes, reliance on, Processes, Lightweight Processes, and Threads
memory barriers, Memory Barriers
paging, Paging in Linux , Handling the TLB
platforms, Hardware Dependency
POSIX compliance, Linux Versus Other Unix-Like Kernels
segmentation, Segmentation in Linux, Segmentation in Linux
segments used, Segmentation in Linux
source code (see source code)
timekeeping (see timekeeping architecture)
Unix kernel and, Introduction
version numbering, Linux Versions
Linux kernels (see kernels)
LinuxThreads library, Processes, Lightweight Processes, and Threads
local APICs, The Advanced Programmable Interrupt Controller (APIC)
arbitration, The Advanced Programmable Interrupt Controller (APIC)
interrupt handlers, The local timer interrupt handler
Local Descriptor Table Descriptors (LDTDs), Segment Descriptors
Local Descriptor Tables (LDTs), Segment Descriptors, Segmentation in Linux
local interrupts, disabling, Local Interrupt Disabling
local TLB, Translation Lookaside Buffers (TLB)
locality principle, Hardware Cache
locking, Spin Locks
locks, global kernel, The Global Kernel Lock
log record, Log records
logical addresses, Memory Addresses
logical block number, Buffer Heads
login name, Users and Groups
login sessions, Process groups and login sessions
loopback, Mounting a Generic Filesystem
low-level driver, An Overview of Block Device Driver Architecture
low-level driver descriptor, Block device low-level driver descriptor
LRU (Least Recently Used) lists, Outline of the Page Frame Reclaiming Algorithm
pages, moving across, Moving pages across the LRU lists

M

magic structure, Swap Area
major faults, Handling a Faulty Address Inside the Address Space
major numbers, Old-Style Device Files
mandatory file locks, File Locking
maskable interrupts, Interrupts and Exceptions
masked signals, The Role of Signals
masking of deferrable functions, Softirqs, Tasklets, and Bottom Halves
Master Boot Record (MBR), Ancient Age: The Boot Loader
master kernel Page Global Directory, Kernel Page Tables
master memory descriptor, Memory Descriptor of Kernel Threads
mathematical coprocessors, Saving the FPU, MMX, and XMM Registers
MBR (Master Boot Record), Ancient Age: The Boot Loader
memory
initialization of data structures for, Initialization of the Memory Handling Data Structures, Initialization of the Memory Handling Data Structures
management, Memory Management, Releasing a Noncontiguous Memory Area
buddy system algorithm, The Buddy System Algorithm, Freeing a block
page frames, Page Frame Management, Freeing a block
permanent kernel mappings, Permanent kernel mappings, Permanent kernel mappings
swapping (see swapping)
temporary kernel mappings, Temporary kernel mappings
memory addresses, Memory Addresses
memory addressing, Memory Addressing, Handling the TLB
memory alignment, Aligning Objects in Memory
memory allocation and demand paging, Process virtual address space handling
memory arbiters, Memory Addresses, Atomic Operations, Direct Memory Access (DMA)
memory area descriptors, Process virtual address space handling
memory area management, Memory Area Management, Releasing a Noncontiguous Memory Area
cache descriptors, Cache Descriptor
caches, General and Specific Caches
interface, slab allocator and buddy system algorithm, Interfacing the Slab Allocator with the Buddy System
multiprocessor systems, Local Array of Objects in Multiprocessor Systems
noncontiguous areas (see noncontiguous memory area management)
object descriptors, Object Descriptor
aligning objects in memory, Aligning Objects in Memory
slab allocators, The Slab Allocator, The Slab Allocator
slab coloring, Slab Coloring
slab descriptors, Slab Descriptor
slabs
allocating to caches, Allocating a Slab to a Cache
releasing from caches, Releasing a Slab from a Cache
memory barriers, Memory Barriers
memory descriptors, The Memory Descriptor, Memory Descriptor of Kernel Threads
fields, The Memory Descriptor
of kernel threads, Memory Descriptor of Kernel Threads
mmap_cache, Finding the closest region to a given address: find_vma( )
read/write semaphores, Memory Descriptor Read/Write Semaphore
red-black trees, Memory Region Data Structures, Memory Region Data Structures
memory fragmentation, Random access memory usage
Memory Management Unit (MMU), Virtual memory
memory mapping, Process Address Space, Memory Mapping, Flushing Dirty Memory Mapping Pages to Disk
creating, Creating a Memory Mapping, Creating a Memory Mapping
data structures, Memory Mapping Data Structures, Memory Mapping Data Structures
demand paging for, Demand Paging for Memory Mapping, Demand Paging for Memory Mapping
destroying, Destroying a Memory Mapping
flushing dirty pages to disk, Flushing Dirty Memory Mapping Pages to Disk
memory nodes, Non-Uniform Memory Access (NUMA)
memory regions, Process Address Space, The Process’s Address Space, Memory Regions, Second phase: updating the Page Tables
access rights, Memory Region Access Rights, Memory Region Access Rights
assignment to processes, The Process’s Address Space
data structures, Memory Region Data Structures, Memory Region Data Structures
fields, Memory Regions
flags, Memory Region Access Rights
handling, Memory Region Handling, Inserting a region in the memory descriptor list: insert_vm_struct( )
finding a free interval, Finding a free interval: arch_get_unmapped_area( )
finding a region that ovelaps an interval, Finding a region that overlaps a given interval: find_vma_intersection( )
finding the closest region to an address, Finding the closest region to a given address: find_vma( )
inserting a region in the memory descriptor list, Inserting a region in the memory descriptor list: insert_vm_struct( )
linear address intervals, Allocating a Linear Address Interval, Second phase: updating the Page Tables
merging, Memory Regions
pages, relation to, Memory Region Access Rights
system calls for creation, deletion, The Process’s Address Space
memory swapping (see swapping)
memory zones, Memory Zones
message queues, Signals and Interprocess Communication
metadata, The Ext3 Journaling Filesystem
microkernels, Kernel Architecture
microprocessors, hyper-threaded, Scheduling on multiprocessor systems
minor faults, Handling a Faulty Address Inside the Address Space
minor numbers, Old-Style Device Files
mke2fs utility program, Creating the Ext2 Filesystem
mkswap command, Swap Area
MMU (Memory Management Unit), Virtual memory
MMX instructions, Saving the FPU, MMX, and XMM Registers
modprobe program, The modprobe Program
modules, Linux Versus Other Unix-Like Kernels, Kernel Architecture, Modules, The request_module( ) Function
advantages, Kernel Architecture
data structures and, To Be (a Module) or Not to Be?
dependencies, Module Dependency
exception tables, Module Implementation
exporting of symbols, Exporting Symbols
implementation, Module Implementation
licenses, Exporting Symbols
linking and unlinking, Linking and Unlinking Modules
linking on demand, Linking Modules on Demand
module objects, Module Implementation
module usage counters, Module Usage Counter
request_module function, The request_module( ) Function
mount points, Filesystem Mounting
mounted filesystem descriptors, Filesystem Mounting
multiprocessing, Processes
multiprocessor systems
caches and, Hardware Cache
interrupt disabling and, Interrupt disabling
interrupt handling on, Interprocessor Interrupt Handling
memory and, Memory Addresses
memory area management, Local Array of Objects in Multiprocessor Systems
nonpreemptive kernels and, Nonpreemptive kernels
processes, scheduling on, Scheduling on multiprocessor systems, Scheduling on multiprocessor systems
timekeeping architecture, Timekeeping Architecture in Multiprocessor Systems, The local timer interrupt handler
initialization, Initialization of the timekeeping architecture
multiprogramming, Processes
multithreaded applications, Linux Versus Other Unix-Like Kernels, Processes, Lightweight Processes, and Threads
multiuser systems, Multiuser Systems

N

N-way set associative caches, Hardware Cache
named pipes, FIFOs
neighbor caches, The neighbor cache
Net-4, Networking
network addresses, Routing Data Structures
network filesystems, The Role of the Virtual Filesystem (VFS)
network interface, Custom I/O interfaces
network interface cards (NICs), Network Interface Cards
network masks, Routing Data Structures
networking, Networking, Receiving Packets from the Network Card
data structures, Main Networking Data Structures, The Socket Buffer
BSD sockets, BSD Sockets
destination caches, The Destination Cache
Forwarding Information Base (FIB), The Forwarding Information Base (FIB)
INET sockets, INET Sockets
neighbor caches, The neighbor cache
NICs (network interface cards), Network Interface Cards
routing caches, The routing cache
socket buffers, The Socket Buffer
frames, The neighbor cache
IP (Internet Protocol layer), Routing Data Structures
network architectures, Network Architectures
Linux, supported by, Network Architectures
network cards, Network Interface Cards, Sending Packets to the Network Card, Receiving Packets from the Network Card
receiving packets from, Receiving Packets from the Network Card, Receiving Packets from the Network Card
sending packets to, Sending Packets to the Network Card
network layers, Networking, Network Architectures
payload, The Socket Buffer
programming for networks, Networking
protocols, Network Architectures
sockets
initialization, Socket initialization
static routing table, The Forwarding Information Base (FIB)
system calls related to, System Calls Related to Networking, Data link layer: enqueueing the socket buffer for transmission
data link layer, Data link layer: composing the hardware header, Data link layer: enqueueing the socket buffer for transmission
network layers, Transport and network layers: the ip_build_xmit( ) function
transport layer, Transport layer: the udp_sendmsg( ) function
zones, The Forwarding Information Base (FIB)
NGPT (Next Generation Posix Threading Package), Processes, Lightweight Processes, and Threads
NMI interrupts, Checking the NMI Watchdogs
nodes, red-black trees, Memory Region Data Structures
noncontiguous memory area management, Noncontiguous Memory Area Management, Releasing a Noncontiguous Memory Area
allocating noncontiguous area, Allocating a Noncontiguous Memory Area
descriptors, Descriptors of Noncontiguous Memory Areas
linear addresses, Linear Addresses of Noncontiguous Memory Areas
Page Fault exception handlers and, Handling Noncontiguous Memory Area Accesses
Page Faults and, Allocating a Noncontiguous Memory Area
releasing memory area, Releasing a Noncontiguous Memory Area
nonexclusive processes, Wait queues
nonmaskable interrupts, Interrupts and Exceptions
nonpreemptive kernels, Nonpreemptive kernels
multiprocessor systems and, Nonpreemptive kernels
nonpreemptive processes, Processes
NUMA (Non-Uniform Memory Access), Non-Uniform Memory Access (NUMA)
nodes, Non-Uniform Memory Access (NUMA)
nodes descriptors, Non-Uniform Memory Access (NUMA)

O

object descriptors, Object Descriptor
object files, Libraries
objects, The Common File Model
caches, allocating in, Allocating an Object in a Cache, The multiprocessor case
multiprocessors, The multiprocessor case
uniprocessors, The uniprocessor case
caches, releasing from, Releasing an Object from a Cache, The multiprocessor case
multiprocessors, The multiprocessor case
uniprocessors, The uniprocessor case
general purpose, General Purpose Objects
offsets, of logical addresses, Memory Addresses
old-style device files, Device Files, Old-Style Device Files
older siblings, Parenthood Relationships Among Processes
operating systems, Basic Operating System Concepts
execution modes, Basic Operating System Concepts
output registers, I/O Ports
owners, The address_space Object

P

PAEs (Physical Address Extensions), The Physical Address Extension (PAE) Paging Mechanism
Page Cache Disable (PCD) flag, Hardware Cache
page caches, Disk Caches, The Page Cache, Page Cache Handling Functions
address_space objects, The address_space Object, The address_space Object
data structures, Page Cache Data Structures, Page descriptor fields related to the page cache
direct I/O transfers, bypassing with, Direct I/O Transfers
handling functions, Page Cache Handling Functions
I/O operations, usage by, Disk Caches
page descriptor fields, Page descriptor fields related to the page cache
page hash tables, The page hash table
page descriptor lists, Page Cache Data Structures
page descriptors, The lists of page descriptors in the address_space object
Page Directories, Regular Paging
Page Fault exceptions, Nested Execution of Exception and Interrupt Handlers, Memory Region Access Rights
Page Fault exception handlers, Page Fault Exception Handler, Handling Noncontiguous Memory Area Accesses
Copy On Write, Copy On Write, Copy On Write
demand paging, Demand Paging, Demand Paging
faulty addresses, Handling a Faulty Address Outside the Address Space, Handling a Faulty Address Inside the Address Space
inside address space, handling, Handling a Faulty Address Inside the Address Space, Handling a Faulty Address Inside the Address Space
outside address space, handling, Handling a Faulty Address Outside the Address Space, Handling a Faulty Address Outside the Address Space
noncontiguous memory area accesses, handling, Handling Noncontiguous Memory Area Accesses
process flow, Page Fault Exception Handler
Page Faults, noncontiguous memory areas and, Allocating a Noncontiguous Memory Area
page frame reclaiming, Reclaiming Page Frame, The kswapd Kernel Thread
algorithm, Outline of the Page Frame Reclaiming Algorithm, Outline of the Page Frame Reclaiming Algorithm
from the dentry cache, Reclaiming page frames from the dentry cache
functions, The try_to_ free_ pages( ) Function, The shrink_cache( ) Function
from the inode cache, Reclaiming page frames from the inode cache
kswapd kernel threads, The kswapd Kernel Thread, The kswapd Kernel Thread
Least Recently Used (LRU) lists, The Least Recently Used (LRU) Lists
pages, moving across, Moving pages across the LRU lists
purpose, Reclaiming Page Frame
page frames, Virtual memory, Paging in Hardware
avoiding race conditions on, Transferring Swap Pages
free page frame, Page Descriptors
high-memory, kernel mapping of, Kernel Mappings of High-Memory Page Frames, Temporary kernel mappings
management, Page Frame Management, Freeing a block
memory zones, Memory Zones
page descriptors, Page Descriptors
processes, sharing among, The Swap Cache
request and release of, Requesting and Releasing Page Frames, Requesting and Releasing Page Frames
reserved, Reserved Page Frames, Reserved Page Frames
page I/O operation, Block and Page I/O Operations
page slots, Swap Area
defective slots, Swap Area Descriptor
functions for allocation and release of, Allocating and Releasing a Page Slot, The swap_free( ) function
Page Tables, Paging in Hardware, Regular Paging
handling, Page Table Handling, Page Table Handling
for kernels
provisional, Provisional kernel Page Tables
protection bits, Memory Region Access Rights
Page Tables
for kernels, Kernel Page Tables
for processes, Process Page Tables
pages, Paging in Hardware
LRU lists, moving across, Moving pages across the LRU lists
memory regions, relation to, Memory Region Access Rights
swapping (see swapping)
paging
demand paging, Demand Paging, Demand Paging
in hardware, Paging in Hardware, Translation Lookaside Buffers (TLB)
in Linux, Paging in Linux , Handling the TLB
vs. segmentation, Segmentation in Linux
paging units, Memory Addresses
parallel ports, General-purpose I/O interfaces
parent filesystems, Filesystem Mounting
password, Users and Groups
pathname lookup, Pathname Lookup, Lookup of Symbolic Links
pathnames, Files
payload, The Socket Buffer
PCD (Page Cache Disable) flag, Hardware Cache
PCI buses, memory mapping, Mapping addresses of I/O shared memory
PCMCIA interfaces, General-purpose I/O interfaces
pending blocked signals, Examining the Pending Blocked Signals
pending signal queues, Data Structures Associated with Signals
pending signals, The Role of Signals
Pentium processors
caching, Hardware Cache
f00f bug, Preliminary Initialization of the IDT
three-level paging and, Paging in Linux
periods in directory notation, Files
permanent kernel mappings, Permanent kernel mappings, Permanent kernel mappings
temporary kernal mappings, contrasted with, Kernel Mappings of High-Memory Page Frames
personalities, Execution Domains
Linux, supported by, Execution Domains
Physical Address Extensions (PAEs), The Physical Address Extension (PAE) Paging Mechanism
physical addresses, Memory Addresses
physical pages, Paging in Hardware
PID (process ID), Identifying a Process
pipe buffer, Pipe Data Structures
pipe size, Pipe Data Structures
pipes, Pipes, Writing into a Pipe
creating and destroying, Creating and Destroying a Pipe
data structures, Pipe Data Structures, The pipefs special filesystem
FIFOs, contrasted with, FIFOs
limitations of, FIFOs
read and write channels, Using a Pipe
reading from, Reading from a Pipe
writing into, Writing into a Pipe
PIT (Programmable Interval Timer), Programmable Interval Timer
interrupt service routine, PIT’s interrupt service routine
multiprocessor systems and, Timekeeping Architecture in Multiprocessor Systems
polling mode, Polling mode
ports
I/O ports, I/O Ports, Accessing I/O ports
POSIX (Portable Operating Systems based on Unix), Linux Versus Other Unix-Like Kernels
signals, Signals and Interprocess Communication
Power-On Self-Test (POST), Reserved Page Frames
preemptive kernels, Process Preemption
preemptive processes, Processes, Process Preemption
prepare_write method, The prepare_write and commit_write methods for regular files, The prepare_write and commit_write methods for block device files
primitive semaphores, IPC Semaphores
priority inversion, Support for real-time applications is weak
private memory mapping, Memory Mapping
process 0, Process 0
process 1, Process 0
process capabilities, Process capabilities, Process capabilities
process credentials, Process Credentials and Capabilities
process descriptors, Process Implementation, Process Descriptor , Process Resource Limits, Process descriptor
hardware context, saving of, The thread field
memory, storage in, Processor descriptors handling
process 0, The process list
process descriptor pointers, Identifying a Process
process lists, The process list
doubly linked lists, Doubly linked lists
representation, Processor descriptors handling
process group ID, Process groups and login sessions
process groups, Process groups and login sessions
process ID (PID), Identifying a Process
process page tables, Process Page Tables
process switches, Process Switch, Saving the FPU, MMX, and XMM Registers
hardware context, Hardware Context
interrupt handling, contrasted with, The Role of Interrupt Signals
kernels, performance by, Performing the Process Switch, Performing the Process Switch
process time-outs, An Application of Dynamic Timers
process/kernel model, Processes
processes, Processes, The Process/Kernel Model, Processes, Process Removal, Program Execution
address spaces, Process Address Space, Process Address Space, Managing the Heap
creating, Creating and Deleting a Process Address Space
deleting, Deleting a Process Address Space
functions and macros for accessing, Accessing the Process Address Space
linear addresses, The Process’s Address Space
children, Process Management, Parenthood Relationships Among Processes
communication between (see interprocess communication)
creating, Creating Processes, Other kernel threads
destroying, Destroying Processes, Process Removal
execution domains, specification, Execution Domains
files associated with, Files Associated with a Process, Files Associated with a Process
files, reading from, Accessing Files
I/O-bound or CPU-bound, Scheduling Policy
implementation, Process Implementation
init, Zombie processes
kernel stack representation, Processor descriptors handling
lightweight processes, Processes, Lightweight Processes, and Threads
creation in Linux, The clone( ), fork( ), and vfork( ) System Calls
management, Process Management
memory regions, assignment circumstances, The Process’s Address Space
memory requests, Process Address Space
original parents, Parenthood Relationships Among Processes
page frames, sharing of, The Swap Cache
parents, Process Management, Parenthood Relationships Among Processes
personality fields, Execution Domains
preemption of, Process Preemption
program execution (see program execution)
quantum duration, How Long Must a Quantum Last?
removal, Process Removal
resource limits, Process Resource Limits
scheduling, Process Scheduling, The sched_rr_ get_interval( ) system call
algorithm (see scheduling algorithm)
base priority, The Scheduling Algorithm
base time quanta, The Scheduling Algorithm
data structures, Data Structures Used by the Scheduler, CPU’s data structures
dynamic priority, The Scheduling Algorithm
epochs, The Scheduling Algorithm
evaluating priority, How good is a runnable process?
multiprocessor systems, Scheduling on multiprocessor systems, Scheduling on multiprocessor systems
policy, Scheduling Policy, How Long Must a Quantum Last?
priority, assignment of, Scheduling Policy, Process Preemption
real-time processes, system calls related to, System Calls Related to Real-Time Processes, The sched_rr_ get_interval( ) system call
schedule function, The schedule( ) Function, Scheduling on multiprocessor systems
static priority, The Scheduling Algorithm
system calls related to, Scheduling Policy, System Calls Related to Scheduling, The sched_rr_ get_interval( ) system call
signals, response to, Actions Performed upon Delivering a Signal
sleeping processes, Wait queues
suspending, Suspending the Process
swapper, The Scheduling Algorithm
termination, Process Termination
time sharing, Scheduling Policy
types of, Scheduling Policy
younger siblings, Parenthood Relationships Among Processes
zombies, Zombie processes
processor-detected exceptions, Interrupts and Exceptions
profile, Profiling the Kernel Code
program counters, The Role of Interrupt Signals
program execution, Program Execution, The exec Functions
command-line arguments, Command-Line Arguments and Shell Environment
environment variables, Command-Line Arguments and Shell Environment
exec functions, The exec Functions, The exec Functions
executable files, Executable Files, Execution Tracing
executable formats, Executable Formats, Executable Formats
execution domains, Execution Domains
libraries, Libraries
process capabilities, Process capabilities, Process capabilities
process memory regions, Program Segments and Process Memory Regions
segments, Program Segments and Process Memory Regions
program interpreters, Libraries
Programmable Interval Timer (PIT), Programmable Interval Timer
programmed exceptions, Interrupts and Exceptions
protected mode, Segmentation in Hardware
protocols, Network Architectures
provisional Page Global Directory, Provisional kernel Page Tables
pthread (POSIX thread) libraries, Processes, Lightweight Processes, and Threads
PWT (Page Write-Through) cache, Hardware Cache

Q

quanta, The Linux Timekeeping Architecture, CPU’s Time Sharing, Scheduling Policy
quantum duration, How Long Must a Quantum Last?

R

race conditions, Synchronization and Critical Regions
dynamic timers and, Dynamic timers and race conditions
prevention, Examples of Race Condition Prevention, Inode Semaphore
swap caches and, The Swap Cache
RAM (random access memory)
dynamic memory and, Memory Management
swapping (see swapping)
Unix, usage in, Random access memory usage
random access memory (see RAM)
Read access rights, Access Rights and File Mode
read file locks, File Locking
read operation descriptors, Reading from a File
read-ahead algorithm, Read-Ahead of Files
read-ahead groups, Read-Ahead of Files
read-ahead of files, Read-Ahead of Files, The accessed page is unlocked (asynchronous read-ahead)
asynchronous read-ahead operations, Read-Ahead of Files, The accessed page is unlocked (asynchronous read-ahead)
synchronous read-ahead operations, Read-Ahead of Files, The accessed page is locked (synchronous read-ahead)
read-ahead windows, Read-Ahead of Files
read/write semaphores, Read/Write Semaphores
read/write spin locks, Read/Write Spin Locks
real mode, Segmentation in Hardware
Real Mode addresses, Prehistoric Age: The BIOS
Real Time Clock (RTC), Real Time Clock
real-time processes, Scheduling Policy
system calls related to, System Calls Related to Real-Time Processes, The sched_rr_ get_interval( ) system call
real-time signals, The Role of Signals, System Calls for Real-Time Signals
red-black trees, Memory Region Data Structures, Memory Region Data Structures
reentrant functions, Reentrant Kernels
reentrant kernels, Reentrant Kernels, Synchronization and Critical Regions
synchronization, Synchronization and Critical Regions
interrupt disabling, Interrupt disabling
reference counters, Reference Counters
registering a device driver, Registering a Device Driver
regular files, Regular file
regular signals, The Role of Signals
relative pathnames, Files
request descriptors, Request descriptors
request queues, An Overview of Block Device Driver Architecture
Requestor Privilege Level, Fast Access to Segment Descriptors
reserved page frames, Reserved Page Frames, Reserved Page Frames
resource, Accessing I/O ports
resource limits, Process Resource Limits
right children, red-black trees, Memory Region Data Structures
root, Users and Groups
root directories, Files, Filesystem Mounting
root filesystems, The Role of the Virtual Filesystem (VFS), Filesystem Mounting
mounting, Mounting the Root Filesystem, Mounting the Root Filesystem
routers, Routing Data Structures
routing caches, The routing cache
routing data structures, Routing Data Structures
routing zone, The Forwarding Information Base (FIB)
runqueues, The list of TASK_RUNNING processes

S

S system flags, Segment Descriptors
schedule function, The schedule( ) Function, Scheduling on multiprocessor systems
direct invocation, Direct invocation
lazy invocation, Lazy invocation
process switches, Actions performed by schedule( ) before a process switch, Actions performed by schedule( ) after a process switch
actions performed after, Actions performed by schedule( ) after a process switch, Actions performed by schedule( ) after a process switch
actions performed before, Actions performed by schedule( ) before a process switch, Actions performed by schedule( ) before a process switch
scheduler, Processes
scheduling algorithm, The Scheduling Algorithm, Support for real-time applications is weak
I/O-bound process boosting, effectiveness of, I/O-bound process boosting strategy is not optimal
performance of, Performance of the Scheduling Algorithm, Support for real-time applications is weak
real-time application support, Support for real-time applications is weak
scaling, The algorithm does not scale well
system load and, The predefined quantum is too large for high system loads
scheduling policy, Scheduling Policy
SCSIs (Small Computer System Interfaces), General-purpose I/O interfaces
bus, General-purpose I/O interfaces
standard, General-purpose I/O interfaces
Second Extended Filesystem (see Ext2)
sectors, Sectors, Blocks, and Buffers
Segment Descriptors, Segment Descriptors, Fast Access to Segment Descriptors
Segment Selectors, Segmentation Registers
segmentation
in Linux, Segmentation in Linux, Segmentation in Linux
vs. paging, Segmentation in Linux
segmentation registers, Segmentation Registers
segmentation units, Memory Addresses, Segmentation Unit
segments, Request descriptors
CPL (Current Privilege Level) and, Segmentation in Linux
Linux, used in, Segmentation in Linux
of logical addresses, Memory Addresses
self-caching applications, Direct I/O Transfers
semaphores, Semaphores
acquiring, Getting and releasing semaphores, Getting and releasing semaphores
kernel semaphores, Semaphores, Read/Write Semaphores
race conditions, preventing with, Memory Descriptor Read/Write Semaphore, Inode Semaphore
read/write semaphores, Read/Write Semaphores
releasing, Getting and releasing semaphores
System V IPC, Signals and Interprocess Communication
serial ports, General-purpose I/O interfaces
Set Group ID (sgid), Access Rights and File Mode
Set User ID (suid), Access Rights and File Mode
setuid programs, Process Credentials and Capabilities
sgid (Set Group ID), Access Rights and File Mode
share-mode mandatory locks, Linux File Locking
shared libraries, Libraries
shared linked lists, insertion of elements into, Synchronizing Accesses to Kernel Data Structures
shared memory, Signals and Interprocess Communication
shared memory mapping, Memory Mapping
shared page swapping, The Swap Cache
signals, Signals and Interprocess Communication, Signals, System Calls for Real-Time Signals
blocked signals, modifying of, Modifying the Set of Blocked Signals
blocking of, The Role of Signals
catching, Catching the Signal, Terminating the signal handler
frames, setting up, Setting up the frame
signal flags, evaluating, Evaluating the signal flags
signal handlers, starting and terminating, Starting the signal handler
changing the action of, Changing a Signal Action
data structures, Data Structures Associated with Signals, Operations on Signal Data Structures
operations on, Operations on Signal Data Structures, Operations on Signal Data Structures
default actions, Signals and Interprocess Communication
delivering, The Role of Signals, Delivering a Signal, Delivering a Signal
descriptors, Data Structures Associated with Signals
exception handlers, Exceptions
executing default actions for, Executing the Default Action for the Signal, Executing the Default Action for the Signal
forcing functions, The force_sig_info( ) and force_sig( ) Functions
generating, The Role of Signals, Generating a Signal, The force_sig_info( ) and force_sig( ) Functions
ignoring, Ignoring the Signal
Linux 2.4, first 31 in, The Role of Signals
masking of, The Role of Signals
pending blocked signals, examining, Examining the Pending Blocked Signals
pending signal queues, Data Structures Associated with Signals
pending signals, The Role of Signals
phases of transmission, The Role of Signals
process descriptor fields for handling, Data Structures Associated with Signals
processes, response of, Actions Performed upon Delivering a Signal
processes, suspending, Suspending the Process
purpose, The Role of Signals
real-time signals, The Role of Signals
real-time signals, system calls for, System Calls for Real-Time Signals
regular signals, The Role of Signals
sender codes, Data Structures Associated with Signals
sending functions, The send_sig_info( ) and send_sig( ) Functions
SIG prefix, The Role of Signals
SIGKILL, Actions Performed upon Delivering a Signal
SIGSTOP, Actions Performed upon Delivering a Signal
system calls, The Role of Signals
for handling of, System Calls Related to Signal Handling, System Calls for Real-Time Signals
reexecuting, Reexecution of System Calls, Reexecution of System Calls
slab allocators, The Slab Allocator, The Slab Allocator
buddy system algorithm, interfacing with, Interfacing the Slab Allocator with the Buddy System
slab cache list semaphores, Slab Cache List Semaphore
slab caches, The Slab Allocator
slab coloring, Slab Coloring
slab descriptors, Slab Descriptor
slab object constructors, The Slab Allocator
slab object destructors, The Slab Allocator
slab objects, The Slab Allocator
slabs, The Slab Allocator
caches, allocating to, Allocating a Slab to a Cache
realeasing from caches, Releasing a Slab from a Cache
sleeping processes, Wait queues
slices, Scheduling Policy
slot indexes, Using an IPC Resource
slot usage sequence numbers, Using an IPC Resource
slots, How to Distribute Pages in the Swap Areas, Swap Area
Small Computer System Interfaces (see SCSIs)
SMP (symmetric multiprocessing), Linux Versus Other Unix-Like Kernels, IRQ distribution in multiprocessor systems
systems, timekeeping in, The Linux Timekeeping Architecture
socket buffers, The Socket Buffer
socket control messages, Writing Packets to a Socket
sockets, BSD Sockets
initialization, Socket initialization
softirqs, Softirqs, Tasklets, and Bottom Halves, Softirqs, The softirq kernel threads
tasklets, contrasted with, Softirqs, Tasklets, and Bottom Halves
software interrupts, Interrupts and Exceptions, Softirqs, Tasklets, and Bottom Halves
software timers, Software Timers
source code, Level of Description
GNU/Linux kernel vs. commercial distributions, Level of Description
source code and instruction order, Memory Barriers
source code directory tree, Source Code Structure, Source Code Structure
special filesystems, The Role of the Virtual Filesystem (VFS), Special Filesystems
specific caches, General and Specific Caches
spin locks, Spin locks, Spin Locks, The Big Reader Lock
global kernel locks, The Global Kernel Lock
SSE extensions (Streaming SIMD Extensions), Saving the FPU, MMX, and XMM Registers
stack segment registers, Segmentation Registers
stack segments, Program Segments and Process Memory Regions
static distribution of IRQs, The Advanced Programmable Interrupt Controller (APIC)
static libraries, Libraries
static priority, The Scheduling Algorithm
static routing table, The Forwarding Information Base (FIB)
static timers, Software Timers
status registers, I/O Ports
sticky flag, Access Rights and File Mode
strategy routine, An Overview of Block Device Driver Architecture
suid (Set User ID), Access Rights and File Mode
superblock, Superblock
superblock objects, The Common File Model, Superblock Objects, Superblock Objects
superblock operations, Superblock Objects, Superblock Objects
superformat utility program, Creating the Ext2 Filesystem
superuser, Users and Groups
supervisor, Users and Groups
swap areas, Swapping and caching, Swap Area, The swap_free( ) function
activation, Swap Area
activation service routine, The sys_swapon( ) service routine
deactivation service routine, The sys_swapoff( ) service routine
descriptors, Swap Area Descriptor, Swap Area Descriptor
format, Swap Area
multiple areas, advantages, Swap Area
page slots, Swap Area
allocating and releasing, Allocating and Releasing a Page Slot, The swap_free( ) function
prioritization, How to Distribute Pages in the Swap Areas
swap-in and updating function, The try_to_unuse( ) function, The try_to_unuse( ) function
swap caches, The Swap Cache, Swap Cache Helper Functions
helper functions, Swap Cache Helper Functions
swapoff program, The sys_swapoff( ) service routine
swapon program, The sys_swapon( ) service routine
swapped-out page identifiers, Swapped-Out Page Identifier
page table value entries, Swapped-Out Page Identifier
swapper, The process list, Process 0, The Scheduling Algorithm
timesharing and, CPU’s Time Sharing
swapping, Swapping: Methods for Freeing Memory, The kswapd Kernel Thread
drawbacks, What Is Swapping?
pages, What Is Swapping?, When to Perform Page Swap Out
choosing, Which Kind of Page to Swap Out
distribution, How to Distribute Pages in the Swap Areas
functions for, Transferring Swap Pages, The do_swap_page( ) Function
Least Recently Used (LRU) algorithms, How to Select the Page to Be Swapped Out
page frame reclaiming (see page frame reclaiming)
selection, How to Select the Page to Be Swapped Out
swapping in, Swapping in Pages, The do_swap_page( ) Function
swapping out, Swapping Out Pages, The try_to_swap_out( ) Function
timing of, When to Perform Page Swap Out
transferring, Transferring Swap Pages, The rw_swap_ page_nolock( ) Function
of process address space, What Is Swapping?
purpose, What Is Swapping?
share page swapping, The Swap Cache
swap areas (see swap areas)
symbolic links, Hard and Soft Links, Symbolic link
symmetric multiprocessing (see SMP)
synchronization primitives, Synchronization Primitives, Inode Semaphore
atomic operations, Atomic Operations, Atomic Operations
choosing among, considerations, Choosing Among Spin Locks, Semaphores, and Interrupt Disabling
completions, Completions
kernel data structures, access using, Synchronizing Accesses to Kernel Data Structures, Protecting a data structure accessed by exceptions, interrupts, and deferrable functions
memory barriers, Memory Barriers
semaphores, Semaphores, Read/Write Semaphores
spin locks, Spin Locks, The Big Reader Lock
synchronous errors or exceptions, Signals and Interprocess Communication
synchronous interrupts, Interrupts and Exceptions
synchronous read-ahead operations, Read-Ahead of Files, The accessed page is locked (synchronous read-ahead)
system administrators, Users and Groups
system bootstrap
I/O APIC initialization, IRQ distribution in multiprocessor systems
system call dispatch tables, System Call Handler and Service Routines
system call numbers, System Call Handler and Service Routines
system call service routines, System Call Handler and Service Routines
system calls, The Process/Kernel Model, System Calls, Kernel Wrapper Routines
dynamic address checking, Dynamic Address Checking: The Fixup Code
file-handling, File-Handling System Calls
handler and service routines, System Call Handler and Service Routines, Generating the exception tables and the fixup code
initializing, Initializing System Calls
kernel wrapper routines, Kernel Wrapper Routines, Kernel Wrapper Routines
networking, related to, System Calls Related to Networking, Data link layer: enqueueing the socket buffer for transmission
parameters, Parameter Passing, Verifying the Parameters
passing, Parameter Passing, Parameter Passing
verifying, Verifying the Parameters, Verifying the Parameters
POSIX APIs and, POSIX APIs and System Calls
process address spaces, accessing, Accessing the Process Address Space
process scheduling, for, Scheduling Policy, System Calls Related to Scheduling, The sched_rr_ get_interval( ) system call
processes, suspending, Suspending the Process
real-time processes, related to, System Calls Related to Real-Time Processes, The sched_rr_ get_interval( ) system call
reexecuting, Reexecution of System Calls, Reexecution of System Calls
signals, The Role of Signals, System Calls Related to Signal Handling, System Calls for Real-Time Signals
changing action of, Changing a Signal Action
system call function, The system_call( ) Function
timing measurements, related to, System Calls Related to Timing Measurements, The setitimer( ) and alarm( ) System Calls
Virtual Filesystem, handled by, System Calls Handled by the VFS
system concurrency level, Synchronizing Accesses to Kernel Data Structures
system gates, Interrupt, Trap, and System Gates
system load, The predefined quantum is too large for high system loads
System Segment, Task State Segment
system startup, System Startup, Modern Age: The start_kernel( ) Function
BIOS, Prehistoric Age: The BIOS
boot loader, Ancient Age: The Boot Loader
Linux boot, Booting Linux from Floppy Disk, Booting Linux from Hard Disk
from floppy disk, Booting Linux from Floppy Disk
from hard disk, Booting Linux from Hard Disk
system statistics, updating by kernel, Updating System Statistics
System V IPC (Interprocess Communication), Signals and Interprocess Communication, System V IPC, Demand paging for IPC shared memory regions
(see also interprocess communications)
IPC identifiers, System V IPC
IPC keys, System V IPC
IPC resources, Signals and Interprocess Communication, System V IPC, Using an IPC Resource
IPC shared memory region, IPC Shared Memory
messages, IPC Messages, IPC Messages
semaphores, IPC Semaphores, The queue of pending requests
shared memory, IPC Shared Memory, Demand paging for IPC shared memory regions
demand paging, Demand paging for IPC shared memory regions
page swapping, Swapping out pages of IPC shared memory regions
shm filesystem, IPC Shared Memory
system calls, The ipc( ) System Call

T

Table Indicator, Fast Access to Segment Descriptors
task gates, Interrupt Descriptor Table
task priority registers, The Advanced Programmable Interrupt Controller (APIC)
task queues, Extending a bottom half
Task State Segment Descriptors (TSSDs), Segment Descriptors, Task State Segment
Task State Segments (TSSs), Segmentation in Linux, Task State Segment
task switch, Process Switch
tasklet descriptors, Tasklets
tasklets, Softirqs, Tasklets, and Bottom Halves, Tasklets, Tasklets
softirqs, contrasted with, Softirqs, Tasklets, and Bottom Halves
tasks, Processes
TCP/IP network architecture, Network Architectures
temporary kernel mappings, Temporary kernel mappings
permanent kernel mappings, contrasted with, Kernel Mappings of High-Memory Page Frames
text segments, Program Segments and Process Memory Regions
thread groups, Identifying a Process
threads, Processes, Processes, Lightweight Processes, and Threads
three-level paging, Three-Level Paging, Paging in Linux
Pentium processors and, Paging in Linux
ticks, Programmable Interval Timer
time multiplexing, Scheduling Policy
time quantum, Scheduling Policy
time sharing in the CPU, CPU’s Time Sharing
Time Stamp Counter, Time Stamp Counter
time-outs, Software Timers
time-sharing, Scheduling Policy
timekeeping
system calls related to, System Calls Related to Timing Measurements, The setitimer( ) and alarm( ) System Calls
time and date updates, Updating the Time and Date
timekeeping architecture, The Linux Timekeeping Architecture, The local timer interrupt handler
initialization, multiprocessor systems, Initialization of the timekeeping architecture
multiprocessor systems, Timekeeping Architecture in Multiprocessor Systems, The local timer interrupt handler
uniprocessor systems, Timekeeping Architecture in Uniprocessor Systems, The TIMER_BH bottom half
timer interrupts, Programmable Interval Timer
timers, Software Timers
real-time applications and, Software Timers
timing measurements, Timing Measurements, The setitimer( ) and alarm( ) System Calls
via hardware, Hardware Clocks
types, Timing Measurements
TLBs (Translation Lookaside Buffers), Translation Lookaside Buffers (TLB)
handling, Handling the Hardware Cache and the TLB
top halves, The Role of Interrupt Signals
Torvalds, Linus, Introduction
transactions, Transactions
Translation Lookaside Buffers (see TLBs)
trap gates, Interrupt Descriptor Table, Interrupt, Trap, and System Gates
traps, Interrupts and Exceptions
TSC (Time Stamp Counter), The Linux Timekeeping Architecture
two-level paging, Regular Paging

U

UID (User ID), Access Rights and File Mode
umask, The clone( ), fork( ), and vfork( ) System Calls
uniprocessor systems
timekeeping architecture, Timekeeping Architecture in Uniprocessor Systems, The TIMER_BH bottom half
unitialized data segments, Program Segments and Process Memory Regions
universal serial buses (USBs), General-purpose I/O interfaces
Unix
process management, Process Management
System V interprocess communication, Signals and Interprocess Communication
Unix filesystem, An Overview of the Unix Filesystem, Renaming and deleting a file
access rights, Access Rights and File Mode
directory structure, Files
file-handling system calls, File-Handling System Calls
files, Files
file types, File Types
Unix kernels (see under kernels)
Unix operating systems, Introduction
Linux and, Introduction
USBs (universal serial buses), General-purpose I/O interfaces
user code segment, Segmentation in Linux
user data segment, Segmentation in Linux
user group, Users and Groups
User ID (UID), Users and Groups, Access Rights and File Mode
User Mode, Basic Operating System Concepts, The Process/Kernel Model
exceptions in, Nested Execution of Exception and Interrupt Handlers
Kernel Mode, contrasted with, Process Address Space
memory, allocation to, Process Address Space
processes, synchronization of (see interprocess communications)
system calls (see system calls)
user threads, Processes, Lightweight Processes, and Threads

V

vectors, Interrupts and Exceptions
VESA Local Buses (VLBs), memory mapping, Mapping addresses of I/O shared memory
virtual address space, Virtual memory
virtual addresses, Memory Addresses
virtual block devices, The Role of the Virtual Filesystem (VFS)
Virtual Filesystem (VFS), The Virtual Filesystem, FL_POSIX Locks
common file model, The Common File Model, The Common File Model
data structures, VFS Data Structures, Files Associated with a Process
dentry objects, dentry Objects, The dentry Cache
file objects, File Objects, File Objects
inode objects, Inode Objects, Inode Objects
processes, Files Associated with a Process, Files Associated with a Process
superblock objects, Superblock Objects, Superblock Objects
description, The Role of the Virtual Filesystem (VFS)
device files, handling of, VFS Handling of Device Files
Ext2 superblock data, The ext2_sb_info and ext2_inode_info Structures
file locking, File Locking, FL_POSIX Locks
filesystems
types, Filesystem Types, Filesystem Type Registration
objects, The Common File Model
pathname lookup, Pathname Lookup, Lookup of Symbolic Links
superblock operations, Superblock Objects, Superblock Objects
supported filesystems, The Role of the Virtual Filesystem (VFS)
system calls, System Calls Handled by the VFS
implementation, Implementations of VFS System Calls, The close( ) System Call
virtual filesystems, The Role of the Virtual Filesystem (VFS)
virtual memory, Virtual memory

W

wait queue head, Wait queues
wait queues, How Processes Are Organized
watchdog system, Checking the NMI Watchdogs
windows, kernel address space, Temporary kernel mappings
wrapper routines, POSIX APIs and System Calls
(see also kernel wrapper routines)
Write access rights, Access Rights and File Mode
write file locks, File Locking

X

XMM registers, Saving the FPU, MMX, and XMM Registers

Z

zero page, Demand Paging
zombie processes, Zombie processes
zone modifier, Requesting and Releasing Page Frames
zones, Memory Zones, The Forwarding Information Base (FIB)
size and addressing, Initialization of the Memory Handling Data Structures
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.224.32.46