LCOV - code coverage report
Current view: top level - src/bin/pg_upgrade - server.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 97 122 79.5 %
Date: 2019-11-15 23:07:02 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  *  server.c
       3             :  *
       4             :  *  database server functions
       5             :  *
       6             :  *  Copyright (c) 2010-2019, PostgreSQL Global Development Group
       7             :  *  src/bin/pg_upgrade/server.c
       8             :  */
       9             : 
      10             : #include "postgres_fe.h"
      11             : 
      12             : #include "fe_utils/connect.h"
      13             : #include "fe_utils/string_utils.h"
      14             : #include "pg_upgrade.h"
      15             : 
      16             : static PGconn *get_db_conn(ClusterInfo *cluster, const char *db_name);
      17             : 
      18             : 
      19             : /*
      20             :  * connectToServer()
      21             :  *
      22             :  *  Connects to the desired database on the designated server.
      23             :  *  If the connection attempt fails, this function logs an error
      24             :  *  message and calls exit() to kill the program.
      25             :  */
      26             : PGconn *
      27          80 : connectToServer(ClusterInfo *cluster, const char *db_name)
      28             : {
      29          80 :     PGconn     *conn = get_db_conn(cluster, db_name);
      30             : 
      31          80 :     if (conn == NULL || PQstatus(conn) != CONNECTION_OK)
      32             :     {
      33           0 :         pg_log(PG_REPORT, "connection to database failed: %s",
      34             :                PQerrorMessage(conn));
      35             : 
      36           0 :         if (conn)
      37           0 :             PQfinish(conn);
      38             : 
      39           0 :         printf(_("Failure, exiting\n"));
      40           0 :         exit(1);
      41             :     }
      42             : 
      43          80 :     PQclear(executeQueryOrDie(conn, ALWAYS_SECURE_SEARCH_PATH_SQL));
      44             : 
      45          80 :     return conn;
      46             : }
      47             : 
      48             : 
      49             : /*
      50             :  * get_db_conn()
      51             :  *
      52             :  * get database connection, using named database + standard params for cluster
      53             :  */
      54             : static PGconn *
      55          88 : get_db_conn(ClusterInfo *cluster, const char *db_name)
      56             : {
      57             :     PQExpBufferData conn_opts;
      58             :     PGconn     *conn;
      59             : 
      60             :     /* Build connection string with proper quoting */
      61          88 :     initPQExpBuffer(&conn_opts);
      62          88 :     appendPQExpBufferStr(&conn_opts, "dbname=");
      63          88 :     appendConnStrVal(&conn_opts, db_name);
      64          88 :     appendPQExpBufferStr(&conn_opts, " user=");
      65          88 :     appendConnStrVal(&conn_opts, os_info.user);
      66          88 :     appendPQExpBuffer(&conn_opts, " port=%d", cluster->port);
      67          88 :     if (cluster->sockdir)
      68             :     {
      69          88 :         appendPQExpBufferStr(&conn_opts, " host=");
      70          88 :         appendConnStrVal(&conn_opts, cluster->sockdir);
      71             :     }
      72             : 
      73          88 :     conn = PQconnectdb(conn_opts.data);
      74          88 :     termPQExpBuffer(&conn_opts);
      75          88 :     return conn;
      76             : }
      77             : 
      78             : 
      79             : /*
      80             :  * cluster_conn_opts()
      81             :  *
      82             :  * Return standard command-line options for connecting to this cluster when
      83             :  * using psql, pg_dump, etc.  Ideally this would match what get_db_conn()
      84             :  * sets, but the utilities we need aren't very consistent about the treatment
      85             :  * of database name options, so we leave that out.
      86             :  *
      87             :  * Result is valid until the next call to this function.
      88             :  */
      89             : char *
      90          32 : cluster_conn_opts(ClusterInfo *cluster)
      91             : {
      92             :     static PQExpBuffer buf;
      93             : 
      94          32 :     if (buf == NULL)
      95           2 :         buf = createPQExpBuffer();
      96             :     else
      97          30 :         resetPQExpBuffer(buf);
      98             : 
      99          32 :     if (cluster->sockdir)
     100             :     {
     101          32 :         appendPQExpBufferStr(buf, "--host ");
     102          32 :         appendShellString(buf, cluster->sockdir);
     103          32 :         appendPQExpBufferChar(buf, ' ');
     104             :     }
     105          32 :     appendPQExpBuffer(buf, "--port %d --username ", cluster->port);
     106          32 :     appendShellString(buf, os_info.user);
     107             : 
     108          32 :     return buf->data;
     109             : }
     110             : 
     111             : 
     112             : /*
     113             :  * executeQueryOrDie()
     114             :  *
     115             :  *  Formats a query string from the given arguments and executes the
     116             :  *  resulting query.  If the query fails, this function logs an error
     117             :  *  message and calls exit() to kill the program.
     118             :  */
     119             : PGresult *
     120         176 : executeQueryOrDie(PGconn *conn, const char *fmt,...)
     121             : {
     122             :     static char query[QUERY_ALLOC];
     123             :     va_list     args;
     124             :     PGresult   *result;
     125             :     ExecStatusType status;
     126             : 
     127         176 :     va_start(args, fmt);
     128         176 :     vsnprintf(query, sizeof(query), fmt, args);
     129         176 :     va_end(args);
     130             : 
     131         176 :     pg_log(PG_VERBOSE, "executing: %s\n", query);
     132         176 :     result = PQexec(conn, query);
     133         176 :     status = PQresultStatus(result);
     134             : 
     135         176 :     if ((status != PGRES_TUPLES_OK) && (status != PGRES_COMMAND_OK))
     136             :     {
     137           0 :         pg_log(PG_REPORT, "SQL command failed\n%s\n%s", query,
     138             :                PQerrorMessage(conn));
     139           0 :         PQclear(result);
     140           0 :         PQfinish(conn);
     141           0 :         printf(_("Failure, exiting\n"));
     142           0 :         exit(1);
     143             :     }
     144             :     else
     145         176 :         return result;
     146             : }
     147             : 
     148             : 
     149             : /*
     150             :  * get_major_server_version()
     151             :  *
     152             :  * gets the version (in unsigned int form) for the given datadir. Assumes
     153             :  * that datadir is an absolute path to a valid pgdata directory. The version
     154             :  * is retrieved by reading the PG_VERSION file.
     155             :  */
     156             : uint32
     157           4 : get_major_server_version(ClusterInfo *cluster)
     158             : {
     159             :     FILE       *version_fd;
     160             :     char        ver_filename[MAXPGPATH];
     161           4 :     int         v1 = 0,
     162           4 :                 v2 = 0;
     163             : 
     164           4 :     snprintf(ver_filename, sizeof(ver_filename), "%s/PG_VERSION",
     165             :              cluster->pgdata);
     166           4 :     if ((version_fd = fopen(ver_filename, "r")) == NULL)
     167           0 :         pg_fatal("could not open version file: %s\n", ver_filename);
     168             : 
     169           8 :     if (fscanf(version_fd, "%63s", cluster->major_version_str) == 0 ||
     170           4 :         sscanf(cluster->major_version_str, "%d.%d", &v1, &v2) < 1)
     171           0 :         pg_fatal("could not parse PG_VERSION file from %s\n", cluster->pgdata);
     172             : 
     173           4 :     fclose(version_fd);
     174             : 
     175           4 :     if (v1 < 10)
     176             :     {
     177             :         /* old style, e.g. 9.6.1 */
     178           0 :         return v1 * 10000 + v2 * 100;
     179             :     }
     180             :     else
     181             :     {
     182             :         /* new style, e.g. 10.1 */
     183           4 :         return v1 * 10000;
     184             :     }
     185             : }
     186             : 
     187             : 
     188             : static void
     189           2 : stop_postmaster_atexit(void)
     190             : {
     191           2 :     stop_postmaster(true);
     192           2 : }
     193             : 
     194             : 
     195             : bool
     196           8 : start_postmaster(ClusterInfo *cluster, bool report_and_exit_on_error)
     197             : {
     198             :     char        cmd[MAXPGPATH * 4 + 1000];
     199             :     PGconn     *conn;
     200           8 :     bool        pg_ctl_return = false;
     201             :     char        socket_string[MAXPGPATH + 200];
     202             : 
     203             :     static bool exit_hook_registered = false;
     204             : 
     205           8 :     if (!exit_hook_registered)
     206             :     {
     207           2 :         atexit(stop_postmaster_atexit);
     208           2 :         exit_hook_registered = true;
     209             :     }
     210             : 
     211           8 :     socket_string[0] = '\0';
     212             : 
     213             : #ifdef HAVE_UNIX_SOCKETS
     214             :     /* prevent TCP/IP connections, restrict socket access */
     215           8 :     strcat(socket_string,
     216             :            " -c listen_addresses='' -c unix_socket_permissions=0700");
     217             : 
     218             :     /* Have a sockdir?  Tell the postmaster. */
     219           8 :     if (cluster->sockdir)
     220          24 :         snprintf(socket_string + strlen(socket_string),
     221           8 :                  sizeof(socket_string) - strlen(socket_string),
     222             :                  " -c %s='%s'",
     223           8 :                  (GET_MAJOR_VERSION(cluster->major_version) < 903) ?
     224             :                  "unix_socket_directory" : "unix_socket_directories",
     225             :                  cluster->sockdir);
     226             : #endif
     227             : 
     228             :     /*
     229             :      * Since PG 9.1, we have used -b to disable autovacuum.  For earlier
     230             :      * releases, setting autovacuum=off disables cleanup vacuum and analyze,
     231             :      * but freeze vacuums can still happen, so we set
     232             :      * autovacuum_freeze_max_age to its maximum.
     233             :      * (autovacuum_multixact_freeze_max_age was introduced after 9.1, so there
     234             :      * is no need to set that.)  We assume all datfrozenxid and relfrozenxid
     235             :      * values are less than a gap of 2000000000 from the current xid counter,
     236             :      * so autovacuum will not touch them.
     237             :      *
     238             :      * Turn off durability requirements to improve object creation speed, and
     239             :      * we only modify the new cluster, so only use it there.  If there is a
     240             :      * crash, the new cluster has to be recreated anyway.  fsync=off is a big
     241             :      * win on ext4.
     242             :      */
     243          24 :     snprintf(cmd, sizeof(cmd),
     244             :              "\"%s/pg_ctl\" -w -l \"%s\" -D \"%s\" -o \"-p %d%s%s %s%s\" start",
     245           8 :              cluster->bindir, SERVER_LOG_FILE, cluster->pgconfig, cluster->port,
     246           8 :              (cluster->controldata.cat_ver >=
     247             :               BINARY_UPGRADE_SERVER_FLAG_CAT_VER) ? " -b" :
     248             :              " -c autovacuum=off -c autovacuum_freeze_max_age=2000000000",
     249             :              (cluster == &new_cluster) ?
     250             :              " -c synchronous_commit=off -c fsync=off -c full_page_writes=off" : "",
     251           8 :              cluster->pgopts ? cluster->pgopts : "", socket_string);
     252             : 
     253             :     /*
     254             :      * Don't throw an error right away, let connecting throw the error because
     255             :      * it might supply a reason for the failure.
     256             :      */
     257           8 :     pg_ctl_return = exec_prog(SERVER_START_LOG_FILE,
     258             :     /* pass both file names if they differ */
     259             :                               (strcmp(SERVER_LOG_FILE,
     260             :                                       SERVER_START_LOG_FILE) != 0) ?
     261             :                               SERVER_LOG_FILE : NULL,
     262             :                               report_and_exit_on_error, false,
     263             :                               "%s", cmd);
     264             : 
     265             :     /* Did it fail and we are just testing if the server could be started? */
     266           8 :     if (!pg_ctl_return && !report_and_exit_on_error)
     267           0 :         return false;
     268             : 
     269             :     /*
     270             :      * We set this here to make sure atexit() shuts down the server, but only
     271             :      * if we started the server successfully.  We do it before checking for
     272             :      * connectivity in case the server started but there is a connectivity
     273             :      * failure.  If pg_ctl did not return success, we will exit below.
     274             :      *
     275             :      * Pre-9.1 servers do not have PQping(), so we could be leaving the server
     276             :      * running if authentication was misconfigured, so someday we might went
     277             :      * to be more aggressive about doing server shutdowns even if pg_ctl
     278             :      * fails, but now (2013-08-14) it seems prudent to be cautious.  We don't
     279             :      * want to shutdown a server that might have been accidentally started
     280             :      * during the upgrade.
     281             :      */
     282           8 :     if (pg_ctl_return)
     283           8 :         os_info.running_cluster = cluster;
     284             : 
     285             :     /*
     286             :      * pg_ctl -w might have failed because the server couldn't be started, or
     287             :      * there might have been a connection problem in _checking_ if the server
     288             :      * has started.  Therefore, even if pg_ctl failed, we continue and test
     289             :      * for connectivity in case we get a connection reason for the failure.
     290             :      */
     291          16 :     if ((conn = get_db_conn(cluster, "template1")) == NULL ||
     292           8 :         PQstatus(conn) != CONNECTION_OK)
     293             :     {
     294           0 :         pg_log(PG_REPORT, "\nconnection to database failed: %s",
     295             :                PQerrorMessage(conn));
     296           0 :         if (conn)
     297           0 :             PQfinish(conn);
     298           0 :         if (cluster == &old_cluster)
     299           0 :             pg_fatal("could not connect to source postmaster started with the command:\n"
     300             :                      "%s\n",
     301             :                      cmd);
     302             :         else
     303           0 :             pg_fatal("could not connect to target postmaster started with the command:\n"
     304             :                      "%s\n",
     305             :                      cmd);
     306             :     }
     307           8 :     PQfinish(conn);
     308             : 
     309             :     /*
     310             :      * If pg_ctl failed, and the connection didn't fail, and
     311             :      * report_and_exit_on_error is enabled, fail now.  This could happen if
     312             :      * the server was already running.
     313             :      */
     314           8 :     if (!pg_ctl_return)
     315             :     {
     316           0 :         if (cluster == &old_cluster)
     317           0 :             pg_fatal("pg_ctl failed to start the source server, or connection failed\n");
     318             :         else
     319           0 :             pg_fatal("pg_ctl failed to start the target server, or connection failed\n");
     320             :     }
     321             : 
     322           8 :     return true;
     323             : }
     324             : 
     325             : 
     326             : void
     327          10 : stop_postmaster(bool in_atexit)
     328             : {
     329             :     ClusterInfo *cluster;
     330             : 
     331          10 :     if (os_info.running_cluster == &old_cluster)
     332           2 :         cluster = &old_cluster;
     333           8 :     else if (os_info.running_cluster == &new_cluster)
     334           6 :         cluster = &new_cluster;
     335             :     else
     336           2 :         return;                 /* no cluster running */
     337             : 
     338          32 :     exec_prog(SERVER_STOP_LOG_FILE, NULL, !in_atexit, !in_atexit,
     339             :               "\"%s/pg_ctl\" -w -D \"%s\" -o \"%s\" %s stop",
     340             :               cluster->bindir, cluster->pgconfig,
     341           8 :               cluster->pgopts ? cluster->pgopts : "",
     342          16 :               in_atexit ? "-m fast" : "-m smart");
     343             : 
     344           8 :     os_info.running_cluster = NULL;
     345             : }
     346             : 
     347             : 
     348             : /*
     349             :  * check_pghost_envvar()
     350             :  *
     351             :  * Tests that PGHOST does not point to a non-local server
     352             :  */
     353             : void
     354           2 : check_pghost_envvar(void)
     355             : {
     356             :     PQconninfoOption *option;
     357             :     PQconninfoOption *start;
     358             : 
     359             :     /* Get valid libpq env vars from the PQconndefaults function */
     360             : 
     361           2 :     start = PQconndefaults();
     362             : 
     363           2 :     if (!start)
     364           0 :         pg_fatal("out of memory\n");
     365             : 
     366          64 :     for (option = start; option->keyword != NULL; option++)
     367             :     {
     368         108 :         if (option->envvar && (strcmp(option->envvar, "PGHOST") == 0 ||
     369          46 :                                strcmp(option->envvar, "PGHOSTADDR") == 0))
     370             :         {
     371           4 :             const char *value = getenv(option->envvar);
     372             : 
     373           6 :             if (value && strlen(value) > 0 &&
     374             :             /* check for 'local' host values */
     375           6 :                 (strcmp(value, "localhost") != 0 && strcmp(value, "127.0.0.1") != 0 &&
     376           4 :                  strcmp(value, "::1") != 0 && value[0] != '/'))
     377           0 :                 pg_fatal("libpq environment variable %s has a non-local server value: %s\n",
     378             :                          option->envvar, value);
     379             :         }
     380             :     }
     381             : 
     382             :     /* Free the memory that libpq allocated on our behalf */
     383           2 :     PQconninfoFree(start);
     384           2 : }

Generated by: LCOV version 1.13