LCOV - differential code coverage report
Current view: top level - src/bin/pg_checksums - pg_checksums.c (source / functions) Coverage Total Hit UNC LBC UBC GIC GNC CBC DCB
Current: Differential Code Coverage 16@8cea358b128 vs 17@8cea358b128 Lines: 77.1 % 262 202 4 56 2 200 1
Current Date: 2024-04-14 14:21:10 Functions: 83.3 % 6 5 1 2 3
Baseline: 16@8cea358b128 Branches: 68.3 % 186 127 2 1 56 1 126
Baseline Date: 2024-04-14 14:21:09 Line coverage date bins:
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed (60,120] days: 100.0 % 2 2 2
(180,240] days: 33.3 % 6 2 4 2
(240..) days: 78.0 % 254 198 56 198
Function coverage date bins:
(240..) days: 83.3 % 6 5 1 2 3
Branch coverage date bins:
(60,120] days: 100.0 % 2 2 2
(180,240] days: 0.0 % 2 0 2
(240..) days: 68.7 % 182 125 1 56 1 124

 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                 :                : }
        

Generated by: LCOV version 2.1-beta2-3-g6141622