Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * pg_checksums.c
4 : : * Checks, enables or disables page level checksums for an offline
5 : : * cluster
6 : : *
7 : : * Copyright (c) 2010-2024, PostgreSQL Global Development Group
8 : : *
9 : : * IDENTIFICATION
10 : : * src/bin/pg_checksums/pg_checksums.c
11 : : *
12 : : *-------------------------------------------------------------------------
13 : : */
14 : :
15 : : #include "postgres_fe.h"
16 : :
17 : : #include <dirent.h>
18 : : #include <limits.h>
19 : : #include <time.h>
20 : : #include <sys/stat.h>
21 : : #include <unistd.h>
22 : :
23 : : #include "common/controldata_utils.h"
24 : : #include "common/file_perm.h"
25 : : #include "common/file_utils.h"
26 : : #include "common/logging.h"
27 : : #include "common/relpath.h"
28 : : #include "fe_utils/option_utils.h"
29 : : #include "getopt_long.h"
30 : : #include "pg_getopt.h"
31 : : #include "storage/bufpage.h"
32 : : #include "storage/checksum.h"
33 : : #include "storage/checksum_impl.h"
34 : :
35 : :
36 : : static int64 files_scanned = 0;
37 : : static int64 files_written = 0;
38 : : static int64 blocks_scanned = 0;
39 : : static int64 blocks_written = 0;
40 : : static int64 badblocks = 0;
41 : : static ControlFileData *ControlFile;
42 : :
43 : : static char *only_filenode = NULL;
44 : : static bool do_sync = true;
45 : : static bool verbose = false;
46 : : static bool showprogress = false;
47 : : static DataDirSyncMethod sync_method = DATA_DIR_SYNC_METHOD_FSYNC;
48 : :
49 : : typedef enum
50 : : {
51 : : PG_MODE_CHECK,
52 : : PG_MODE_DISABLE,
53 : : PG_MODE_ENABLE,
54 : : } PgChecksumMode;
55 : :
56 : : static PgChecksumMode mode = PG_MODE_CHECK;
57 : :
58 : : static const char *progname;
59 : :
60 : : /*
61 : : * Progress status information.
62 : : */
63 : : int64 total_size = 0;
64 : : int64 current_size = 0;
65 : : static pg_time_t last_progress_report = 0;
66 : :
67 : : static void
2053 tgl@sss.pgh.pa.us 68 :CBC 1 : usage(void)
69 : : {
1749 peter@eisentraut.org 70 : 1 : printf(_("%s enables, disables, or verifies data checksums in a PostgreSQL database cluster.\n\n"), progname);
2201 magnus@hagander.net 71 : 1 : printf(_("Usage:\n"));
2061 peter_e@gmx.net 72 : 1 : printf(_(" %s [OPTION]... [DATADIR]\n"), progname);
2201 magnus@hagander.net 73 : 1 : printf(_("\nOptions:\n"));
1781 michael@paquier.xyz 74 : 1 : printf(_(" [-D, --pgdata=]DATADIR data directory\n"));
75 : 1 : printf(_(" -c, --check check data checksums (default)\n"));
76 : 1 : printf(_(" -d, --disable disable data checksums\n"));
77 : 1 : printf(_(" -e, --enable enable data checksums\n"));
78 : 1 : printf(_(" -f, --filenode=FILENODE check only relation with specified filenode\n"));
79 : 1 : printf(_(" -N, --no-sync do not wait for changes to be written safely to disk\n"));
80 : 1 : printf(_(" -P, --progress show progress information\n"));
221 nathan@postgresql.or 81 :GNC 1 : printf(_(" --sync-method=METHOD set method for syncing files to disk\n"));
1781 michael@paquier.xyz 82 :CBC 1 : printf(_(" -v, --verbose output verbose messages\n"));
83 : 1 : printf(_(" -V, --version output version information, then exit\n"));
84 : 1 : printf(_(" -?, --help show this help, then exit\n"));
2201 magnus@hagander.net 85 : 1 : printf(_("\nIf no data directory (DATADIR) is specified, "
86 : : "the environment variable PGDATA\nis used.\n\n"));
1507 peter@eisentraut.org 87 : 1 : printf(_("Report bugs to <%s>.\n"), PACKAGE_BUGREPORT);
88 : 1 : printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL);
2201 magnus@hagander.net 89 : 1 : }
90 : :
91 : : /*
92 : : * Definition of one element part of an exclusion list, used for files
93 : : * to exclude from checksum validation. "name" is the name of the file
94 : : * or path to check for exclusion. If "match_prefix" is true, any items
95 : : * matching the name as prefix are excluded.
96 : : */
97 : : struct exclude_list_item
98 : : {
99 : : const char *name;
100 : : bool match_prefix;
101 : : };
102 : :
103 : : /*
104 : : * List of files excluded from checksum validation.
105 : : *
106 : : * Note: this list should be kept in sync with what basebackup.c includes.
107 : : */
108 : : static const struct exclude_list_item skip[] = {
109 : : {"pg_control", false},
110 : : {"pg_filenode.map", false},
111 : : {"pg_internal.init", true},
112 : : {"PG_VERSION", false},
113 : : #ifdef EXEC_BACKEND
114 : : {"config_exec_params", true},
115 : : #endif
116 : : {NULL, false}
117 : : };
118 : :
119 : : /*
120 : : * Report current progress status. Parts borrowed from
121 : : * src/bin/pg_basebackup/pg_basebackup.c.
122 : : */
123 : : static void
1336 heikki.linnakangas@i 124 :UBC 0 : progress_report(bool finished)
125 : : {
126 : : int percent;
127 : : pg_time_t now;
128 : :
1839 michael@paquier.xyz 129 [ # # ]: 0 : Assert(showprogress);
130 : :
131 : 0 : now = time(NULL);
1336 heikki.linnakangas@i 132 [ # # # # ]: 0 : if (now == last_progress_report && !finished)
1839 michael@paquier.xyz 133 : 0 : return; /* Max once per second */
134 : :
135 : : /* Save current time */
136 : 0 : last_progress_report = now;
137 : :
138 : : /* Adjust total size if current_size is larger */
139 [ # # ]: 0 : if (current_size > total_size)
140 : 0 : total_size = current_size;
141 : :
142 : : /* Calculate current percentage of size done */
143 [ # # ]: 0 : percent = total_size ? (int) ((current_size) * 100 / total_size) : 0;
144 : :
755 tgl@sss.pgh.pa.us 145 : 0 : fprintf(stderr, _("%lld/%lld MB (%d%%) computed"),
146 : 0 : (long long) (current_size / (1024 * 1024)),
147 : 0 : (long long) (total_size / (1024 * 1024)),
148 : : percent);
149 : :
150 : : /*
151 : : * Stay on the same line if reporting to a terminal and we're not done
152 : : * yet.
153 : : */
1335 heikki.linnakangas@i 154 [ # # # # ]: 0 : fputc((!finished && isatty(fileno(stderr))) ? '\r' : '\n', stderr);
155 : : }
156 : :
157 : : static bool
1962 michael@paquier.xyz 158 :CBC 13147 : skipfile(const char *fn)
159 : : {
160 : : int excludeIdx;
161 : :
1511 162 [ + + ]: 65350 : for (excludeIdx = 0; skip[excludeIdx].name != NULL; excludeIdx++)
163 : : {
164 : 52364 : int cmplen = strlen(skip[excludeIdx].name);
165 : :
166 [ + + ]: 52364 : if (!skip[excludeIdx].match_prefix)
167 : 39298 : cmplen++;
168 [ + + ]: 52364 : if (strncmp(skip[excludeIdx].name, fn, cmplen) == 0)
1962 169 : 161 : return true;
170 : : }
171 : :
172 : 12986 : return false;
173 : : }
174 : :
175 : : static void
851 peter@eisentraut.org 176 : 9162 : scan_file(const char *fn, int segmentno)
177 : : {
178 : : PGIOAlignedBlock buf;
2052 tgl@sss.pgh.pa.us 179 : 9162 : PageHeader header = (PageHeader) buf.data;
180 : : int f;
181 : : BlockNumber blockno;
182 : : int flags;
1019 michael@paquier.xyz 183 : 9162 : int64 blocks_written_in_file = 0;
184 : :
1849 185 [ + + - + ]: 9162 : Assert(mode == PG_MODE_ENABLE ||
186 : : mode == PG_MODE_CHECK);
187 : :
188 [ + + ]: 9162 : flags = (mode == PG_MODE_ENABLE) ? O_RDWR : O_RDONLY;
189 : 9162 : f = open(fn, PG_BINARY | flags, 0);
190 : :
2201 magnus@hagander.net 191 [ - + ]: 9162 : if (f < 0)
737 tgl@sss.pgh.pa.us 192 :UBC 0 : pg_fatal("could not open file \"%s\": %m", fn);
193 : :
1019 michael@paquier.xyz 194 :CBC 9162 : files_scanned++;
195 : :
2201 magnus@hagander.net 196 : 9162 : for (blockno = 0;; blockno++)
197 : 26759 : {
198 : : uint16 csum;
2052 tgl@sss.pgh.pa.us 199 : 35921 : int r = read(f, buf.data, BLCKSZ);
200 : :
2201 magnus@hagander.net 201 [ + + ]: 35921 : if (r == 0)
202 : 9154 : break;
203 [ + + ]: 26767 : if (r != BLCKSZ)
204 : : {
1685 peter@eisentraut.org 205 [ - + ]: 8 : if (r < 0)
737 tgl@sss.pgh.pa.us 206 :UBC 0 : pg_fatal("could not read block %u in file \"%s\": %m",
207 : : blockno, fn);
208 : : else
737 tgl@sss.pgh.pa.us 209 :CBC 8 : pg_fatal("could not read block %u in file \"%s\": read %d of %d",
210 : : blockno, fn, r, BLCKSZ);
211 : : }
1019 michael@paquier.xyz 212 : 26759 : blocks_scanned++;
213 : :
214 : : /*
215 : : * Since the file size is counted as total_size for progress status
216 : : * information, the sizes of all pages including new ones in the file
217 : : * should be counted as current_size. Otherwise the progress reporting
218 : : * calculated using those counters may not reach 100%.
219 : : */
1107 fujii@postgresql.org 220 : 26759 : current_size += r;
221 : :
222 : : /* New pages have no checksum yet */
643 peter@eisentraut.org 223 [ + + ]: 26759 : if (PageIsNew(buf.data))
2191 magnus@hagander.net 224 : 114 : continue;
225 : :
2052 tgl@sss.pgh.pa.us 226 : 26645 : csum = pg_checksum_page(buf.data, blockno + segmentno * RELSEG_SIZE);
1849 michael@paquier.xyz 227 [ + + ]: 26645 : if (mode == PG_MODE_CHECK)
228 : : {
229 [ + + ]: 20903 : if (csum != header->pd_checksum)
230 : : {
231 [ + - ]: 4 : if (ControlFile->data_checksum_version == PG_DATA_CHECKSUM_VERSION)
1840 peter@eisentraut.org 232 : 4 : pg_log_error("checksum verification failed in file \"%s\", block %u: calculated checksum %X but block contains %X",
233 : : fn, blockno, csum, header->pd_checksum);
1849 michael@paquier.xyz 234 : 4 : badblocks++;
235 : : }
236 : : }
237 [ + - ]: 5742 : else if (mode == PG_MODE_ENABLE)
238 : : {
239 : : int w;
240 : :
241 : : /*
242 : : * Do not rewrite if the checksum is already set to the expected
243 : : * value.
244 : : */
1019 245 [ + + ]: 5742 : if (header->pd_checksum == csum)
246 : 2871 : continue;
247 : :
248 : 2871 : blocks_written_in_file++;
249 : :
250 : : /* Set checksum in page header */
1849 251 : 2871 : header->pd_checksum = csum;
252 : :
253 : : /* Seek back to beginning of block */
254 [ - + ]: 2871 : if (lseek(f, -BLCKSZ, SEEK_CUR) < 0)
737 tgl@sss.pgh.pa.us 255 :UBC 0 : pg_fatal("seek failed for block %u in file \"%s\": %m", blockno, fn);
256 : :
257 : : /* Write block with checksum */
1685 peter@eisentraut.org 258 :CBC 2871 : w = write(f, buf.data, BLCKSZ);
259 [ - + ]: 2871 : if (w != BLCKSZ)
260 : : {
1685 peter@eisentraut.org 261 [ # # ]:UBC 0 : if (w < 0)
737 tgl@sss.pgh.pa.us 262 : 0 : pg_fatal("could not write block %u in file \"%s\": %m",
263 : : blockno, fn);
264 : : else
265 : 0 : pg_fatal("could not write block %u in file \"%s\": wrote %d of %d",
266 : : blockno, fn, w, BLCKSZ);
267 : : }
268 : : }
269 : :
1839 michael@paquier.xyz 270 [ - + ]:CBC 23774 : if (showprogress)
1839 michael@paquier.xyz 271 :UBC 0 : progress_report(false);
272 : : }
273 : :
2054 alvherre@alvh.no-ip. 274 [ - + ]:CBC 9154 : if (verbose)
275 : : {
1849 michael@paquier.xyz 276 [ # # ]:UBC 0 : if (mode == PG_MODE_CHECK)
1840 peter@eisentraut.org 277 : 0 : pg_log_info("checksums verified in file \"%s\"", fn);
1849 michael@paquier.xyz 278 [ # # ]: 0 : if (mode == PG_MODE_ENABLE)
1840 peter@eisentraut.org 279 : 0 : pg_log_info("checksums enabled in file \"%s\"", fn);
280 : : }
281 : :
282 : : /* Update write counters if any write activity has happened */
1019 michael@paquier.xyz 283 [ + + ]:CBC 9154 : if (blocks_written_in_file > 0)
284 : : {
285 : 780 : files_written++;
286 : 780 : blocks_written += blocks_written_in_file;
287 : : }
288 : :
2201 magnus@hagander.net 289 : 9154 : close(f);
290 : 9154 : }
291 : :
292 : : /*
293 : : * Scan the given directory for items which can be checksummed and
294 : : * operate on each one of them. If "sizeonly" is true, the size of
295 : : * all the items which have checksums is computed and returned back
296 : : * to the caller without operating on the files. This is used to compile
297 : : * the total size of the data directory for progress reports.
298 : : */
299 : : static int64
1839 michael@paquier.xyz 300 : 96 : scan_directory(const char *basedir, const char *subdir, bool sizeonly)
301 : : {
302 : 96 : int64 dirsize = 0;
303 : : char path[MAXPGPATH];
304 : : DIR *dir;
305 : : struct dirent *de;
306 : :
2200 peter_e@gmx.net 307 : 96 : snprintf(path, sizeof(path), "%s/%s", basedir, subdir);
2201 magnus@hagander.net 308 : 96 : dir = opendir(path);
309 [ - + ]: 96 : if (!dir)
737 tgl@sss.pgh.pa.us 310 :UBC 0 : pg_fatal("could not open directory \"%s\": %m", path);
2201 magnus@hagander.net 311 [ + + ]:CBC 13539 : while ((de = readdir(dir)) != NULL)
312 : : {
313 : : char fn[MAXPGPATH];
314 : : struct stat st;
315 : :
1962 michael@paquier.xyz 316 [ + + ]: 13451 : if (strcmp(de->d_name, ".") == 0 ||
317 [ + + ]: 13355 : strcmp(de->d_name, "..") == 0)
2201 magnus@hagander.net 318 : 4240 : continue;
319 : :
320 : : /* Skip temporary files */
1962 michael@paquier.xyz 321 [ + + ]: 13259 : if (strncmp(de->d_name,
322 : : PG_TEMP_FILE_PREFIX,
323 : : strlen(PG_TEMP_FILE_PREFIX)) == 0)
324 : 42 : continue;
325 : :
326 : : /* Skip temporary folders */
327 [ - + ]: 13217 : if (strncmp(de->d_name,
328 : : PG_TEMP_FILES_DIR,
329 : : strlen(PG_TEMP_FILES_DIR)) == 0)
1858 michael@paquier.xyz 330 :UBC 0 : continue;
331 : :
332 : : /* Skip macOS system files */
61 dgustafsson@postgres 333 [ + + ]:CBC 13217 : if (strcmp(de->d_name, ".DS_Store") == 0)
334 : 21 : continue;
335 : :
2200 peter_e@gmx.net 336 : 13196 : snprintf(fn, sizeof(fn), "%s/%s", path, de->d_name);
2201 magnus@hagander.net 337 [ - + ]: 13196 : if (lstat(fn, &st) < 0)
737 tgl@sss.pgh.pa.us 338 :UBC 0 : pg_fatal("could not stat file \"%s\": %m", fn);
2201 magnus@hagander.net 339 [ + + ]:CBC 13196 : if (S_ISREG(st.st_mode))
340 : : {
341 : : char fnonly[MAXPGPATH];
342 : : char *forkpath,
343 : : *segmentpath;
851 peter@eisentraut.org 344 : 13147 : int segmentno = 0;
345 : :
1962 michael@paquier.xyz 346 [ + + ]: 13147 : if (skipfile(de->d_name))
347 : 3985 : continue;
348 : :
349 : : /*
350 : : * Cut off at the segment boundary (".") to get the segment number
351 : : * in order to mix it into the checksum. Then also cut off at the
352 : : * fork boundary, to get the filenode the file belongs to for
353 : : * filtering.
354 : : */
2053 tgl@sss.pgh.pa.us 355 : 12986 : strlcpy(fnonly, de->d_name, sizeof(fnonly));
356 : 12986 : segmentpath = strchr(fnonly, '.');
2201 magnus@hagander.net 357 [ + + ]: 12986 : if (segmentpath != NULL)
358 : : {
359 : 88 : *segmentpath++ = '\0';
360 : 88 : segmentno = atoi(segmentpath);
361 [ - + ]: 88 : if (segmentno == 0)
737 tgl@sss.pgh.pa.us 362 :UBC 0 : pg_fatal("invalid segment number %d in file name \"%s\"",
363 : : segmentno, fn);
364 : : }
365 : :
2053 tgl@sss.pgh.pa.us 366 :CBC 12986 : forkpath = strchr(fnonly, '_');
2201 magnus@hagander.net 367 [ + + ]: 12986 : if (forkpath != NULL)
368 : 3228 : *forkpath++ = '\0';
369 : :
1781 michael@paquier.xyz 370 [ + + + + ]: 12986 : if (only_filenode && strcmp(only_filenode, fnonly) != 0)
371 : : /* filenode not to be included */
2201 magnus@hagander.net 372 : 3824 : continue;
373 : :
1839 michael@paquier.xyz 374 : 9162 : dirsize += st.st_size;
375 : :
376 : : /*
377 : : * No need to work on the file when calculating only the size of
378 : : * the items in the data folder.
379 : : */
380 [ + - ]: 9162 : if (!sizeonly)
381 : 9162 : scan_file(fn, segmentno);
382 : : }
2201 magnus@hagander.net 383 [ + + + - ]: 49 : else if (S_ISDIR(st.st_mode) || S_ISLNK(st.st_mode))
384 : : {
385 : : /*
386 : : * If going through the entries of pg_tblspc, we assume to operate
387 : : * on tablespace locations where only TABLESPACE_VERSION_DIRECTORY
388 : : * is valid, resolving the linked locations and dive into them
389 : : * directly.
390 : : */
1508 michael@paquier.xyz 391 [ + + ]: 49 : if (strncmp("pg_tblspc", subdir, strlen("pg_tblspc")) == 0)
392 : : {
393 : : char tblspc_path[MAXPGPATH];
394 : : struct stat tblspc_st;
395 : :
396 : : /*
397 : : * Resolve tablespace location path and check whether
398 : : * TABLESPACE_VERSION_DIRECTORY exists. Not finding a valid
399 : : * location is unexpected, since there should be no orphaned
400 : : * links and no links pointing to something else than a
401 : : * directory.
402 : : */
403 : 5 : snprintf(tblspc_path, sizeof(tblspc_path), "%s/%s/%s",
404 : 5 : path, de->d_name, TABLESPACE_VERSION_DIRECTORY);
405 : :
406 [ - + ]: 5 : if (lstat(tblspc_path, &tblspc_st) < 0)
737 tgl@sss.pgh.pa.us 407 :UBC 0 : pg_fatal("could not stat file \"%s\": %m",
408 : : tblspc_path);
409 : :
410 : : /*
411 : : * Move backwards once as the scan needs to happen for the
412 : : * contents of TABLESPACE_VERSION_DIRECTORY.
413 : : */
1508 michael@paquier.xyz 414 :CBC 5 : snprintf(tblspc_path, sizeof(tblspc_path), "%s/%s",
415 : 5 : path, de->d_name);
416 : :
417 : : /* Looks like a valid tablespace location */
418 : 5 : dirsize += scan_directory(tblspc_path,
419 : : TABLESPACE_VERSION_DIRECTORY,
420 : : sizeonly);
421 : : }
422 : : else
423 : : {
424 : 44 : dirsize += scan_directory(path, de->d_name, sizeonly);
425 : : }
426 : : }
427 : : }
2201 magnus@hagander.net 428 : 88 : closedir(dir);
1839 michael@paquier.xyz 429 : 88 : return dirsize;
430 : : }
431 : :
432 : : int
2201 magnus@hagander.net 433 : 31 : main(int argc, char *argv[])
434 : : {
435 : : static struct option long_options[] = {
436 : : {"check", no_argument, NULL, 'c'},
437 : : {"pgdata", required_argument, NULL, 'D'},
438 : : {"disable", no_argument, NULL, 'd'},
439 : : {"enable", no_argument, NULL, 'e'},
440 : : {"filenode", required_argument, NULL, 'f'},
441 : : {"no-sync", no_argument, NULL, 'N'},
442 : : {"progress", no_argument, NULL, 'P'},
443 : : {"verbose", no_argument, NULL, 'v'},
444 : : {"sync-method", required_argument, NULL, 1},
445 : : {NULL, 0, NULL, 0}
446 : : };
447 : :
448 : 31 : char *DataDir = NULL;
449 : : int c;
450 : : int option_index;
451 : : bool crc_ok;
452 : :
1840 peter@eisentraut.org 453 : 31 : pg_logging_init(argv[0]);
1859 michael@paquier.xyz 454 : 31 : set_pglocale_pgservice(argv[0], PG_TEXTDOMAIN("pg_checksums"));
2201 magnus@hagander.net 455 : 31 : progname = get_progname(argv[0]);
456 : :
457 [ + - ]: 31 : if (argc > 1)
458 : : {
459 [ + + - + ]: 31 : if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-?") == 0)
460 : : {
461 : 1 : usage();
462 : 1 : exit(0);
463 : : }
464 [ + + - + ]: 30 : if (strcmp(argv[1], "--version") == 0 || strcmp(argv[1], "-V") == 0)
465 : : {
1859 michael@paquier.xyz 466 : 1 : puts("pg_checksums (PostgreSQL) " PG_VERSION);
2201 magnus@hagander.net 467 : 1 : exit(0);
468 : : }
469 : : }
470 : :
489 peter@eisentraut.org 471 [ + + ]: 93 : while ((c = getopt_long(argc, argv, "cdD:ef:NPv", long_options, &option_index)) != -1)
472 : : {
2201 magnus@hagander.net 473 [ + + + + : 65 : switch (c)
+ + - - -
+ ]
474 : : {
1849 michael@paquier.xyz 475 : 19 : case 'c':
476 : 19 : mode = PG_MODE_CHECK;
477 : 19 : break;
478 : 3 : case 'd':
479 : 3 : mode = PG_MODE_DISABLE;
480 : 3 : break;
489 peter@eisentraut.org 481 : 28 : case 'D':
482 : 28 : DataDir = optarg;
483 : 28 : break;
1849 michael@paquier.xyz 484 : 4 : case 'e':
485 : 4 : mode = PG_MODE_ENABLE;
486 : 4 : break;
1781 487 : 6 : case 'f':
564 rhaas@postgresql.org 488 [ - + ]: 6 : if (!option_parse_int(optarg, "-f/--filenode", 0,
489 : : INT_MAX,
490 : : NULL))
1781 michael@paquier.xyz 491 :UBC 0 : exit(1);
1781 michael@paquier.xyz 492 :CBC 6 : only_filenode = pstrdup(optarg);
493 : 6 : break;
1849 494 : 4 : case 'N':
495 : 4 : do_sync = false;
496 : 4 : break;
1839 michael@paquier.xyz 497 :UBC 0 : case 'P':
498 : 0 : showprogress = true;
499 : 0 : break;
489 peter@eisentraut.org 500 : 0 : case 'v':
501 : 0 : verbose = true;
502 : 0 : break;
221 nathan@postgresql.or 503 :UNC 0 : case 1:
504 [ # # ]: 0 : if (!parse_sync_method(optarg, &sync_method))
505 : 0 : exit(1);
506 : 0 : break;
2201 magnus@hagander.net 507 :CBC 1 : default:
508 : : /* getopt_long already emitted a complaint */
737 tgl@sss.pgh.pa.us 509 : 1 : pg_log_error_hint("Try \"%s --help\" for more information.", progname);
2201 magnus@hagander.net 510 : 1 : exit(1);
511 : : }
512 : : }
513 : :
514 [ - + ]: 28 : if (DataDir == NULL)
515 : : {
2201 magnus@hagander.net 516 [ # # ]:UBC 0 : if (optind < argc)
517 : 0 : DataDir = argv[optind++];
518 : : else
519 : 0 : DataDir = getenv("PGDATA");
520 : :
521 : : /* If no DataDir was specified, and none could be found, error out */
522 [ # # ]: 0 : if (DataDir == NULL)
523 : : {
1840 peter@eisentraut.org 524 : 0 : pg_log_error("no data directory specified");
737 tgl@sss.pgh.pa.us 525 : 0 : pg_log_error_hint("Try \"%s --help\" for more information.", progname);
2201 magnus@hagander.net 526 : 0 : exit(1);
527 : : }
528 : : }
529 : :
530 : : /* Complain if any arguments remain */
2201 magnus@hagander.net 531 [ - + ]:CBC 28 : if (optind < argc)
532 : : {
1840 peter@eisentraut.org 533 :UBC 0 : pg_log_error("too many command-line arguments (first is \"%s\")",
534 : : argv[optind]);
737 tgl@sss.pgh.pa.us 535 : 0 : pg_log_error_hint("Try \"%s --help\" for more information.", progname);
2201 magnus@hagander.net 536 : 0 : exit(1);
537 : : }
538 : :
539 : : /* filenode checking only works in --check mode */
1781 michael@paquier.xyz 540 [ + + + + ]:CBC 28 : if (mode != PG_MODE_CHECK && only_filenode)
541 : : {
1741 peter@eisentraut.org 542 : 2 : pg_log_error("option -f/--filenode can only be used with --check");
737 tgl@sss.pgh.pa.us 543 : 2 : pg_log_error_hint("Try \"%s --help\" for more information.", progname);
1849 michael@paquier.xyz 544 : 2 : exit(1);
545 : : }
546 : :
547 : : /* Read the control file and check compatibility */
1840 peter@eisentraut.org 548 : 26 : ControlFile = get_controlfile(DataDir, &crc_ok);
2201 magnus@hagander.net 549 [ - + ]: 26 : if (!crc_ok)
737 tgl@sss.pgh.pa.us 550 :UBC 0 : pg_fatal("pg_control CRC value is incorrect");
551 : :
1859 michael@paquier.xyz 552 [ - + ]:CBC 26 : if (ControlFile->pg_control_version != PG_CONTROL_VERSION)
737 tgl@sss.pgh.pa.us 553 :UBC 0 : pg_fatal("cluster is not compatible with this version of pg_checksums");
554 : :
1854 michael@paquier.xyz 555 [ - + ]:CBC 26 : if (ControlFile->blcksz != BLCKSZ)
556 : : {
1840 peter@eisentraut.org 557 :UBC 0 : pg_log_error("database cluster is not compatible");
737 tgl@sss.pgh.pa.us 558 : 0 : pg_log_error_detail("The database cluster was initialized with block size %u, but pg_checksums was compiled with block size %u.",
559 : : ControlFile->blcksz, BLCKSZ);
1854 michael@paquier.xyz 560 : 0 : exit(1);
561 : : }
562 : :
563 : : /*
564 : : * Check if cluster is running. A clean shutdown is required to avoid
565 : : * random checksum failures caused by torn pages. Note that this doesn't
566 : : * guard against someone starting the cluster concurrently.
567 : : */
2201 magnus@hagander.net 568 [ + + ]:CBC 26 : if (ControlFile->state != DB_SHUTDOWNED &&
569 [ + - ]: 1 : ControlFile->state != DB_SHUTDOWNED_IN_RECOVERY)
737 tgl@sss.pgh.pa.us 570 : 1 : pg_fatal("cluster must be shut down");
571 : :
1849 michael@paquier.xyz 572 [ + + ]: 25 : if (ControlFile->data_checksum_version == 0 &&
573 [ + + ]: 4 : mode == PG_MODE_CHECK)
737 tgl@sss.pgh.pa.us 574 : 1 : pg_fatal("data checksums are not enabled in cluster");
575 : :
1849 michael@paquier.xyz 576 [ + + ]: 24 : if (ControlFile->data_checksum_version == 0 &&
577 [ + + ]: 3 : mode == PG_MODE_DISABLE)
737 tgl@sss.pgh.pa.us 578 : 1 : pg_fatal("data checksums are already disabled in cluster");
579 : :
1849 michael@paquier.xyz 580 [ + + ]: 23 : if (ControlFile->data_checksum_version > 0 &&
581 [ + + ]: 21 : mode == PG_MODE_ENABLE)
737 tgl@sss.pgh.pa.us 582 : 1 : pg_fatal("data checksums are already enabled in cluster");
583 : :
584 : : /* Operate on all files if checking or enabling checksums */
1849 michael@paquier.xyz 585 [ + + + + ]: 22 : if (mode == PG_MODE_CHECK || mode == PG_MODE_ENABLE)
586 : : {
587 : : /*
588 : : * If progress status information is requested, we need to scan the
589 : : * directory tree twice: once to know how much total data needs to be
590 : : * processed and once to do the real work.
591 : : */
1839 592 [ - + ]: 21 : if (showprogress)
593 : : {
1839 michael@paquier.xyz 594 :UBC 0 : total_size = scan_directory(DataDir, "global", true);
595 : 0 : total_size += scan_directory(DataDir, "base", true);
596 : 0 : total_size += scan_directory(DataDir, "pg_tblspc", true);
597 : : }
598 : :
1839 michael@paquier.xyz 599 :CBC 21 : (void) scan_directory(DataDir, "global", false);
600 : 13 : (void) scan_directory(DataDir, "base", false);
601 : 13 : (void) scan_directory(DataDir, "pg_tblspc", false);
602 : :
603 [ - + ]: 13 : if (showprogress)
1839 michael@paquier.xyz 604 :UBC 0 : progress_report(true);
605 : :
1849 michael@paquier.xyz 606 :CBC 13 : printf(_("Checksum operation completed\n"));
755 tgl@sss.pgh.pa.us 607 : 13 : printf(_("Files scanned: %lld\n"), (long long) files_scanned);
608 : 13 : printf(_("Blocks scanned: %lld\n"), (long long) blocks_scanned);
1849 michael@paquier.xyz 609 [ + + ]: 13 : if (mode == PG_MODE_CHECK)
610 : : {
755 tgl@sss.pgh.pa.us 611 : 11 : printf(_("Bad checksums: %lld\n"), (long long) badblocks);
1230 bruce@momjian.us 612 : 11 : printf(_("Data checksum version: %u\n"), ControlFile->data_checksum_version);
613 : :
1849 michael@paquier.xyz 614 [ + + ]: 11 : if (badblocks > 0)
615 : 4 : exit(1);
616 : : }
1019 617 [ + - ]: 2 : else if (mode == PG_MODE_ENABLE)
618 : : {
755 tgl@sss.pgh.pa.us 619 : 2 : printf(_("Files written: %lld\n"), (long long) files_written);
620 : 2 : printf(_("Blocks written: %lld\n"), (long long) blocks_written);
621 : : }
622 : : }
623 : :
624 : : /*
625 : : * Finally make the data durable on disk if enabling or disabling
626 : : * checksums. Flush first the data directory for safety, and then update
627 : : * the control file to keep the switch consistent.
628 : : */
1849 michael@paquier.xyz 629 [ + + + + ]: 10 : if (mode == PG_MODE_ENABLE || mode == PG_MODE_DISABLE)
630 : : {
631 : 3 : ControlFile->data_checksum_version =
632 : 3 : (mode == PG_MODE_ENABLE) ? PG_DATA_CHECKSUM_VERSION : 0;
633 : :
634 [ + + ]: 3 : if (do_sync)
635 : : {
1840 peter@eisentraut.org 636 : 1 : pg_log_info("syncing data directory");
221 nathan@postgresql.or 637 :GNC 1 : sync_pgdata(DataDir, PG_VERSION_NUM, sync_method);
638 : : }
639 : :
1840 peter@eisentraut.org 640 :CBC 3 : pg_log_info("updating control file");
641 : 3 : update_controlfile(DataDir, ControlFile, do_sync);
642 : :
1849 michael@paquier.xyz 643 [ - + ]: 3 : if (verbose)
1230 bruce@momjian.us 644 :UBC 0 : printf(_("Data checksum version: %u\n"), ControlFile->data_checksum_version);
1849 michael@paquier.xyz 645 [ + + ]:CBC 3 : if (mode == PG_MODE_ENABLE)
646 : 2 : printf(_("Checksums enabled in cluster\n"));
647 : : else
648 : 1 : printf(_("Checksums disabled in cluster\n"));
649 : : }
650 : :
2201 magnus@hagander.net 651 : 10 : return 0;
652 : : }
|
