Network Hardware: Physical Components of Networked Systems
Network Interface Cards (NICs)
Read aloud is unavailable in this browser.
The Gateway Between Software and Wire
Every email you send, every video you stream, every web page you load begins its journey through a small but remarkably sophisticated piece of hardware: the Network Interface Card (NIC). This unassuming component serves as the critical bridge between the digital world of software and the physical world of electrical signals, light pulses, or radio waves.
Without the NIC, your computer would be an island—capable of processing data at extraordinary speeds but utterly unable to share that data with the outside world. Understanding NICs is therefore foundational to understanding how computer networks actually function at the physical level.
By the end of this page, you will understand the complete architecture of network interface cards, how they translate between software packets and physical signals, the evolution from separate expansion cards to integrated chipsets, and the modern advancements that enable multi-gigabit networking. You'll also gain insight into MAC addresses, DMA operations, and the hardware offloading capabilities that make modern networking efficient.
Fundamental Concepts: What Is a Network Interface Card?
A Network Interface Card (NIC), also known as a network adapter, network controller, or LAN adapter, is a hardware component that connects a computer or other device to a network. The NIC operates at Layer 1 (Physical) and Layer 2 (Data Link) of the OSI model, performing the essential task of converting data from the parallel format used internally by computers into the serial format required for network transmission.
The Dual Nature of the NIC:
The NIC lives at an interesting intersection:
- To the computer: It appears as a hardware device accessible through device drivers, capable of sending and receiving data frames
- To the network: It appears as a participant with a unique hardware address (MAC address), capable of transmitting and receiving electrical or optical signals
This dual role requires the NIC to perform complex transformations in both directions, managing everything from signal timing to error detection.
- •Data Conversion — Transforms parallel data from the computer's internal bus into serial data suitable for transmission over network media, and vice versa
- •Framing — Encapsulates data into frames with proper headers, addressing, and error-checking information according to the network protocol (e.g., Ethernet)
- •Media Access Control — Implements the media access protocol (e.g., CSMA/CD for Ethernet) to determine when to transmit and how to handle collisions
- •Signal Generation — Converts digital data into the appropriate physical signals (electrical voltages, light pulses, or radio waves) for the specific medium
- •Signal Reception — Detects incoming signals from the network medium and converts them back into digital data
- •Buffering — Temporarily stores incoming and outgoing data to handle speed differences between the network and the computer's processing capability
- •Error Detection — Calculates and verifies checksums (typically CRC) to detect transmission errors
- •Addressing — Uses the unique MAC address to identify which frames are addressed to this specific interface
While the term 'card' suggests a physical expansion card, modern NICs come in many forms: PCIe expansion cards, integrated motherboard chipsets, USB adapters, and even complete systems-on-chip for embedded devices. The fundamental functions remain identical regardless of the physical implementation.
NIC Architecture: Internal Components and Data Flow
A modern network interface card is a sophisticated piece of engineering containing multiple specialized subsystems that work together to enable high-speed, reliable network communication. Understanding this architecture is crucial for anyone who needs to troubleshoot network performance issues, configure advanced networking features, or design systems that depend on network hardware.
High-Level Architecture Overview:
The NIC can be conceptually divided into several major functional blocks:
- Host Interface — Connects to the computer's internal bus
- MAC Controller — Implements the Media Access Control protocol
- PHY (Physical Layer Device) — Handles signal transmission and reception
- Memory Controller — Manages on-card buffers and interfaces with system memory
- Offload Engines — Hardware acceleration for common operations
Component Deep Dive:
1. Host Interface (Bus Controller)
The host interface connects the NIC to the computer's internal data bus. Modern NICs use PCIe (PCI Express), which provides high bandwidth and low latency.
- PCIe 3.0 x1: ~1 GB/s (sufficient for 1 Gbps Ethernet)
- PCIe 3.0 x4: ~4 GB/s (suitable for 10 Gbps Ethernet)
- PCIe 4.0 x8: ~16 GB/s (required for 40-100 Gbps Ethernet)
- PCIe 5.0 x16: ~64 GB/s (emerging 400 Gbps networks)
The host interface includes registers that the operating system's device driver reads and writes to control the NIC's operation.
2. DMA Engine (Direct Memory Access)
The DMA engine is critical for performance. Instead of requiring the CPU to copy every byte of network data, the DMA engine can transfer data directly between the NIC's buffers and the system's main memory.
DMA Operation Flow:
- The device driver prepares descriptor rings in system memory
- Each descriptor points to a buffer location and contains control information
- The NIC's DMA engine follows these descriptors to read/write data
- When done, the NIC notifies the CPU via interrupt or polls a status location
This architecture dramatically reduces CPU overhead—a critical factor when processing millions of packets per second.
| Aspect | Programmed I/O (PIO) | Direct Memory Access (DMA) |
|---|---|---|
| CPU Involvement | CPU copies every byte | CPU only sets up descriptors |
| Data Path | Device → CPU → Memory | Device → Memory directly |
| CPU Cycles per Packet | Thousands | Tens (descriptor setup only) |
| Suitable For | Legacy, low-speed devices | High-speed modern networking |
| Maximum Throughput | < 100 Mbps practical limit | 400+ Gbps achievable |
3. Transmit and Receive Buffers
The NIC contains dedicated memory buffers (typically ranging from 8KB to several MB) to temporarily hold frames:
- Transmit (TX) Buffers: Hold outgoing frames waiting to be sent. The NIC's MAC controller reads from these buffers when the medium is available.
- Receive (RX) Buffers: Store incoming frames until the DMA engine can transfer them to system memory. Crucial for handling burst traffic.
Buffer sizing matters: Insufficient buffer space causes frame drops during traffic bursts. High-end server NICs may have 16MB or more of onboard memory.
4. MAC Controller
The MAC (Media Access Control) controller is the heart of the NIC's Layer 2 functionality:
- Constructs Ethernet frames from data provided by upper layers
- Implements the Ethernet protocol's timing and framing rules
- Performs CSMA/CD (for half-duplex) or manages full-duplex operation
- Calculates CRC-32 checksums for frames (on transmit)
- Verifies CRC checksums for incoming frames (on receive)
- Filters frames based on destination MAC address
- Implements flow control mechanisms (IEEE 802.3x PAUSE frames)
The MAC controller doesn't just blindly receive all frames. It filters based on: (1) Unicast frames matching the NIC's own MAC address, (2) Broadcast frames (FF:FF:FF:FF:FF:FF), (3) Configured multicast addresses, and (4) Optionally all frames in 'promiscuous mode'—useful for packet capture and network monitoring tools.
5. PHY (Physical Layer Device)
The PHY, or Physical Layer Transceiver, handles the actual conversion between digital data and physical signals:
- Encoding/Decoding: Applies line coding schemes (e.g., 8b/10b, 64b/66b) to ensure clock recovery and DC balance
- Serialization/Deserialization (SerDes): Converts parallel data to high-speed serial streams and vice versa
- Signal Conditioning: Adjusts signal amplitude, equalization, and timing
- Media Interface: Connects to the specific physical medium (twisted pair, fiber, etc.)
- Auto-Negotiation: Determines the highest common speed and duplex mode between link partners
PHY Types by Media:
| PHY Type | Medium | Typical Speeds |
|---|---|---|
| BASE-T | Twisted Pair Copper | 10M to 10G |
| BASE-X | Fiber (Single-mode or Multi-mode) | 1G to 400G |
| BASE-SR | Multi-mode Fiber (Short Range) | 10G to 100G |
| BASE-LR | Single-mode Fiber (Long Range) | 10G to 100G |
6. Offload Engines
Modern NICs include dedicated hardware to perform operations that would otherwise burden the CPU:
- Checksum Offload: Calculates/verifies IP, TCP, UDP checksums in hardware
- TCP Segmentation Offload (TSO): Splits large data into multiple TCP segments
- Large Receive Offload (LRO): Combines multiple incoming segments into larger buffers
- RSS (Receive-Side Scaling): Distributes incoming traffic across multiple CPU cores
- VLAN Tagging/Stripping: Handles 802.1Q VLAN tags in hardware
MAC Addresses: The Hardware Identity
Every network interface card is assigned a unique identifier known as the MAC address (Media Access Control address), also called the hardware address, physical address, or burned-in address (BIA). This address is fundamental to how Ethernet networks operate, serving as the definitive identifier for a device on a local network segment.
MAC Address Structure:
A MAC address is a 48-bit (6-byte) value, typically represented in hexadecimal notation:
OUI NIC Specific
┌──────────┬─────────────────┐
│ 00:1A:2B │ 3C:4D:5E │
└──────────┴─────────────────┘
Bytes 0-2 Bytes 3-5
Organizational Unique Identifier (OUI):
The first three bytes (24 bits) identify the manufacturer. The IEEE assigns OUI values to vendors:
00:00:0C— Cisco Systems00:1A:11— Google3C:22:FB— Apple00:50:56— VMwareAC:DE:48— Intel
NIC-Specific Portion:
The last three bytes are assigned by the manufacturer to uniquely identify each interface they produce. A manufacturer with one OUI can create 2²⁴ ≈ 16.7 million unique addresses.
| Bit Position | Bit Value | Meaning When Set (1) |
|---|---|---|
| Bit 0 (LSB of first byte) | I/G bit | Multicast/Group address |
| Bit 0 (when 0) | I/G bit | Unicast (individual) address |
| Bit 1 (of first byte) | U/L bit | Locally Administered address |
| Bit 1 (when 0) | U/L bit | Universally Administered (OUI-assigned) |
Special MAC Addresses:
- FF:FF:FF:FF:FF:FF — Broadcast address; frames sent here are received by all devices on the network segment
- 01:00:5E:xx:xx:xx — IPv4 multicast range (lower 23 bits map to IP multicast group)
- 33:33:xx:xx:xx:xx — IPv6 multicast range
- 01:80:C2:00:00:00 — Spanning Tree Protocol (STP)
Locally Administered Addresses (LAA):
When the U/L bit is set, the address is treated as locally administered, meaning it was assigned by system software rather than burned into hardware. This is commonly used in:
- Virtual machines (hypervisors assign MACs to virtual NICs)
- Container networking (each container gets a unique virtual interface)
- MAC address spoofing (testing and privacy scenarios)
- Network interface bonding/teaming
Example: A locally administered unicast address might look like 02:42:AC:11:00:02 (note the 02 in the first byte—bit 1 is set).
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
def analyze_mac_address(mac_string: str) -> dict: """ Analyze a MAC address and extract its properties. Args: mac_string: MAC address in common formats (e.g., "00:1A:2B:3C:4D:5E" or "00-1A-2B-3C-4D-5E") Returns: Dictionary containing MAC address analysis """ # Normalize the MAC address mac_clean = mac_string.replace(':', '').replace('-', '').replace('.', '').upper() if len(mac_clean) != 12: raise ValueError(f"Invalid MAC address format: {mac_string}") # Convert to bytes mac_bytes = bytes.fromhex(mac_clean) first_byte = mac_bytes[0] # Extract properties is_unicast = (first_byte & 0x01) == 0 is_universal = (first_byte & 0x02) == 0 # Extract OUI (first 3 bytes) oui = ':'.join(f'{b:02X}' for b in mac_bytes[:3]) # Known OUI lookup (abbreviated) known_ouis = { '00:00:0C': 'Cisco Systems', '00:50:56': 'VMware', '00:1A:11': 'Google', 'AC:DE:48': 'Intel', '3C:22:FB': 'Apple', } return { 'original': mac_string, 'normalized': ':'.join(f'{b:02X}' for b in mac_bytes), 'oui': oui, 'vendor': known_ouis.get(oui, 'Unknown'), 'type': 'Unicast' if is_unicast else 'Multicast/Broadcast', 'administration': 'Universal (OUI)' if is_universal else 'Local', 'is_broadcast': mac_clean == 'FFFFFFFFFFFF', } # Example usageif __name__ == "__main__": test_addresses = [ "00:1A:2B:3C:4D:5E", # Standard unicast "FF:FF:FF:FF:FF:FF", # Broadcast "02:42:AC:11:00:02", # Docker container (locally administered) "01:00:5E:00:00:01", # IPv4 multicast ] for mac in test_addresses: result = analyze_mac_address(mac) print(f"MAC: {result['normalized']}") print(f" Vendor: {result['vendor']}") print(f" Type: {result['type']}") print(f" Admin: {result['administration']}")MAC addresses should never be relied upon for security. They are transmitted in cleartext, visible to any device on the same network segment, and can be trivially spoofed. MAC-based access control (MAC filtering) provides at best a minor deterrent, not genuine security.
Evolution and Form Factors: From ISA Cards to Integrated Chipsets
The network interface card has undergone remarkable evolution over five decades, mirroring the broader trajectory of computing—from bulky, expensive peripherals to invisible, integrated functionality. Understanding this evolution provides context for modern NIC capabilities and helps explain why certain legacy considerations still exist.
The Early Era: Stand-Alone Cards (1970s-1980s)
The first network adapters were large expansion cards, often requiring manual configuration of interrupt requests (IRQs), DMA channels, and I/O port addresses via physical jumpers or DIP switches.
- ISA Cards (Industry Standard Architecture): 8-bit or 16-bit bus, speeds up to 10 Mbps
- Common protocols: Ethernet (10BASE2, 10BASE5), Token Ring, ARCNET
- Configuration nightmare: Conflicts between cards were common; "IRQ conflicts" became a familiar troubleshooting ritual
- BNC connectors for coaxial cable (10BASE2) were standard
The Transition Era (1990s)
- PCI Bus Adoption: 32-bit, 33 MHz bus dramatically improved bandwidth
- Plug and Play: Automatic configuration eliminated jumper settings
- 100 Mbps Fast Ethernet: Required PCI bandwidth; ISA couldn't keep up
- Driver standardization: NDIS (Windows), ODI (NetWare) unified driver interfaces
| Era | Bus Type | Typical Speed | Notable Features |
|---|---|---|---|
| 1980-1990 | ISA (8/16-bit) | 10 Mbps | Jumper configuration, IRQ/DMA conflicts |
| 1990-2000 | PCI (32-bit) | 10/100 Mbps | Plug and Play, auto-negotiation |
| 2000-2010 | PCI-X / PCIe 1.x | 1 Gbps | Hardware offloads, VLAN support |
| 2010-2020 | PCIe 2.x / 3.x | 10/25/40 Gbps | SR-IOV, RDMA, advanced RSS |
| 2020-Present | PCIe 4.x / 5.x | 100/200/400 Gbps | SmartNICs, P4 programmability |
Modern Form Factors:
1. Integrated Motherboard NICs (LOM — LAN on Motherboard)
The vast majority of modern computers include network functionality integrated directly into the motherboard:
- Consumer motherboards: Typically include 1 Gbps or 2.5 Gbps Ethernet
- Server motherboards: Often include dual 10 Gbps ports or more
- Advantages: No slot consumption, lower cost, simpler cable management
- Disadvantages: Cannot be upgraded without replacing motherboard; failure requires motherboard replacement
2. PCIe Network Adapters
For high-performance or specialized requirements, discrete PCIe NICs remain essential:
- Data center: 25 Gbps, 40 Gbps, 100 Gbps, and 200 Gbps cards
- Workstations: 10 Gbps for video editing, storage access
- Specialty: Low-latency cards for HFT (High-Frequency Trading), RDMA for storage
3. USB Network Adapters
Portable, convenient, but with inherent limitations:
- USB 3.0: Can support 1 Gbps (practical limit ~940 Mbps)
- USB 3.1/3.2: Can support 2.5/5 Gbps Ethernet
- Use cases: Laptops lacking Ethernet, troubleshooting, temporary setups
- Limitation: Higher latency than PCIe; not suitable for server workloads
4. M.2 Network Modules
Wi-Fi and sometimes Ethernet in compact M.2 form factor:
- Common in laptops and compact desktops
- Wi-Fi 6E (802.11ax) and Wi-Fi 7 (802.11be) increasingly standard
- Combined Wi-Fi/Bluetooth modules common
- •Lower total system cost
- •No expansion slot required
- •Reduced power consumption
- •Simpler system integration
- •Standard driver support
- •Higher performance options
- •Upgradeable independently
- •Advanced offload features
- •Multiple port configurations
- •Specialized capabilities (RDMA, FPGA)
Modern NIC Technologies and Advanced Features
Modern network interface cards have evolved far beyond simple packet transmission. Today's NICs are essentially specialized computers, incorporating programmable processors, dedicated memory, and sophisticated acceleration engines. Understanding these capabilities is essential for designing high-performance network applications and infrastructure.
Hardware Offload Technologies:
Offloading moves computationally expensive operations from the CPU to dedicated NIC hardware:
Checksum Offload:
- TX Checksum Offload: NIC calculates IP/TCP/UDP checksums; software sends frames with placeholder values
- RX Checksum Offload: NIC verifies checksums and flags errors before delivery to software
- Impact: Reduces CPU load by eliminating per-packet checksum calculations
Segmentation Offload:
- TSO (TCP Segmentation Offload): Application sends large buffers (up to 64KB); NIC segments into MTU-sized frames
- UFO (UDP Fragmentation Offload): Similar for UDP (less common)
- Impact: Dramatically reduces per-packet overhead for bulk transfers
| Feature | CPU Savings | Bandwidth Impact | Latency Impact |
|---|---|---|---|
| Checksum Offload | 15-30% reduction | Negligible | Slight improvement |
| TSO/LSO | 40-60% reduction | 10-20% improvement | Variable (batching) |
| LRO/GRO | 30-50% reduction | Negligible | Increases (coalescing) |
| RSS (Receive-Side Scaling) | Enables multi-core | Linear with cores | May increase slightly |
Receive-Side Scaling (RSS):
Modern multi-core CPUs can process packets in parallel, but incoming packets arrive on a single NIC. RSS solves this by distributing incoming packets across multiple receive queues, each associated with a different CPU core.
How RSS Works:
- NIC calculates a hash from packet headers (typically source/dest IP and ports)
- Hash value maps to a specific queue via an indirection table
- Each queue generates interrupts to its assigned CPU core
- Result: Packets from the same connection always go to the same core (cache-friendly)
RDMA (Remote Direct Memory Access):
RDMA allows direct memory-to-memory transfers between computers without involving the CPU or OS:
- Zero-copy: Data moves directly between application buffers
- Kernel bypass: No system calls in the data path
- Ultra-low latency: Sub-microsecond transfers possible
- Technologies: InfiniBand, RoCE (RDMA over Converged Ethernet), iWARP
SR-IOV (Single Root I/O Virtualization):
SR-IOV allows a single physical NIC to present itself as multiple independent virtual NICs:
- Virtual Functions (VFs): Lightweight virtual NICs assigned directly to VMs
- Physical Function (PF): The full NIC with management capabilities
- Benefit: Near-native network performance for virtualized workloads
- Use case: Cloud providers, virtualized data centers
The latest evolution is the SmartNIC or DPU (Data Processing Unit)—NICs with embedded processors (ARM cores, FPGAs, or custom ASICs) capable of running network functions traditionally handled by the main CPU. These can implement firewalls, encryption, load balancing, and even container networking entirely in hardware, freeing the host CPU for application workloads.
NIC Configuration, Drivers, and Management
Effective network interface management requires understanding both the software interface (device drivers) and the configuration options that control NIC behavior. Proper configuration can significantly impact performance, reliability, and security.
Device Drivers: The Software Interface
The device driver is the critical software component that enables the operating system to communicate with the NIC hardware:
- Kernel module (Linux) or NDIS driver (Windows)
- Implements a standard interface that network stack uses
- Translates OS commands into hardware register operations
- Handles interrupts from the NIC
- Manages descriptor rings and buffer allocation
Key Driver Parameters:
12345678910111213141516171819202122232425262728293031323334
#!/bin/bash# Common NIC Configuration Commands (Linux) # View NIC informationethtool eth0 # Check link status and speedethtool eth0 | grep -E "Speed|Link detected" # View and modify ring buffer sizesethtool -g eth0 # Show current ring sizesethtool -G eth0 rx 4096 tx 4096 # Increase ring buffers # Enable/disable offload featuresethtool -K eth0 tso on # Enable TCP Segmentation Offloadethtool -K eth0 gso on # Enable Generic Segmentation Offloadethtool -K eth0 gro on # Enable Generic Receive Offloadethtool -K eth0 rx-checksumming on # Enable RX checksum offload # View current offload settingsethtool -k eth0 # Configure interrupt coalescing (reduce interrupt rate)ethtool -C eth0 rx-usecs 50 rx-frames 16 # View NIC statisticsethtool -S eth0 | head -50 # Check driver informationethtool -i eth0 # View and configure RSSethtool -x eth0 # Show RSS hash indirection tableethtool -X eth0 equal 4 # Distribute across 4 queues equallyCritical Configuration Parameters:
1. Ring Buffer Sizes
Ring buffers hold packet descriptors waiting to be processed:
- Too small: Packet drops during burst traffic
- Too large: Increased memory usage, potentially higher latency
- Default: Often 256-512; high-performance scenarios may use 2048-4096
2. Interrupt Coalescing
Controls how the NIC batches interrupts:
- Low values: Lower latency, higher CPU overhead
- High values: Higher latency, lower CPU overhead
- Adaptive: NIC adjusts based on traffic patterns
3. Flow Control (IEEE 802.3x PAUSE)
Allows congested receivers to signal senders to slow down:
- Enable for: Storage networks, lossless Ethernet requirements
- Disable for: Networks where pause propagation could cause problems
4. Maximum Transmission Unit (MTU)
- Standard: 1500 bytes (Ethernet default)
- Jumbo Frames: 9000 bytes (reduces per-packet overhead for bulk transfer)
- Consideration: All devices in path must support same MTU
NIC drivers should be kept up to date for security and performance. However, in production environments, test new drivers thoroughly before deployment. Driver bugs can cause complete network outages, packet corruption, or system instability. Many organizations maintain a validated driver version rather than always using the newest release.
Troubleshooting Network Interface Issues
Network interface problems can range from complete connectivity failure to subtle performance degradation. A systematic approach to troubleshooting, combined with understanding of NIC statistics, enables efficient problem resolution.
Common NIC Problems and Symptoms:
| Symptom | Possible Causes | Diagnostic Steps |
|---|---|---|
| No link (LED off) | Cable, port, or PHY failure | Check cable, try different port, verify switch port up |
| Link but no traffic | Driver, IP config, VLAN mismatch | Check driver status, verify IP, check switch VLAN |
| Intermittent connectivity | Duplex mismatch, cable quality | Force auto-neg, check for CRC errors, test cable |
| Slow performance | Offload disabled, ring buffer too small | Enable offloads, increase ring buffers, check CPU usage |
| Packet loss under load | Buffer exhaustion, CPU overload | Increase ring buffers, enable RSS, check for rx_dropped |
| High CPU during transfers | Offloads disabled, interrupt storm | Enable checksum/TSO offload, tune interrupt coalescing |
Key NIC Statistics to Monitor:
Modern NICs expose detailed statistics that reveal the health of the interface:
Physical Layer Issues:
rx_crc_errors: Frames received with invalid CRC (cable or PHY problem)rx_frame_errors: Frames with incorrect lengthrx_align_errors: Frames not aligned to byte boundaries
Buffer/Congestion Issues:
rx_dropped: Frames dropped due to ring buffer exhaustionrx_missed_errors: Frames missed due to lack of receive bufferstx_dropped: Frames that couldn't be queued for transmission
Collision Issues (half-duplex only):
collisions: Total collisions detectedtx_aborted_errors: Transmissions aborted due to excessive collisions
Performance Indicators:
rx_packets,tx_packets: Total frame countsrx_bytes,tx_bytes: Total data volume- Interrupt counts per queue (for RSS verification)
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
#!/bin/bash# NIC Diagnostic Script IFACE="${1:- eth0}" echo "=== NIC Diagnostics for $IFACE ==="echo # Basic link statusecho "--- Link Status ---"ip link show "$IFACE"ethtool "$IFACE" | grep - E "Speed|Duplex|Link detected|Auto-negotiation"echo # Error statisticsecho "--- Error Counters ---"ethtool - S "$IFACE" 2 > /dev/null | grep - iE "error|drop|miss|crc|collision" | head - 20echo # Ring buffer statusecho "--- Ring Buffers ---"ethtool - g "$IFACE"echo # Offload statusecho "--- Offload Features ---"ethtool - k "$IFACE" | grep - E "^(tcp|rx|tx|generic)" | head - 10echo # Interrupt distribution(RSS check)echo "--- Interrupt Distribution ---"grep "$IFACE" /proc/interrupts | head - 8echo # Driver informationecho "--- Driver Info ---"ethtool - i "$IFACE" # Quick health summaryRX_ERRORS=$(cat / sys / class/ net / $IFACE / statistics / rx_errors)TX_ERRORS=$(cat / sys / class/ net / $IFACE / statistics / tx_errors)RX_DROPPED=$(cat / sys / class/ net / $IFACE / statistics / rx_dropped) echoecho "--- Health Summary ---"if ["$RX_ERRORS" - gt 0] || ["$TX_ERRORS" - gt 0]; then echo "⚠ Errors detected: RX=$RX_ERRORS TX=$TX_ERRORS"else echo "✓ No errors detected"fi if ["$RX_DROPPED" - gt 0]; then echo "⚠ Dropped packets: $RX_DROPPED (consider increasing ring buffers)"else echo "✓ No dropped packets"fiOne of the most common and frustrating NIC issues is duplex mismatch—one side operates at full duplex while the other uses half duplex. The link appears up, but performance is terrible with high collision counts and packet loss. Always verify that auto-negotiation succeeds on both ends, or manually configure both sides to the same settings.
KEEP LEARNING
There’s more to understand.
You’re reading the introduction. Create a free account to read the complete lesson, save notes and keep track of your progress.