Understanding Linux Network Internals (Paperback)
內容描述
Description
If you've ever wondered how Linux carries out the complicated tasks assigned to it by the IP protocols -- or if you just want to learn about modern networking through real-life examples -- Understanding Linux Network Internals is for you.
Like the popular O'Reilly book, Understanding the Linux Kernel, this book clearly explains the underlying concepts and teaches you how to follow the actual C code that implements it. Although some background in the TCP/IP protocols is helpful, you can learn a great deal from this text about the protocols themselves and their uses. And if you already have a base knowledge of C, you can use the book's code walkthroughs to figure out exactly what this sophisticated part of the Linux kernel is doing.
Part of the difficulty in understanding networks -- and implementing them -- is that the tasks are broken up and performed at many different times by different pieces of code. One of the strengths of this book is to integrate the pieces and reveal the relationships between far-flung functions and data structures. Understanding Linux Network Internals is both a big-picture discussion and a no-nonsense guide to the details of Linux networking. Topics include:
Key problems with networking
Network interface card (NIC) device drivers
System initialization
Layer 2 (link-layer) tasks and implementation
Layer 3 (IPv4) tasks and implementation
Neighbor infrastructure and protocols (ARP)
Bridging
Routing
ICMP
Table of Contents
Preface
Part I. General Background
- Introduction
Basic Terminology
Common Coding Patterns
User-Space Tools
Browsing the Source Code
When a Feature Is Offered as a Patch
- Critical Data Structures
The Socket Buffer: sk_buff Structure
net_device Structure
Files Mentioned in This Chapter
- User-Space-to-Kernel Interface
Overview
procfs Versus sysctl
ioctl
Netlink
Serializing Configuration Changes
Part II. System Initialization
- Notification Chains
Reasons for Notification Chains
Overview
Defining a Chain
Registering with a Chain
Notifying Events on a Chain
Notification Chains for the Networking Subsystems
Tuning via /proc Filesystem
Functions and Variables Featured in This Chapter
Files and Directories Featured in This Chapter
- Network Device Initialization
System Initialization Overview
Device Registration and Initialization
Basic Goals of NIC Initialization
Interaction Between Devices and Kernel
Initialization Options
Module Options
Initializing the Device Handling Layer: net_dev_init
User-Space Helpers
Virtual Devices
Tuning via /proc Filesystem
Functions and Variables Featured in This Chapter
Files and Directories Featured in This Chapter
- The PCI Layer and Network Interface Cards
Data Structures Featured in This Chapter
Registering a PCI NIC Device Driver
Power Management and Wake-on-LAN
Example of PCI NIC Driver Registration
The Big Picture
Tuning via /proc Filesystem
Functions and Variables Featured in This Chapter
Files and Directories Featured in This Chapter
- Kernel Infrastructure for Component Initialization
Boot-Time Kernel Options
Module Initialization Code
Optimized Macro-Based Tagging
Boot-Time Initialization Routines
Memory Optimizations
Tuning via /proc Filesystem
Functions and Variables Featured in This Chapter
Files and Directories Featured in This Chapter
- Device Registration and Initialization
When a Device Is Registered
When a Device Is Unregistered
Allocating net_device Structures
Skeleton of NIC Registration and Unregistration
Device Initialization
Organization of net_device Structures
Device State
Registering and Unregistering Devices
Device Registration
Device Unregistration
Enabling and Disabling a Network Device
Updating the Device Queuing Discipline State
Configuring Device-Related Information from User Space
Virtual Devices
Locking
Tuning via /proc Filesystem
Functions and Variables Featured in This Chapter
Files and Directories Featured in This Chapter
Part III. Transmission and Reception
- Interrupts and Network Drivers
Decisions and Traffic Direction
Notifying Drivers When Frames Are Received
Interrupt Handlers
softnet_data Structure
- Frame Reception
Interactions with Other Features
Enabling and Disabling a Device
Queues
Notifying the Kernel of Frame Reception: NAPI and netif_rx
Old Interface Between Device Drivers and Kernel: First Part of netif_rx
Congestion Management
Processing the NET_RX_SOFTIRQ: net_rx_action
- Frame Transmission
Enabling and Disabling Transmissions
- General and Reference Material About Interrupts
Statistics
Tuning via /proc and sysfs Filesystems
Functions and Variables Featured in This Part of the Book
Files and Directories Featured in This Part of the Book
- Protocol Handlers
Overview of Network Stack
Executing the Right Protocol Handler
Protocol Handler Organization
Protocol Handler Registration
Ethernet Versus IEEE 802.3 Frames
Tuning via /proc Filesystem
Functions and Variables Featured in This Chapter
Files and Directories Featured in This Chapter
Part IV. Bridging
- Bridging: Concepts
Repeaters, Bridges, and Routers
Bridges Versus Switches
Hosts
Merging LANs with Bridges
Bridging Different LAN Technologies
Address Learning
Multiple Bridges
- Bridging: The Spanning Tree Protocol
Basic Terminology
Example of Hierarchical Switched L2 Topology
Basic Elements of the Spanning Tree Protocol
Bridge and Port IDs
Bridge Protocol Data Units (BPDUs)
Defining the Active Topology
Timers
Topology Changes
BPDU Encapsulation
Transmitting Configuration BPDUs
Processing Ingress Frames
Convergence Time
Overview of Newer Spanning Tree Protocols
- Bridging: Linux Implementation
Bridge Device Abstraction
Important Data Structures
Initialization of Bridging Code
Creating Bridge Devices and Bridge Ports
Creating a New Bridge Device
Bridge Device Setup Routine
Deleting a Bridge
Adding Ports to a Bridge
Enabling and Disabling a Bridge Device
Enabling and Disabling a Bridge Port
Changing State on a Bridge Port
The Big Picture
Forwarding Database
Handling Ingress Traffic
Transmitting on a Bridge Device
Spanning Tree Protocol (STP)
netdevice Notification Chain
- Bridging: Miscellaneous Topics
User-Space Configuration Tools
Tuning via /proc Filesystem
Tuning via /sys Filesystem
Statistics
Data Structures Featured in This Part of the Book
Functions and Variables Featured in This Part of the Book
Files and Directories Featured in This Part of the Book
Part V. Internet Protocol Version 4 (IPv4)
- Internet Protocol Version 4 (IPv4): Concepts
IP Protocol: The Big Picture
IP Header
IP Options
Packet Fragmentation/Defragmentation
Checksums
- Internet Protocol Version 4 (IPv4): Linux Foundations and Features
Main IPv4 Data Structures
General Packet Handling
IP Options
- Internet Protocol Version 4 (IPv4): Forwarding and Local Delivery
Forwarding
Local Delivery
- Internet Protocol Version 4 (IPv4): Transmission
Key Functions That Perform Transmission
Interface to the Neighboring Subsystem
- Internet Protocol Version 4 (IPv4): Handling Fragmentation
IP Fragmentation
IP Defragmentation
- Internet Protocol Version 4 (IPv4): Miscellaneous Topics
Long-Living IP Peer Information
Selecting the IP Header's ID Field
IP Statistics
IP Configuration
IP-over-IP
IPv4: What's Wrong with It?
Tuning via /proc Filesystem
Data Structures Featured in This Part of the Book
Functions and Variables Featured in This Part of the Book
Files and Directories Featured in This Part of the Book
- Layer Four Protocol and Raw IP Handling
Available L4 Protocols
L4 Protocol Registration
L3 to L4 Delivery: ip_local_deliver_finish
IPv4 Versus IPv6
Tuning via /proc Filesystem
Functions and Variables Featured in This Chapter
Files and Directories Featured in This Chapter
- Internet Control Message Protocol (ICMPv4)
ICMP Header
ICMP Payload
ICMP Types
Applications of the ICMP Protocol
The Big Picture
Protocol Initialization
Data Structures Featured in This Chapter
Transmitting ICMP Messages
Receiving ICMP Messages
ICMP Statistics
Passing Error Notifications to the Transport Layer
Tuning via /proc Filesystem
Functions and Variables Featured in This Chapter
Files and Directories Featured in This Chapter
Part VI. Neighboring Subsystem
- Neighboring Subsystem: Concepts
What Is a Neighbor?
Reasons That Neighboring Protocols Are Needed
Linux Implementation
Proxying the Neighboring Protocol
When Solicitation Requests Are Transmitted and Processed
Neighbor States and Network Unreachability Detection (NUD)
- Neighboring Subsystem: Infrastructure
Main Data Structures
Common Interface Between L3 Protocols and Neighboring Protocols
General Tasks of the Neighboring Infrastructure
Reference Counts on neighbour Structures
Creating a neighbour Entry
Neighbor Deletion
Acting As a Proxy
L2 Header Caching
Protocol Initialization and Cleanup
Interaction with Other Subsystems
Interaction Between Neighboring Protocols and L3 Transmission Functions
Queuing
- Neighboring Subsystem: Address Resolution Protocol (ARP)
ARP Packet Format
Example of an ARP Transaction
Gratuitous ARP
Responding from Multiple Interfaces
Tunable ARP Options
ARP Protocol Initialization
Initialization of a neighbour Structure
Transmitting and Receiving ARP Packets
Processing Ingress ARP Packets
Proxy ARP
Examples
External Events
ARPD
Reverse Address Resolution Protocol (RARP)
Improvements in ND (IPv6) over ARP (IPv4)
- Neighboring Subsystem: Miscellaneous Topics
System Administration of Neighbors
Tuning via /proc Filesystem
Data Structures Featured in This Part of the Book
Files and Directories Featured in This Part of the Book
Part VII. Routing
- Routing: Concepts
Routers, Routes, and Routing Tables
Essential Elements of Routing
Routing Table
Lookups
Packet Reception Versus Packet Transmission
- Routing: Advanced
Concepts Behind Policy Routing
Concepts Behind Multipath Routing
Interactions with Other Kernel Subsystems
Routing Protocol Daemons
Verbose Monitoring
ICMP_REDIRECT Messages
Reverse Path Filtering
- Routing: Linux Implementation
Kernel Options
Main Data Structures
Route and Address Scopes
Primary and Secondary IP Addresses
Generic Helper Routines and Macros
Global Locks
Routing Subsystem Initialization
External Events
Interactions with Other Subsystems
- Routing: The Routing Cache
Routing Cache Initialization
Hash Table Organization
Major Cache Operations
Multipath Caching
Interface Between the DST and Calling Protocols
Flushing the Routing Cache
Garbage Collection
Egress ICMP REDIRECT Rate Limiting
- Routing: Routing Tables
Organization of Routing Hash Tables
Routing Table Initialization
Adding and Removing Routes
Policy Routing and Its Effects on Routing Table Definitions
- Routing: Lookups
High-Level View of Lookup Functions
Helper Routines
The Table Lookup: fn_hash_lookup
fib_lookup Function
Setting Functions for Reception and Transmission
General Structure of the Input and Output Routing Routines
Input Routing
Output Routing
Effects of Multipath on Next Hop Selection
Policy Routing
Source Routing
Policy Routing and Routing Table Based Classifier
- Routing: Miscellaneous Topics
User-Space Configuration Tools
Statistics
Tuning via /proc Filesystem
Enabling and Disabling Forwarding
Data Structures Featured in This Part of the Book
Functions and Variables Featured in This Part of the Book
Files and Directories Featured in This Part of the Book
Index
_@9787512433403_https://static.coderbridge.com/images/books/9787512433403.jpg)
_@9789861542935_https://static.coderbridge.com/images/books/9789861542935.jpg)
_@9787115537676_https://static.coderbridge.com/images/books/9787115537676.jpg)