Content-Type: multipart/mixed; boundary="------------615cqGtUzbHEzlxKeWnwI3S7"
Message-ID: <89884b8a-2a50-4f6d-9e9c-223c6741643e@gmail.com>
Date: Sat, 16 May 2026 22:00:00 +0300
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: BUG #18374: Printing memory contexts on OOM condition might lead
 to segmentation fault
To: Tom Lane <tgl@sss.pgh.pa.us>
Cc: pgsql-bugs@lists.postgresql.org, Heikki Linnakangas <hlinnaka@iki.fi>
References: <18374-ebb8113ce4d02f0d@postgresql.org>
 <3120721.1709395887@sss.pgh.pa.us>
 <b1a1eaf3-d5b7-da52-6bb7-c5b3fbe47f3e@gmail.com>
 <3140126.1709405398@sss.pgh.pa.us> <3148162.1709409519@sss.pgh.pa.us>
 <3399097.1709501969@sss.pgh.pa.us>
Content-Language: en-US
From: Alexander Lakhin <exclusion@gmail.com>
In-Reply-To: <3399097.1709501969@sss.pgh.pa.us>
Archived-At: 
 <https://www.postgresql.org/message-id/89884b8a-2a50-4f6d-9e9c-223c6741643e%40gmail.com>
Precedence: bulk

This is a multi-part message in MIME format.
--------------615cqGtUzbHEzlxKeWnwI3S7
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit

Hello Tom,

03.03.2024 23:39, Tom Lane wrote:
> I wrote:
>> I find this in [1]:
>>
>>    The C language stack growth does an implicit mremap. If you want absolute
>>    guarantees and run close to the edge you MUST mmap your stack for the
>>    largest size you think you will need. For typical stack usage this does
>>    not matter much but it's a corner case if you really really care
>>
>> Seems like we need to do some more work at startup to enforce that
>> we have the amount of stack we think we do, if we're on Linux.
> After thinking about that some more, I'm really quite unenthused about
> trying to remap the stack for ourselves.  It'd be both platform- and
> architecture-dependent, and I'm afraid it'd introduce as many failure
> modes as it removes.  (Notably, I'm not sure we could guarantee
> there's a guard page below the stack.)  Since we've not seen reports
> of this failure from the wild, I doubt it's worth the trouble.

I'm not too excited either, but I observed such SIGSEGVs in a
memory-restricted cloud (neon) environment (perhaps it could be considered
the wild), and what looks bad to me is that there is no protection from it
at all. That is, if you can get an out-of-memory error in some environment,
you can also bring the whole server down with the segfault, occasionally or
intentionally.

I researched the subject and found the only way to prevent this -- to
allocate the stack memory (up to max_stack_depth) on postmaster child's
start.

Please look at a test, which triggers the server crash, and a possible
protection.

When running this test on Linux, I'm getting:
PROVE_TESTS="t/099*" make -s check -C src/test/modules/test_misc/
# Testing ulimit -Sv 280000
# out of memory
# Testing ulimit -Sv 1140000
# stack depth limit exceeded
...
# Boundary between 'out of memory' and 'stack depth limit exceeded' found: 283779
...
# Testing ulimit -Sv 275587
# psql:<stdin>:17: server closed the connection unexpectedly
#       This probably means the server terminated abnormally
#       before or while processing the request.

2026-05-16 20:33:30.724 EEST postmaster[4101481] LOG:  client backend (PID 4101496) was terminated by signal 11: 
Segmentation fault
2026-05-16 20:33:30.724 EEST postmaster[4101481] DETAIL:  Failed process was running: select explainer('execute stmt');

While with echo "preallocate_stack=on" >/tmp/temp.config;
TEMP_CONFIG=/tmp/temp.config PROVE_TESTS="t/099*" make -s check -C src/test/modules/test_misc/
survives the test.

ulimit -Sv is easy to use for the test, but in the wild the restriction
would be rather on the total amount of memory for all (postgres) processes,
so there could be more interesting scenarios...

Catching sigsegv in allocate_stack() is needed to handle correctly the
even worse situation, when there is not enough memory to preallocate stack
even on a process start.

The test and the fix work for me on Linux and FreeBSD.

Yes, this protection has it's price (max_stack_depth * num processes), but
perhaps one who wants to avoid server crashes should have the choice.

Thanks to Heikki for help with making the solution robust.

Best regards,
Alexander
--------------615cqGtUzbHEzlxKeWnwI3S7
Content-Type: application/x-perl; name="099_stack_overflow.pl"
Content-Disposition: attachment; filename="099_stack_overflow.pl"
Content-Transfer-Encoding: 7bit

# Copyright (c) 2026, PostgreSQL Global Development Group

# Test if stack overflow with SIGSEGV happens under memory pressure

use strict;
use warnings FATAL => 'all';
use PostgreSQL::Test::Cluster;
use PostgreSQL::Test::Utils;
use Test::More;
use Config;

if ($windows_os)
{
	plan skip_all => 'preallocate_stack is not supported on Windows';
}

if ($Config{osname} eq 'darwin')
{
	plan skip_all => 'ulimit fails on macOS with "virtual memory: cannot modify limit: Invalid argument"';
}

# Initialize a test cluster
my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init();

sub test_server
{
	my $node = shift;
	my $mem = shift;

	diag("Testing ulimit -Sv $mem");

	my $data_dir = $node->data_dir;
	my $logfile = $node->logfile;
	local %ENV = $node->_get_env(PGAPPNAME => undef);

	my $res = system_log("ulimit -Sv $mem; pg_ctl -w -D $data_dir -l $logfile start");
	if ($res != 0)
	{
		print "# pg_ctl start failed; see logfile for details: $logfile\n";
		BAIL_OUT("pg_ctl start failed");
	}
	$node->_update_pid(1);

	$node->safe_psql('postgres', 'DROP DATABASE IF EXISTS testdb');
	$node->safe_psql('postgres', 'CREATE DATABASE testdb');

	my ($ret, $out, $err) = $node->psql(
		'testdb',
		q[
create function explainer(text) returns setof text
language plpgsql as
$$
declare
  ln text;
  begin
    for ln in execute format('explain analyze %s', $1)
    loop
      return next ln;
    end loop;
  end;
$$;

prepare stmt as select explainer('execute stmt');

select explainer('execute stmt');]
	);

	$node->stop;
	return $err;
}

my $lb = 280000;
my $ub = 2000000;
my $v;

for ($v = $lb; $lb < $ub - 1;)
{
	my $err = test_server($node, $v);
	if ($err =~ /ERROR:  (stack depth limit exceeded)/)
	{
		diag("$1");
		$ub = $v;
		$v = $v - int(($v - $lb)/ 2);
	}
	elsif ($err =~ /ERROR:  (out of memory)/)
	{
		diag("$1");
		$lb = $v;
		$v = $v + int(($ub - $v) / 2);
	}
	else
	{
		diag($err);
		BAIL_OUT("unexpected error occurred");
	}
}

diag("Boundary between 'out of memory' and 'stack depth limit exceeded' found: $v");
# More precise check below the boundary found
for (my $i = 1; $i < 32; $i++)
{
	my $err = test_server($node, $v - $i * 1024);
	if ($err =~ /ERROR:  (stack depth limit exceeded|out of memory)/)
	{
		diag($1);
	}
	else
	{
		diag($err);
		BAIL_OUT("unexpected error occurred");
	}
}

ok(1, 'OK');

done_testing();
--------------615cqGtUzbHEzlxKeWnwI3S7
Content-Type: text/x-patch; charset=UTF-8;
 name="prevent-segfaults-under-memory-pressure.patch"
Content-Disposition: attachment;
 filename="prevent-segfaults-under-memory-pressure.patch"
Content-Transfer-Encoding: base64
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--------------615cqGtUzbHEzlxKeWnwI3S7--