Content-Type: multipart/mixed; boundary="------------039VLw0kFoiPSKdhD07erXm9"
Message-ID: <31f43d88-9949-48c5-9497-b9a9b7cdee2b@gmail.com>
Date: Fri, 31 Oct 2025 22:40:58 -0600
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: [PATCH] Add Windows support for backtrace_functions (MSVC only)
From: Bryan Green <dbryan.green@gmail.com>
To: Euler Taveira <euler@eulerto.com>,
 Jakub Wartak <jakub.wartak@enterprisedb.com>
Cc: =?UTF-8?Q?=C3=81lvaro_Herrera?= <alvherre@kurilemu.de>,
 Michael Paquier <michael@paquier.xyz>,
 pgsql-hackers <pgsql-hackers@postgresql.org>
References: <202510300932.isdvgkzqzshk@alvherre.pgsql>
 <5b4c6ce0-ed17-4abb-9127-859cc95cbdf3@gmail.com>
 <CAKZiRmzuqPmgd_A+M+RiuT-4UtDt_TASqQJoqCdvCUrVY3w7cg@mail.gmail.com>
 <30aea073-109c-43cc-979c-081b922d055d@gmail.com>
 <2241662b-da7d-428f-beba-a416ef48e9e9@app.fastmail.com>
 <c04e5ca9-d1e1-48a6-acf3-0fd42f103ac0@gmail.com>
Content-Language: en-US
In-Reply-To: <c04e5ca9-d1e1-48a6-acf3-0fd42f103ac0@gmail.com>
Archived-At: 
 <https://www.postgresql.org/message-id/31f43d88-9949-48c5-9497-b9a9b7cdee2b%40gmail.com>
Precedence: bulk

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

On 10/31/2025 2:07 PM, Bryan Green wrote:
> On 10/31/2025 1:46 PM, Euler Taveira wrote:
>> On Thu, Oct 30, 2025, at 11:51 AM, Bryan Green wrote:
>>> I had reservations about the value the tests were adding, and
>>> considering I am getting more concern around having the tests than not
>>> having them for this initial release I have decided to remove them.  v4
>>> patch is attached.  It is the same as the initial 0001-* patch.
>>>
>>
>> I spent some time on this patch. Here are some comments and suggestions.
>>
> 
> Thanks for the review.
> 
>> +#ifdef _MSC_VER
>> +#include <windows.h>
>> +#include <dbghelp.h>
>> +static bool win32_backtrace_symbols_initialized = false;
>> +static HANDLE win32_backtrace_process = NULL;
>> +#endif
>>
>> We usually a different style. Headers go to the top on the same 
>> section as
>> system headers and below postgres.h. It is generally kept sorted. The 
>> same
> 
> Will fix. I will rework the style (error and otherwise) to follow the 
> project tradition.
> 
>> applies to variables. Add them near the other static variables. BTW 
>> does it need
>> the win32_ prefix for a Window-only variable?
>>
>> +        wchar_t        buffer[sizeof(SYMBOL_INFOW) + MAX_SYM_NAME * 
>> sizeof(wchar_t)];
>> +        PSYMBOL_INFOW symbol;
>>
>> According to [1], SYMBOL_INFO is an alias that automatically selects 
>> ANSI vs
>> UNICODE. Shouldn't we use it instead of SYMBOL_INFOW?
>>
> 
> Good point. I was being overly explicit about wanting wide chars, but 
> you're right that the generic versions are the way to go.
> 
>> +                elog(WARNING, "SymInitialize failed with error %lu", 
>> error);
>>
>> Is there a reason to continue if SymInitialize failed? It should 
>> return after
> 
> None at all.  Will return immediately.
> 
>> printing the message. Per the error message style guide [2], my 
>> suggestion is
>> "could not initialize the symbol handler: error code %lu". You can 
>> also use
>> GetLastError() directly in the elog call.
>>
>> +        symbol = (PSYMBOL_INFOW) buffer;
>> +        symbol      ->MaxNameLen = MAX_SYM_NAME;
>> +        symbol      ->SizeOfStruct = sizeof(SYMBOL_INFOW);
>>
>> We generally don't add spaces between variable and a member.
>>
>> +        DWORD        i;
>>
>> I'm curious why did you declare this variable as DWORD? Shouldn't int be
>> sufficient? The CaptureStackBackTrace function returns an unsigned short
>> (UShort). You can also declare it in the for loop.
>>
> 
> Out of habit.  I will change it to int.
> 
>> +            DWORD64        address = (DWORD64) (stack[i]);
>>
>> The parenthesis around stack is superfluous. The code usually doesn't 
>> contain
>> additional parenthesis (unless it improves readability).
>>
> 
> I will remove the parenthesis.
> 
>> +        if (frames == 0)
>> +        {
>> +            appendStringInfoString(&errtrace, "\nNo stack frames 
>> captured");
>> +            edata->backtrace = errtrace.data;
>> +            return;
>> +        }
>>
>> It seems CaptureStackBackTrace function may return zero frames under 
>> certain
>> conditions. It is a good point having this additional message. I 
>> noticed that
>> the current code path (HAVE_BACKTRACE_SYMBOLS) doesn't have this 
>> block. IIUC,
>> in certain circumstances (ARM vs unwind-tables flag), the backtrace() 
>> also
>> returns zero frames. Should we add this block for the backtrace() code 
>> path?
>>
> 
> Probably, though that seems like separate cleanup. Want me to include it
> here or handle separately (in another patch)?
> 
>> +            sym_result = SymFromAddrW(win32_backtrace_process,
>> +                                      address,
>> +                                      &displacement,
>> +                                      symbol);
>>
>> You should use SymFromAddr, no? [3] I saw that you used the Unicode 
>> functions
>> instead of the generic functions [4].
>>
>> +                    /* Convert symbol name to UTF-8 */
>> +                    utf8_len = WideCharToMultiByte(CP_UTF8, 0, 
>> symbol->Name, -1,
>> +                                                   NULL, 0, NULL, NULL);
>> +                    if (utf8_len > 0)
>> +                    {
>> +                        char       *filename_utf8;
>> +                        int            filename_len;
>> +
>> +                        utf8_buffer = palloc(utf8_len);
>> +                        WideCharToMultiByte(CP_UTF8, 0, symbol->Name, 
>> -1,
>> +                                            utf8_buffer, utf8_len, 
>> NULL, NULL);
>>
>> +                    /* Convert symbol name to UTF-8 */
>> +                    utf8_len = WideCharToMultiByte(CP_UTF8, 0, 
>> symbol->Name, -1,
>> +                                                   NULL, 0, NULL, NULL);
>>
>> You are calling WideCharToMultiByte twice. The reason is to allocate 
>> the exact
>> memory size. However, you can adopt another logic to avoid the first 
>> call.
>>
>> maxlen = symbol->NameLen * pg_database_encoding_max_length();
>> symbol_name = palloc(maxlen + 1);
>>
>> (I suggest symbol_name instead of ut8_buffer.)
>>
>> You are considering only the UTF-8 case. Shouldn't it use wcstombs or
>> wcstombs_l? Maybe (re)use wchar2char -- see pg_locale_libc.c.
>>
> 
> Hmm, you're probably right. I was thinking these Windows API strings 
> needed special handling, but wchar2char should handle the conversion to 
> database encoding correctly. Let me test that approach.
> 
>> +                        if (filename_len > 0)
>> +                        {
>> +                            filename_utf8 = palloc(filename_len);
>> +                            WideCharToMultiByte(CP_UTF8, 0, 
>> line.FileName, -1,
>> +                                                filename_utf8, 
>> filename_len,
>> +                                                NULL, NULL);
>> +
>> +                            appendStringInfo(&errtrace,
>> +                                             "\n%s+0x%llx [%s:%lu]",
>> +                                             utf8_buffer,
>> +                                             (unsigned long long) 
>> displacement,
>> +                                             filename_utf8,
>> +                                             (unsigned long) 
>> line.LineNumber);
>> +
>> +                            pfree(filename_utf8);
>> +                        }
>> +                        else
>> +                        {
>> +                            appendStringInfo(&errtrace,
>> +                                             "\n%s+0x%llx [0x%llx]",
>> +                                             utf8_buffer,
>> +                                             (unsigned long long) 
>> displacement,
>> +                                             (unsigned long long) 
>> address);
>> +                        }
>>
>> Maybe I missed something but is there a reason for not adding the 
>> address in the
>> first condition?
>>
> 
> No particular reason. I was trying to keep it concise when we have file/ 
> line info, but for consistency it probably should be there.
> 
> Will send v5 with these fixes.
> 
>>
>> [1] https://learn.microsoft.com/en-us/windows/win32/api/dbghelp/ns- 
>> dbghelp-symbol_infow
>> [2] https://www.postgresql.org/docs/current/error-style-guide.html
>> [3] https://learn.microsoft.com/en-us/windows/win32/api/dbghelp/nf- 
>> dbghelp-symfromaddrw
>> [4] https://learn.microsoft.com/en-us/windows/win32/intl/conventions- 
>> for-function-prototypes
>>
>>
> 
> Thanks again for the review,
> Bryan
Hi all,

v5 patch attached, incorporating all of Euler's feedback with a caveat 
around unicode.

The most interesting aspect turned out to be the encoding conversion for
symbol names and file paths. Initially I tried using the generic 
SYMBOL_INFO and SymFromAddr functions as Euler suggested, but ran into a 
subtle issue: on PostgreSQL's Windows builds, these become SYMBOL_INFOA 
and SymFromAddrA (the ANSI versions), which return strings in whatever 
Windows ANSI codepage happens to be active (CP1252, etc). This doesn't 
necessarily match the database encoding.

When I tried converting these with wchar2char(), it failed because the
input wasn't actually wide characters - leading to backtraces showing 
only raw addresses even though symbols were present.

The solution was to use the explicit Unicode versions (SYMBOL_INFOW and
SymFromAddrW), which reliably return UTF-16 strings that wchar2char() 
can properly convert to the database encoding. This handles both UTF-8 
and non-UTF-8 databases correctly, and wchar2char() gracefully returns 
-1 on conversion failure rather than throwing errors during error 
handling. Of course this also necessitated using IMAGEHLP_LINEW64 and 
SymGetLineFromAddrW64.

Tested with both UTF-8 and WIN1252 databases - backtraces now show 
proper symbol names in both cases.

This patch also adds a check for zero frames returned by backtrace() on
Unix/Linux platforms, which can occur in certain circumstances such as 
ARM builds without unwind tables.

Bryan
--------------039VLw0kFoiPSKdhD07erXm9
Content-Type: text/plain; charset=UTF-8;
 name="v5-0001-Add-Windows-support-for-backtrace_functions.patch"
Content-Disposition: attachment;
 filename*0="v5-0001-Add-Windows-support-for-backtrace_functions.patch"
Content-Transfer-Encoding: base64
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--------------039VLw0kFoiPSKdhD07erXm9--