1 /*-------------------------------------------------------------------------
2 *
3 * evtcache.c
4 * Special-purpose cache for event trigger data.
5 *
6 * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
8 *
9 * IDENTIFICATION
10 * src/backend/utils/cache/evtcache.c
11 *
12 *-------------------------------------------------------------------------
13 */
14 #include "postgres.h"
15
16 #include "access/genam.h"
17 #include "access/htup_details.h"
18 #include "access/relation.h"
19 #include "catalog/pg_event_trigger.h"
20 #include "catalog/pg_type.h"
21 #include "commands/trigger.h"
22 #include "tcop/cmdtag.h"
23 #include "utils/array.h"
24 #include "utils/builtins.h"
25 #include "utils/catcache.h"
26 #include "utils/evtcache.h"
27 #include "utils/hsearch.h"
28 #include "utils/inval.h"
29 #include "utils/memutils.h"
30 #include "utils/rel.h"
31 #include "utils/snapmgr.h"
32 #include "utils/syscache.h"
33
34 typedef enum
35 {
36 ETCS_NEEDS_REBUILD,
37 ETCS_REBUILD_STARTED,
38 ETCS_VALID
39 } EventTriggerCacheStateType;
40
41 typedef struct
42 {
43 EventTriggerEvent event;
44 List *triggerlist;
45 } EventTriggerCacheEntry;
46
47 static HTAB *EventTriggerCache;
48 static MemoryContext EventTriggerCacheContext;
49 static EventTriggerCacheStateType EventTriggerCacheState = ETCS_NEEDS_REBUILD;
50
51 static void BuildEventTriggerCache(void);
52 static void InvalidateEventCacheCallback(Datum arg,
53 int cacheid, uint32 hashvalue);
54 static Bitmapset *DecodeTextArrayToBitmapset(Datum array);
55
56 /*
57 * Search the event cache by trigger event.
58 *
59 * Note that the caller had better copy any data it wants to keep around
60 * across any operation that might touch a system catalog into some other
61 * memory context, since a cache reset could blow the return value away.
62 */
63 List *
EventCacheLookup(EventTriggerEvent event)64 EventCacheLookup(EventTriggerEvent event)
65 {
66 EventTriggerCacheEntry *entry;
67
68 if (EventTriggerCacheState != ETCS_VALID)
69 BuildEventTriggerCache();
70 entry = hash_search(EventTriggerCache, &event, HASH_FIND, NULL);
71 return entry != NULL ? entry->triggerlist : NIL;
72 }
73
74 /*
75 * Rebuild the event trigger cache.
76 */
77 static void
BuildEventTriggerCache(void)78 BuildEventTriggerCache(void)
79 {
80 HASHCTL ctl;
81 HTAB *cache;
82 MemoryContext oldcontext;
83 Relation rel;
84 Relation irel;
85 SysScanDesc scan;
86
87 if (EventTriggerCacheContext != NULL)
88 {
89 /*
90 * Free up any memory already allocated in EventTriggerCacheContext.
91 * This can happen either because a previous rebuild failed, or
92 * because an invalidation happened before the rebuild was complete.
93 */
94 MemoryContextResetAndDeleteChildren(EventTriggerCacheContext);
95 }
96 else
97 {
98 /*
99 * This is our first time attempting to build the cache, so we need to
100 * set up the memory context and register a syscache callback to
101 * capture future invalidation events.
102 */
103 if (CacheMemoryContext == NULL)
104 CreateCacheMemoryContext();
105 EventTriggerCacheContext =
106 AllocSetContextCreate(CacheMemoryContext,
107 "EventTriggerCache",
108 ALLOCSET_DEFAULT_SIZES);
109 CacheRegisterSyscacheCallback(EVENTTRIGGEROID,
110 InvalidateEventCacheCallback,
111 (Datum) 0);
112 }
113
114 /* Switch to correct memory context. */
115 oldcontext = MemoryContextSwitchTo(EventTriggerCacheContext);
116
117 /* Prevent the memory context from being nuked while we're rebuilding. */
118 EventTriggerCacheState = ETCS_REBUILD_STARTED;
119
120 /* Create new hash table. */
121 ctl.keysize = sizeof(EventTriggerEvent);
122 ctl.entrysize = sizeof(EventTriggerCacheEntry);
123 ctl.hcxt = EventTriggerCacheContext;
124 cache = hash_create("Event Trigger Cache", 32, &ctl,
125 HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
126
127 /*
128 * Prepare to scan pg_event_trigger in name order.
129 */
130 rel = relation_open(EventTriggerRelationId, AccessShareLock);
131 irel = index_open(EventTriggerNameIndexId, AccessShareLock);
132 scan = systable_beginscan_ordered(rel, irel, NULL, 0, NULL);
133
134 /*
135 * Build a cache item for each pg_event_trigger tuple, and append each one
136 * to the appropriate cache entry.
137 */
138 for (;;)
139 {
140 HeapTuple tup;
141 Form_pg_event_trigger form;
142 char *evtevent;
143 EventTriggerEvent event;
144 EventTriggerCacheItem *item;
145 Datum evttags;
146 bool evttags_isnull;
147 EventTriggerCacheEntry *entry;
148 bool found;
149
150 /* Get next tuple. */
151 tup = systable_getnext_ordered(scan, ForwardScanDirection);
152 if (!HeapTupleIsValid(tup))
153 break;
154
155 /* Skip trigger if disabled. */
156 form = (Form_pg_event_trigger) GETSTRUCT(tup);
157 if (form->evtenabled == TRIGGER_DISABLED)
158 continue;
159
160 /* Decode event name. */
161 evtevent = NameStr(form->evtevent);
162 if (strcmp(evtevent, "ddl_command_start") == 0)
163 event = EVT_DDLCommandStart;
164 else if (strcmp(evtevent, "ddl_command_end") == 0)
165 event = EVT_DDLCommandEnd;
166 else if (strcmp(evtevent, "sql_drop") == 0)
167 event = EVT_SQLDrop;
168 else if (strcmp(evtevent, "table_rewrite") == 0)
169 event = EVT_TableRewrite;
170 else
171 continue;
172
173 /* Allocate new cache item. */
174 item = palloc0(sizeof(EventTriggerCacheItem));
175 item->fnoid = form->evtfoid;
176 item->enabled = form->evtenabled;
177
178 /* Decode and sort tags array. */
179 evttags = heap_getattr(tup, Anum_pg_event_trigger_evttags,
180 RelationGetDescr(rel), &evttags_isnull);
181 if (!evttags_isnull)
182 item->tagset = DecodeTextArrayToBitmapset(evttags);
183
184 /* Add to cache entry. */
185 entry = hash_search(cache, &event, HASH_ENTER, &found);
186 if (found)
187 entry->triggerlist = lappend(entry->triggerlist, item);
188 else
189 entry->triggerlist = list_make1(item);
190 }
191
192 /* Done with pg_event_trigger scan. */
193 systable_endscan_ordered(scan);
194 index_close(irel, AccessShareLock);
195 relation_close(rel, AccessShareLock);
196
197 /* Restore previous memory context. */
198 MemoryContextSwitchTo(oldcontext);
199
200 /* Install new cache. */
201 EventTriggerCache = cache;
202
203 /*
204 * If the cache has been invalidated since we entered this routine, we
205 * still use and return the cache we just finished constructing, to avoid
206 * infinite loops, but we leave the cache marked stale so that we'll
207 * rebuild it again on next access. Otherwise, we mark the cache valid.
208 */
209 if (EventTriggerCacheState == ETCS_REBUILD_STARTED)
210 EventTriggerCacheState = ETCS_VALID;
211 }
212
213 /*
214 * Decode text[] to a Bitmapset of CommandTags.
215 *
216 * We could avoid a bit of overhead here if we were willing to duplicate some
217 * of the logic from deconstruct_array, but it doesn't seem worth the code
218 * complexity.
219 */
220 static Bitmapset *
DecodeTextArrayToBitmapset(Datum array)221 DecodeTextArrayToBitmapset(Datum array)
222 {
223 ArrayType *arr = DatumGetArrayTypeP(array);
224 Datum *elems;
225 Bitmapset *bms;
226 int i;
227 int nelems;
228
229 if (ARR_NDIM(arr) != 1 || ARR_HASNULL(arr) || ARR_ELEMTYPE(arr) != TEXTOID)
230 elog(ERROR, "expected 1-D text array");
231 deconstruct_array(arr, TEXTOID, -1, false, TYPALIGN_INT,
232 &elems, NULL, &nelems);
233
234 for (bms = NULL, i = 0; i < nelems; ++i)
235 {
236 char *str = TextDatumGetCString(elems[i]);
237
238 bms = bms_add_member(bms, GetCommandTagEnum(str));
239 pfree(str);
240 }
241
242 pfree(elems);
243
244 return bms;
245 }
246
247 /*
248 * Flush all cache entries when pg_event_trigger is updated.
249 *
250 * This should be rare enough that we don't need to be very granular about
251 * it, so we just blow away everything, which also avoids the possibility of
252 * memory leaks.
253 */
254 static void
InvalidateEventCacheCallback(Datum arg,int cacheid,uint32 hashvalue)255 InvalidateEventCacheCallback(Datum arg, int cacheid, uint32 hashvalue)
256 {
257 /*
258 * If the cache isn't valid, then there might be a rebuild in progress, so
259 * we can't immediately blow it away. But it's advantageous to do this
260 * when possible, so as to immediately free memory.
261 */
262 if (EventTriggerCacheState == ETCS_VALID)
263 {
264 MemoryContextResetAndDeleteChildren(EventTriggerCacheContext);
265 EventTriggerCache = NULL;
266 }
267
268 /* Mark cache for rebuild. */
269 EventTriggerCacheState = ETCS_NEEDS_REBUILD;
270 }
271