Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * mcxtfuncs.c
4 : : * Functions to show backend memory context.
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : *
10 : : * IDENTIFICATION
11 : : * src/backend/utils/adt/mcxtfuncs.c
12 : : *
13 : : *-------------------------------------------------------------------------
14 : : */
15 : :
16 : : #include "postgres.h"
17 : :
18 : : #include "catalog/pg_type_d.h"
19 : : #include "funcapi.h"
20 : : #include "mb/pg_wchar.h"
21 : : #include "storage/proc.h"
22 : : #include "storage/procarray.h"
23 : : #include "storage/procsignal.h"
24 : : #include "utils/array.h"
25 : : #include "utils/builtins.h"
26 : : #include "utils/hsearch.h"
27 : : #include "utils/tuplestore.h"
28 : :
29 : : /* ----------
30 : : * The max bytes for showing identifiers of MemoryContext.
31 : : * ----------
32 : : */
33 : : #define MEMORY_CONTEXT_IDENT_DISPLAY_SIZE 1024
34 : :
35 : : /*
36 : : * MemoryContextId
37 : : * Used for storage of transient identifiers for
38 : : * pg_get_backend_memory_contexts.
39 : : */
40 : : typedef struct MemoryContextId
41 : : {
42 : : MemoryContext context;
43 : : int context_id;
44 : : } MemoryContextId;
45 : :
46 : : /*
47 : : * int_list_to_array
48 : : * Convert an IntList to an array of INT4OIDs.
49 : : */
50 : : static Datum
51 : 2216 : int_list_to_array(const List *list)
52 : : {
53 : : Datum *datum_array;
54 : : int length;
55 : : ArrayType *result_array;
56 : :
57 : 2216 : length = list_length(list);
58 : 2216 : datum_array = palloc_array(Datum, length);
59 : :
60 [ + - + + : 10996 : foreach_int(i, list)
+ + ]
61 : 6564 : datum_array[foreach_current_index(i)] = Int32GetDatum(i);
62 : :
63 : 2216 : result_array = construct_array_builtin(datum_array, length, INT4OID);
64 : :
65 : 2216 : return PointerGetDatum(result_array);
66 : : }
67 : :
68 : : /*
69 : : * PutMemoryContextsStatsTupleStore
70 : : * Add details for the given MemoryContext to 'tupstore'.
71 : : */
72 : : static void
73 : 2216 : PutMemoryContextsStatsTupleStore(Tuplestorestate *tupstore,
74 : : TupleDesc tupdesc, MemoryContext context,
75 : : HTAB *context_id_lookup)
76 : : {
77 : : #define PG_GET_BACKEND_MEMORY_CONTEXTS_COLS 10
78 : :
79 : : Datum values[PG_GET_BACKEND_MEMORY_CONTEXTS_COLS];
80 : : bool nulls[PG_GET_BACKEND_MEMORY_CONTEXTS_COLS];
81 : : MemoryContextCounters stat;
82 : 2216 : List *path = NIL;
83 : : const char *name;
84 : : const char *ident;
85 : : const char *type;
86 : :
87 : : Assert(MemoryContextIsValid(context));
88 : :
89 : : /*
90 : : * Figure out the transient context_id of this context and each of its
91 : : * ancestors.
92 : : */
93 [ + + ]: 8780 : for (MemoryContext cur = context; cur != NULL; cur = cur->parent)
94 : : {
95 : : MemoryContextId *entry;
96 : : bool found;
97 : :
98 : 6564 : entry = hash_search(context_id_lookup, &cur, HASH_FIND, &found);
99 : :
100 [ - + ]: 6564 : if (!found)
101 [ # # ]: 0 : elog(ERROR, "hash table corrupted");
102 : 6564 : path = lcons_int(entry->context_id, path);
103 : : }
104 : :
105 : : /* Examine the context itself */
106 : 2216 : memset(&stat, 0, sizeof(stat));
107 : 2216 : (*context->methods->stats) (context, NULL, NULL, &stat, true);
108 : :
109 : 2216 : memset(values, 0, sizeof(values));
110 : 2216 : memset(nulls, 0, sizeof(nulls));
111 : :
112 : 2216 : name = context->name;
113 : 2216 : ident = context->ident;
114 : :
115 : : /*
116 : : * To be consistent with logging output, we label dynahash contexts with
117 : : * just the hash table name as with MemoryContextStatsPrint().
118 : : */
119 [ + + + + ]: 2216 : if (ident && strcmp(name, "dynahash") == 0)
120 : : {
121 : 184 : name = ident;
122 : 184 : ident = NULL;
123 : : }
124 : :
125 [ + - ]: 2216 : if (name)
126 : 2216 : values[0] = CStringGetTextDatum(name);
127 : : else
128 : 0 : nulls[0] = true;
129 : :
130 [ + + ]: 2216 : if (ident)
131 : : {
132 : 1644 : int idlen = strlen(ident);
133 : : char clipped_ident[MEMORY_CONTEXT_IDENT_DISPLAY_SIZE];
134 : :
135 : : /*
136 : : * Some identifiers such as SQL query string can be very long,
137 : : * truncate oversize identifiers.
138 : : */
139 [ - + ]: 1644 : if (idlen >= MEMORY_CONTEXT_IDENT_DISPLAY_SIZE)
140 : 0 : idlen = pg_mbcliplen(ident, idlen, MEMORY_CONTEXT_IDENT_DISPLAY_SIZE - 1);
141 : :
142 : 1644 : memcpy(clipped_ident, ident, idlen);
143 : 1644 : clipped_ident[idlen] = '\0';
144 : 1644 : values[1] = CStringGetTextDatum(clipped_ident);
145 : : }
146 : : else
147 : 572 : nulls[1] = true;
148 : :
149 [ + + - + : 2216 : switch (context->type)
- ]
150 : : {
151 : 2192 : case T_AllocSetContext:
152 : 2192 : type = "AllocSet";
153 : 2192 : break;
154 : 20 : case T_GenerationContext:
155 : 20 : type = "Generation";
156 : 20 : break;
157 : 0 : case T_SlabContext:
158 : 0 : type = "Slab";
159 : 0 : break;
160 : 4 : case T_BumpContext:
161 : 4 : type = "Bump";
162 : 4 : break;
163 : 0 : default:
164 : 0 : type = "???";
165 : 0 : break;
166 : : }
167 : :
168 : 2216 : values[2] = CStringGetTextDatum(type);
169 : 2216 : values[3] = Int32GetDatum(list_length(path)); /* level */
170 : 2216 : values[4] = int_list_to_array(path);
171 : 2216 : values[5] = Int64GetDatum(stat.totalspace);
172 : 2216 : values[6] = Int64GetDatum(stat.nblocks);
173 : 2216 : values[7] = Int64GetDatum(stat.freespace);
174 : 2216 : values[8] = Int64GetDatum(stat.freechunks);
175 : 2216 : values[9] = Int64GetDatum(stat.totalspace - stat.freespace);
176 : :
177 : 2216 : tuplestore_putvalues(tupstore, tupdesc, values, nulls);
178 : 2216 : list_free(path);
179 : 2216 : }
180 : :
181 : : /*
182 : : * pg_get_backend_memory_contexts
183 : : * SQL SRF showing backend memory context.
184 : : */
185 : : Datum
186 : 16 : pg_get_backend_memory_contexts(PG_FUNCTION_ARGS)
187 : : {
188 : 16 : ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
189 : : int context_id;
190 : : List *contexts;
191 : : HASHCTL ctl;
192 : : HTAB *context_id_lookup;
193 : :
194 : 16 : ctl.keysize = sizeof(MemoryContext);
195 : 16 : ctl.entrysize = sizeof(MemoryContextId);
196 : 16 : ctl.hcxt = CurrentMemoryContext;
197 : :
198 : 16 : context_id_lookup = hash_create("pg_get_backend_memory_contexts",
199 : : 256,
200 : : &ctl,
201 : : HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
202 : :
203 : 16 : InitMaterializedSRF(fcinfo, 0);
204 : :
205 : : /*
206 : : * Here we use a non-recursive algorithm to visit all MemoryContexts
207 : : * starting with TopMemoryContext. The reason we avoid using a recursive
208 : : * algorithm is because we want to assign the context_id breadth-first.
209 : : * I.e. all contexts at level 1 are assigned IDs before contexts at level
210 : : * 2. Because contexts closer to TopMemoryContext are less likely to
211 : : * change, this makes the assigned context_id more stable. Otherwise, if
212 : : * the first child of TopMemoryContext obtained an additional grandchild,
213 : : * the context_id for the second child of TopMemoryContext would change.
214 : : */
215 : 16 : contexts = list_make1(TopMemoryContext);
216 : :
217 : : /* TopMemoryContext will always have a context_id of 1 */
218 : 16 : context_id = 1;
219 : :
220 [ + - + + : 2248 : foreach_ptr(MemoryContextData, cur, contexts)
+ + ]
221 : : {
222 : : MemoryContextId *entry;
223 : : bool found;
224 : :
225 : : /*
226 : : * Record the context_id that we've assigned to each MemoryContext.
227 : : * PutMemoryContextsStatsTupleStore needs this to populate the "path"
228 : : * column with the parent context_ids.
229 : : */
230 : 2216 : entry = (MemoryContextId *) hash_search(context_id_lookup, &cur,
231 : : HASH_ENTER, &found);
232 : 2216 : entry->context_id = context_id++;
233 : : Assert(!found);
234 : :
235 : 2216 : PutMemoryContextsStatsTupleStore(rsinfo->setResult,
236 : : rsinfo->setDesc,
237 : : cur,
238 : : context_id_lookup);
239 : :
240 : : /*
241 : : * Append all children onto the contexts list so they're processed by
242 : : * subsequent iterations.
243 : : */
244 [ + + ]: 4416 : for (MemoryContext c = cur->firstchild; c != NULL; c = c->nextchild)
245 : 2200 : contexts = lappend(contexts, c);
246 : : }
247 : :
248 : 16 : hash_destroy(context_id_lookup);
249 : :
250 : 16 : return (Datum) 0;
251 : : }
252 : :
253 : : /*
254 : : * pg_log_backend_memory_contexts
255 : : * Signal a backend or an auxiliary process to log its memory contexts.
256 : : *
257 : : * By default, only superusers are allowed to signal to log the memory
258 : : * contexts because allowing any users to issue this request at an unbounded
259 : : * rate would cause lots of log messages and which can lead to denial of
260 : : * service. Additional roles can be permitted with GRANT.
261 : : *
262 : : * On receipt of this signal, a backend or an auxiliary process sets the flag
263 : : * in the signal handler, which causes the next CHECK_FOR_INTERRUPTS()
264 : : * or process-specific interrupt handler to log the memory contexts.
265 : : */
266 : : Datum
267 : 13 : pg_log_backend_memory_contexts(PG_FUNCTION_ARGS)
268 : : {
269 : 13 : int pid = PG_GETARG_INT32(0);
270 : : PGPROC *proc;
271 : 13 : ProcNumber procNumber = INVALID_PROC_NUMBER;
272 : :
273 : : /*
274 : : * See if the process with given pid is a backend or an auxiliary process.
275 : : */
276 : 13 : proc = BackendPidGetProc(pid);
277 [ + + ]: 13 : if (proc == NULL)
278 : 4 : proc = AuxiliaryPidGetProc(pid);
279 : :
280 : : /*
281 : : * BackendPidGetProc() and AuxiliaryPidGetProc() return NULL if the pid
282 : : * isn't valid; but by the time we reach kill(), a process for which we
283 : : * get a valid proc here might have terminated on its own. There's no way
284 : : * to acquire a lock on an arbitrary process to prevent that. But since
285 : : * this mechanism is usually used to debug a backend or an auxiliary
286 : : * process running and consuming lots of memory, that it might end on its
287 : : * own first and its memory contexts are not logged is not a problem.
288 : : */
289 [ - + ]: 13 : if (proc == NULL)
290 : : {
291 : : /*
292 : : * This is just a warning so a loop-through-resultset will not abort
293 : : * if one backend terminated on its own during the run.
294 : : */
295 [ # # ]: 0 : ereport(WARNING,
296 : : (errmsg("PID %d is not a PostgreSQL server process", pid)));
297 : 0 : PG_RETURN_BOOL(false);
298 : : }
299 : :
300 : 13 : procNumber = GetNumberFromPGProc(proc);
301 [ - + ]: 13 : if (SendProcSignal(pid, PROCSIG_LOG_MEMORY_CONTEXT, procNumber) < 0)
302 : : {
303 : : /* Again, just a warning to allow loops */
304 [ # # ]: 0 : ereport(WARNING,
305 : : (errmsg("could not send signal to process %d: %m", pid)));
306 : 0 : PG_RETURN_BOOL(false);
307 : : }
308 : :
309 : 13 : PG_RETURN_BOOL(true);
310 : : }
|
