Skip to content

Gnoppix MTU Guide

Imagine your internet data is a bunch of pizzas being delivered from a pizzeria (the server/other side) to your house (your device).

Your delivery roads and your oven are totally fine. The problem is all about box sizes and extra stickers/sleeves!

Every home internet connection is different, so I can’t safely change your settings behind the scenes—you need to know what’s being adjusted. While automating this is technically possible, it would break the setup for a lot of people, so I won’t do it.


1. What happens when a VPN adds extra “packages” to the IP header?

Section titled “1. What happens when a VPN adds extra “packages” to the IP header?”

Every piece of data sent over the internet travels inside a packet (like a pizza box), and the IP header is like the shipping label and address tag on top of the box.

When you turn on a VPN, it wraps your original data box inside a bigger outer box (or adds extra layers/headers for encryption and routing).

  • Now the whole bundle takes up more space than before.
  • If the tunnel/pipe has a strict size limit for one trip, an oversized bundle won’t fit cleanly through in a single piece.

MTU (Maximum Transmission Unit) is basically the maximum box size that can fit through a network lane in one go without getting stuck or split up.

  • Suppose a lane can handle a box up to 1,500 units wide.
  • Your normal game or video packet is 1,460 units, plus a 40-unit IP label = 1,500 units (fits like a glove!).
  • Now add 80 units of VPN wrapping = 1,580 units (too big!).

When a packet is too big for the MTU:

  1. Fragmentation (chopping it up): The network might slice the big bundle into smaller pieces and glue them back together on the other side. That adds lag, extra work, and more chances for a piece to get lost.
  2. “Don’t Fragment” drops (getting bounced): Sometimes a packet is marked “Do not split this!” When it hits a spot with a smaller MTU, routers just throw it away and send back a “Too big!” message. If those messages get blocked (which happens surprisingly often), pages freeze, downloads stall, or games rubber-band even though your internet is actually fast.

3. Why can “everything look broken” when your internet is fine?

Section titled “3. Why can “everything look broken” when your internet is fine?”

This is the sneakiest part:

  • Your actual internet line is healthy: Your Wi-Fi signal is strong, your ISP isn’t down, and the website or game server on the other side is running smoothly (“everything is clean” on the other side).
  • One bad setting ruins the flow: Just like putting a too-wide box on a conveyor belt that jams at one narrow gate, a wrong MTU (or mismatched network setting) can block big packets—like web pages loading or game updates—while tiny pings or small messages might still sneak through. It makes it feel like your whole internet is broken, when really it’s just a sizing/tuning mismatch.

Thing Pizza / Delivery Analogy Real Networking
IP Header Address label & delivery instructions Routing info attached to each packet
VPN Extra Layer Extra protective outer sleeve/box Encryption + tunnel headers added around packets
MTU Widest box that fits through the doorway Max packet size (in bytes) a link can carry at once
Bad MTU Tuning Oversized boxes getting jammed or tossed Big packets getting dropped/fragmented, causing stalls or lag

Adjusting/lowering the MTU on your VPN or router gives that extra VPN wrapper room to fit inside the limit so packets glide through smoothly instead of getting stuck.

Slow or Stalling Uploads Over VPN — Generic Test & Fix Guide

Section titled “Slow or Stalling Uploads Over VPN — Generic Test & Fix Guide”

Who this is for: you upload a file with scp/rsync/curl -T from your machine through a VPN (WireGuard or similar) to a remote server and it is much slower than your line should be, or it stalls in bursts. Works on any Linux client; the server side matters too, so those checks are included.

Golden rule: measure each leg separately before changing anything. Most “VPN is slow” cases are one of exactly three problems:

  1. path MTU smaller than the interfaces claim (handshake stalls),
  2. policy/routing mess on the client (two tunnels fighting),
  3. uplink quality under sustained load (settings fine, line is the limit).

Here it becomes bit technical.

Slow or Stalling Uploads Over VPN — Generic Test & Fix Guide

Section titled “Slow or Stalling Uploads Over VPN — Generic Test & Fix Guide”

Who this is for: you upload a file with scp/rsync/curl -T from your machine through a VPN (WireGuard or similar) to a remote server and it is much slower than your line should be, or it stalls in bursts. Works on any Linux client; the server side matters too, so those checks are included.

Golden rule: measure each leg separately before changing anything. Most “VPN is slow” cases are one of exactly three problems:

  1. path MTU smaller than the interfaces claim (handshake stalls),
  2. policy/routing mess on the client (two tunnels fighting),
  3. uplink quality under sustained load (settings fine, line is the limit).

Terminal window
cd /tmp
curl -sS -O https://proof.ovh.net/files/100Mb.dat
head -c 10485760 100Mb.dat > 10Mb.dat # small-burst variant

Do not use /dev/zero guesses — use a known file so every leg tests the same bytes.


Terminal window
# download direction (server -> you)
time curl -sS -O https://proof.ovh.net/files/100Mb.dat
# upload direction, raw WAN, bypassing VPN policy routing:
# -B forces the socket onto the physical interface (works with scp/rsync/ssh)
time scp -B eth0 -q /tmp/100Mb.dat user@nearest-server:/tmp/

Read the numbers as MB/s x 8 = Mbit (12.5 MB/s ≈ 100 Mbit). Pick the closest remote server for the upload test — a far target mixes line limits with path loss.

Typical truths this exposes:

  • download fast, upload slow → uplink or ISP asymmetry, not VPN.
  • both fine raw, bad only via VPN → the VPN layer (continue to §3/§4).

2. Find the real path MTU (this is where handshake stalls come from)

Section titled “2. Find the real path MTU (this is where handshake stalls come from)”

The kernel advertises MSS from the interface MTU (usually 1500). If any hop on your path is smaller (PPPoE = 1492, ISP/GRE/IPsec tunnels 1480–1492, double-NAT CGNAT 1476+), full-size DF packets get silently dropped. SSH dies at the key exchange; scp dies right after “Connection closed” / long preauth stalls.

Binary-search with DF pings from the physical interface:

Terminal window
for sz in 1472 1444 1436 1400; do
echo -n "MTU $((sz+28)): "
ping -I eth0 -c 3 -M do -s $sz <gateway-or-server-IP> 2>&1 | tail -2 | head -1
done
  • 1472 payload = 1500-byte packet. Loss at 1500 but 0% at 1492 → your path MTU is ~1492 (PPPoE signature). 100% loss at 1500 with no ICMP errors returned = PMTU discovery is blackholed — the worst case, and the usual one.
  • Test toward both your VPN gateway and your final target; asymmetry is normal.

Fix (client): set the physical interface to the measured value, e.g.:

Terminal window
sudo ip link set eth0 mtu 1492 # until reboot
sudo nmcli con modify "<your wired connection>" 802-3-ethernet.mtu 1492 # persistent

Symptoms this fixes: ssh to servers timing out mid-handshake, scp: Connection closed after seconds, small transfers OK but any bulk transfer stalls instantly.


WireGuard adds ~70–80 bytes per packet (outer IP 20 + UDP 8 + wg header/padding). The tunnel MTU must satisfy: tunnel_MTU + 80 <= path_MTU.

measured path MTU safe wg MTU
1500 1420
1492 1400–1412
1480 1400
CGNAT ~1476 1396
Terminal window
# NetworkManager-managed profile
nmcli con list | grep wireguard
sudo nmcli con modify "<profile>" wireguard.mtu 1400
sudo nmcli con up "<profile>"
# wg-quick config: set MTU = 1400 in [IF] section

Note: 1420 is the common default and is wrong on a 1492 line — its outer packets sit exactly on the drop edge. Getting this right removes stalls, but it will NOT make a bad sustained uplink fast. If only MTU was wrong, uploads go from “stalls after 1MB” to “steady if the line can sustain it”.


4. Check for routing/tunnel mess on the client

Section titled “4. Check for routing/tunnel mess on the client”

Two full-tunnel VPNs on one machine fight each other and kill long transfers mid-stream (connections egress from different gateways at different times).

Terminal window
ip rule # look for stale rules, [detached] devices, leftovers
sudo wg show # how many wg interfaces actually exist/handshaked?
ip -brief link | grep -viE "veth|docker|br-"
ip route get <target-IP> # which table/dev wins for THIS destination?
  • Expect exactly ONE full-tunnel active. Verify the egress IP on the far side (server auth.log, or curl https://api.ipify.org) is consistent — mixed source IPs in logs = tunnel flapping = your “sometimes stalls”.
  • Delete/disable the duplicate profile; some VPN clients leave policy-routing rules and empty tables behind after disconnect — reboot or clean the rules.

5. Look at the far end during a transfer (names the real cause)

Section titled “5. Look at the far end during a transfer (names the real cause)”

Start a bulk upload, then on the destination server:

Terminal window
ss -tn state established '( dport = :22 or sport = :22 )' -ti

Read the flow block:

what you see what it means
cwnd:2..23 pinned, retrans:... climbing, rcv_ooopack: thousands real loss + reordering bursts on the long path — uplink/line issue, MTU won’t fix
unacked: stuck while bytes freeze return ACKs lost — path problem in the reverse direction
stalls only above ~1MB transferred, MTU probe (§2) failed PMTUD blackhole — apply §2/§3
healthy cwnd growth, steady delivery_rate network is fine; app/protocol issue (check disk, sshd, scp vs rsync)

Also worth a cheap cross-check between two remote servers (no home line involved): scp server A → server B. If A→B is fast, your home uplink is the constraint, not the VPN.


Terminal window
time scp -q /tmp/10Mb.dat user@host:/tmp/ # burst: 1-3s expected on a good line
time scp -q /tmp/100Mb.dat user@host:/tmp/ # sustained: watch for collapse after the first ~20MB

Burst fine, sustained collapses to single-digit Mbit with stall windows of 0 bytes = uplink policing or loss under sustained load. No client setting fixes this; the workaround is structure:

  • rsync -P --partial instead of scp (resumable, survives the stalls),
  • two-hop transfer: upload to the nearest gateway fast, relay onward there,
  • split into ~100MB chunks for very large sets.

Terminal window
mtu-check.sh

mtu-check.sh is a gnoppix-tool which is in the gnoppix included. if you can not find it, please update your system.

Example1:

My network card MTU is set to 1500 in my VPN connection settings. Check gnoppixctl -> edit profile ! mine is set to 1412

Terminal window
mtu-check.sh
== Interfaces ==
physical eth0 mtu 1500
wg gnoppix-us mtu 1412
== Measured path MTU (DF ping, via eth0) ==
1.1.1.1 path MTU 1492
8.8.8.8 path MTU 1492
== Verdict / suggested values ==
worst measured path MTU : 1492
suggested physical MTU : 1492 (1500 on a smaller path = handshake stalls)
suggested wg MTU : 1412 (= path 1492 - 80 overhead)
eth0: mtu 1500 too high -> sudo ip link set eth0 mtu 1492
persist: sudo nmcli con modify "$(nmcli -t -f NAME,DEVICE con show --active | awk -F: -v d=eth0 '$2==d{print $1}')" 802-3-ethernet.mtu 1492
gnoppix-us: wg mtu 1412 OK (<= suggested 1412)
Note: path MTU is measured via eth0; re-run per target (gateway AND final server), asymmetry is normal.
Note: measured path == your interface MTU means the NIC itself is now the cap (raise it and re-test if suspicious).

Example2:

My network card MTU is set to 1492 in my VPN connection settings. Check gnoppixctl -> edit profile ! mine is set to 1412

Terminal window
mtu-check.sh
== Interfaces ==
physical eth0 mtu 1492
wg gnoppix-us mtu 1412
== Measured path MTU (DF ping, via eth0) ==
1.1.1.1 path MTU 1492
8.8.8.8 path MTU 1492
== Verdict / suggested values ==
worst measured path MTU : 1492
suggested physical MTU : 1492 (1500 on a smaller path = handshake stalls)
suggested wg MTU : 1412 (= path 1492 - 80 overhead)
eth0: mtu 1492 OK (<= path 1492)
gnoppix-us: wg mtu 1412 OK (<= suggested 1412)
all current MTUs already fit the measured path - nothing to change.
Note: path MTU is measured via eth0; re-run per target (gateway AND final server), asymmetry is normal.
Note: measured path == your interface MTU means the NIC itself is now the cap (raise it and re-test if suspicious).

symptom cause adjustment
ssh/scp hang before/at handshake, Connection closed in ~1-15s path MTU < 1500 + blackholed PMTU NIC MTU = measured (§2), tunnel MTU = path − 80 (§3)
mixed egress IPs, transfers die mid-stream two tunnels / stale policy rules one tunnel only, clean ip rule leftovers (§4)
bursts fast, sustained streams crawl uplink loss bursts / ISP shaping nothing to “fix” — rsync/resume, two-hop, chunks (§6); consider ISP/path
raw (no VPN) already slow line itself measure at ISP, compare ISPs/directions; no VPN setting helps

After changes, re-run §1 and §6 and compare — the numbers before/after are the deliverable, not a feeling of smoothness.