public inbox for [email protected]help / color / mirror / Atom feed
pgsql: Avoid concurrent calls to bindtextdomain(). 6+ messages / 1 participants [nested] [flat]
* pgsql: Avoid concurrent calls to bindtextdomain(). @ 2024-02-09 16:21 Tom Lane <[email protected]> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-02-09 16:21 UTC (permalink / raw) To: [email protected] Avoid concurrent calls to bindtextdomain(). We previously supposed that it was okay for different threads to call bindtextdomain() concurrently (cf. commit 1f655fdc3). It now emerges that there's at least one gettext implementation in which that triggers an abort() crash, so let's stop doing that. Add mutexes guarding libpq's and ecpglib's calls, which are the only ones that need worry about multithreaded callers. Note: in libpq, we could perhaps have piggybacked on default_threadlock() to avoid defining a new mutex variable. I judge that not terribly safe though, since libpq_gettext could be called from code that is holding the default mutex. If that were the first such call in the process, it'd fail. An extra mutex is cheap insurance against unforeseen interactions. Per bug #18312 from Christian Maurer. Back-patch to all supported versions. Discussion: https://postgr.es/m/[email protected] Discussion: https://postgr.es/m/[email protected] Branch ------ master Details ------- https://git.postgresql.org/pg/commitdiff/a584d03ced5fe302256160b4d8961d4ea9b3cc52 Modified Files -------------- src/interfaces/ecpg/ecpglib/misc.c | 39 +++++++++++++++++++++++++------------- src/interfaces/libpq/fe-misc.c | 39 +++++++++++++++++++++++++------------- 2 files changed, 52 insertions(+), 26 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Avoid concurrent calls to bindtextdomain(). @ 2024-02-09 16:21 Tom Lane <[email protected]> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-02-09 16:21 UTC (permalink / raw) To: [email protected] Avoid concurrent calls to bindtextdomain(). We previously supposed that it was okay for different threads to call bindtextdomain() concurrently (cf. commit 1f655fdc3). It now emerges that there's at least one gettext implementation in which that triggers an abort() crash, so let's stop doing that. Add mutexes guarding libpq's and ecpglib's calls, which are the only ones that need worry about multithreaded callers. Note: in libpq, we could perhaps have piggybacked on default_threadlock() to avoid defining a new mutex variable. I judge that not terribly safe though, since libpq_gettext could be called from code that is holding the default mutex. If that were the first such call in the process, it'd fail. An extra mutex is cheap insurance against unforeseen interactions. Per bug #18312 from Christian Maurer. Back-patch to all supported versions. Discussion: https://postgr.es/m/[email protected] Discussion: https://postgr.es/m/[email protected] Branch ------ REL_16_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/52afe563206e753f4c45c014fee2459ad0855826 Modified Files -------------- src/interfaces/ecpg/ecpglib/misc.c | 39 +++++++++++++++++++++++++------------- src/interfaces/libpq/fe-misc.c | 39 +++++++++++++++++++++++++------------- 2 files changed, 52 insertions(+), 26 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Avoid concurrent calls to bindtextdomain(). @ 2024-02-09 16:21 Tom Lane <[email protected]> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-02-09 16:21 UTC (permalink / raw) To: [email protected] Avoid concurrent calls to bindtextdomain(). We previously supposed that it was okay for different threads to call bindtextdomain() concurrently (cf. commit 1f655fdc3). It now emerges that there's at least one gettext implementation in which that triggers an abort() crash, so let's stop doing that. Add mutexes guarding libpq's and ecpglib's calls, which are the only ones that need worry about multithreaded callers. Note: in libpq, we could perhaps have piggybacked on default_threadlock() to avoid defining a new mutex variable. I judge that not terribly safe though, since libpq_gettext could be called from code that is holding the default mutex. If that were the first such call in the process, it'd fail. An extra mutex is cheap insurance against unforeseen interactions. Per bug #18312 from Christian Maurer. Back-patch to all supported versions. Discussion: https://postgr.es/m/[email protected] Discussion: https://postgr.es/m/[email protected] Branch ------ REL_13_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/8c5da20db298024ef22368c46bf8a5b90a371cc6 Modified Files -------------- src/interfaces/ecpg/ecpglib/misc.c | 39 +++++++++++++++++++++++++------------- src/interfaces/libpq/fe-misc.c | 39 +++++++++++++++++++++++++------------- 2 files changed, 52 insertions(+), 26 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Avoid concurrent calls to bindtextdomain(). @ 2024-02-09 16:21 Tom Lane <[email protected]> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-02-09 16:21 UTC (permalink / raw) To: [email protected] Avoid concurrent calls to bindtextdomain(). We previously supposed that it was okay for different threads to call bindtextdomain() concurrently (cf. commit 1f655fdc3). It now emerges that there's at least one gettext implementation in which that triggers an abort() crash, so let's stop doing that. Add mutexes guarding libpq's and ecpglib's calls, which are the only ones that need worry about multithreaded callers. Note: in libpq, we could perhaps have piggybacked on default_threadlock() to avoid defining a new mutex variable. I judge that not terribly safe though, since libpq_gettext could be called from code that is holding the default mutex. If that were the first such call in the process, it'd fail. An extra mutex is cheap insurance against unforeseen interactions. Per bug #18312 from Christian Maurer. Back-patch to all supported versions. Discussion: https://postgr.es/m/[email protected] Discussion: https://postgr.es/m/[email protected] Branch ------ REL_14_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/8ead39e3895ed7b1a60036a4bcc09fbe2f8d6bde Modified Files -------------- src/interfaces/ecpg/ecpglib/misc.c | 39 +++++++++++++++++++++++++------------- src/interfaces/libpq/fe-misc.c | 39 +++++++++++++++++++++++++------------- 2 files changed, 52 insertions(+), 26 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Avoid concurrent calls to bindtextdomain(). @ 2024-02-09 16:21 Tom Lane <[email protected]> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-02-09 16:21 UTC (permalink / raw) To: [email protected] Avoid concurrent calls to bindtextdomain(). We previously supposed that it was okay for different threads to call bindtextdomain() concurrently (cf. commit 1f655fdc3). It now emerges that there's at least one gettext implementation in which that triggers an abort() crash, so let's stop doing that. Add mutexes guarding libpq's and ecpglib's calls, which are the only ones that need worry about multithreaded callers. Note: in libpq, we could perhaps have piggybacked on default_threadlock() to avoid defining a new mutex variable. I judge that not terribly safe though, since libpq_gettext could be called from code that is holding the default mutex. If that were the first such call in the process, it'd fail. An extra mutex is cheap insurance against unforeseen interactions. Per bug #18312 from Christian Maurer. Back-patch to all supported versions. Discussion: https://postgr.es/m/[email protected] Discussion: https://postgr.es/m/[email protected] Branch ------ REL_12_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/9fb1396a96bd3b3bba4adf81b28ebbf60d66d1ee Modified Files -------------- src/interfaces/ecpg/ecpglib/misc.c | 39 +++++++++++++++++++++++++------------- src/interfaces/libpq/fe-misc.c | 39 +++++++++++++++++++++++++------------- 2 files changed, 52 insertions(+), 26 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Avoid concurrent calls to bindtextdomain(). @ 2024-02-09 16:21 Tom Lane <[email protected]> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2024-02-09 16:21 UTC (permalink / raw) To: [email protected] Avoid concurrent calls to bindtextdomain(). We previously supposed that it was okay for different threads to call bindtextdomain() concurrently (cf. commit 1f655fdc3). It now emerges that there's at least one gettext implementation in which that triggers an abort() crash, so let's stop doing that. Add mutexes guarding libpq's and ecpglib's calls, which are the only ones that need worry about multithreaded callers. Note: in libpq, we could perhaps have piggybacked on default_threadlock() to avoid defining a new mutex variable. I judge that not terribly safe though, since libpq_gettext could be called from code that is holding the default mutex. If that were the first such call in the process, it'd fail. An extra mutex is cheap insurance against unforeseen interactions. Per bug #18312 from Christian Maurer. Back-patch to all supported versions. Discussion: https://postgr.es/m/[email protected] Discussion: https://postgr.es/m/[email protected] Branch ------ REL_15_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/806f98951511715fb36a70a582e87e1c40293407 Modified Files -------------- src/interfaces/ecpg/ecpglib/misc.c | 39 +++++++++++++++++++++++++------------- src/interfaces/libpq/fe-misc.c | 39 +++++++++++++++++++++++++------------- 2 files changed, 52 insertions(+), 26 deletions(-) ^ permalink raw reply [nested|flat] 6+ messages in thread
end of thread, other threads:[~2024-02-09 16:21 UTC | newest] Thread overview: 6+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2024-02-09 16:21 pgsql: Avoid concurrent calls to bindtextdomain(). Tom Lane <[email protected]> 2024-02-09 16:21 pgsql: Avoid concurrent calls to bindtextdomain(). Tom Lane <[email protected]> 2024-02-09 16:21 pgsql: Avoid concurrent calls to bindtextdomain(). Tom Lane <[email protected]> 2024-02-09 16:21 pgsql: Avoid concurrent calls to bindtextdomain(). Tom Lane <[email protected]> 2024-02-09 16:21 pgsql: Avoid concurrent calls to bindtextdomain(). Tom Lane <[email protected]> 2024-02-09 16:21 pgsql: Avoid concurrent calls to bindtextdomain(). Tom Lane <[email protected]>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox