1 /*
2 * controldata.c - functions for reading the pg_control file
3 *
4 * The functions provided here enable repmgr to read a pg_control file
5 * in a version-indepent way, even if the PostgreSQL instance is not
6 * running. For that reason we can't use on the pg_control_*() functions
7 * provided in PostgreSQL 9.6 and later.
8 *
9 * Copyright (c) 2ndQuadrant, 2010-2020
10 *
11 * Portions Copyright (c) 1996-2016, PostgreSQL Global Development Group
12 * Portions Copyright (c) 1994, Regents of the University of California
13 *
14 * This program is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation, either version 3 of the License, or
17 * (at your option) any later version.
18 *
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with this program. If not, see <http://www.gnu.org/licenses/>.
26 */
27
28 #include <unistd.h>
29 #include <sys/stat.h>
30 #include <fcntl.h>
31
32 #include "postgres_fe.h"
33
34 #include "repmgr.h"
35 #include "controldata.h"
36
37 static ControlFileInfo *get_controlfile(const char *DataDir);
38
39 int
get_pg_version(const char * data_directory,char * version_string)40 get_pg_version(const char *data_directory, char *version_string)
41 {
42 char PgVersionPath[MAXPGPATH] = "";
43 FILE *fp = NULL;
44 char *endptr = NULL;
45 char file_version_string[MAX_VERSION_STRING] = "";
46 long file_major, file_minor;
47 int ret;
48
49 snprintf(PgVersionPath, MAXPGPATH, "%s/PG_VERSION", data_directory);
50
51 fp = fopen(PgVersionPath, "r");
52
53 if (fp == NULL)
54 {
55 log_warning(_("could not open file \"%s\" for reading"),
56 PgVersionPath);
57 log_detail("%s", strerror(errno));
58 return UNKNOWN_SERVER_VERSION_NUM;
59 }
60
61 file_version_string[0] = '\0';
62
63 ret = fscanf(fp, "%23s", file_version_string);
64 fclose(fp);
65
66 if (ret != 1 || endptr == file_version_string)
67 {
68 log_warning(_("unable to determine major version number from PG_VERSION"));
69
70 return UNKNOWN_SERVER_VERSION_NUM;
71 }
72
73 file_major = strtol(file_version_string, &endptr, 10);
74 file_minor = 0;
75
76 if (*endptr == '.')
77 file_minor = strtol(endptr + 1, NULL, 10);
78
79 if (version_string != NULL)
80 strncpy(version_string, file_version_string, MAX_VERSION_STRING);
81
82 return ((int) file_major * 10000) + ((int) file_minor * 100);
83 }
84
85
86 uint64
get_system_identifier(const char * data_directory)87 get_system_identifier(const char *data_directory)
88 {
89 ControlFileInfo *control_file_info = NULL;
90 uint64 system_identifier = UNKNOWN_SYSTEM_IDENTIFIER;
91
92 control_file_info = get_controlfile(data_directory);
93
94 if (control_file_info->control_file_processed == true)
95 system_identifier = control_file_info->system_identifier;
96
97 pfree(control_file_info);
98
99 return system_identifier;
100 }
101
102
103 bool
get_db_state(const char * data_directory,DBState * state)104 get_db_state(const char *data_directory, DBState *state)
105 {
106 ControlFileInfo *control_file_info = NULL;
107 bool control_file_processed;
108
109 control_file_info = get_controlfile(data_directory);
110 control_file_processed = control_file_info->control_file_processed;
111
112 if (control_file_processed == true)
113 *state = control_file_info->state;
114
115 pfree(control_file_info);
116
117 return control_file_processed;
118 }
119
120
121 XLogRecPtr
get_latest_checkpoint_location(const char * data_directory)122 get_latest_checkpoint_location(const char *data_directory)
123 {
124 ControlFileInfo *control_file_info = NULL;
125 XLogRecPtr checkPoint = InvalidXLogRecPtr;
126
127 control_file_info = get_controlfile(data_directory);
128
129 if (control_file_info->control_file_processed == true)
130 checkPoint = control_file_info->checkPoint;
131
132 pfree(control_file_info);
133
134 return checkPoint;
135 }
136
137
138 int
get_data_checksum_version(const char * data_directory)139 get_data_checksum_version(const char *data_directory)
140 {
141 ControlFileInfo *control_file_info = NULL;
142 int data_checksum_version = UNKNOWN_DATA_CHECKSUM_VERSION;
143
144 control_file_info = get_controlfile(data_directory);
145
146 if (control_file_info->control_file_processed == true)
147 data_checksum_version = (int) control_file_info->data_checksum_version;
148
149 pfree(control_file_info);
150
151 return data_checksum_version;
152 }
153
154
155 const char *
describe_db_state(DBState state)156 describe_db_state(DBState state)
157 {
158 switch (state)
159 {
160 case DB_STARTUP:
161 return _("starting up");
162 case DB_SHUTDOWNED:
163 return _("shut down");
164 case DB_SHUTDOWNED_IN_RECOVERY:
165 return _("shut down in recovery");
166 case DB_SHUTDOWNING:
167 return _("shutting down");
168 case DB_IN_CRASH_RECOVERY:
169 return _("in crash recovery");
170 case DB_IN_ARCHIVE_RECOVERY:
171 return _("in archive recovery");
172 case DB_IN_PRODUCTION:
173 return _("in production");
174 }
175
176 return _("unrecognized status code");
177 }
178
179
180 TimeLineID
get_timeline(const char * data_directory)181 get_timeline(const char *data_directory)
182 {
183 ControlFileInfo *control_file_info = NULL;
184 TimeLineID timeline = -1;
185
186 control_file_info = get_controlfile(data_directory);
187
188 timeline = (int) control_file_info->timeline;
189
190 pfree(control_file_info);
191
192 return timeline;
193 }
194
195
196 TimeLineID
get_min_recovery_end_timeline(const char * data_directory)197 get_min_recovery_end_timeline(const char *data_directory)
198 {
199 ControlFileInfo *control_file_info = NULL;
200 TimeLineID timeline = -1;
201
202 control_file_info = get_controlfile(data_directory);
203
204 timeline = (int) control_file_info->minRecoveryPointTLI;
205
206 pfree(control_file_info);
207
208 return timeline;
209 }
210
211
212 XLogRecPtr
get_min_recovery_location(const char * data_directory)213 get_min_recovery_location(const char *data_directory)
214 {
215 ControlFileInfo *control_file_info = NULL;
216 XLogRecPtr minRecoveryPoint = InvalidXLogRecPtr;
217
218 control_file_info = get_controlfile(data_directory);
219
220 minRecoveryPoint = control_file_info->minRecoveryPoint;
221
222 pfree(control_file_info);
223
224 return minRecoveryPoint;
225 }
226
227
228 /*
229 * We maintain our own version of get_controlfile() as we need cross-version
230 * compatibility, and also don't care if the file isn't readable.
231 */
232 static ControlFileInfo *
get_controlfile(const char * DataDir)233 get_controlfile(const char *DataDir)
234 {
235 char file_version_string[MAX_VERSION_STRING] = "";
236 ControlFileInfo *control_file_info;
237 int fd, version_num;
238 char ControlFilePath[MAXPGPATH] = "";
239 void *ControlFileDataPtr = NULL;
240 int expected_size = 0;
241
242 control_file_info = palloc0(sizeof(ControlFileInfo));
243
244 /* set default values */
245 control_file_info->control_file_processed = false;
246 control_file_info->system_identifier = UNKNOWN_SYSTEM_IDENTIFIER;
247 control_file_info->state = DB_SHUTDOWNED;
248 control_file_info->checkPoint = InvalidXLogRecPtr;
249 control_file_info->data_checksum_version = -1;
250 control_file_info->timeline = -1;
251 control_file_info->minRecoveryPointTLI = -1;
252 control_file_info->minRecoveryPoint = InvalidXLogRecPtr;
253
254 /*
255 * Read PG_VERSION, as we'll need to determine which struct to read
256 * the control file contents into
257 */
258
259 version_num = get_pg_version(DataDir, file_version_string);
260
261 if (version_num == UNKNOWN_SERVER_VERSION_NUM)
262 {
263 log_warning(_("unable to determine server version number from PG_VERSION"));
264 return control_file_info;
265 }
266
267 if (version_num < MIN_SUPPORTED_VERSION_NUM)
268 {
269 log_warning(_("data directory appears to be initialised for %s"),
270 file_version_string);
271 log_detail(_("minimum supported PostgreSQL version is %s"),
272 MIN_SUPPORTED_VERSION);
273 return control_file_info;
274 }
275
276 snprintf(ControlFilePath, MAXPGPATH, "%s/global/pg_control", DataDir);
277
278 if ((fd = open(ControlFilePath, O_RDONLY | PG_BINARY, 0)) == -1)
279 {
280 log_warning(_("could not open file \"%s\" for reading"),
281 ControlFilePath);
282 log_detail("%s", strerror(errno));
283 return control_file_info;
284 }
285
286 if (version_num >= 120000)
287 {
288 #if PG_ACTUAL_VERSION_NUM >= 120000
289 expected_size = sizeof(ControlFileData12);
290 ControlFileDataPtr = palloc0(expected_size);
291 #endif
292 }
293 else if (version_num >= 110000)
294 {
295 expected_size = sizeof(ControlFileData11);
296 ControlFileDataPtr = palloc0(expected_size);
297 }
298 else if (version_num >= 90500)
299 {
300 expected_size = sizeof(ControlFileData95);
301 ControlFileDataPtr = palloc0(expected_size);
302 }
303 else if (version_num >= 90400)
304 {
305 expected_size = sizeof(ControlFileData94);
306 ControlFileDataPtr = palloc0(expected_size);
307 }
308
309 if (read(fd, ControlFileDataPtr, expected_size) != expected_size)
310 {
311 log_warning(_("could not read file \"%s\""),
312 ControlFilePath);
313 log_detail("%s", strerror(errno));
314
315 close(fd);
316
317 return control_file_info;
318 }
319
320 close(fd);
321
322 control_file_info->control_file_processed = true;
323
324 if (version_num >= 120000)
325 {
326 #if PG_ACTUAL_VERSION_NUM >= 120000
327 ControlFileData12 *ptr = (struct ControlFileData12 *)ControlFileDataPtr;
328 control_file_info->system_identifier = ptr->system_identifier;
329 control_file_info->state = ptr->state;
330 control_file_info->checkPoint = ptr->checkPoint;
331 control_file_info->data_checksum_version = ptr->data_checksum_version;
332 control_file_info->timeline = ptr->checkPointCopy.ThisTimeLineID;
333 control_file_info->minRecoveryPointTLI = ptr->minRecoveryPointTLI;
334 control_file_info->minRecoveryPoint = ptr->minRecoveryPoint;
335 #else
336 fprintf(stderr, "ERROR: please use a repmgr version built for PostgreSQL 12\n");
337 exit(ERR_BAD_CONFIG);
338 #endif
339 }
340 else if (version_num >= 110000)
341 {
342 ControlFileData11 *ptr = (struct ControlFileData11 *)ControlFileDataPtr;
343 control_file_info->system_identifier = ptr->system_identifier;
344 control_file_info->state = ptr->state;
345 control_file_info->checkPoint = ptr->checkPoint;
346 control_file_info->data_checksum_version = ptr->data_checksum_version;
347 control_file_info->timeline = ptr->checkPointCopy.ThisTimeLineID;
348 control_file_info->minRecoveryPointTLI = ptr->minRecoveryPointTLI;
349 control_file_info->minRecoveryPoint = ptr->minRecoveryPoint;
350 }
351 else if (version_num >= 90500)
352 {
353 ControlFileData95 *ptr = (struct ControlFileData95 *)ControlFileDataPtr;
354 control_file_info->system_identifier = ptr->system_identifier;
355 control_file_info->state = ptr->state;
356 control_file_info->checkPoint = ptr->checkPoint;
357 control_file_info->data_checksum_version = ptr->data_checksum_version;
358 control_file_info->timeline = ptr->checkPointCopy.ThisTimeLineID;
359 control_file_info->minRecoveryPointTLI = ptr->minRecoveryPointTLI;
360 control_file_info->minRecoveryPoint = ptr->minRecoveryPoint;
361 }
362 else if (version_num >= 90400)
363 {
364 ControlFileData94 *ptr = (struct ControlFileData94 *)ControlFileDataPtr;
365 control_file_info->system_identifier = ptr->system_identifier;
366 control_file_info->state = ptr->state;
367 control_file_info->checkPoint = ptr->checkPoint;
368 control_file_info->data_checksum_version = ptr->data_checksum_version;
369 control_file_info->timeline = ptr->checkPointCopy.ThisTimeLineID;
370 control_file_info->minRecoveryPointTLI = ptr->minRecoveryPointTLI;
371 control_file_info->minRecoveryPoint = ptr->minRecoveryPoint;
372 }
373
374 pfree(ControlFileDataPtr);
375
376 /*
377 * We don't check the CRC here as we're potentially checking a pg_control
378 * file from a different PostgreSQL version to the one repmgr was compiled
379 * against.
380 */
381
382 return control_file_info;
383 }
384