> ## Content Index
> Fetch the complete content index at: https://iadar.sh/llms.txt
> Use this file to discover other available public pages before exploring further.

# My PC Uploaded 196 GB to "Netflix". I Don't Have Netflix.
- URL: https://iadar.sh/omarchy-speedtest-196gb-upload/
- Published: 2026-10-02T10:35:47.000Z
- Updated: 2026-10-02T10:35:47.000Z
- Description: 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.
- Author: Adarsh Pandey
- Tags: linux, omarchy, debugging, networking, open-source

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](https://github.com/elesiuta/picosnitch?ref=iadar.sh) | 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:

```bash
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**](http://fast.com/?ref=iadar.sh), 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.

![](https://iadar.sh/content/images/2026/10/screenshot-2026-10-02_15-39-28.png)

## Part 4: Why the speed test never stopped

[Omarchy](https://omarchy.org/?ref=iadar.sh) (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:

```bash
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:

```diff
+# 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](https://github.com/omacom/omarchy/issues/14025?ref=iadar.sh), with the symptoms, cause and offline reproduction steps.
2. **Pull request:** [omacom/omarchy#14026](https://github.com/omacom/omarchy/pull/14026?ref=iadar.sh), 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`, `SIGKILL`s 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](http://fast.com/?ref=iadar.sh) 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:

```bash
pgrep -af nflxvideo

```

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