Line data Source code
1 : /*-------------------------------------------------------------------------
2 : *
3 : * relfilenumbermap.c
4 : * relfilenumber to oid mapping cache.
5 : *
6 : * Portions Copyright (c) 1996-2024, 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 37584 : 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 37584 : hash_seq_init(&status, RelfilenumberMapHash);
61 20743086 : 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 20705502 : if (relid == InvalidOid || /* complete reset */
69 20704672 : entry->relid == InvalidOid || /* negative cache entry */
70 20704560 : entry->relid == relid) /* individual flushed relation */
71 : {
72 1366 : if (hash_search(RelfilenumberMapHash,
73 1366 : &entry->key,
74 : HASH_REMOVE,
75 : NULL) == NULL)
76 0 : elog(ERROR, "hash table corrupted");
77 : }
78 : }
79 37584 : }
80 :
81 : /*
82 : * InitializeRelfilenumberMap
83 : * Initialize cache, either on first use or after a reset.
84 : */
85 : static void
86 376 : InitializeRelfilenumberMap(void)
87 : {
88 : HASHCTL ctl;
89 : int i;
90 :
91 : /* Make sure we've initialized CacheMemoryContext. */
92 376 : if (CacheMemoryContext == NULL)
93 0 : CreateCacheMemoryContext();
94 :
95 : /* build skey */
96 7144 : MemSet(&relfilenumber_skey, 0, sizeof(relfilenumber_skey));
97 :
98 1128 : for (i = 0; i < 2; i++)
99 : {
100 752 : fmgr_info_cxt(F_OIDEQ,
101 : &relfilenumber_skey[i].sk_func,
102 : CacheMemoryContext);
103 752 : relfilenumber_skey[i].sk_strategy = BTEqualStrategyNumber;
104 752 : relfilenumber_skey[i].sk_subtype = InvalidOid;
105 752 : relfilenumber_skey[i].sk_collation = InvalidOid;
106 : }
107 :
108 376 : relfilenumber_skey[0].sk_attno = Anum_pg_class_reltablespace;
109 376 : 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 376 : ctl.keysize = sizeof(RelfilenumberMapKey);
117 376 : ctl.entrysize = sizeof(RelfilenumberMapEntry);
118 376 : ctl.hcxt = CacheMemoryContext;
119 :
120 376 : RelfilenumberMapHash =
121 376 : hash_create("RelfilenumberMap cache", 64, &ctl,
122 : HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
123 :
124 : /* Watch for invalidation events. */
125 376 : CacheRegisterRelcacheCallback(RelfilenumberMapInvalidateCallback,
126 : (Datum) 0);
127 376 : }
128 :
129 : /*
130 : * Map a relation's (tablespace, relfilenumber) to a relation's oid and cache
131 : * the result.
132 : *
133 : * Returns InvalidOid if no relation matching the criteria could be found.
134 : */
135 : Oid
136 687960 : RelidByRelfilenumber(Oid reltablespace, RelFileNumber relfilenumber)
137 : {
138 : RelfilenumberMapKey key;
139 : RelfilenumberMapEntry *entry;
140 : bool found;
141 : SysScanDesc scandesc;
142 : Relation relation;
143 : HeapTuple ntp;
144 : Oid relid;
145 :
146 687960 : if (RelfilenumberMapHash == NULL)
147 376 : InitializeRelfilenumberMap();
148 :
149 : /* pg_class will show 0 when the value is actually MyDatabaseTableSpace */
150 687960 : if (reltablespace == MyDatabaseTableSpace)
151 679950 : reltablespace = 0;
152 :
153 1375920 : MemSet(&key, 0, sizeof(key));
154 687960 : key.reltablespace = reltablespace;
155 687960 : key.relfilenumber = relfilenumber;
156 :
157 : /*
158 : * Check cache and return entry if one is found. Even if no target
159 : * relation can be found later on we store the negative match and return a
160 : * InvalidOid from cache. That's not really necessary for performance
161 : * since querying invalid values isn't supposed to be a frequent thing,
162 : * but it's basically free.
163 : */
164 687960 : entry = hash_search(RelfilenumberMapHash, &key, HASH_FIND, &found);
165 :
166 687960 : if (found)
167 677772 : return entry->relid;
168 :
169 : /* ok, no previous cache entry, do it the hard way */
170 :
171 : /* initialize empty/negative cache entry before doing the actual lookups */
172 10188 : relid = InvalidOid;
173 :
174 10188 : if (reltablespace == GLOBALTABLESPACE_OID)
175 : {
176 : /*
177 : * Ok, shared table, check relmapper.
178 : */
179 306 : relid = RelationMapFilenumberToOid(relfilenumber, true);
180 : }
181 : else
182 : {
183 : ScanKeyData skey[2];
184 :
185 : /*
186 : * Not a shared table, could either be a plain relation or a
187 : * non-shared, nailed one, like e.g. pg_class.
188 : */
189 :
190 : /* check for plain relations by looking in pg_class */
191 9882 : relation = table_open(RelationRelationId, AccessShareLock);
192 :
193 : /* copy scankey to local copy and set scan arguments */
194 9876 : memcpy(skey, relfilenumber_skey, sizeof(skey));
195 9876 : skey[0].sk_argument = ObjectIdGetDatum(reltablespace);
196 9876 : skey[1].sk_argument = ObjectIdGetDatum(relfilenumber);
197 :
198 9876 : scandesc = systable_beginscan(relation,
199 : ClassTblspcRelfilenodeIndexId,
200 : true,
201 : NULL,
202 : 2,
203 : skey);
204 :
205 9876 : found = false;
206 :
207 18982 : while (HeapTupleIsValid(ntp = systable_getnext(scandesc)))
208 : {
209 9106 : Form_pg_class classform = (Form_pg_class) GETSTRUCT(ntp);
210 :
211 9106 : if (found)
212 0 : elog(ERROR,
213 : "unexpected duplicate for tablespace %u, relfilenumber %u",
214 : reltablespace, relfilenumber);
215 9106 : found = true;
216 :
217 : Assert(classform->reltablespace == reltablespace);
218 : Assert(classform->relfilenode == relfilenumber);
219 9106 : relid = classform->oid;
220 : }
221 :
222 9866 : systable_endscan(scandesc);
223 9866 : table_close(relation, AccessShareLock);
224 :
225 : /* check for tables that are mapped but not shared */
226 9866 : if (!found)
227 760 : relid = RelationMapFilenumberToOid(relfilenumber, false);
228 : }
229 :
230 : /*
231 : * Only enter entry into cache now, our opening of pg_class could have
232 : * caused cache invalidations to be executed which would have deleted a
233 : * new entry if we had entered it above.
234 : */
235 10172 : entry = hash_search(RelfilenumberMapHash, &key, HASH_ENTER, &found);
236 10172 : if (found)
237 0 : elog(ERROR, "corrupted hashtable");
238 10172 : entry->relid = relid;
239 :
240 10172 : return relid;
241 : }
|
