linux ↗

My PC Uploaded 196 GB to "Netflix". I Don't Have Netflix.

How a runaway speed test quietly uploaded 196 GB from my Linux desktop, how I tracked it down with per-process network monitoring, and the 4-line fix I sent upstream to Omarchy.

My PC Uploaded 196 GB to "Netflix". I Don't Have Netflix.

One morning I noticed something off with my home network, so I asked a simple question: is anything on this machine uploading or downloading a lot right now?

The live answer was boring: a few KB/s, mostly Claude Code, Spotify, Slack and my browser idling. But the interface counters told a different story:

$ awk '/enp0s31f6/{printf "down %.2f GB  up %.2f GB\n",$2/2^30,$10/2^30}' /proc/net/dev
down 148.27 GB  up 195.97 GB

$ uptime -p
up 2 days, 18 hours, 34 minutes

196 GB uploaded in under three days. On a desktop that mostly runs an editor, a browser and a terminal.

My router's traffic analyzer had an answer too: the traffic was "Netflix". There's just one problem: we don't have Netflix.

Part 1: Hunting a process that no longer exists

The frustrating thing about Linux is that it doesn't keep per-process network history. /proc/net/dev tells you how much went through the interface, and ss -tupn tells you who's connected right now, but nothing tells you who sent 196 GB yesterday.

So I started eliminating suspects (with Claude Code doing most of the legwork):

  • Per-process I/O counters (/proc/<pid>/io): the biggest live writers were my status bar (polling /proc, not network), a Codex daemon and the browser, adding up to maybe 15–20 GB, and that number includes disk and pipe I/O too.
  • Tailscale: not an exit node, no advertised routes, about 2 MB total on tailscale0.
  • Docker, VMs, sync tools, torrents: nothing running.
  • Shell history: no rsync, scp, rclone, docker push, cloud CLIs.
  • Large new files: none since boot.
  • Unknown processes, cron jobs, autostart entries: nothing suspicious.
  • Current connections: Anthropic, Google, GitHub, Cloudflare, Microsoft, AWS (Slack). No Netflix anywhere.

At 196 GB over ~2.75 days, the average was about 6.6 Mbit/s of continuous upload. That's not "someone uploaded a big file once". It looks more like a stream or a loop.

I also assumed the router's "Netflix" label was a misclassification. Consumer routers guess app names from IP ranges, and Netflix runs on AWS and big CDNs. Upload traffic labelled as a streaming service felt like a classic false positive.

That assumption turned out to be wrong, but I didn't know that yet.

Part 2: Install monitoring so it can't hide again

Since I couldn't reconstruct the past, I set up tools to catch the next occurrence:

Tool What it gives you
picosnitch A BPF daemon that logs bytes sent/received per executable and per remote host into SQLite. This is the important one.
vnstat Hourly/daily totals per interface, to see when a spike happened
nethogs Live per-process bandwidth view

On Arch / Omarchy:

sudo pacman -S --needed nethogs vnstat
yay -S picosnitch            # review the PKGBUILD first
sudo systemctl enable --now vnstat picosnitch

picosnitch's database lives at /var/lib/picosnitch/picosnitch.db and is world-readable, so I wrapped it in a small Python curses TUI, nettop-report, with three views:

  • Processes: total / upload / download per program, plus the last-minute rate
  • Destinations: which process talked to which host, and how much
  • Timeline: upload/download bars per time bucket, to spot when a spike happened

Two details worth knowing if you query picosnitch yourself:

  • Group by executables.exe, not name. name is often a thread name like Socket Thread or tokio-rt-worker.
  • Domains are stored reversed (com.anthropic.api), so flip them back for display.

Part 3: Caught in the act

A few hours later I glanced at running processes and saw this:

curl -fsS -o /dev/null -X POST --data-binary @- \
  https://ipv4-c029-maa001-ix.1.oca.nflxvideo.net/speedtest?...

Five of them. oca.nflxvideo.net is Netflix's Open Connect CDN, which is also what powers fast.com, Netflix's speed test. So the router was right after all: this really was Netflix traffic, just not Netflix the streaming service.

The parent process:

PID      PPID  COMMAND
1113135  898   /bin/bash /usr/share/omarchy/bin/omarchy-network-speedtest up

And PID 898 was systemd --user. These were orphans: their parent script was gone, and they'd been re-parented to the user's systemd instance.

picosnitch put a number on it. In just over three minutes, these orphans had uploaded:

5.25 GB   (~240 Mbit/s)

At that rate, my mysterious 196 GB is only about two hours of the same thing.

I killed them, and upload dropped straight back to ~2 KB/s.

Part 4: Why the speed test never stopped

Omarchy (the Arch + Hyprland setup I run) ships a Network Speed Test in its menu. The panel runs omarchy-network-speedtest down for five seconds, then omarchy-network-speedtest up for five seconds, stopping each phase when time is up.

The upload phase looks roughly like this:

trap cleanup EXIT     # cleanup() kills the workers

traffic_worker() {
  while true; do
    dd if=/dev/zero bs=1M count=64 | curl -X POST --data-binary @- "$url" || return
  done
}

for (( i = 0; i < 8; i++ )); do
  traffic_worker $fast_urls &
done

Eight background workers, each POSTing 64 MB of zeros in an infinite loop. The only thing that ever stops them is the cleanup function, run by the EXIT trap.

I reproduced it fully offline, using the real script with a fake curl on PATH that returns made-up endpoints and just sleeps instead of transferring anything:

How the script is stopped Workers left behind
SIGTERM (graceful) 0: the trap runs, cleanup works
SIGKILL (hard kill) 8: re-parented to systemd --user, looping forever

SIGKILL can't be trapped, so cleanup never runs. Any path that kills the script hard, or interrupts it partway through cleanup, leaves the workers with nothing to stop them. (In my live case 5 of 8 survived, which suggests cleanup was interrupted midway.)

Each orphan then uploads 64 MB, starts the next 64 MB, and so on, until you log out.

Part 5: The fix: let the workers notice

The workers can't rely on someone else to stop them, so they should check for themselves. In a bash background subshell, $$ still refers to the parent script's PID, so a worker can test whether its parent is alive before starting each transfer:

+# Workers stop once this script is gone, so a hard kill (SIGKILL) that skips the
+# EXIT trap can't leave them uploading/downloading forever as orphans.
+parent_pid=$$
+
 traffic_worker() {
   ...
-    while true; do
+    while kill -0 "$parent_pid" 2>/dev/null; do
       ...

kill -0 sends no signal at all. It just checks that the process exists. Now, if the script dies however it dies, each worker finishes its current transfer and exits. The normal SIGTERM path is unchanged.

Same offline test, with the fix:

Script Workers left 6s after SIGKILL
original, upload 8
fixed, upload 0
original, download 8
fixed, download 0

Part 6: Sending it upstream

The upstream script was byte-for-byte identical to mine, and there were no existing issues about it, so I sent a fix:

  1. Issue: omacom/omarchy#14025, with the symptoms, cause and offline reproduction steps.
  2. Pull request: omacom/omarchy#14026, with the 4-line fix plus a regression test in test/shell.d/network-speedtest-test.sh. The test runs the real script with stubbed ip and curl, SIGKILLs it, and asserts the workers exit. It fails without the fix and passes with it.

The repo's automated reviewer (Greptile) flagged a fair point: my test found workers by matching the command line, so it could have counted or killed a speed test it didn't start. Since each test run is launched with setsid, the script and all its workers share a session whose ID is the script's PID, so I switched the test to pgrep -s <pid>. I verified that with a decoy speed test running alongside it: the decoy's processes were untouched before and after.

(At the time of writing, the PR is open and waiting on maintainer review.)

What I took away from this

  • Interface counters tell you something is wrong; they can't tell you who. If you care about where your bandwidth goes, install per-process logging before you need it. picosnitch is lightweight and answers the question you'll actually ask: which program, how much, to where, and when.
  • Your router's app labels might be right in a way you didn't expect. "Netflix" wasn't a misclassification. It was the fast.com speed test infrastructure.
  • Background workers should never depend only on an EXIT trap. Traps don't run on SIGKILL. If a child can outlive its parent, make it check that the parent is still there.
  • Reproduce offline before you touch anything. A stub curl on PATH let me run the real script, kill it every way I wanted, and prove the fix without sending a single byte over the network.

If you run Omarchy and have used the Network Speed Test, it's worth a quick check:

pgrep -af nflxvideo

If that prints anything when no speed test is open, you have the same runaway workers.