mirror of https://github.com/postgres/postgres
Commitpull/236/head232d8caeafixed a case where postgres_fdw could lose track of a PGresult object, resulting in a process-lifespan memory leak. But I have little faith that there aren't other potential PGresult leakages, now or in future, in the backend modules that use libpq. Therefore, this patch proposes infrastructure that makes all PGresults returned from libpq act as though they are palloc'd in the CurrentMemoryContext (with the option to relocate them to another context later). This should greatly reduce the risk of careless leaks, and it also permits removal of a bunch of code that attempted to prevent such leaks via PG_TRY blocks. This patch adds infrastructure that wraps each PGresult in a "libpqsrv_PGresult" that provides a memory context reset callback to PQclear the PGresult. Code using this abstraction is inherently memory-safe to the same extent as we are accustomed to in most backend code. Furthermore, we add some macros that automatically redirect calls of the libpq functions concerned with PGresults to use this infrastructure, so that almost no source-code changes are needed to wheel this infrastructure into place in all the backend code that uses libpq. Perhaps in future we could create similar infrastructure for PGconn objects, but there seems less need for that. This patch just creates the infrastructure and makes relevant code use it, including reverting232d8caeain favor of this mechanism. A good deal of follow-on simplification is possible now that we don't have to be so cautious about freeing PGresults, but I'll put that in a separate patch. Author: Tom Lane <tgl@sss.pgh.pa.us> Reviewed-by: Matheus Alcantara <matheusssilv97@gmail.com> Discussion: https://postgr.es/m/2976982.1748049023@sss.pgh.pa.us
Tom Lane
5 months ago
parent
5457ea46d1
commit
7d8f595779
@ -0,0 +1,259 @@ |
||||
/*-------------------------------------------------------------------------
|
||||
* |
||||
* libpq-be-fe.h |
||||
* Wrapper functions for using libpq in extensions |
||||
* |
||||
* Code built directly into the backend is not allowed to link to libpq |
||||
* directly. Extension code is allowed to use libpq however. One of the |
||||
* main risks in doing so is leaking the malloc-allocated structures |
||||
* returned by libpq, causing a process-lifespan memory leak. |
||||
* |
||||
* This file provides wrapper objects to help in building memory-safe code. |
||||
* A PGresult object wrapped this way acts much as if it were palloc'd: |
||||
* it will go away when the specified context is reset or deleted. |
||||
* We might later extend the concept to other objects such as PGconns. |
||||
* |
||||
* See also the libpq-be-fe-helpers.h file, which provides additional |
||||
* facilities built on top of this one. |
||||
* |
||||
* Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group |
||||
* Portions Copyright (c) 1994, Regents of the University of California |
||||
* |
||||
* src/include/libpq/libpq-be-fe.h |
||||
* |
||||
*------------------------------------------------------------------------- |
||||
*/ |
||||
#ifndef LIBPQ_BE_FE_H |
||||
#define LIBPQ_BE_FE_H |
||||
|
||||
/*
|
||||
* Despite the name, BUILDING_DLL is set only when building code directly part |
||||
* of the backend. Which also is where libpq isn't allowed to be |
||||
* used. Obviously this doesn't protect against libpq-fe.h getting included |
||||
* otherwise, but perhaps still protects against a few mistakes... |
||||
*/ |
||||
#ifdef BUILDING_DLL |
||||
#error "libpq may not be used in code directly built into the backend" |
||||
#endif |
||||
|
||||
#include "libpq-fe.h" |
||||
|
||||
/*
|
||||
* Memory-context-safe wrapper object for a PGresult. |
||||
*/ |
||||
typedef struct libpqsrv_PGresult |
||||
{ |
||||
PGresult *res; /* the wrapped PGresult */ |
||||
MemoryContext ctx; /* the MemoryContext it's attached to */ |
||||
MemoryContextCallback cb; /* the callback that implements freeing */ |
||||
} libpqsrv_PGresult; |
||||
|
||||
|
||||
/*
|
||||
* Wrap the given PGresult in a libpqsrv_PGresult object, so that it will |
||||
* go away automatically if the current memory context is reset or deleted. |
||||
* |
||||
* To avoid potential memory leaks, backend code must always apply this |
||||
* immediately to the output of any PGresult-yielding libpq function. |
||||
*/ |
||||
static inline libpqsrv_PGresult * |
||||
libpqsrv_PQwrap(PGresult *res) |
||||
{ |
||||
libpqsrv_PGresult *bres; |
||||
MemoryContext ctx = CurrentMemoryContext; |
||||
|
||||
/* We pass through a NULL result as-is, since there's nothing to free */ |
||||
if (res == NULL) |
||||
return NULL; |
||||
/* Attempt to allocate the wrapper ... this had better not throw error */ |
||||
bres = (libpqsrv_PGresult *) |
||||
MemoryContextAllocExtended(ctx, |
||||
sizeof(libpqsrv_PGresult), |
||||
MCXT_ALLOC_NO_OOM); |
||||
/* If we failed to allocate a wrapper, free the PGresult before failing */ |
||||
if (bres == NULL) |
||||
{ |
||||
PQclear(res); |
||||
ereport(ERROR, |
||||
(errcode(ERRCODE_OUT_OF_MEMORY), |
||||
errmsg("out of memory"))); |
||||
} |
||||
/* Okay, set up the wrapper */ |
||||
bres->res = res; |
||||
bres->ctx = ctx; |
||||
bres->cb.func = (MemoryContextCallbackFunction) PQclear; |
||||
bres->cb.arg = res; |
||||
MemoryContextRegisterResetCallback(ctx, &bres->cb); |
||||
return bres; |
||||
} |
||||
|
||||
/*
|
||||
* Free a wrapped PGresult, after detaching it from the memory context. |
||||
* Like PQclear(), allow the argument to be NULL. |
||||
*/ |
||||
static inline void |
||||
libpqsrv_PQclear(libpqsrv_PGresult *bres) |
||||
{ |
||||
if (bres) |
||||
{ |
||||
MemoryContextUnregisterResetCallback(bres->ctx, &bres->cb); |
||||
PQclear(bres->res); |
||||
pfree(bres); |
||||
} |
||||
} |
||||
|
||||
/*
|
||||
* Move a wrapped PGresult to have a different parent context. |
||||
*/ |
||||
static inline libpqsrv_PGresult * |
||||
libpqsrv_PGresultSetParent(libpqsrv_PGresult *bres, MemoryContext ctx) |
||||
{ |
||||
libpqsrv_PGresult *newres; |
||||
|
||||
/* We pass through a NULL result as-is */ |
||||
if (bres == NULL) |
||||
return NULL; |
||||
/* Make a new wrapper in the target context, raising error on OOM */ |
||||
newres = (libpqsrv_PGresult *) |
||||
MemoryContextAlloc(ctx, sizeof(libpqsrv_PGresult)); |
||||
/* Okay, set up the new wrapper */ |
||||
newres->res = bres->res; |
||||
newres->ctx = ctx; |
||||
newres->cb.func = (MemoryContextCallbackFunction) PQclear; |
||||
newres->cb.arg = bres->res; |
||||
MemoryContextRegisterResetCallback(ctx, &newres->cb); |
||||
/* Disarm and delete the old wrapper */ |
||||
MemoryContextUnregisterResetCallback(bres->ctx, &bres->cb); |
||||
pfree(bres); |
||||
return newres; |
||||
} |
||||
|
||||
/*
|
||||
* Convenience wrapper for PQgetResult. |
||||
* |
||||
* We could supply wrappers for other PGresult-returning functions too, |
||||
* but at present there's no need. |
||||
*/ |
||||
static inline libpqsrv_PGresult * |
||||
libpqsrv_PQgetResult(PGconn *conn) |
||||
{ |
||||
return libpqsrv_PQwrap(PQgetResult(conn)); |
||||
} |
||||
|
||||
/*
|
||||
* Accessor functions for libpqsrv_PGresult. While it's not necessary to use |
||||
* these, they emulate the behavior of the underlying libpq functions when |
||||
* passed a NULL pointer. This is particularly important for PQresultStatus, |
||||
* which is often the first check on a result. |
||||
*/ |
||||
|
||||
static inline ExecStatusType |
||||
libpqsrv_PQresultStatus(const libpqsrv_PGresult *res) |
||||
{ |
||||
if (!res) |
||||
return PGRES_FATAL_ERROR; |
||||
return PQresultStatus(res->res); |
||||
} |
||||
|
||||
static inline const char * |
||||
libpqsrv_PQresultErrorMessage(const libpqsrv_PGresult *res) |
||||
{ |
||||
if (!res) |
||||
return ""; |
||||
return PQresultErrorMessage(res->res); |
||||
} |
||||
|
||||
static inline char * |
||||
libpqsrv_PQresultErrorField(const libpqsrv_PGresult *res, int fieldcode) |
||||
{ |
||||
if (!res) |
||||
return NULL; |
||||
return PQresultErrorField(res->res, fieldcode); |
||||
} |
||||
|
||||
static inline char * |
||||
libpqsrv_PQcmdStatus(const libpqsrv_PGresult *res) |
||||
{ |
||||
if (!res) |
||||
return NULL; |
||||
return PQcmdStatus(res->res); |
||||
} |
||||
|
||||
static inline int |
||||
libpqsrv_PQntuples(const libpqsrv_PGresult *res) |
||||
{ |
||||
if (!res) |
||||
return 0; |
||||
return PQntuples(res->res); |
||||
} |
||||
|
||||
static inline int |
||||
libpqsrv_PQnfields(const libpqsrv_PGresult *res) |
||||
{ |
||||
if (!res) |
||||
return 0; |
||||
return PQnfields(res->res); |
||||
} |
||||
|
||||
static inline char * |
||||
libpqsrv_PQgetvalue(const libpqsrv_PGresult *res, int tup_num, int field_num) |
||||
{ |
||||
if (!res) |
||||
return NULL; |
||||
return PQgetvalue(res->res, tup_num, field_num); |
||||
} |
||||
|
||||
static inline int |
||||
libpqsrv_PQgetlength(const libpqsrv_PGresult *res, int tup_num, int field_num) |
||||
{ |
||||
if (!res) |
||||
return 0; |
||||
return PQgetlength(res->res, tup_num, field_num); |
||||
} |
||||
|
||||
static inline int |
||||
libpqsrv_PQgetisnull(const libpqsrv_PGresult *res, int tup_num, int field_num) |
||||
{ |
||||
if (!res) |
||||
return 1; /* pretend it is null */ |
||||
return PQgetisnull(res->res, tup_num, field_num); |
||||
} |
||||
|
||||
static inline char * |
||||
libpqsrv_PQfname(const libpqsrv_PGresult *res, int field_num) |
||||
{ |
||||
if (!res) |
||||
return NULL; |
||||
return PQfname(res->res, field_num); |
||||
} |
||||
|
||||
static inline const char * |
||||
libpqsrv_PQcmdTuples(const libpqsrv_PGresult *res) |
||||
{ |
||||
if (!res) |
||||
return ""; |
||||
return PQcmdTuples(res->res); |
||||
} |
||||
|
||||
/*
|
||||
* Redefine these libpq entry point names concerned with PGresults so that |
||||
* they will operate on libpqsrv_PGresults instead. This avoids needing to |
||||
* convert a lot of pre-existing code, and reduces the notational differences |
||||
* between frontend and backend libpq-using code. |
||||
*/ |
||||
#define PGresult libpqsrv_PGresult |
||||
#define PQclear libpqsrv_PQclear |
||||
#define PQgetResult libpqsrv_PQgetResult |
||||
#define PQresultStatus libpqsrv_PQresultStatus |
||||
#define PQresultErrorMessage libpqsrv_PQresultErrorMessage |
||||
#define PQresultErrorField libpqsrv_PQresultErrorField |
||||
#define PQcmdStatus libpqsrv_PQcmdStatus |
||||
#define PQntuples libpqsrv_PQntuples |
||||
#define PQnfields libpqsrv_PQnfields |
||||
#define PQgetvalue libpqsrv_PQgetvalue |
||||
#define PQgetlength libpqsrv_PQgetlength |
||||
#define PQgetisnull libpqsrv_PQgetisnull |
||||
#define PQfname libpqsrv_PQfname |
||||
#define PQcmdTuples libpqsrv_PQcmdTuples |
||||
|
||||
#endif /* LIBPQ_BE_FE_H */ |
||||
Loading…
Reference in new issue