Branch data     Line data    Source code

       1                 :             : /*-------------------------------------------------------------------------
       2                 :             :  *
       3                 :             :  * archive.c
       4                 :             :  *    Routines to access WAL archives from frontend
       5                 :             :  *
       6                 :             :  * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
       7                 :             :  * Portions Copyright (c) 1994, Regents of the University of California
       8                 :             :  *
       9                 :             :  *
      10                 :             :  * IDENTIFICATION
      11                 :             :  *    src/fe_utils/archive.c
      12                 :             :  *
      13                 :             :  *-------------------------------------------------------------------------
      14                 :             :  */
      15                 :             : 
      16                 :             : #include "postgres_fe.h"
      17                 :             : 
      18                 :             : #include <unistd.h>
      19                 :             : #include <sys/stat.h>
      20                 :             : 
      21                 :             : #include "access/xlog_internal.h"
      22                 :             : #include "common/archive.h"
      23                 :             : #include "common/logging.h"
      24                 :             : #include "fe_utils/archive.h"
      25                 :             : 
      26                 :             : 
      27                 :             : /*
      28                 :             :  * RestoreArchivedFile
      29                 :             :  *
      30                 :             :  * Attempt to retrieve the specified file from off-line archival storage.
      31                 :             :  * If successful, return a file descriptor of the restored file, else
      32                 :             :  * return -1.
      33                 :             :  *
      34                 :             :  * For fixed-size files, the caller may pass the expected size as an
      35                 :             :  * additional crosscheck on successful recovery.  If the file size is not
      36                 :             :  * known, set expectedSize = 0.
      37                 :             :  */
      38                 :             : int
      39                 :           1 : RestoreArchivedFile(const char *path, const char *xlogfname,
      40                 :             :                     off_t expectedSize, const char *restoreCommand)
      41                 :             : {
      42                 :             :     char        xlogpath[MAXPGPATH];
      43                 :             :     char       *xlogRestoreCmd;
      44                 :             :     int         rc;
      45                 :             :     struct stat stat_buf;
      46                 :             : 
      47                 :           1 :     snprintf(xlogpath, MAXPGPATH, "%s/" XLOGDIR "/%s", path, xlogfname);
      48                 :             : 
      49                 :           1 :     xlogRestoreCmd = BuildRestoreCommand(restoreCommand, xlogpath,
      50                 :             :                                          xlogfname, NULL);
      51                 :             : 
      52                 :             :     /*
      53                 :             :      * Execute restore_command, which should copy the missing file from
      54                 :             :      * archival storage.
      55                 :             :      */
      56                 :           1 :     fflush(NULL);
      57                 :           1 :     rc = system(xlogRestoreCmd);
      58                 :           1 :     pfree(xlogRestoreCmd);
      59                 :             : 
      60         [ +  - ]:           1 :     if (rc == 0)
      61                 :             :     {
      62                 :             :         /*
      63                 :             :          * Command apparently succeeded, but let's make sure the file is
      64                 :             :          * really there now and has the correct size.
      65                 :             :          */
      66         [ +  - ]:           1 :         if (stat(xlogpath, &stat_buf) == 0)
      67                 :             :         {
      68   [ +  -  -  + ]:           1 :             if (expectedSize > 0 && stat_buf.st_size != expectedSize)
      69                 :           0 :                 pg_fatal("unexpected file size for \"%s\": %lld instead of %lld",
      70                 :             :                          xlogfname, (long long int) stat_buf.st_size,
      71                 :             :                          (long long int) expectedSize);
      72                 :             :             else
      73                 :             :             {
      74                 :           1 :                 int         xlogfd = open(xlogpath, O_RDONLY | PG_BINARY, 0);
      75                 :             : 
      76         [ -  + ]:           1 :                 if (xlogfd < 0)
      77                 :           0 :                     pg_fatal("could not open file \"%s\" restored from archive: %m",
      78                 :             :                              xlogpath);
      79                 :             :                 else
      80                 :           1 :                     return xlogfd;
      81                 :             :             }
      82                 :             :         }
      83                 :             :         else
      84                 :             :         {
      85         [ #  # ]:           0 :             if (errno != ENOENT)
      86                 :           0 :                 pg_fatal("could not stat file \"%s\": %m",
      87                 :             :                          xlogpath);
      88                 :             :         }
      89                 :             :     }
      90                 :             : 
      91                 :             :     /*
      92                 :             :      * If the failure was due to a signal, then it would be misleading to
      93                 :             :      * return with a failure at restoring the file.  So just bail out and
      94                 :             :      * exit.  Hard shell errors such as "command not found" are treated as
      95                 :             :      * fatal too.
      96                 :             :      */
      97         [ #  # ]:           0 :     if (wait_result_is_any_signal(rc, true))
      98                 :           0 :         pg_fatal("\"restore_command\" failed: %s",
      99                 :             :                  wait_result_to_str(rc));
     100                 :             : 
     101                 :             :     /*
     102                 :             :      * The file is not available, so just let the caller decide what to do
     103                 :             :      * next.
     104                 :             :      */
     105                 :           0 :     pg_log_error("could not restore file \"%s\" from archive",
     106                 :             :                  xlogfname);
     107                 :           0 :     return -1;
     108                 :             : }