Configure MTU Recalculation on Network Change

Applies To: Accops Workspace Windows Client 7.2.0.1040 and above

Category: Network & Performance

Feature Status: Stable

Overview

This guide explains how to configure and optimize MTU (Maximum Transmission Unit) recalculation on network change for Accops Workspace Windows Client. This enhancement enables automatic MTU recalculation when network changes are detected, maintaining optimal connection performance and stability during network transitions. Previous client versions calculated MTU only during initial gateway login, but the latest version continuously monitors network changes and dynamically adjusts MTU values to ensure optimal packet size for current network conditions.

Prerequisites

Gateway Version: HySecure Gateway 5.4 SP6 or HySecure Gateway 7.0 (Build 651) and above
Client Version: Accops Workspace Windows Client 7.2.0.1040 or higher
Administrative Access: Local Administrator privileges for network configuration optimization
Network Knowledge: Understanding of MTU concepts, network fragmentation, and performance optimization
Network Monitoring Tools: Access to network monitoring and diagnostic tools for performance validation
Knowledge Requirement: Understanding of TCP/IP networking, packet fragmentation, and network performance optimization principles

Benefits

Improved Network Performance: Automatic MTU optimization ensures optimal packet size for current network conditions without manual intervention
Enhanced Connection Stability: Prevents connection drops and performance degradation during network transitions and changes
Mobile User Support: Seamless experience for users switching between different network environments (WiFi, cellular, VPN, etc.)
Reduced Network Issues: Eliminates fragmentation-related performance problems and connection instabilities caused by MTU mismatches

MTU Fundamentals

Understanding MTU

Maximum Transmission Unit (MTU) Definition:

Description: Largest packet size that can be transmitted over a network link without fragmentation
Typical Values: Ethernet: 1500 bytes, PPPoE: 1492 bytes, VPN tunnels: 1436-1460 bytes
Impact on Performance: Optimal MTU reduces fragmentation overhead and improves network efficiency
Fragmentation Issues: Incorrect MTU causes packet fragmentation, reducing performance and increasing latency

Network Path MTU Discovery:

Path MTU: Smallest MTU along entire network path from source to destination
Discovery Process: Automatic detection of optimal MTU through network path analysis
Dynamic Adjustment: Real-time adjustment based on current network path characteristics
Performance Benefits: Prevents fragmentation and optimizes data transmission efficiency

Network Change Scenarios

Common Network Transition Scenarios:

WiFi to Cellular: Switching from office WiFi to mobile data connection
VPN Connection/Disconnection: Establishing or terminating VPN tunnels with different MTU requirements
Network Roaming: Moving between different WiFi networks with varying MTU configurations
Wired to Wireless: Transitioning between Ethernet and wireless connections

MTU Impact During Network Changes:

Connection Drops: Incorrect MTU can cause connection failures during network transitions
Performance Degradation: Suboptimal MTU reduces throughput and increases latency
Application Timeouts: Large packets may fail to transmit, causing application timeouts
User Experience Impact: Network changes result in poor user experience without automatic MTU adjustment

Platform Support

Client Mode	Windows 8/8.1	Windows 10/11	Server 2016-2025	Support Level
Full Admin Client	Yes	Yes	Yes	Full Support
HyBrid Mode	Yes	Yes	Yes	Full Support
HyLite Mode	No	No	No	Not Supported
On-Demand Client	Yes	Yes	Yes	Full Support

Procedure Part 1: MTU Optimization Configuration

Step 1: Network Environment Assessment

Current Network Analysis
Network Infrastructure Mapping: Document current network infrastructure including routers, switches, and gateway configurations
MTU Value Discovery: Identify current MTU values across different network segments and connections
Performance Baseline: Establish baseline network performance metrics before MTU optimization
Fragmentation Analysis: Analyze current packet fragmentation patterns and performance impact
Network Path Analysis ```powershell # Discover Path MTU to gateway server $GatewayAddress = "gateway.company.com"

# Test different packet sizes to find optimal MTU for ($size = 1472; $size -ge 1200; $size -= 8) { $result = ping $GatewayAddress -f -l $size -n 1 if ($result -match "Reply from") { Write-Host "Optimal MTU discovered: $($size + 28) bytes" break } }

# Alternative using PowerShell Test-NetConnection Test-NetConnection -ComputerName $GatewayAddress -DiagnoseRouting ```

Mobile Network Considerations
Cellular Network MTU: Document typical MTU values for cellular network providers
WiFi Network Variations: Catalog MTU values for different WiFi networks in organization
VPN Tunnel Overhead: Calculate MTU reduction for various VPN tunnel types
Network Provider Differences: Document MTU variations between different network providers

Step 2: Client-Side MTU Configuration

Automatic MTU Recalculation Enablement
Feature Activation: MTU recalculation is automatically enabled in Workspace Client 7.2.0.1040 and above
No Manual Configuration: No additional client-side configuration required for basic functionality
Network Change Detection: Client automatically detects network interface changes and triggers MTU recalculation
Performance Monitoring: Client continuously monitors connection performance and adjusts MTU as needed
Network Interface Monitoring ```powershell # Monitor network interface changes Get-WmiObject -Class Win32_NetworkAdapter | Where-Object {$_.NetEnabled -eq $true} | Select-Object Name, InterfaceIndex, Speed

# Check current MTU settings Get-NetIPInterface | Select-Object InterfaceAlias, InterfaceIndex, NlMtu

# Monitor network connectivity changes Register-WmiEvent -Query "SELECT * FROM Win32_VolumeChangeEvent WHERE EventType = 2" -Action { Write-Host "Network change detected at $(Get-Date)" } ```

Advanced MTU Configuration (If Required) ```powershell # Set specific MTU for network interface (administrative override) $InterfaceAlias = "WiFi" $OptimalMTU = 1450

# Configure MTU for specific interface Set-NetIPInterface -InterfaceAlias $InterfaceAlias -NlMtuBytes $OptimalMTU

# Verify MTU configuration Get-NetIPInterface -InterfaceAlias $InterfaceAlias | Select-Object InterfaceAlias, NlMtu ```

Step 3: Gateway Configuration Coordination

Gateway MTU Settings
No Additional Configuration: No new gateway configuration required for MTU recalculation feature
Existing MTU Policies: Maintain existing gateway MTU policies and configurations
Performance Monitoring: Monitor gateway performance during client MTU adjustments
Load Balancing Impact: Consider MTU impact on gateway load balancing and failover scenarios
Network Infrastructure Coordination
Router Configuration: Ensure routers support Path MTU Discovery (PMTUD)
Firewall Settings: Configure firewalls to allow ICMP fragmentation needed messages
Load Balancer Configuration: Verify load balancers properly handle variable MTU sizes
Network Monitoring: Implement monitoring for MTU-related network performance issues

Network Optimization Strategies

Performance Optimization Techniques

MTU Size Optimization:

# Function to test optimal MTU for specific destination
function Test-OptimalMTU {
    param(
        [string]$Destination,
        [int]$StartSize = 1472,
        [int]$MinSize = 1200
    )

    Write-Host "Testing optimal MTU for $Destination"

    for ($size = $StartSize; $size -ge $MinSize; $size -= 8) {
        $pingResult = ping $Destination -f -l $size -n 1 -w 1000

        if ($pingResult -match "Reply from") {
            $optimalMTU = $size + 28  # Add IP and ICMP headers
            Write-Host "Optimal MTU: $optimalMTU bytes (payload: $size bytes)"
            return $optimalMTU
        }
        elseif ($pingResult -match "fragmentation needed") {
            Write-Host "Fragmentation required at size: $size"
        }
    }

    Write-Warning "Could not determine optimal MTU for $Destination"
    return $null
}

# Test multiple gateways
$gateways = @("gateway1.company.com", "gateway2.company.com")
foreach ($gateway in $gateways) {
    Test-OptimalMTU -Destination $gateway
}

Network Performance Monitoring:

# Monitor network performance metrics
function Monitor-NetworkPerformance {
    param([int]$Duration = 300)  # 5 minutes

    $startTime = Get-Date
    $endTime = $startTime.AddSeconds($Duration)

    Write-Host "Starting network performance monitoring..."

    while ((Get-Date) -lt $endTime) {
        # Test connectivity and response time
        $pingResult = Test-NetConnection -ComputerName "gateway.company.com" -Port 443

        if ($pingResult.TcpTestSucceeded) {
            Write-Host "$(Get-Date): Connection successful - RTT: $($pingResult.PingReplyDetails.RoundtripTime)ms"
        } else {
            Write-Warning "$(Get-Date): Connection failed"
        }

        Start-Sleep -Seconds 30
    }
}

Mobile User Optimization

Network Transition Scenarios:

WiFi to Cellular Handoff: Optimize MTU during transition from WiFi (1500 MTU) to cellular (1428-1460 MTU)
VPN Establishment: Adjust MTU when VPN tunnels are established with overhead considerations
Public WiFi Connections: Handle varying MTU configurations across different public WiFi networks
Network Roaming: Maintain performance during movement between different network coverage areas

Adaptive MTU Strategies:

# Adaptive MTU configuration based on network type
function Set-AdaptiveMTU {
    $networkProfiles = Get-NetConnectionProfile

    foreach ($profile in $networkProfiles) {
        switch ($profile.NetworkCategory) {
            "DomainAuthenticated" {
                # Corporate network - use standard MTU
                $targetMTU = 1500
            }
            "Private" {
                # Home network - conservative MTU
                $targetMTU = 1460
            }
            "Public" {
                # Public network - smaller MTU for compatibility
                $targetMTU = 1428
            }
        }

        # Apply MTU setting to active interfaces
        $activeInterfaces = Get-NetIPInterface | Where-Object {$_.ConnectionState -eq "Connected"}
        foreach ($interface in $activeInterfaces) {
            Set-NetIPInterface -InterfaceIndex $interface.InterfaceIndex -NlMtuBytes $targetMTU
            Write-Host "Set MTU to $targetMTU for interface: $($interface.InterfaceAlias)"
        }
    }
}

Configuration Examples

Example 1: Corporate Mobile Workforce

Configuration:

Network Environment: Mixed WiFi, cellular, and VPN connections
MTU Strategy: Automatic recalculation with conservative defaults
Mobile Device Optimization: Optimized for laptop and mobile device users
Performance Priority: Balance between performance and compatibility
Monitoring: Comprehensive network performance monitoring

Use Case: Large corporation with mobile workforce frequently changing network connections

Benefits: Seamless network transitions with optimal performance across different connection types

Example 2: High-Performance Technical Environment

Configuration:

Network Environment: High-speed dedicated connections with optimized infrastructure
MTU Strategy: Aggressive MTU optimization for maximum performance
Jumbo Frame Support: Utilize jumbo frames where supported (9000 byte MTU)
Performance Priority: Maximum throughput and minimum latency
Monitoring: Detailed performance analytics and optimization

Use Case: Technical environments requiring maximum network performance (CAD, video editing, data analysis)

Benefits: Maximum network performance with automatic optimization for changing conditions

Example 3: Mixed Infrastructure Enterprise

Configuration:

Network Environment: Legacy and modern network infrastructure with varying MTU support
MTU Strategy: Conservative MTU values for maximum compatibility
Compatibility Priority: Ensure functionality across all network segments
Performance Monitoring: Focus on connectivity stability over maximum performance
Troubleshooting: Enhanced diagnostics for MTU-related issues

Use Case: Enterprises with mixed legacy and modern network infrastructure

Benefits: Reliable connectivity across diverse network infrastructure with automatic adjustment capabilities

Verification and Testing

MTU Performance Testing

Baseline Performance Measurement ```powershell # Measure network performance before MTU optimization function Measure-NetworkBaseline { param([string]$TargetHost = "gateway.company.com")

Write-Host "Measuring baseline network performance..."

# Test various packet sizes $packetSizes = @(64, 128, 256, 512, 1024, 1472) $results = @()

foreach ($size in $packetSizes) { $pingResults = ping $TargetHost -l $size -n 10 $avgTime = ($pingResults | Where-Object {$_ -match "Average = (\d+)ms"} | ForEach-Object {int})
```
   $results += [PSCustomObject]@{
       PacketSize = $size
       AverageRTT = $avgTime
   }
```
}

return $results } ```
MTU Optimization Validation
Performance Comparison: Compare network performance before and after MTU optimization
Fragmentation Analysis: Verify elimination of packet fragmentation
Throughput Testing: Measure data transfer rates with optimized MTU values
Latency Measurement: Confirm reduced latency with proper MTU configuration
Network Change Simulation ```powershell # Simulate network changes and test MTU recalculation function Test-NetworkChangeResponse { Write-Host "Testing network change response..."

# Disable and enable network adapter to simulate network change $adapter = Get-NetAdapter | Where-Object {$_.Status -eq "Up"} | Select-Object -First 1

Write-Host "Disabling adapter: $($adapter.Name)" Disable-NetAdapter -Name $adapter.Name -Confirm:$false Start-Sleep -Seconds 5

Write-Host "Re-enabling adapter: $($adapter.Name)" Enable-NetAdapter -Name $adapter.Name Start-Sleep -Seconds 10

# Test connectivity and MTU after change $newMTU = Get-NetIPInterface -InterfaceAlias $adapter.Name | Select-Object -ExpandProperty NlMtu Write-Host "MTU after network change: $newMTU"

# Test connectivity Test-NetConnection -ComputerName "gateway.company.com" -Port 443 } ```

Real-World Testing Scenarios

WiFi Network Switching
Test Procedure: Switch between different WiFi networks with varying MTU configurations
Validation Points: Verify automatic MTU recalculation and performance optimization
Expected Results: Seamless connectivity with optimal performance on each network
Performance Metrics: Measure connection establishment time and data transfer rates
VPN Connection Testing
Test Procedure: Establish and disconnect VPN connections while monitoring MTU changes
Validation Points: Confirm MTU adjustment for VPN tunnel overhead
Expected Results: Proper MTU reduction for VPN tunnels without fragmentation
Performance Metrics: Compare performance with and without VPN connection
Cellular Network Handoff
Test Procedure: Transition from WiFi to cellular network connection
Validation Points: Verify MTU adjustment for cellular network characteristics
Expected Results: Maintained connectivity with optimized performance on cellular
Performance Metrics: Monitor connection stability and data transfer performance

Monitoring and Logging

MTU-Related Event Logging:

Network Change Detection: Log network interface changes and MTU recalculation events
Performance Metrics: Track network performance before and after MTU adjustments
Fragmentation Events: Monitor and log packet fragmentation incidents
Connection Stability: Log connection drops and performance degradation events

Performance Monitoring:

# Continuous MTU and performance monitoring
function Start-MTUMonitoring {
    param([int]$IntervalSeconds = 60)

    Write-Host "Starting MTU monitoring (interval: $IntervalSeconds seconds)"

    while ($true) {
        $timestamp = Get-Date
        $interfaces = Get-NetIPInterface | Where-Object {$_.ConnectionState -eq "Connected"}

        foreach ($interface in $interfaces) {
            $mtu = $interface.NlMtu
            $alias = $interface.InterfaceAlias

            # Test connectivity
            $connectivity = Test-NetConnection -ComputerName "gateway.company.com" -Port 443 -InformationLevel Quiet

            Write-Host "$timestamp - Interface: $alias, MTU: $mtu, Connected: $connectivity"
        }

        Start-Sleep -Seconds $IntervalSeconds
    }
}

Key Performance Indicators:

MTU Optimization Success Rate: Percentage of successful MTU recalculations
Network Transition Performance: Time required for MTU adjustment during network changes
Connection Stability Metrics: Connection drop rates and recovery times
User Experience Impact: User-reported connectivity issues and performance complaints

Security Considerations

Network Security Impact

MTU and Security:

Packet Inspection: Consider impact of variable MTU on network security device packet inspection
Intrusion Detection: Ensure IDS/IPS systems properly handle variable packet sizes
Firewall Configuration: Verify firewall rules accommodate different MTU values
DDoS Protection: Consider MTU impact on distributed denial of service protection mechanisms

PMTUD Security:

ICMP Security: Ensure ICMP messages required for Path MTU Discovery are not blocked by security devices
Man-in-the-Middle Protection: Protect against PMTUD manipulation attacks
Network Monitoring: Monitor for suspicious MTU-related network behavior
Access Control: Implement appropriate access controls for MTU configuration changes

Configuration Security

Administrative Controls:

Change Management: Implement formal change management for MTU-related network configurations
Access Restrictions: Limit MTU configuration capabilities to authorized network administrators
Audit Trail: Maintain comprehensive audit trails of MTU configuration changes
Security Testing: Include MTU-related testing in security vulnerability assessments

Network Infrastructure Security:

Router Security: Ensure routers supporting PMTUD are properly secured and updated
Switch Configuration: Verify switch configurations properly handle variable MTU sizes
Gateway Security: Confirm gateway security settings accommodate MTU optimization features
Monitoring Security: Secure network monitoring systems collecting MTU-related performance data

Troubleshooting

Common Issues:

MTU Recalculation Not Working:

Issue: Client does not automatically recalculate MTU when network changes are detected
Check: Verify client version is 7.2.0.1040 or higher with MTU recalculation support
Verify: Confirm network change detection is functioning by monitoring network interface events
Solution: Restart client application or manually trigger network interface reset
Prevention: Ensure client software is updated and network interface drivers are current

Performance Degradation After Network Change:

Issue: Network performance decreases after switching networks despite MTU recalculation
Check: Verify optimal MTU value has been calculated correctly for new network
Verify: Confirm no packet fragmentation is occurring with current MTU setting
Solution: Manually test and configure optimal MTU value for problematic network
Prevention: Implement comprehensive network performance monitoring and alerting

Connectivity Issues During Network Transitions:

Issue: Temporary connectivity loss or application timeouts during network changes
Check: Monitor MTU recalculation timing and network transition process
Verify: Confirm applications properly handle temporary network interruptions
Solution: Adjust application timeout settings or implement connection retry logic
Prevention: Optimize network transition procedures and user training

Inconsistent MTU Values Across Interfaces:

Issue: Different network interfaces showing different MTU values causing connectivity problems
Check: Verify MTU configuration across all active network interfaces
Verify: Confirm routing table and interface priorities are properly configured
Solution: Standardize MTU values across interfaces or implement interface-specific optimization
Prevention: Establish MTU configuration standards and monitoring procedures

Diagnostic Steps

Network Diagnostics:

# Comprehensive network and MTU diagnostics
function Test-NetworkMTUDiagnostics {
    Write-Host "=== Network MTU Diagnostics ==="

    # Check current network interfaces and MTU values
    Write-Host "`nCurrent Network Interfaces:"
    Get-NetIPInterface | Where-Object {$_.ConnectionState -eq "Connected"} | 
        Select-Object InterfaceAlias, InterfaceIndex, NlMtu, Dhcp | Format-Table

    # Test Path MTU to gateway
    Write-Host "`nTesting Path MTU to gateway..."
    $gateway = "gateway.company.com"

    # Test different packet sizes
    $testSizes = @(1472, 1460, 1428, 1400, 1200)
    foreach ($size in $testSizes) {
        $result = ping $gateway -f -l $size -n 1 -w 2000
        if ($result -match "Reply from") {
            Write-Host "Packet size $size bytes: SUCCESS"
            break
        } else {
            Write-Host "Packet size $size bytes: FAILED"
        }
    }

    # Check routing table
    Write-Host "`nCurrent routing table:"
    Get-NetRoute | Where-Object {$_.DestinationPrefix -eq "0.0.0.0/0"} | 
        Select-Object InterfaceAlias, NextHop, RouteMetric | Format-Table

    # Test connectivity to gateway
    Write-Host "`nTesting gateway connectivity:"
    Test-NetConnection -ComputerName $gateway -Port 443
}

Performance Analysis:

# Analyze network performance and MTU efficiency
function Analyze-MTUPerformance {
    param([string]$TargetHost = "gateway.company.com")

    Write-Host "Analyzing MTU performance for $TargetHost"

    # Get current MTU
    $currentMTU = Get-NetIPInterface | Where-Object {$_.ConnectionState -eq "Connected"} | 
                  Select-Object -First 1 -ExpandProperty NlMtu

    Write-Host "Current MTU: $currentMTU bytes"

    # Test performance with different payload sizes
    $payloadSizes = @(100, 500, 1000, ($currentMTU - 28))

    foreach ($size in $payloadSizes) {
        Write-Host "`nTesting payload size: $size bytes"

        # Measure round-trip time
        $pingResults = ping $TargetHost -l $size -n 10
        $avgTime = $pingResults | Where-Object {$_ -match "Average = (\d+)ms"} | 
                   ForEach-Object {if ($matches) {[int]$matches[1]} else {$null}}

        if ($avgTime) {
            Write-Host "Average RTT: ${avgTime}ms"
        } else {
            Write-Host "Failed to get RTT measurement"
        }
    }
}

Event Log Analysis:

# Check Windows event logs for network-related events
function Check-NetworkEventLogs {
    Write-Host "Checking network-related event logs..."

    # Check system log for network events
    $networkEvents = Get-WinEvent -FilterHashtable @{LogName='System'; ID=4202,4201,4200} -MaxEvents 50

    if ($networkEvents) {
        Write-Host "Recent network interface events:"
        $networkEvents | Select-Object TimeCreated, Id, LevelDisplayName, Message | 
            Format-Table -Wrap
    }

    # Check for TCP/IP events
    $tcpEvents = Get-WinEvent -FilterHashtable @{LogName='System'; ProviderName='Tcpip'} -MaxEvents 20

    if ($tcpEvents) {
        Write-Host "`nRecent TCP/IP events:"
        $tcpEvents | Select-Object TimeCreated, Id, LevelDisplayName, Message | 
            Format-Table -Wrap
    }
}

Advanced Configuration

Enterprise Network Optimization

Network-Wide MTU Standardization:

# Enterprise MTU standardization script
function Set-EnterpriseMTUStandards {
    param(
        [hashtable]$NetworkMTUMap = @{
            "Corporate WiFi" = 1500
            "Guest WiFi" = 1460
            "VPN Connection" = 1436
            "Cellular" = 1428
        }
    )

    Write-Host "Applying enterprise MTU standards..."

    # Get current network profile
    $currentProfile = Get-NetConnectionProfile | Where-Object {$_.IPv4Connectivity -eq "Internet"}

    foreach ($profile in $currentProfile) {
        $networkName = $profile.Name
        $recommendedMTU = $NetworkMTUMap[$networkName]

        if ($recommendedMTU) {
            Write-Host "Setting MTU to $recommendedMTU for network: $networkName"

            # Apply MTU to all connected interfaces
            $interfaces = Get-NetIPInterface | Where-Object {$_.ConnectionState -eq "Connected"}
            foreach ($interface in $interfaces) {
                Set-NetIPInterface -InterfaceIndex $interface.InterfaceIndex -NlMtuBytes $recommendedMTU
            }
        }
    }
}

Automated Performance Optimization:

# Automated MTU optimization based on network conditions
function Optimize-NetworkMTU {
    param([string]$GatewayHost = "gateway.company.com")

    Write-Host "Starting automated MTU optimization..."

    # Discover optimal MTU
    $optimalMTU = Test-OptimalMTU -Destination $GatewayHost

    if ($optimalMTU) {
        # Apply optimal MTU to active interfaces
        $activeInterfaces = Get-NetIPInterface | Where-Object {$_.ConnectionState -eq "Connected"}

        foreach ($interface in $activeInterfaces) {
            Write-Host "Applying optimal MTU ($optimalMTU) to interface: $($interface.InterfaceAlias)"
            Set-NetIPInterface -InterfaceIndex $interface.InterfaceIndex -NlMtuBytes $optimalMTU
        }

        # Verify optimization
        Start-Sleep -Seconds 5
        Test-NetConnection -ComputerName $GatewayHost -Port 443
    }
}

Integration with Network Management Systems

SNMP Integration:

MTU Monitoring: Monitor MTU values across network infrastructure via SNMP
Performance Correlation: Correlate MTU settings with network performance metrics
Automated Alerting: Generate alerts for MTU mismatches or performance degradation
Trend Analysis: Analyze MTU optimization trends and effectiveness over time

Network Automation:

# Integration with network automation systems
function Register-MTUAutomation {
    # Register for network change events
    $action = {
        Write-Host "Network change detected - triggering MTU optimization"
        Optimize-NetworkMTU
    }

    # Monitor network adapter changes
    Register-WmiEvent -Query "SELECT * FROM Win32_NetworkAdapterConfiguration" -Action $action

    # Monitor IP address changes
    Register-WmiEvent -Query "SELECT * FROM Win32_IP4RouteTableEvent" -Action $action

    Write-Host "MTU automation registered for network changes"
}

Note

Automatic Feature: MTU recalculation is automatically enabled in Workspace Client 7.2.0.1040 and above - no manual configuration required
Platform Limitations: MTU recalculation not supported for HyLite mode - Full Admin Client, HyBrid mode, and On-Demand Client supported
Network Dependencies: Feature effectiveness depends on network infrastructure supporting Path MTU Discovery (PMTUD)
Performance Impact: MTU recalculation may cause brief connectivity interruptions during network transitions