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