From: Tom Lane Date: Thu, 5 Mar 2026 19:43:21 +0000 (-0500) Subject: Exit after fatal errors in client-side compression code. X-Git-Tag: REL_16_14~84 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=cce939c71c11e9434d96c60977bc805682f3d18d;p=thirdparty%2Fpostgresql.git Exit after fatal errors in client-side compression code. It looks like whoever wrote the astreamer (nee bbstreamer) code thought that pg_log_error() is equivalent to elog(ERROR), but it's not; it just prints a message. So all these places tried to continue on after a compression or decompression error return, with the inevitable result being garbage output and possibly cascading error messages. We should use pg_fatal() instead. These error conditions are probably pretty unlikely in practice, which no doubt accounts for the lack of field complaints. Author: Tom Lane Reviewed-by: Chao Li Discussion: https://postgr.es/m/1531718.1772644615@sss.pgh.pa.us Backpatch-through: 15 --- diff --git a/src/bin/pg_basebackup/bbstreamer_gzip.c b/src/bin/pg_basebackup/bbstreamer_gzip.c index 3bdbfa0bc43..c62265ac86f 100644 --- a/src/bin/pg_basebackup/bbstreamer_gzip.c +++ b/src/bin/pg_basebackup/bbstreamer_gzip.c @@ -293,7 +293,7 @@ bbstreamer_gzip_decompressor_content(bbstreamer *streamer, res = inflate(zs, Z_NO_FLUSH); if (res == Z_STREAM_ERROR) - pg_log_error("could not decompress data: %s", zs->msg); + pg_fatal("could not decompress data: %s", zs->msg); mystreamer->bytes_written = mystreamer->base.bbs_buffer.maxlen - zs->avail_out; diff --git a/src/bin/pg_basebackup/bbstreamer_lz4.c b/src/bin/pg_basebackup/bbstreamer_lz4.c index 283fafcb961..a9f57d56ac0 100644 --- a/src/bin/pg_basebackup/bbstreamer_lz4.c +++ b/src/bin/pg_basebackup/bbstreamer_lz4.c @@ -92,8 +92,8 @@ bbstreamer_lz4_compressor_new(bbstreamer *next, pg_compress_specification *compr ctxError = LZ4F_createCompressionContext(&streamer->cctx, LZ4F_VERSION); if (LZ4F_isError(ctxError)) - pg_log_error("could not create lz4 compression context: %s", - LZ4F_getErrorName(ctxError)); + pg_fatal("could not create lz4 compression context: %s", + LZ4F_getErrorName(ctxError)); return &streamer->base; #else @@ -137,8 +137,8 @@ bbstreamer_lz4_compressor_content(bbstreamer *streamer, &mystreamer->prefs); if (LZ4F_isError(compressed_size)) - pg_log_error("could not write lz4 header: %s", - LZ4F_getErrorName(compressed_size)); + pg_fatal("could not write lz4 header: %s", + LZ4F_getErrorName(compressed_size)); mystreamer->bytes_written += compressed_size; mystreamer->header_written = true; @@ -186,8 +186,8 @@ bbstreamer_lz4_compressor_content(bbstreamer *streamer, next_in, len, NULL); if (LZ4F_isError(compressed_size)) - pg_log_error("could not compress data: %s", - LZ4F_getErrorName(compressed_size)); + pg_fatal("could not compress data: %s", + LZ4F_getErrorName(compressed_size)); mystreamer->bytes_written += compressed_size; } @@ -238,8 +238,8 @@ bbstreamer_lz4_compressor_finalize(bbstreamer *streamer) next_out, avail_out, NULL); if (LZ4F_isError(compressed_size)) - pg_log_error("could not end lz4 compression: %s", - LZ4F_getErrorName(compressed_size)); + pg_fatal("could not end lz4 compression: %s", + LZ4F_getErrorName(compressed_size)); mystreamer->bytes_written += compressed_size; @@ -351,8 +351,8 @@ bbstreamer_lz4_decompressor_content(bbstreamer *streamer, next_in, &read_size, NULL); if (LZ4F_isError(ret)) - pg_log_error("could not decompress data: %s", - LZ4F_getErrorName(ret)); + pg_fatal("could not decompress data: %s", + LZ4F_getErrorName(ret)); /* Update input buffer based on number of bytes consumed */ avail_in -= read_size; diff --git a/src/bin/pg_basebackup/bbstreamer_zstd.c b/src/bin/pg_basebackup/bbstreamer_zstd.c index 58e32ca5bb0..6e220a2ebd7 100644 --- a/src/bin/pg_basebackup/bbstreamer_zstd.c +++ b/src/bin/pg_basebackup/bbstreamer_zstd.c @@ -112,11 +112,8 @@ bbstreamer_zstd_compressor_new(bbstreamer *next, pg_compress_specification *comp ZSTD_c_enableLongDistanceMatching, compress->long_distance); if (ZSTD_isError(ret)) - { - pg_log_error("could not enable long-distance mode: %s", - ZSTD_getErrorName(ret)); - exit(1); - } + pg_fatal("could not enable long-distance mode: %s", + ZSTD_getErrorName(ret)); } /* Initialize the ZSTD output buffer. */ @@ -178,8 +175,8 @@ bbstreamer_zstd_compressor_content(bbstreamer *streamer, &inBuf, ZSTD_e_continue); if (ZSTD_isError(yet_to_flush)) - pg_log_error("could not compress data: %s", - ZSTD_getErrorName(yet_to_flush)); + pg_fatal("could not compress data: %s", + ZSTD_getErrorName(yet_to_flush)); } } @@ -220,8 +217,8 @@ bbstreamer_zstd_compressor_finalize(bbstreamer *streamer) &in, ZSTD_e_end); if (ZSTD_isError(yet_to_flush)) - pg_log_error("could not compress data: %s", - ZSTD_getErrorName(yet_to_flush)); + pg_fatal("could not compress data: %s", + ZSTD_getErrorName(yet_to_flush)); } while (yet_to_flush > 0); @@ -326,8 +323,8 @@ bbstreamer_zstd_decompressor_content(bbstreamer *streamer, &mystreamer->zstd_outBuf, &inBuf); if (ZSTD_isError(ret)) - pg_log_error("could not decompress data: %s", - ZSTD_getErrorName(ret)); + pg_fatal("could not decompress data: %s", + ZSTD_getErrorName(ret)); } } diff --git a/src/bin/pg_dump/compress_lz4.c b/src/bin/pg_dump/compress_lz4.c index 3c4418a4873..6f3bd2fd22a 100644 --- a/src/bin/pg_dump/compress_lz4.c +++ b/src/bin/pg_dump/compress_lz4.c @@ -678,6 +678,7 @@ LZ4Stream_close(CompressFileHandle *CFH) LZ4State *state = (LZ4State *) CFH->private_data; size_t status; int ret; + bool success = true; fp = state->fp; if (state->inited) @@ -689,6 +690,7 @@ LZ4Stream_close(CompressFileHandle *CFH) { pg_log_error("could not end compression: %s", LZ4F_getErrorName(status)); + success = false; } else { @@ -697,20 +699,27 @@ LZ4Stream_close(CompressFileHandle *CFH) { errno = (errno) ? errno : ENOSPC; pg_log_error("could not write to output file: %m"); + success = false; } } status = LZ4F_freeCompressionContext(state->ctx); if (LZ4F_isError(status)) + { pg_log_error("could not end compression: %s", LZ4F_getErrorName(status)); + success = false; + } } else { status = LZ4F_freeDecompressionContext(state->dtx); if (LZ4F_isError(status)) + { pg_log_error("could not end decompression: %s", LZ4F_getErrorName(status)); + success = false; + } pg_free(state->overflowbuf); } @@ -725,10 +734,10 @@ LZ4Stream_close(CompressFileHandle *CFH) if (ret != 0) { pg_log_error("could not close file: %m"); - return false; + success = false; } - return true; + return success; } static bool