LCOV - code coverage report
Current view: top level - src/common - controldata_utils.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 47 67 70.1 %
Date: 2023-11-29 05:10:53 Functions: 2 2 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * controldata_utils.c
       4             :  *      Common code for control data file output.
       5             :  *
       6             :  *
       7             :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
       8             :  * Portions Copyright (c) 1994, Regents of the University of California
       9             :  *
      10             :  *
      11             :  * IDENTIFICATION
      12             :  *    src/common/controldata_utils.c
      13             :  *
      14             :  *-------------------------------------------------------------------------
      15             :  */
      16             : 
      17             : #ifndef FRONTEND
      18             : #include "postgres.h"
      19             : #else
      20             : #include "postgres_fe.h"
      21             : #endif
      22             : 
      23             : #include <unistd.h>
      24             : #include <sys/stat.h>
      25             : #include <fcntl.h>
      26             : #include <time.h>
      27             : 
      28             : #include "access/xlog_internal.h"
      29             : #include "catalog/pg_control.h"
      30             : #include "common/controldata_utils.h"
      31             : #include "common/file_perm.h"
      32             : #ifdef FRONTEND
      33             : #include "common/logging.h"
      34             : #endif
      35             : #include "port/pg_crc32c.h"
      36             : 
      37             : #ifndef FRONTEND
      38             : #include "pgstat.h"
      39             : #include "storage/fd.h"
      40             : #endif
      41             : 
      42             : /*
      43             :  * get_controlfile()
      44             :  *
      45             :  * Get controlfile values.  The result is returned as a palloc'd copy of the
      46             :  * control file data.
      47             :  *
      48             :  * crc_ok_p can be used by the caller to see whether the CRC of the control
      49             :  * file data is correct.
      50             :  */
      51             : ControlFileData *
      52         390 : get_controlfile(const char *DataDir, bool *crc_ok_p)
      53             : {
      54             :     ControlFileData *ControlFile;
      55             :     int         fd;
      56             :     char        ControlFilePath[MAXPGPATH];
      57             :     pg_crc32c   crc;
      58             :     int         r;
      59             : #ifdef FRONTEND
      60             :     pg_crc32c   last_crc;
      61         360 :     int         retries = 0;
      62             : #endif
      63             : 
      64             :     Assert(crc_ok_p);
      65             : 
      66         390 :     ControlFile = palloc_object(ControlFileData);
      67         390 :     snprintf(ControlFilePath, MAXPGPATH, "%s/global/pg_control", DataDir);
      68             : 
      69             : #ifdef FRONTEND
      70         360 :     INIT_CRC32C(last_crc);
      71             : 
      72         362 : retry:
      73             : #endif
      74             : 
      75             : #ifndef FRONTEND
      76          30 :     if ((fd = OpenTransientFile(ControlFilePath, O_RDONLY | PG_BINARY)) == -1)
      77           0 :         ereport(ERROR,
      78             :                 (errcode_for_file_access(),
      79             :                  errmsg("could not open file \"%s\" for reading: %m",
      80             :                         ControlFilePath)));
      81             : #else
      82         362 :     if ((fd = open(ControlFilePath, O_RDONLY | PG_BINARY, 0)) == -1)
      83           2 :         pg_fatal("could not open file \"%s\" for reading: %m",
      84             :                  ControlFilePath);
      85             : #endif
      86             : 
      87         390 :     r = read(fd, ControlFile, sizeof(ControlFileData));
      88         390 :     if (r != sizeof(ControlFileData))
      89             :     {
      90           0 :         if (r < 0)
      91             : #ifndef FRONTEND
      92           0 :             ereport(ERROR,
      93             :                     (errcode_for_file_access(),
      94             :                      errmsg("could not read file \"%s\": %m", ControlFilePath)));
      95             : #else
      96           0 :             pg_fatal("could not read file \"%s\": %m", ControlFilePath);
      97             : #endif
      98             :         else
      99             : #ifndef FRONTEND
     100           0 :             ereport(ERROR,
     101             :                     (errcode(ERRCODE_DATA_CORRUPTED),
     102             :                      errmsg("could not read file \"%s\": read %d of %zu",
     103             :                             ControlFilePath, r, sizeof(ControlFileData))));
     104             : #else
     105           0 :             pg_fatal("could not read file \"%s\": read %d of %zu",
     106             :                      ControlFilePath, r, sizeof(ControlFileData));
     107             : #endif
     108             :     }
     109             : 
     110             : #ifndef FRONTEND
     111          30 :     if (CloseTransientFile(fd) != 0)
     112           0 :         ereport(ERROR,
     113             :                 (errcode_for_file_access(),
     114             :                  errmsg("could not close file \"%s\": %m",
     115             :                         ControlFilePath)));
     116             : #else
     117         360 :     if (close(fd) != 0)
     118           0 :         pg_fatal("could not close file \"%s\": %m", ControlFilePath);
     119             : #endif
     120             : 
     121             :     /* Check the CRC. */
     122         390 :     INIT_CRC32C(crc);
     123         390 :     COMP_CRC32C(crc,
     124             :                 (char *) ControlFile,
     125             :                 offsetof(ControlFileData, crc));
     126         390 :     FIN_CRC32C(crc);
     127             : 
     128         390 :     *crc_ok_p = EQ_CRC32C(crc, ControlFile->crc);
     129             : 
     130             : #ifdef FRONTEND
     131             : 
     132             :     /*
     133             :      * If the server was writing at the same time, it is possible that we read
     134             :      * partially updated contents on some systems.  If the CRC doesn't match,
     135             :      * retry a limited number of times until we compute the same bad CRC twice
     136             :      * in a row with a short sleep in between.  Then the failure is unlikely
     137             :      * to be due to a concurrent write.
     138             :      */
     139         360 :     if (!*crc_ok_p &&
     140           4 :         (retries == 0 || !EQ_CRC32C(crc, last_crc)) &&
     141             :         retries < 10)
     142             :     {
     143           2 :         retries++;
     144           2 :         last_crc = crc;
     145           2 :         pg_usleep(10000);
     146           2 :         goto retry;
     147             :     }
     148             : #endif
     149             : 
     150             :     /* Make sure the control file is valid byte order. */
     151         388 :     if (ControlFile->pg_control_version % 65536 == 0 &&
     152           2 :         ControlFile->pg_control_version / 65536 != 0)
     153             : #ifndef FRONTEND
     154           0 :         elog(ERROR, _("byte ordering mismatch"));
     155             : #else
     156           0 :         pg_log_warning("possible byte ordering mismatch\n"
     157             :                        "The byte ordering used to store the pg_control file might not match the one\n"
     158             :                        "used by this program.  In that case the results below would be incorrect, and\n"
     159             :                        "the PostgreSQL installation would be incompatible with this data directory.");
     160             : #endif
     161             : 
     162         388 :     return ControlFile;
     163             : }
     164             : 
     165             : /*
     166             :  * update_controlfile()
     167             :  *
     168             :  * Update controlfile values with the contents given by caller.  The
     169             :  * contents to write are included in "ControlFile". "do_sync" can be
     170             :  * optionally used to flush the updated control file.  Note that it is up
     171             :  * to the caller to properly lock ControlFileLock when calling this
     172             :  * routine in the backend.
     173             :  */
     174             : void
     175       16028 : update_controlfile(const char *DataDir,
     176             :                    ControlFileData *ControlFile, bool do_sync)
     177             : {
     178             :     int         fd;
     179             :     char        buffer[PG_CONTROL_FILE_SIZE];
     180             :     char        ControlFilePath[MAXPGPATH];
     181             : 
     182             :     /* Update timestamp  */
     183       16028 :     ControlFile->time = (pg_time_t) time(NULL);
     184             : 
     185             :     /* Recalculate CRC of control file */
     186       16028 :     INIT_CRC32C(ControlFile->crc);
     187       16028 :     COMP_CRC32C(ControlFile->crc,
     188             :                 (char *) ControlFile,
     189             :                 offsetof(ControlFileData, crc));
     190       16028 :     FIN_CRC32C(ControlFile->crc);
     191             : 
     192             :     /*
     193             :      * Write out PG_CONTROL_FILE_SIZE bytes into pg_control by zero-padding
     194             :      * the excess over sizeof(ControlFileData), to avoid premature EOF related
     195             :      * errors when reading it.
     196             :      */
     197       16028 :     memset(buffer, 0, PG_CONTROL_FILE_SIZE);
     198       16028 :     memcpy(buffer, ControlFile, sizeof(ControlFileData));
     199             : 
     200       16028 :     snprintf(ControlFilePath, sizeof(ControlFilePath), "%s/%s", DataDir, XLOG_CONTROL_FILE);
     201             : 
     202             : #ifndef FRONTEND
     203             : 
     204             :     /*
     205             :      * All errors issue a PANIC, so no need to use OpenTransientFile() and to
     206             :      * worry about file descriptor leaks.
     207             :      */
     208       15962 :     if ((fd = BasicOpenFile(ControlFilePath, O_RDWR | PG_BINARY)) < 0)
     209           0 :         ereport(PANIC,
     210             :                 (errcode_for_file_access(),
     211             :                  errmsg("could not open file \"%s\": %m",
     212             :                         ControlFilePath)));
     213             : #else
     214          66 :     if ((fd = open(ControlFilePath, O_WRONLY | PG_BINARY,
     215             :                    pg_file_create_mode)) == -1)
     216           0 :         pg_fatal("could not open file \"%s\": %m", ControlFilePath);
     217             : #endif
     218             : 
     219       16028 :     errno = 0;
     220             : #ifndef FRONTEND
     221       15962 :     pgstat_report_wait_start(WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE);
     222             : #endif
     223       16028 :     if (write(fd, buffer, PG_CONTROL_FILE_SIZE) != PG_CONTROL_FILE_SIZE)
     224             :     {
     225             :         /* if write didn't set errno, assume problem is no disk space */
     226           0 :         if (errno == 0)
     227           0 :             errno = ENOSPC;
     228             : 
     229             : #ifndef FRONTEND
     230           0 :         ereport(PANIC,
     231             :                 (errcode_for_file_access(),
     232             :                  errmsg("could not write file \"%s\": %m",
     233             :                         ControlFilePath)));
     234             : #else
     235           0 :         pg_fatal("could not write file \"%s\": %m", ControlFilePath);
     236             : #endif
     237             :     }
     238             : #ifndef FRONTEND
     239       15962 :     pgstat_report_wait_end();
     240             : #endif
     241             : 
     242       16028 :     if (do_sync)
     243             :     {
     244             : #ifndef FRONTEND
     245       15962 :         pgstat_report_wait_start(WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE);
     246       15962 :         if (pg_fsync(fd) != 0)
     247           0 :             ereport(PANIC,
     248             :                     (errcode_for_file_access(),
     249             :                      errmsg("could not fsync file \"%s\": %m",
     250             :                             ControlFilePath)));
     251       15962 :         pgstat_report_wait_end();
     252             : #else
     253          42 :         if (fsync(fd) != 0)
     254           0 :             pg_fatal("could not fsync file \"%s\": %m", ControlFilePath);
     255             : #endif
     256             :     }
     257             : 
     258       16028 :     if (close(fd) != 0)
     259             :     {
     260             : #ifndef FRONTEND
     261           0 :         ereport(PANIC,
     262             :                 (errcode_for_file_access(),
     263             :                  errmsg("could not close file \"%s\": %m",
     264             :                         ControlFilePath)));
     265             : #else
     266           0 :         pg_fatal("could not close file \"%s\": %m", ControlFilePath);
     267             : #endif
     268             :     }
     269       16028 : }

Generated by: LCOV version 1.14