The client wrote: the sites are down, looks like a DDoS. The server runs about 5,500 WordPress sites on nginx, PHP-FPM 8.4 and MariaDB, with 125 GB of RAM on Debian 13. I found a scanner, blocked it in nginx, and the sites came back. Two days later the client wrote again: now everything falls over every five minutes.
The cause was not outside. Every new PHP-FPM worker weighed about 600 MB from its very first request, and the OOM killer took turns shooting the database and nginx. The workers were inflated by a bug in OPcache that fires on every cache reset under load. The resets came from Yoast SEO during an update. Not the regular update across all sites, but a catch-up run on 467 sites where the scheduled one had failed. In the end, the order of two commands decided everything.
Below is how I found it, step by step, and what I changed. The command output is real; I removed domains and addresses.
The server
All sites are served by one PHP-FPM pool:
pm.max_children = 200 pm.start_servers = 20 pm.min_spare_servers = 10 pm.max_spare_servers = 30 pm.max_requests = 500 And one 1 GB OPcache:
opcache.enable=1 opcache.memory_consumption=1024 opcache.max_accelerated_files=200000 opcache.validate_timestamps=1 opcache.revalidate_freq=0 There is one FPM master, so the OPcache shared memory is also one for all 5,500 sites. Sizes below are the way ps and /proc count them: 1 MB is 1024 KB.
First call: a scanner
Load average 205-235 on 32 cores, all 200 workers busy, 116 GB of memory used, swap full. About 34 requests per second from outside across 1,536 domains. More than half were looking for .env, .git and other service files, from hundreds of cloud addresses.
An ordinary scanner, they walk every public server. But on WordPress each such request turns into a full 404 page render in PHP, so the fastest fix is to stop them before PHP: a map in nginx and one line in the snippet every virtual host includes.
The map and the snippet linemap $uri $scanner_block { default 0; "~^/\.well-known/" 0; "~/\." 1; "~*(phpinfo|serverless\.ya?ml|docker-compose)" 1; "~*\.(sql|bak|swp|old|orig|env|ya?ml)$" 1; } if ($scanner_block) { return 404; } /.well-known/ is carved out so certificate issuance keeps working. I return 404 rather than 444: there is a load balancer and Cloudflare in front, and a dropped connection would turn into a 502 for a real visitor.
In the first minute with the filter, nginx itself answered 1,013 requests with 404, there were 293 normal responses and not a single 5xx. Some services had been killed by OOM along the way and were brought back. It looked like the usual scanner story.
Second call: "every five minutes"
Two days later: DDoS again, now it goes down every five minutes. A different scanner, this one tries archives:
"GET /phpinfo.zip HTTP/2.0" status=404 "GET /cvs.zip HTTP/2.0" status=404 "GET /usermanager.zip HTTP/2.0" status=404 "GET /fortune.zip HTTP/2.0" status=499 I could have added archives to the same map and moved on. But a couple of days later a third scanner would show up. I asked the client not to touch anything on the server, set up a script that logs the memory of nginx, PHP and the database every five minutes, and started with the kernel log.
Who gets killed
# journalctl -k --since 2026-10-01 | grep -c 'Killed process' 82 # journalctl -k --since 2026-10-01 | grep 'Killed process' | grep -o '([a-z()-]*)' | sort | uniq -c | sort -rn 36 (mariadbd) 22 (systemd) 17 ((sd-pam)) 7 (nginx) # journalctl -k --since 2026-10-01 -o short-iso | grep 'Killed process' | cut -c1-10 | uniq -c 18 2026-10-12 48 2026-10-13 16 2026-10-15 82 kills since the start of the month, all of them in the last four days. Before that the OOM killer was silent. None on the day after the filter, then again. This is what the morning of the second call looked like:
# journalctl -k --since 2026-10-15 --until '2026-10-15 13:00' | grep 'Killed process' Oct 15 04:21:01 srv kernel: Out of memory: Killed process 1597116 (mariadbd) total-vm:48713652kB, anon-rss:23905292kB, ... Oct 15 08:23:20 srv kernel: Out of memory: Killed process 2704383 (mariadbd) total-vm:44486476kB, anon-rss:23059620kB, ... Oct 15 08:23:27 srv kernel: Out of memory: Killed process 3285965 (systemd) total-vm:22132kB, anon-rss:2048kB, ... Oct 15 12:19:52 srv kernel: Out of memory: Killed process 3847971 (mariadbd) total-vm:43939700kB, anon-rss:13486656kB, ... Oct 15 12:47:58 srv kernel: Out of memory: Killed process 1661507 (systemd) total-vm:22140kB, anon-rss:2048kB, ... Oct 15 12:47:58 srv kernel: Out of memory: Killed process 1661509 ((sd-pam)) total-vm:22436kB, anon-rss:1032kB, ... Oct 15 12:47:58 srv kernel: Out of memory: Killed process 430332 (mariadbd) total-vm:44793656kB, anon-rss:10777012kB, ... Oct 15 12:48:04 srv kernel: Out of memory: Killed process 3776728 (nginx) total-vm:3247688kB, anon-rss:2518036kB, ... The database is the biggest process, so it gets killed most often, 36 times out of 82. MariaDB's unit has Restart=on-abnormal and RestartSec=5s: systemd brings it back, it grows again, and the cycle repeats. Every database kill means a minute or two of errors on all sites while it starts. That is the "goes down every five minutes" from the client's message.
systemd and (sd-pam) in the list are not PID 1 but a user session manager. systemd raises its kill priority:
# systemctl show user@1003.service -p OOMScoreAdjust OOMScoreAdjust=100 For such a process the kernel adds a tenth of total memory to its score, so a process of a few megabytes looks to the OOM killer like one of 12+ GB. That puts it in line right next to the database, even though it uses almost nothing.
nginx is more interesting. The kernel kills one of its processes, and systemd does the rest:
# journalctl -u nginx -S '2026-10-15 12:47' -U '2026-10-15 14:00' Oct 15 12:48:04 srv systemd[1]: nginx.service: A process of this unit has been killed by the OOM killer. Oct 15 12:48:09 srv systemd[1]: nginx.service: Stopping timed out. Terminating. Oct 15 12:48:14 srv systemd[1]: nginx.service: State 'stop-sigterm' timed out. Killing. Oct 15 12:48:14 srv systemd[1]: nginx.service: Killing process 1661457 (nginx) with signal SIGKILL. Oct 15 12:48:19 srv systemd[1]: nginx.service: Processes still around after SIGKILL. Ignoring. Oct 15 12:48:24 srv systemd[1]: nginx.service: Main process exited, code=killed, status=9/KILL Oct 15 12:48:24 srv systemd[1]: nginx.service: Failed with result 'oom-kill'. Oct 15 12:48:24 srv systemd[1]: nginx.service: Consumed 1h 20min 47.726s CPU time, 33.1G memory peak, 883.5M memory swap peak. The service has OOMPolicy=stop, which is the default: after any of its processes is killed, systemd stops the whole service. And Restart=no, so the sites stay down until someone starts nginx by hand.
It's not the bots
My first thought was the simplest one: the bots got meaner. proxy-audit.log here is a shared nginx request log for all sites (address, X-Forwarded-For, host, request, status), rotated daily. I counted archive requests per day in it, and upstream timeouts to PHP in the nginx error log:
# zgrep -cE '\.(zip|rar|7z|tar|gz|tgz|bz2) HTTP' /var/log/nginx/proxy-audit.log.[2-9].gz /var/log/nginx/proxy-audit.log.1 /var/log/nginx/proxy-audit.log # zgrep -c 'upstream timed out' /var/log/nginx/error.log.[2-9].gz | Days ago | Archive requests | upstream timed out |
|---|---|---|
| 9 | 12,235 | 0 |
| 8 | 6,669 | 0 |
| 7 | 16,573 | 0 |
| 6 | 8,538 | 0 |
| 5 | 8,941 | 0 |
| 4 | 415 | 0 |
| 3, first outage | 6,140 | 14 |
| 2, first call | 6,442 | 8,325 |
| 1 | 8,850 | not counted |
| today, until evening | 14,892 | not counted |
Four days before the first outage there were 16,573 archive requests, more than on any outage day, and not a single timeout. Timeouts appeared on the day of the first outage.
And a back-of-the-envelope check. A clean 404 through FPM, as the measurement below shows, takes 0.29 seconds. At 34 requests per second, Little's law says about ten workers would cover it (34 × 0.29 ≈ 10). The first time, all 200 were busy, which means almost 6 seconds per request (200 / 34 ≈ 5.9). What made requests slow was not their complexity but the state of the server: memory gone, swap full, the database restarting every few minutes. The bot theory was wrong: nothing changed outside, something changed inside.
A 600 MB worker from the first request
# ps -o pid,etimes,rss,time -C php-fpm8.4 --sort=rss | head -8 PID ELAPSED RSS TIME 3532685 1681700 11728 00:08:54 2655701 5 594932 00:00:00 2655702 5 603992 00:00:00 2655700 6 605512 00:00:00 2551941 305 648276 00:00:10 2556065 291 698096 00:00:10 2481721 519 704116 00:00:18 The first line is the master, 11 MB. Then the workers: alive for 5 seconds, less than a second of CPU time, and they weigh almost 600 MB. The older ones are at 630-690 MB.
Maybe the request itself is heavy? I sent one request for a non-existent .zip, exactly like the scanner, straight into the FPM socket with cgi-fcgi. A small script fakes $_SERVER, loads WordPress and writes stats to a file at the end:
# SCRIPT_FILENAME=/tmp/wp404-probe.php REQUEST_METHOD=GET PROBE_HOST=example.com PROBE_URI=/probe-20261015-xq7.zip timeout 110 cgi-fcgi -bind -connect /run/php/php8.4-fpm.sock # cat /tmp/wp404-probe.out { "time_s": 0.29, "peak_mb_real": 36, "peak_mb": 34, "queries": 133, "is_404": true, "included_files": 1464, ... } <?php $host = getenv('PROBE_HOST') ?: 'example.com'; $uri = getenv('PROBE_URI') ?: '/probe-20261015-xq7.zip'; $root = "/var/www/$host"; foreach (['HTTP_HOST' => $host, 'SERVER_NAME' => $host, 'REQUEST_URI' => $uri, 'REQUEST_METHOD' => 'GET', 'HTTPS' => 'on', 'SERVER_PORT' => '443', 'SCRIPT_NAME' => '/index.php', 'PHP_SELF' => '/index.php', 'SCRIPT_FILENAME' => "$root/index.php", 'DOCUMENT_ROOT' => $root, 'QUERY_STRING' => '', 'HTTP_USER_AGENT' => 'wp404-probe', 'REMOTE_ADDR' => '127.0.0.1'] as $k => $v) { $_SERVER[$k] = $v; } unset($_SERVER['PATH_INFO'], $_SERVER['ORIG_PATH_INFO']); $t0 = microtime(true); register_shutdown_function(function () use ($t0, $host, $uri) { global $wpdb; $st = function_exists('opcache_get_status') ? opcache_get_status(false) : null; $err = error_get_last(); $out = [ 'host' => $host, 'uri' => $uri, 'time_s' => round(microtime(true) - $t0, 2), 'peak_mb_real' => round(memory_get_peak_usage(true) / 1048576, 1), 'peak_mb' => round(memory_get_peak_usage(false) / 1048576, 1), 'queries' => isset($wpdb) ? $wpdb->num_queries : null, 'is_404' => function_exists('is_404') ? is_404() : null, 'included_files' => count(get_included_files()), 'last_error' => $err ? substr($err['message'], 0, 200) . ' @' . $err['file'] . ':' . $err['line'] : null, 'opcache' => $st ? [ 'used_mb' => round($st['memory_usage']['used_memory'] / 1048576), 'free_mb' => round($st['memory_usage']['free_memory'] / 1048576), 'wasted_mb' => round($st['memory_usage']['wasted_memory'] / 1048576), 'wasted_pct' => round($st['memory_usage']['current_wasted_percentage'], 1), 'interned_used_mb' => round($st['interned_strings_usage']['used_memory'] / 1048576), 'interned_free_mb' => round($st['interned_strings_usage']['free_memory'] / 1048576), 'cache_full' => $st['cache_full'], 'restart_pending' => $st['restart_pending'], 'scripts' => $st['opcache_statistics']['num_cached_scripts'], 'keys' => $st['opcache_statistics']['num_cached_keys'], 'max_keys' => $st['opcache_statistics']['max_cached_keys'], 'hits' => $st['opcache_statistics']['hits'], 'misses' => $st['opcache_statistics']['misses'], 'blacklist_misses' => $st['opcache_statistics']['blacklist_misses'], 'hit_rate' => round($st['opcache_statistics']['opcache_hit_rate'], 2), 'oom_restarts' => $st['opcache_statistics']['oom_restarts'], 'hash_restarts' => $st['opcache_statistics']['hash_restarts'], 'manual_restarts' => $st['opcache_statistics']['manual_restarts'], 'start_time' => date('c', $st['opcache_statistics']['start_time']), 'last_restart' => date('c', $st['opcache_statistics']['last_restart_time']), ] : null, ]; file_put_contents('/tmp/wp404-probe.out', json_encode($out, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES) . "\n", FILE_APPEND); }); ob_start(); chdir($root); require "$root/index.php"; The script sat in /tmp only for the measurement, then I deleted it.
0.29 seconds and 36 MB at peak. PHP does not know about its 600 MB, memory_get_peak_usage() does not see them. So the memory lives somewhere below PHP.
Where the 500 MB are
# grep -E '^(VmRSS|RssAnon|RssFile|RssShmem)' /proc/2481721/status VmRSS: 648724 kB RssAnon: 533656 kB RssFile: 30196 kB RssShmem: 84872 kB RssShmem is the OPcache shared memory, all workers share it. But the 521 MB of RssAnon belong to each worker alone. I looked in /proc/2481721/smaps for regions larger than 10 MB. There are just two: /dev/zero (deleted) at 84,868 KB, which is that OPcache shared memory, and a nameless 7f6cdd686000-7f6cfc6a7000 at 508,032 KB. Its smaps entry, without zero and housekeeping fields:
7f6cdd686000-7f6cfc6a7000 rw-p 00000000 00:00 0 Size: 508036 kB Rss: 508032 kB Private_Dirty: 508032 kB Anonymous: 508032 kB AnonHugePages: 505856 kB Swap: 0 kB SwapPss: 0 kB THPeligible: 1 VmFlags: rd wr mr mw me ac sd A 496 MB anonymous chunk, fully populated: Rss equals Size. How many processes hold a region at this address:
# grep -l '7f6cdd686000-7f6cfc6a7000' /proc/[0-9]*/maps | wc -l 30 # ps -C php-fpm8.4 --no-headers | wc -l 31 All 30 workers; the 31st process is the master. The master has 5 MB of RssAnon:
# grep -E '^(VmRSS|RssAnon|VmData|VmSize)' /proc/3532685/status VmSize: 1261320 kB VmRSS: 11728 kB RssAnon: 5344 kB VmData: 12440 kB So a worker allocates this chunk after fork, on its very first request, and fills it right away. This is not a leak that builds up over the life of a process. The worker pays a tax at birth.
The php-src bug, #23859
I searched for the symptom and found a php-src issue: #23859, "Repeated opcache_reset() under concurrency permanently grows ZCSG(map_ptr_last), inflating every newly spawned php-fpm worker". It had been opened three weeks before my investigation, status Needs Triage, no patch. The author's workers weighed about 960 MB at birth, the whole FPM was at 52 GB, and a graceful reload brought it down to 2.4 GB. They reproduced the growth on 8.1, 8.3, 8.4 and 8.5, including Debian 13's 8.4, and honestly call the code path a hypothesis. The first commenter laid out the mechanism with line references. I checked it against the 8.4.26 source running on this server. Step by step:
- Every PHP process has a
map_ptrtable: one slot for each function, method and class from the OPcache cache. The process that puts a script into the cache takes new slots from its own counterCG(map_ptr_last)and writes it into the shared counterZCSG(map_ptr_last)(zend_persist.c:1457). - A new worker, loading its first script from the cache, stretches its table up to the shared counter (zend_accelerator_util_funcs.c:388). At the start of every request the whole table is zeroed (zend.c:1321), so all of it is resident at once.
- A cache restart zeroes the shared counter, but only in the process that performs the restart (ZendAccelerator.c:2714). The other workers notice that the cache was restarted and reset only their path and regex caches (2748-2756). Their own counter stays at the old value.
- The first of them to put a script into the cache allocates slots on top of that old value and writes it into the shared counter. The counter never goes down, and every restart under load adds another generation to it. This lasts until FPM itself is restarted.
Any restart counts here: opcache_reset(), the cache running out of memory, the hash table overflowing. All three go through the same block of code (2695-2730). While a restart waits for all processes to let go of the cache, OPcache is disabled for everyone (3473-3476), and new resets are not scheduled in the meantime, the source literally says "don't schedule twice" (3459). That is why there are noticeably more opcache_reset() calls than restarts in the stats.
The bug leaves a recognizable fingerprint. The table grows in steps of 4096 pointers, that is 32 KB (zend.c:2063), and 508,036 KB is exactly 15,876 steps of 32 KB plus 4 KB. If you see a nameless chunk of that kind of size, identical in every worker and missing in the master, it is almost certainly this.
In the author's synthetic test, 1,800 resets give about 200 MB per worker. Here a couple of hundred restarts were enough. Reading the code, a generation gets longer the more scripts manage to get back into the cache before the next restart, and this server's cache holds 45 thousand scripts. That is my reading of the code; I did not measure it.
There is one more cost. Since the table is zeroed at the start of every request, every request does a memset over 496 MB. My estimate is tens of milliseconds of CPU per request; I did not measure that either.
Who resets the cache
OPcache stats have to come from FPM itself. php -r in a console is useless: the CLI has its own OPcache, usually disabled. The same probe writes them:
"opcache": { "used_mb": 979, "free_mb": 0, "wasted_pct": 4.4, "cache_full": true, "scripts": 45037, "hit_rate": 34.72, "oom_restarts": 2, "hash_restarts": 0, "manual_restarts": 205, "start_time": "2026-10-09T07:39:32+00:00", "last_restart": "2026-10-13T12:15:07+00:00" } The cache is completely full, two thirds of lookups miss, and those scripts get compiled again on every request. manual_restarts: 205 are restarts by opcache_reset(), oom_restarts: 2 are two more from the cache itself running out of memory, and they take the same path. All of it counts from start_time, the last FPM restart.
I looked for who calls opcache_reset() with a plain grep over one site:
# grep -rn opcache_reset wp-content/plugins wp-content/themes wp-content/plugins/wordpress-seo/wp-seo-main.php:344: if ( $should_invalidate_opcache && function_exists( 'opcache_reset' ) ) { wp-content/plugins/wordpress-seo/wp-seo-main.php:346: @opcache_reset(); I went over one copy of every plugin present on the server, all three themes and the mu-plugins. Besides Yoast, only Google Site Kit turned up: it resets the cache after any update through the upgrader_process_complete hook, but it is installed on one site out of 5,500. Fun detail: right next to the call they have a comment saying "opcache_reset is prohibited on the WordPress VIP platform due to memory corruption".
Yoast's code (wp-seo-main.php, lines 329-346), shortened:
if ( version_compare( WPSEO_Options::get( 'version', 1, [ 'wpseo' ] ), WPSEO_VERSION, '<' ) ) { // Invalidate the opcache in 50% of the cases, randomly staggered based on the site URL. $random_seed = hexdec( substr( hash( 'sha256', site_url() ), 0, 8 ) ); $should_invalidate_opcache = ( $random_seed % 2 ) !== 0; $should_invalidate_opcache = (bool) apply_filters( 'Yoast\WP\SEO\should_invalidate_opcache', $should_invalidate_opcache ); if ( $should_invalidate_opcache && function_exists( 'opcache_reset' ) ) { @opcache_reset(); } new WPSEO_Upgrade(); After an update, the first WordPress load sees that the stored version is older than the code, and on half of the sites it resets OPcache. Which half is decided by a hash of the site URL, so it is always the same half. For a single site on its own server that is reasonable: you do not want to live with a mix of old and new files in the cache. Note the words "the first WordPress load", not "the first request". That is the key to the rest.
Why it didn't fall over before
# journalctl -u php8.4-fpm --since 2026-10-01 | grep Reloaded Oct 01 05:23:08 srv systemd[1]: Reloaded php8.4-fpm.service - The PHP 8.4 FastCGI Oct 01 05:25:17 srv systemd[1]: Reloaded php8.4-fpm.service - The PHP 8.4 FastCGI Oct 02 14:12:44 srv systemd[1]: Reloaded php8.4-fpm.service - The PHP 8.4 FastCGI Oct 06 07:01:34 srv systemd[1]: Reloaded php8.4-fpm.service - The PHP 8.4 FastCGI Oct 08 05:44:48 srv systemd[1]: Reloaded php8.4-fpm.service - The PHP 8.4 FastCGI Oct 09 07:12:06 srv systemd[1]: Reloaded php8.4-fpm.service - The PHP 8.4 FastCGI [...] Oct 09 07:39:31 srv systemd[1]: Reloaded php8.4-fpm.service - The PHP 8.4 FastCGI Oct 15 18:14:41 srv systemd[1]: Reloaded php8.4-fpm.service - The PHP 8.4 FastCGI PHP-FPM used to be reloaded every one to four days, and each reload reset the table: the OPcache shared memory is created fresh, the counter starts from zero, and nobody ever sees the inflation. The last reload before the outages was three days before the first one. The last line in the output is mine, more on it below.
What reset the cache during those three days is not obvious from the logs: OPcache resets are not logged by name anywhere. I had to piece it together from update logs, the sudo journal and OOM killer reports.
The sites here are updated by a cron script: every five minutes it checks for new versions and installs them on all sites. Its log for the previous Yoast update, two weeks before the outages, and for the next one, the day after the first outage:
# grep -E 'wordpress-seo|Updated|FAILED' 2026-09-29_12-40-01/main.log 2026-10-13_11-30-01/main.log 2026-09-29_12-40-01/main.log:[2026-09-29 12:40:03] wordpress-seo: 28.5 -> 28.6 2026-09-29_12-40-01/main.log:[2026-09-29 12:40:03] [DOWNLOAD] wordpress-seo 28.6 2026-09-29_12-40-01/main.log:[2026-09-29 12:40:04] [OK] wordpress-seo 28.6 2026-09-29_12-40-01/main.log:[2026-09-29 13:22:31] Updated: 5058 2026-09-29_12-40-01/main.log:[2026-09-29 13:22:31] FAILED: 469 2026-10-13_11-30-01/main.log:[2026-10-13 11:30:03] wordpress-seo: 28.6 -> 28.7 2026-10-13_11-30-01/main.log:[2026-10-13 11:30:03] [DOWNLOAD] wordpress-seo 28.7 2026-10-13_11-30-01/main.log:[2026-10-13 11:30:04] [OK] wordpress-seo 28.7 2026-10-13_11-30-01/main.log:[2026-10-13 12:16:41] Updated: 5478 2026-10-13_11-30-01/main.log:[2026-10-13 12:16:41] FAILED: 7 On 469 sites the update to 28.6 failed, and 467 of them have [PLUGIN:wordpress-seo] ERROR: update failed in the site log. Cron did not retry them: the next run with Yoast in the logs is two weeks later, already for 28.7.
The lagging sites were caught up by a manual run on the morning of the first outage: wp plugin update --all across all sites and a couple of wp-config.php edits. The order of WP-CLI commands on one of the lagging sites, from the sudo journal:
# journalctl _COMM=sudo -S '2026-10-12 06:25:30' -U '2026-10-12 06:26' | grep 'PWD=/var/www/<site> ' | grep -o 'COMMAND=/usr/local/bin/wp.*' COMMAND=/usr/local/bin/wp option update tfa_administrator 1 COMMAND=/usr/local/bin/wp config set WP_DEBUG false --raw COMMAND=/usr/local/bin/wp config set WP_DEBUG_LOG false COMMAND=/usr/local/bin/wp plugin update --all wp plugin update --all is the last command, and after it WP-CLI never loads the site again. So Yoast's upgrade code, together with opcache_reset(), was run by the site's first visitor, which means by PHP-FPM, under live traffic. That the lagging sites got 28.6 exactly then shows up in the site logs of the next run:
# grep -l '28.5 -> 28.7' 2026-10-13_11-30-01/sites/*.log | wc -l 2 # grep -l '28.6 -> 28.7' 2026-10-13_11-30-01/sites/*.log | wc -l 5483 There are no other Yoast updates between these runs in the sudo journal; I checked a sample of ten lagging sites. So about 467 sites were updated that morning, and roughly half of them, per Yoast's code, reset OPcache. The resets were spread over a couple of hours as the run worked through the sites.
How big the table had grown by the first outage I worked out after the fact. The OOM killer report has each process's total_vm in 4 KB pages. A fresh worker that has not served a request yet matches the master, while a worker after its first request is heavier by the table plus a little heap:
# journalctl -k -S '2026-10-12 14:11:15' -U '2026-10-12 14:11:22' | grep -E 'tgid|php-fpm8.4$' | sort -k9 -n | head -9 Oct 12 14:11:21 srv kernel: [ pid ] uid tgid total_vm rss rss_anon rss_file rss_shmem pgtables_bytes swapents oom_score_adj name Oct 12 14:11:21 srv kernel: [3522917] 33 3522917 315330 3443 2552 763 128 258048 179 0 php-fpm8.4 Oct 12 14:11:21 srv kernel: [3522923] 33 3522923 315330 3474 2656 818 0 245760 243 0 php-fpm8.4 Oct 12 14:11:21 srv kernel: [3522941] 33 3522941 315330 3863 2656 1076 131 262144 243 0 php-fpm8.4 Oct 12 14:11:21 srv kernel: [3522944] 33 3522944 315330 3604 2656 948 0 245760 243 0 php-fpm8.4 Oct 12 14:11:21 srv kernel: [3532685] 0 3532685 315330 4738 2819 767 1152 290816 64 0 php-fpm8.4 Oct 12 14:11:21 srv kernel: [3522852] 33 3522852 436387 114225 112350 849 1026 1155072 244 0 php-fpm8.4 Oct 12 14:11:21 srv kernel: [3522859] 33 3522859 436387 125260 123359 875 1026 1241088 243 0 php-fpm8.4 Oct 12 14:11:21 srv kernel: [3522866] 33 3522866 436387 126088 123551 934 1603 1245184 243 0 php-fpm8.4 The master (uid 0) and four fresh workers are at 315,330 pages, the workers after a request start at 436,387. The difference is 121,057 pages, about 473 MB: the table was nearly full size already at the first outage. Later reports give about 476 MB the next morning and about 496 MB that evening, after the mass Yoast 28.7 update across 5,478 sites. That is what smaps showed later.
The mass update on 5,478 sites added less to the table than the catch-up on 467. The sudo journal shows why: after installing, cron immediately activates the plugin.
# journalctl _COMM=sudo -S '2026-10-13 11:57:00' -U '2026-10-13 11:57:12' | gre...
