Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * relfilenumbermap.c
4 : * relfilenumber to oid mapping cache.
5 : *
6 : * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
7 : * Portions Copyright (c) 1994, Regents of the University of California
8 : *
9 : * IDENTIFICATION
10 : * src/backend/utils/cache/relfilenumbermap.c
11 : *
12 : *-------------------------------------------------------------------------
13 : */
14 : #include "postgres.h"
15 :
16 : #include "access/genam.h"
17 : #include "access/htup_details.h"
18 : #include "access/table.h"
19 : #include "catalog/pg_class.h"
20 : #include "catalog/pg_tablespace.h"
21 : #include "miscadmin.h"
22 : #include "utils/catcache.h"
23 : #include "utils/fmgroids.h"
24 : #include "utils/hsearch.h"
25 : #include "utils/inval.h"
26 : #include "utils/relfilenumbermap.h"
27 : #include "utils/relmapper.h"
28 :
29 : /* Hash table for information about each relfilenumber <-> oid pair */
30 : static HTAB *RelfilenumberMapHash = NULL;
31 :
32 : /* built first time through in InitializeRelfilenumberMap */
33 : static ScanKeyData relfilenumber_skey[2];
34 :
35 : typedef struct
36 : {
37 : Oid reltablespace;
38 : RelFileNumber relfilenumber;
39 : } RelfilenumberMapKey;
40 :
41 : typedef struct
42 : {
43 : RelfilenumberMapKey key; /* lookup key - must be first */
44 : Oid relid; /* pg_class.oid */
45 : } RelfilenumberMapEntry;
46 :
47 : /*
48 : * RelfilenumberMapInvalidateCallback
49 : * Flush mapping entries when pg_class is updated in a relevant fashion.
50 : */
51 : static void
52 49978 : RelfilenumberMapInvalidateCallback(Datum arg, Oid relid)
53 : {
54 : HASH_SEQ_STATUS status;
55 : RelfilenumberMapEntry *entry;
56 :
57 : /* callback only gets registered after creating the hash */
58 : Assert(RelfilenumberMapHash != NULL);
59 :
60 49978 : hash_seq_init(&status, RelfilenumberMapHash);
61 23640748 : while ((entry = (RelfilenumberMapEntry *) hash_seq_search(&status)) != NULL)
62 : {
63 : /*
64 : * If relid is InvalidOid, signaling a complete reset, we must remove
65 : * all entries, otherwise just remove the specific relation's entry.
66 : * Always remove negative cache entries.
67 : */
68 23590770 : if (relid == InvalidOid || /* complete reset */
69 23589890 : entry->relid == InvalidOid || /* negative cache entry */
70 23589772 : entry->relid == relid) /* individual flushed relation */
71 : {
72 1398 : if (hash_search(RelfilenumberMapHash,
73 1398 : &entry->key,
74 : HASH_REMOVE,
75 : NULL) == NULL)
76 0 : elog(ERROR, "hash table corrupted");
77 : }
78 : }
79 49978 : }
80 :
81 : /*
82 : * InitializeRelfilenumberMap
83 : * Initialize cache, either on first use or after a reset.
84 : */
85 : static void
86 452 : InitializeRelfilenumberMap(void)
87 : {
88 : HASHCTL ctl;
89 : int i;
90 :
91 : /* Make sure we've initialized CacheMemoryContext. */
92 452 : if (CacheMemoryContext == NULL)
93 0 : CreateCacheMemoryContext();
94 :
95 : /* build skey */
96 8588 : MemSet(&relfilenumber_skey, 0, sizeof(relfilenumber_skey));
97 :
98 1356 : for (i = 0; i < 2; i++)
99 : {
100 904 : fmgr_info_cxt(F_OIDEQ,
101 : &relfilenumber_skey[i].sk_func,
102 : CacheMemoryContext);
103 904 : relfilenumber_skey[i].sk_strategy = BTEqualStrategyNumber;
104 904 : relfilenumber_skey[i].sk_subtype = InvalidOid;
105 904 : relfilenumber_skey[i].sk_collation = InvalidOid;
106 : }
107 :
108 452 : relfilenumber_skey[0].sk_attno = Anum_pg_class_reltablespace;
109 452 : relfilenumber_skey[1].sk_attno = Anum_pg_class_relfilenode;
110 :
111 : /*
112 : * Only create the RelfilenumberMapHash now, so we don't end up partially
113 : * initialized when fmgr_info_cxt() above ERRORs out with an out of memory
114 : * error.
115 : */
116 452 : ctl.keysize = sizeof(RelfilenumberMapKey);
117 452 : ctl.entrysize = sizeof(RelfilenumberMapEntry);
118 452 : ctl.hcxt = CacheMemoryContext;
119 :
120 452 : RelfilenumberMapHash =
121 452 : hash_create("RelfilenumberMap cache", 64, &ctl,
122 : HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
123 :
124 : /* Watch for invalidation events. */
125 452 : CacheRegisterRelcacheCallback(RelfilenumberMapInvalidateCallback,
126 : (Datum) 0);
127 452 : }
128 :
129 : /*
130 : * Map a relation's (tablespace, relfilenumber) to a relation's oid and cache
131 : * the result.
132 : *
133 : * A temporary relation may share its relfilenumber with a permanent relation
134 : * or temporary relations created in other backends. Being able to uniquely
135 : * identify a temporary relation would require a backend's proc number, which
136 : * we do not know about. Hence, this function ignores this case.
137 : *
138 : * Returns InvalidOid if no relation matching the criteria could be found.
139 : */
140 : Oid
141 689838 : RelidByRelfilenumber(Oid reltablespace, RelFileNumber relfilenumber)
142 : {
143 : RelfilenumberMapKey key;
144 : RelfilenumberMapEntry *entry;
145 : bool found;
146 : SysScanDesc scandesc;
147 : Relation relation;
148 : HeapTuple ntp;
149 : Oid relid;
150 :
151 689838 : if (RelfilenumberMapHash == NULL)
152 452 : InitializeRelfilenumberMap();
153 :
154 : /* pg_class will show 0 when the value is actually MyDatabaseTableSpace */
155 689838 : if (reltablespace == MyDatabaseTableSpace)
156 681300 : reltablespace = 0;
157 :
158 1379676 : MemSet(&key, 0, sizeof(key));
159 689838 : key.reltablespace = reltablespace;
160 689838 : key.relfilenumber = relfilenumber;
161 :
162 : /*
163 : * Check cache and return entry if one is found. Even if no target
164 : * relation can be found later on we store the negative match and return a
165 : * InvalidOid from cache. That's not really necessary for performance
166 : * since querying invalid values isn't supposed to be a frequent thing,
167 : * but it's basically free.
168 : */
169 689838 : entry = hash_search(RelfilenumberMapHash, &key, HASH_FIND, &found);
170 :
171 689838 : if (found)
172 678938 : return entry->relid;
173 :
174 : /* ok, no previous cache entry, do it the hard way */
175 :
176 : /* initialize empty/negative cache entry before doing the actual lookups */
177 10900 : relid = InvalidOid;
178 :
179 10900 : if (reltablespace == GLOBALTABLESPACE_OID)
180 : {
181 : /*
182 : * Ok, shared table, check relmapper.
183 : */
184 294 : relid = RelationMapFilenumberToOid(relfilenumber, true);
185 : }
186 : else
187 : {
188 : ScanKeyData skey[2];
189 :
190 : /*
191 : * Not a shared table, could either be a plain relation or a
192 : * non-shared, nailed one, like e.g. pg_class.
193 : */
194 :
195 : /* check for plain relations by looking in pg_class */
196 10606 : relation = table_open(RelationRelationId, AccessShareLock);
197 :
198 : /* copy scankey to local copy and set scan arguments */
199 10598 : memcpy(skey, relfilenumber_skey, sizeof(skey));
200 10598 : skey[0].sk_argument = ObjectIdGetDatum(reltablespace);
201 10598 : skey[1].sk_argument = ObjectIdGetDatum(relfilenumber);
202 :
203 10598 : scandesc = systable_beginscan(relation,
204 : ClassTblspcRelfilenodeIndexId,
205 : true,
206 : NULL,
207 : 2,
208 : skey);
209 :
210 10598 : found = false;
211 :
212 20398 : while (HeapTupleIsValid(ntp = systable_getnext(scandesc)))
213 : {
214 9800 : Form_pg_class classform = (Form_pg_class) GETSTRUCT(ntp);
215 :
216 9800 : if (classform->relpersistence == RELPERSISTENCE_TEMP)
217 6 : continue;
218 :
219 9794 : if (found)
220 0 : elog(ERROR,
221 : "unexpected duplicate for tablespace %u, relfilenumber %u",
222 : reltablespace, relfilenumber);
223 9794 : found = true;
224 :
225 : Assert(classform->reltablespace == reltablespace);
226 : Assert(classform->relfilenode == relfilenumber);
227 9794 : relid = classform->oid;
228 : }
229 :
230 10588 : systable_endscan(scandesc);
231 10588 : table_close(relation, AccessShareLock);
232 :
233 : /* check for tables that are mapped but not shared */
234 10588 : if (!found)
235 794 : relid = RelationMapFilenumberToOid(relfilenumber, false);
236 : }
237 :
238 : /*
239 : * Only enter entry into cache now, our opening of pg_class could have
240 : * caused cache invalidations to be executed which would have deleted a
241 : * new entry if we had entered it above.
242 : */
243 10882 : entry = hash_search(RelfilenumberMapHash, &key, HASH_ENTER, &found);
244 10882 : if (found)
245 0 : elog(ERROR, "corrupted hashtable");
246 10882 : entry->relid = relid;
247 :
248 10882 : return relid;
249 : }
|
