granicus.if.org Git - postgresql/blob - src/backend/postmaster/pgstat.c

   1 /* ----------
   2  * pgstat.c
   3  *
   4  *      All the statistics collector stuff hacked up in one big, ugly file.
   5  *
   6  *      TODO:   - Separate collector, postmaster and backend stuff
   7  *                        into different files.
   8  *
   9  *                      - Add some automatic call for pgstat vacuuming.
  10  *
  11  *                      - Add a pgstat config column to pg_database, so this
  12  *                        entire thing can be enabled/disabled on a per db basis.
  13  *
  14  *      Copyright (c) 2001-2010, PostgreSQL Global Development Group
  15  *
  16  *      $PostgreSQL: pgsql/src/backend/postmaster/pgstat.c,v 1.199 2010/01/28 14:25:41 mha Exp $
  17  * ----------
  18  */
  19 #include "postgres.h"
  20
  21 #include <unistd.h>
  22 #include <fcntl.h>
  23 #include <sys/param.h>
  24 #include <sys/time.h>
  25 #include <sys/socket.h>
  26 #include <netdb.h>
  27 #include <netinet/in.h>
  28 #include <arpa/inet.h>
  29 #include <signal.h>
  30 #include <time.h>
  31 #ifdef HAVE_POLL_H
  32 #include <poll.h>
  33 #endif
  34 #ifdef HAVE_SYS_POLL_H
  35 #include <sys/poll.h>
  36 #endif
  37
  38 #include "pgstat.h"
  39
  40 #include "access/heapam.h"
  41 #include "access/transam.h"
  42 #include "access/twophase_rmgr.h"
  43 #include "access/xact.h"
  44 #include "catalog/pg_database.h"
  45 #include "catalog/pg_proc.h"
  46 #include "libpq/ip.h"
  47 #include "libpq/libpq.h"
  48 #include "libpq/pqsignal.h"
  49 #include "mb/pg_wchar.h"
  50 #include "miscadmin.h"
  51 #include "pg_trace.h"
  52 #include "postmaster/autovacuum.h"
  53 #include "postmaster/fork_process.h"
  54 #include "postmaster/postmaster.h"
  55 #include "storage/backendid.h"
  56 #include "storage/fd.h"
  57 #include "storage/ipc.h"
  58 #include "storage/pg_shmem.h"
  59 #include "storage/pmsignal.h"
  60 #include "utils/guc.h"
  61 #include "utils/memutils.h"
  62 #include "utils/ps_status.h"
  63 #include "utils/rel.h"
  64 #include "utils/tqual.h"
  65
  66
  67 /* ----------
  68  * Paths for the statistics files (relative to installation's $PGDATA).
  69  * ----------
  70  */
  71 #define PGSTAT_STAT_PERMANENT_FILENAME          "global/pgstat.stat"
  72 #define PGSTAT_STAT_PERMANENT_TMPFILE           "global/pgstat.tmp"
  73
  74 /* ----------
  75  * Timer definitions.
  76  * ----------
  77  */
  78 #define PGSTAT_STAT_INTERVAL    500             /* Minimum time between stats file
  79                                                                                  * updates; in milliseconds. */
  80
  81 #define PGSTAT_RETRY_DELAY              10              /* How long to wait between statistics
  82                                                                                  * update requests; in milliseconds. */
  83
  84 #define PGSTAT_MAX_WAIT_TIME    5000    /* Maximum time to wait for a stats
  85                                                                                  * file update; in milliseconds. */
  86
  87 #define PGSTAT_RESTART_INTERVAL 60              /* How often to attempt to restart a
  88                                                                                  * failed statistics collector; in
  89                                                                                  * seconds. */
  90
  91 #define PGSTAT_SELECT_TIMEOUT   2               /* How often to check for postmaster
  92                                                                                  * death; in seconds. */
  93
  94 #define PGSTAT_POLL_LOOP_COUNT  (PGSTAT_MAX_WAIT_TIME / PGSTAT_RETRY_DELAY)
  95
  96
  97 /* ----------
  98  * The initial size hints for the hash tables used in the collector.
  99  * ----------
 100  */
 101 #define PGSTAT_DB_HASH_SIZE             16
 102 #define PGSTAT_TAB_HASH_SIZE    512
 103 #define PGSTAT_FUNCTION_HASH_SIZE       512
 104
 105
 106 /* ----------
 107  * GUC parameters
 108  * ----------
 109  */
 110 bool            pgstat_track_activities = false;
 111 bool            pgstat_track_counts = false;
 112 int                     pgstat_track_functions = TRACK_FUNC_OFF;
 113 int                     pgstat_track_activity_query_size = 1024;
 114
 115 /* ----------
 116  * Built from GUC parameter
 117  * ----------
 118  */
 119 char       *pgstat_stat_filename = NULL;
 120 char       *pgstat_stat_tmpname = NULL;
 121
 122 /*
 123  * BgWriter global statistics counters (unused in other processes).
 124  * Stored directly in a stats message structure so it can be sent
 125  * without needing to copy things around.  We assume this inits to zeroes.
 126  */
 127 PgStat_MsgBgWriter BgWriterStats;
 128
 129 /* ----------
 130  * Local data
 131  * ----------
 132  */
 133 NON_EXEC_STATIC pgsocket pgStatSock = PGINVALID_SOCKET;
 134
 135 static struct sockaddr_storage pgStatAddr;
 136
 137 static time_t last_pgstat_start_time;
 138
 139 static bool pgStatRunningInCollector = false;
 140
 141 /*
 142  * Structures in which backends store per-table info that's waiting to be
 143  * sent to the collector.
 144  *
 145  * NOTE: once allocated, TabStatusArray structures are never moved or deleted
 146  * for the life of the backend.  Also, we zero out the t_id fields of the
 147  * contained PgStat_TableStatus structs whenever they are not actively in use.
 148  * This allows relcache pgstat_info pointers to be treated as long-lived data,
 149  * avoiding repeated searches in pgstat_initstats() when a relation is
 150  * repeatedly opened during a transaction.
 151  */
 152 #define TABSTAT_QUANTUM         100 /* we alloc this many at a time */
 153
 154 typedef struct TabStatusArray
 155 {
 156         struct TabStatusArray *tsa_next;        /* link to next array, if any */
 157         int                     tsa_used;               /* # entries currently used */
 158         PgStat_TableStatus tsa_entries[TABSTAT_QUANTUM];        /* per-table data */
 159 } TabStatusArray;
 160
 161 static TabStatusArray *pgStatTabList = NULL;
 162
 163 /*
 164  * Backends store per-function info that's waiting to be sent to the collector
 165  * in this hash table (indexed by function OID).
 166  */
 167 static HTAB *pgStatFunctions = NULL;
 168
 169 /*
 170  * Indicates if backend has some function stats that it hasn't yet
 171  * sent to the collector.
 172  */
 173 static bool have_function_stats = false;
 174
 175 /*
 176  * Tuple insertion/deletion counts for an open transaction can't be propagated
 177  * into PgStat_TableStatus counters until we know if it is going to commit
 178  * or abort.  Hence, we keep these counts in per-subxact structs that live
 179  * in TopTransactionContext.  This data structure is designed on the assumption
 180  * that subxacts won't usually modify very many tables.
 181  */
 182 typedef struct PgStat_SubXactStatus
 183 {
 184         int                     nest_level;             /* subtransaction nest level */
 185         struct PgStat_SubXactStatus *prev;      /* higher-level subxact if any */
 186         PgStat_TableXactStatus *first;          /* head of list for this subxact */
 187 } PgStat_SubXactStatus;
 188
 189 static PgStat_SubXactStatus *pgStatXactStack = NULL;
 190
 191 static int      pgStatXactCommit = 0;
 192 static int      pgStatXactRollback = 0;
 193
 194 /* Record that's written to 2PC state file when pgstat state is persisted */
 195 typedef struct TwoPhasePgStatRecord
 196 {
 197         PgStat_Counter tuples_inserted;         /* tuples inserted in xact */
 198         PgStat_Counter tuples_updated;          /* tuples updated in xact */
 199         PgStat_Counter tuples_deleted;          /* tuples deleted in xact */
 200         Oid                     t_id;                   /* table's OID */
 201         bool            t_shared;               /* is it a shared catalog? */
 202 } TwoPhasePgStatRecord;
 203
 204 /*
 205  * Info about current "snapshot" of stats file
 206  */
 207 static MemoryContext pgStatLocalContext = NULL;
 208 static HTAB *pgStatDBHash = NULL;
 209 static PgBackendStatus *localBackendStatusTable = NULL;
 210 static int      localNumBackends = 0;
 211
 212 /*
 213  * Cluster wide statistics, kept in the stats collector.
 214  * Contains statistics that are not collected per database
 215  * or per table.
 216  */
 217 static PgStat_GlobalStats globalStats;
 218
 219 /* Last time the collector successfully wrote the stats file */
 220 static TimestampTz last_statwrite;
 221
 222 /* Latest statistics request time from backends */
 223 static TimestampTz last_statrequest;
 224
 225 static volatile bool need_exit = false;
 226 static volatile bool got_SIGHUP = false;
 227
 228 /*
 229  * Total time charged to functions so far in the current backend.
 230  * We use this to help separate "self" and "other" time charges.
 231  * (We assume this initializes to zero.)
 232  */
 233 static instr_time total_func_time;
 234
 235
 236 /* ----------
 237  * Local function forward declarations
 238  * ----------
 239  */
 240 #ifdef EXEC_BACKEND
 241 static pid_t pgstat_forkexec(void);
 242 #endif
 243
 244 NON_EXEC_STATIC void PgstatCollectorMain(int argc, char *argv[]);
 245 static void pgstat_exit(SIGNAL_ARGS);
 246 static void pgstat_beshutdown_hook(int code, Datum arg);
 247 static void pgstat_sighup_handler(SIGNAL_ARGS);
 248
 249 static PgStat_StatDBEntry *pgstat_get_db_entry(Oid databaseid, bool create);
 250 static PgStat_StatTabEntry *pgstat_get_tab_entry(PgStat_StatDBEntry *dbentry,
 251                                                                                                  Oid tableoid, bool create);
 252 static void pgstat_write_statsfile(bool permanent);
 253 static HTAB *pgstat_read_statsfile(Oid onlydb, bool permanent);
 254 static void backend_read_statsfile(void);
 255 static void pgstat_read_current_status(void);
 256
 257 static void pgstat_send_tabstat(PgStat_MsgTabstat *tsmsg);
 258 static void pgstat_send_funcstats(void);
 259 static HTAB *pgstat_collect_oids(Oid catalogid);
 260
 261 static PgStat_TableStatus *get_tabstat_entry(Oid rel_id, bool isshared);
 262
 263 static void pgstat_setup_memcxt(void);
 264
 265 static void pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype);
 266 static void pgstat_send(void *msg, int len);
 267
 268 static void pgstat_recv_inquiry(PgStat_MsgInquiry *msg, int len);
 269 static void pgstat_recv_tabstat(PgStat_MsgTabstat *msg, int len);
 270 static void pgstat_recv_tabpurge(PgStat_MsgTabpurge *msg, int len);
 271 static void pgstat_recv_dropdb(PgStat_MsgDropdb *msg, int len);
 272 static void pgstat_recv_resetcounter(PgStat_MsgResetcounter *msg, int len);
 273 static void pgstat_recv_resetsharedcounter(PgStat_MsgResetsharedcounter *msg, int len);
 274 static void pgstat_recv_resetsinglecounter(PgStat_MsgResetsinglecounter *msg, int len);
 275 static void pgstat_recv_autovac(PgStat_MsgAutovacStart *msg, int len);
 276 static void pgstat_recv_vacuum(PgStat_MsgVacuum *msg, int len);
 277 static void pgstat_recv_analyze(PgStat_MsgAnalyze *msg, int len);
 278 static void pgstat_recv_bgwriter(PgStat_MsgBgWriter *msg, int len);
 279 static void pgstat_recv_funcstat(PgStat_MsgFuncstat *msg, int len);
 280 static void pgstat_recv_funcpurge(PgStat_MsgFuncpurge *msg, int len);
 281
 282
 283 /* ------------------------------------------------------------
 284  * Public functions called from postmaster follow
 285  * ------------------------------------------------------------
 286  */
 287
 288 /* ----------
 289  * pgstat_init() -
 290  *
 291  *      Called from postmaster at startup. Create the resources required
 292  *      by the statistics collector process.  If unable to do so, do not
 293  *      fail --- better to let the postmaster start with stats collection
 294  *      disabled.
 295  * ----------
 296  */
 297 void
 298 pgstat_init(void)
 299 {
 300         ACCEPT_TYPE_ARG3 alen;
 301         struct addrinfo *addrs = NULL,
 302                            *addr,
 303                                 hints;
 304         int                     ret;
 305         fd_set          rset;
 306         struct timeval tv;
 307         char            test_byte;
 308         int                     sel_res;
 309         int                     tries = 0;
 310
 311 #define TESTBYTEVAL ((char) 199)
 312
 313         /*
 314          * Create the UDP socket for sending and receiving statistic messages
 315          */
 316         hints.ai_flags = AI_PASSIVE;
 317         hints.ai_family = PF_UNSPEC;
 318         hints.ai_socktype = SOCK_DGRAM;
 319         hints.ai_protocol = 0;
 320         hints.ai_addrlen = 0;
 321         hints.ai_addr = NULL;
 322         hints.ai_canonname = NULL;
 323         hints.ai_next = NULL;
 324         ret = pg_getaddrinfo_all("localhost", NULL, &hints, &addrs);
 325         if (ret || !addrs)
 326         {
 327                 ereport(LOG,
 328                                 (errmsg("could not resolve \"localhost\": %s",
 329                                                 gai_strerror(ret))));
 330                 goto startup_failed;
 331         }
 332
 333         /*
 334          * On some platforms, pg_getaddrinfo_all() may return multiple addresses
 335          * only one of which will actually work (eg, both IPv6 and IPv4 addresses
 336          * when kernel will reject IPv6).  Worse, the failure may occur at the
 337          * bind() or perhaps even connect() stage.      So we must loop through the
 338          * results till we find a working combination. We will generate LOG
 339          * messages, but no error, for bogus combinations.
 340          */
 341         for (addr = addrs; addr; addr = addr->ai_next)
 342         {
 343 #ifdef HAVE_UNIX_SOCKETS
 344                 /* Ignore AF_UNIX sockets, if any are returned. */
 345                 if (addr->ai_family == AF_UNIX)
 346                         continue;
 347 #endif
 348
 349                 if (++tries > 1)
 350                         ereport(LOG,
 351                         (errmsg("trying another address for the statistics collector")));
 352
 353                 /*
 354                  * Create the socket.
 355                  */
 356                 if ((pgStatSock = socket(addr->ai_family, SOCK_DGRAM, 0)) < 0)
 357                 {
 358                         ereport(LOG,
 359                                         (errcode_for_socket_access(),
 360                         errmsg("could not create socket for statistics collector: %m")));
 361                         continue;
 362                 }
 363
 364                 /*
 365                  * Bind it to a kernel assigned port on localhost and get the assigned
 366                  * port via getsockname().
 367                  */
 368                 if (bind(pgStatSock, addr->ai_addr, addr->ai_addrlen) < 0)
 369                 {
 370                         ereport(LOG,
 371                                         (errcode_for_socket_access(),
 372                           errmsg("could not bind socket for statistics collector: %m")));
 373                         closesocket(pgStatSock);
 374                         pgStatSock = PGINVALID_SOCKET;
 375                         continue;
 376                 }
 377
 378                 alen = sizeof(pgStatAddr);
 379                 if (getsockname(pgStatSock, (struct sockaddr *) & pgStatAddr, &alen) < 0)
 380                 {
 381                         ereport(LOG,
 382                                         (errcode_for_socket_access(),
 383                                          errmsg("could not get address of socket for statistics collector: %m")));
 384                         closesocket(pgStatSock);
 385                         pgStatSock = PGINVALID_SOCKET;
 386                         continue;
 387                 }
 388
 389                 /*
 390                  * Connect the socket to its own address.  This saves a few cycles by
 391                  * not having to respecify the target address on every send. This also
 392                  * provides a kernel-level check that only packets from this same
 393                  * address will be received.
 394                  */
 395                 if (connect(pgStatSock, (struct sockaddr *) & pgStatAddr, alen) < 0)
 396                 {
 397                         ereport(LOG,
 398                                         (errcode_for_socket_access(),
 399                         errmsg("could not connect socket for statistics collector: %m")));
 400                         closesocket(pgStatSock);
 401                         pgStatSock = PGINVALID_SOCKET;
 402                         continue;
 403                 }
 404
 405                 /*
 406                  * Try to send and receive a one-byte test message on the socket. This
 407                  * is to catch situations where the socket can be created but will not
 408                  * actually pass data (for instance, because kernel packet filtering
 409                  * rules prevent it).
 410                  */
 411                 test_byte = TESTBYTEVAL;
 412
 413 retry1:
 414                 if (send(pgStatSock, &test_byte, 1, 0) != 1)
 415                 {
 416                         if (errno == EINTR)
 417                                 goto retry1;    /* if interrupted, just retry */
 418                         ereport(LOG,
 419                                         (errcode_for_socket_access(),
 420                                          errmsg("could not send test message on socket for statistics collector: %m")));
 421                         closesocket(pgStatSock);
 422                         pgStatSock = PGINVALID_SOCKET;
 423                         continue;
 424                 }
 425
 426                 /*
 427                  * There could possibly be a little delay before the message can be
 428                  * received.  We arbitrarily allow up to half a second before deciding
 429                  * it's broken.
 430                  */
 431                 for (;;)                                /* need a loop to handle EINTR */
 432                 {
 433                         FD_ZERO(&rset);
 434                         FD_SET          (pgStatSock, &rset);
 435
 436                         tv.tv_sec = 0;
 437                         tv.tv_usec = 500000;
 438                         sel_res = select(pgStatSock + 1, &rset, NULL, NULL, &tv);
 439                         if (sel_res >= 0 || errno != EINTR)
 440                                 break;
 441                 }
 442                 if (sel_res < 0)
 443                 {
 444                         ereport(LOG,
 445                                         (errcode_for_socket_access(),
 446                                          errmsg("select() failed in statistics collector: %m")));
 447                         closesocket(pgStatSock);
 448                         pgStatSock = PGINVALID_SOCKET;
 449                         continue;
 450                 }
 451                 if (sel_res == 0 || !FD_ISSET(pgStatSock, &rset))
 452                 {
 453                         /*
 454                          * This is the case we actually think is likely, so take pains to
 455                          * give a specific message for it.
 456                          *
 457                          * errno will not be set meaningfully here, so don't use it.
 458                          */
 459                         ereport(LOG,
 460                                         (errcode(ERRCODE_CONNECTION_FAILURE),
 461                                          errmsg("test message did not get through on socket for statistics collector")));
 462                         closesocket(pgStatSock);
 463                         pgStatSock = PGINVALID_SOCKET;
 464                         continue;
 465                 }
 466
 467                 test_byte++;                    /* just make sure variable is changed */
 468
 469 retry2:
 470                 if (recv(pgStatSock, &test_byte, 1, 0) != 1)
 471                 {
 472                         if (errno == EINTR)
 473                                 goto retry2;    /* if interrupted, just retry */
 474                         ereport(LOG,
 475                                         (errcode_for_socket_access(),
 476                                          errmsg("could not receive test message on socket for statistics collector: %m")));
 477                         closesocket(pgStatSock);
 478                         pgStatSock = PGINVALID_SOCKET;
 479                         continue;
 480                 }
 481
 482                 if (test_byte != TESTBYTEVAL)   /* strictly paranoia ... */
 483                 {
 484                         ereport(LOG,
 485                                         (errcode(ERRCODE_INTERNAL_ERROR),
 486                                          errmsg("incorrect test message transmission on socket for statistics collector")));
 487                         closesocket(pgStatSock);
 488                         pgStatSock = PGINVALID_SOCKET;
 489                         continue;
 490                 }
 491
 492                 /* If we get here, we have a working socket */
 493                 break;
 494         }
 495
 496         /* Did we find a working address? */
 497         if (!addr || pgStatSock < 0)
 498                 goto startup_failed;
 499
 500         /*
 501          * Set the socket to non-blocking IO.  This ensures that if the collector
 502          * falls behind, statistics messages will be discarded; backends won't
 503          * block waiting to send messages to the collector.
 504          */
 505         if (!pg_set_noblock(pgStatSock))
 506         {
 507                 ereport(LOG,
 508                                 (errcode_for_socket_access(),
 509                                  errmsg("could not set statistics collector socket to nonblocking mode: %m")));
 510                 goto startup_failed;
 511         }
 512
 513         pg_freeaddrinfo_all(hints.ai_family, addrs);
 514
 515         return;
 516
 517 startup_failed:
 518         ereport(LOG,
 519           (errmsg("disabling statistics collector for lack of working socket")));
 520
 521         if (addrs)
 522                 pg_freeaddrinfo_all(hints.ai_family, addrs);
 523
 524         if (pgStatSock >= 0)
 525                 closesocket(pgStatSock);
 526         pgStatSock = PGINVALID_SOCKET;
 527
 528         /*
 529          * Adjust GUC variables to suppress useless activity, and for debugging
 530          * purposes (seeing track_counts off is a clue that we failed here). We
 531          * use PGC_S_OVERRIDE because there is no point in trying to turn it back
 532          * on from postgresql.conf without a restart.
 533          */
 534         SetConfigOption("track_counts", "off", PGC_INTERNAL, PGC_S_OVERRIDE);
 535 }
 536
 537 /*
 538  * pgstat_reset_all() -
 539  *
 540  * Remove the stats file.  This is currently used only if WAL
 541  * recovery is needed after a crash.
 542  */
 543 void
 544 pgstat_reset_all(void)
 545 {
 546         unlink(pgstat_stat_filename);
 547         unlink(PGSTAT_STAT_PERMANENT_FILENAME);
 548 }
 549
 550 #ifdef EXEC_BACKEND
 551
 552 /*
 553  * pgstat_forkexec() -
 554  *
 555  * Format up the arglist for, then fork and exec, statistics collector process
 556  */
 557 static pid_t
 558 pgstat_forkexec(void)
 559 {
 560         char       *av[10];
 561         int                     ac = 0;
 562
 563         av[ac++] = "postgres";
 564         av[ac++] = "--forkcol";
 565         av[ac++] = NULL;                        /* filled in by postmaster_forkexec */
 566
 567         av[ac] = NULL;
 568         Assert(ac < lengthof(av));
 569
 570         return postmaster_forkexec(ac, av);
 571 }
 572 #endif   /* EXEC_BACKEND */
 573
 574
 575 /*
 576  * pgstat_start() -
 577  *
 578  *      Called from postmaster at startup or after an existing collector
 579  *      died.  Attempt to fire up a fresh statistics collector.
 580  *
 581  *      Returns PID of child process, or 0 if fail.
 582  *
 583  *      Note: if fail, we will be called again from the postmaster main loop.
 584  */
 585 int
 586 pgstat_start(void)
 587 {
 588         time_t          curtime;
 589         pid_t           pgStatPid;
 590
 591         /*
 592          * Check that the socket is there, else pgstat_init failed and we can do
 593          * nothing useful.
 594          */
 595         if (pgStatSock < 0)
 596                 return 0;
 597
 598         /*
 599          * Do nothing if too soon since last collector start.  This is a safety
 600          * valve to protect against continuous respawn attempts if the collector
 601          * is dying immediately at launch.      Note that since we will be re-called
 602          * from the postmaster main loop, we will get another chance later.
 603          */
 604         curtime = time(NULL);
 605         if ((unsigned int) (curtime - last_pgstat_start_time) <
 606                 (unsigned int) PGSTAT_RESTART_INTERVAL)
 607                 return 0;
 608         last_pgstat_start_time = curtime;
 609
 610         /*
 611          * Okay, fork off the collector.
 612          */
 613 #ifdef EXEC_BACKEND
 614         switch ((pgStatPid = pgstat_forkexec()))
 615 #else
 616         switch ((pgStatPid = fork_process()))
 617 #endif
 618         {
 619                 case -1:
 620                         ereport(LOG,
 621                                         (errmsg("could not fork statistics collector: %m")));
 622                         return 0;
 623
 624 #ifndef EXEC_BACKEND
 625                 case 0:
 626                         /* in postmaster child ... */
 627                         /* Close the postmaster's sockets */
 628                         ClosePostmasterPorts(false);
 629
 630                         /* Lose the postmaster's on-exit routines */
 631                         on_exit_reset();
 632
 633                         /* Drop our connection to postmaster's shared memory, as well */
 634                         PGSharedMemoryDetach();
 635
 636                         PgstatCollectorMain(0, NULL);
 637                         break;
 638 #endif
 639
 640                 default:
 641                         return (int) pgStatPid;
 642         }
 643
 644         /* shouldn't get here */
 645         return 0;
 646 }
 647
 648 void
 649 allow_immediate_pgstat_restart(void)
 650 {
 651         last_pgstat_start_time = 0;
 652 }
 653
 654 /* ------------------------------------------------------------
 655  * Public functions used by backends follow
 656  *------------------------------------------------------------
 657  */
 658
 659
 660 /* ----------
 661  * pgstat_report_stat() -
 662  *
 663  *      Called from tcop/postgres.c to send the so far collected per-table
 664  *      and function usage statistics to the collector.  Note that this is
 665  *      called only when not within a transaction, so it is fair to use
 666  *      transaction stop time as an approximation of current time.
 667  * ----------
 668  */
 669 void
 670 pgstat_report_stat(bool force)
 671 {
 672         /* we assume this inits to all zeroes: */
 673         static const PgStat_TableCounts all_zeroes;
 674         static TimestampTz last_report = 0;
 675
 676         TimestampTz now;
 677         PgStat_MsgTabstat regular_msg;
 678         PgStat_MsgTabstat shared_msg;
 679         TabStatusArray *tsa;
 680         int                     i;
 681
 682         /* Don't expend a clock check if nothing to do */
 683         if ((pgStatTabList == NULL || pgStatTabList->tsa_used == 0)
 684                 && !have_function_stats)
 685                 return;
 686
 687         /*
 688          * Don't send a message unless it's been at least PGSTAT_STAT_INTERVAL
 689          * msec since we last sent one, or the caller wants to force stats out.
 690          */
 691         now = GetCurrentTransactionStopTimestamp();
 692         if (!force &&
 693                 !TimestampDifferenceExceeds(last_report, now, PGSTAT_STAT_INTERVAL))
 694                 return;
 695         last_report = now;
 696
 697         /*
 698          * Scan through the TabStatusArray struct(s) to find tables that actually
 699          * have counts, and build messages to send.  We have to separate shared
 700          * relations from regular ones because the databaseid field in the message
 701          * header has to depend on that.
 702          */
 703         regular_msg.m_databaseid = MyDatabaseId;
 704         shared_msg.m_databaseid = InvalidOid;
 705         regular_msg.m_nentries = 0;
 706         shared_msg.m_nentries = 0;
 707
 708         for (tsa = pgStatTabList; tsa != NULL; tsa = tsa->tsa_next)
 709         {
 710                 for (i = 0; i < tsa->tsa_used; i++)
 711                 {
 712                         PgStat_TableStatus *entry = &tsa->tsa_entries[i];
 713                         PgStat_MsgTabstat *this_msg;
 714                         PgStat_TableEntry *this_ent;
 715
 716                         /* Shouldn't have any pending transaction-dependent counts */
 717                         Assert(entry->trans == NULL);
 718
 719                         /*
 720                          * Ignore entries that didn't accumulate any actual counts, such
 721                          * as indexes that were opened by the planner but not used.
 722                          */
 723                         if (memcmp(&entry->t_counts, &all_zeroes,
 724                                            sizeof(PgStat_TableCounts)) == 0)
 725                                 continue;
 726
 727                         /*
 728                          * OK, insert data into the appropriate message, and send if full.
 729                          */
 730                         this_msg = entry->t_shared ? &shared_msg : &regular_msg;
 731                         this_ent = &this_msg->m_entry[this_msg->m_nentries];
 732                         this_ent->t_id = entry->t_id;
 733                         memcpy(&this_ent->t_counts, &entry->t_counts,
 734                                    sizeof(PgStat_TableCounts));
 735                         if (++this_msg->m_nentries >= PGSTAT_NUM_TABENTRIES)
 736                         {
 737                                 pgstat_send_tabstat(this_msg);
 738                                 this_msg->m_nentries = 0;
 739                         }
 740                 }
 741                 /* zero out TableStatus structs after use */
 742                 MemSet(tsa->tsa_entries, 0,
 743                            tsa->tsa_used * sizeof(PgStat_TableStatus));
 744                 tsa->tsa_used = 0;
 745         }
 746
 747         /*
 748          * Send partial messages.  If force is true, make sure that any pending
 749          * xact commit/abort gets counted, even if no table stats to send.
 750          */
 751         if (regular_msg.m_nentries > 0 ||
 752                 (force && (pgStatXactCommit > 0 || pgStatXactRollback > 0)))
 753                 pgstat_send_tabstat(&regular_msg);
 754         if (shared_msg.m_nentries > 0)
 755                 pgstat_send_tabstat(&shared_msg);
 756
 757         /* Now, send function statistics */
 758         pgstat_send_funcstats();
 759 }
 760
 761 /*
 762  * Subroutine for pgstat_report_stat: finish and send a tabstat message
 763  */
 764 static void
 765 pgstat_send_tabstat(PgStat_MsgTabstat *tsmsg)
 766 {
 767         int                     n;
 768         int                     len;
 769
 770         /* It's unlikely we'd get here with no socket, but maybe not impossible */
 771         if (pgStatSock < 0)
 772                 return;
 773
 774         /*
 775          * Report accumulated xact commit/rollback whenever we send a normal
 776          * tabstat message
 777          */
 778         if (OidIsValid(tsmsg->m_databaseid))
 779         {
 780                 tsmsg->m_xact_commit = pgStatXactCommit;
 781                 tsmsg->m_xact_rollback = pgStatXactRollback;
 782                 pgStatXactCommit = 0;
 783                 pgStatXactRollback = 0;
 784         }
 785         else
 786         {
 787                 tsmsg->m_xact_commit = 0;
 788                 tsmsg->m_xact_rollback = 0;
 789         }
 790
 791         n = tsmsg->m_nentries;
 792         len = offsetof(PgStat_MsgTabstat, m_entry[0]) +
 793                 n * sizeof(PgStat_TableEntry);
 794
 795         pgstat_setheader(&tsmsg->m_hdr, PGSTAT_MTYPE_TABSTAT);
 796         pgstat_send(tsmsg, len);
 797 }
 798
 799 /*
 800  * Subroutine for pgstat_report_stat: populate and send a function stat message
 801  */
 802 static void
 803 pgstat_send_funcstats(void)
 804 {
 805         /* we assume this inits to all zeroes: */
 806         static const PgStat_FunctionCounts all_zeroes;
 807
 808         PgStat_MsgFuncstat msg;
 809         PgStat_BackendFunctionEntry *entry;
 810         HASH_SEQ_STATUS fstat;
 811
 812         if (pgStatFunctions == NULL)
 813                 return;
 814
 815         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_FUNCSTAT);
 816         msg.m_databaseid = MyDatabaseId;
 817         msg.m_nentries = 0;
 818
 819         hash_seq_init(&fstat, pgStatFunctions);
 820         while ((entry = (PgStat_BackendFunctionEntry *) hash_seq_search(&fstat)) != NULL)
 821         {
 822                 PgStat_FunctionEntry *m_ent;
 823
 824                 /* Skip it if no counts accumulated since last time */
 825                 if (memcmp(&entry->f_counts, &all_zeroes,
 826                                    sizeof(PgStat_FunctionCounts)) == 0)
 827                         continue;
 828
 829                 /* need to convert format of time accumulators */
 830                 m_ent = &msg.m_entry[msg.m_nentries];
 831                 m_ent->f_id = entry->f_id;
 832                 m_ent->f_numcalls = entry->f_counts.f_numcalls;
 833                 m_ent->f_time = INSTR_TIME_GET_MICROSEC(entry->f_counts.f_time);
 834                 m_ent->f_time_self = INSTR_TIME_GET_MICROSEC(entry->f_counts.f_time_self);
 835
 836                 if (++msg.m_nentries >= PGSTAT_NUM_FUNCENTRIES)
 837                 {
 838                         pgstat_send(&msg, offsetof(PgStat_MsgFuncstat, m_entry[0]) +
 839                                                 msg.m_nentries * sizeof(PgStat_FunctionEntry));
 840                         msg.m_nentries = 0;
 841                 }
 842
 843                 /* reset the entry's counts */
 844                 MemSet(&entry->f_counts, 0, sizeof(PgStat_FunctionCounts));
 845         }
 846
 847         if (msg.m_nentries > 0)
 848                 pgstat_send(&msg, offsetof(PgStat_MsgFuncstat, m_entry[0]) +
 849                                         msg.m_nentries * sizeof(PgStat_FunctionEntry));
 850
 851         have_function_stats = false;
 852 }
 853
 854
 855 /* ----------
 856  * pgstat_vacuum_stat() -
 857  *
 858  *      Will tell the collector about objects he can get rid of.
 859  * ----------
 860  */
 861 void
 862 pgstat_vacuum_stat(void)
 863 {
 864         HTAB       *htab;
 865         PgStat_MsgTabpurge msg;
 866         PgStat_MsgFuncpurge f_msg;
 867         HASH_SEQ_STATUS hstat;
 868         PgStat_StatDBEntry *dbentry;
 869         PgStat_StatTabEntry *tabentry;
 870         PgStat_StatFuncEntry *funcentry;
 871         int                     len;
 872
 873         if (pgStatSock < 0)
 874                 return;
 875
 876         /*
 877          * If not done for this transaction, read the statistics collector stats
 878          * file into some hash tables.
 879          */
 880         backend_read_statsfile();
 881
 882         /*
 883          * Read pg_database and make a list of OIDs of all existing databases
 884          */
 885         htab = pgstat_collect_oids(DatabaseRelationId);
 886
 887         /*
 888          * Search the database hash table for dead databases and tell the
 889          * collector to drop them.
 890          */
 891         hash_seq_init(&hstat, pgStatDBHash);
 892         while ((dbentry = (PgStat_StatDBEntry *) hash_seq_search(&hstat)) != NULL)
 893         {
 894                 Oid                     dbid = dbentry->databaseid;
 895
 896                 CHECK_FOR_INTERRUPTS();
 897
 898                 /* the DB entry for shared tables (with InvalidOid) is never dropped */
 899                 if (OidIsValid(dbid) &&
 900                         hash_search(htab, (void *) &dbid, HASH_FIND, NULL) == NULL)
 901                         pgstat_drop_database(dbid);
 902         }
 903
 904         /* Clean up */
 905         hash_destroy(htab);
 906
 907         /*
 908          * Lookup our own database entry; if not found, nothing more to do.
 909          */
 910         dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
 911                                                                                                  (void *) &MyDatabaseId,
 912                                                                                                  HASH_FIND, NULL);
 913         if (dbentry == NULL || dbentry->tables == NULL)
 914                 return;
 915
 916         /*
 917          * Similarly to above, make a list of all known relations in this DB.
 918          */
 919         htab = pgstat_collect_oids(RelationRelationId);
 920
 921         /*
 922          * Initialize our messages table counter to zero
 923          */
 924         msg.m_nentries = 0;
 925
 926         /*
 927          * Check for all tables listed in stats hashtable if they still exist.
 928          */
 929         hash_seq_init(&hstat, dbentry->tables);
 930         while ((tabentry = (PgStat_StatTabEntry *) hash_seq_search(&hstat)) != NULL)
 931         {
 932                 Oid                     tabid = tabentry->tableid;
 933
 934                 CHECK_FOR_INTERRUPTS();
 935
 936                 if (hash_search(htab, (void *) &tabid, HASH_FIND, NULL) != NULL)
 937                         continue;
 938
 939                 /*
 940                  * Not there, so add this table's Oid to the message
 941                  */
 942                 msg.m_tableid[msg.m_nentries++] = tabid;
 943
 944                 /*
 945                  * If the message is full, send it out and reinitialize to empty
 946                  */
 947                 if (msg.m_nentries >= PGSTAT_NUM_TABPURGE)
 948                 {
 949                         len = offsetof(PgStat_MsgTabpurge, m_tableid[0])
 950                                 +msg.m_nentries * sizeof(Oid);
 951
 952                         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
 953                         msg.m_databaseid = MyDatabaseId;
 954                         pgstat_send(&msg, len);
 955
 956                         msg.m_nentries = 0;
 957                 }
 958         }
 959
 960         /*
 961          * Send the rest
 962          */
 963         if (msg.m_nentries > 0)
 964         {
 965                 len = offsetof(PgStat_MsgTabpurge, m_tableid[0])
 966                         +msg.m_nentries * sizeof(Oid);
 967
 968                 pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
 969                 msg.m_databaseid = MyDatabaseId;
 970                 pgstat_send(&msg, len);
 971         }
 972
 973         /* Clean up */
 974         hash_destroy(htab);
 975
 976         /*
 977          * Now repeat the above steps for functions.  However, we needn't bother
 978          * in the common case where no function stats are being collected.
 979          */
 980         if (dbentry->functions != NULL &&
 981                 hash_get_num_entries(dbentry->functions) > 0)
 982         {
 983                 htab = pgstat_collect_oids(ProcedureRelationId);
 984
 985                 pgstat_setheader(&f_msg.m_hdr, PGSTAT_MTYPE_FUNCPURGE);
 986                 f_msg.m_databaseid = MyDatabaseId;
 987                 f_msg.m_nentries = 0;
 988
 989                 hash_seq_init(&hstat, dbentry->functions);
 990                 while ((funcentry = (PgStat_StatFuncEntry *) hash_seq_search(&hstat)) != NULL)
 991                 {
 992                         Oid                     funcid = funcentry->functionid;
 993
 994                         CHECK_FOR_INTERRUPTS();
 995
 996                         if (hash_search(htab, (void *) &funcid, HASH_FIND, NULL) != NULL)
 997                                 continue;
 998
 999                         /*
1000                          * Not there, so add this function's Oid to the message
1001                          */
1002                         f_msg.m_functionid[f_msg.m_nentries++] = funcid;
1003
1004                         /*
1005                          * If the message is full, send it out and reinitialize to empty
1006                          */
1007                         if (f_msg.m_nentries >= PGSTAT_NUM_FUNCPURGE)
1008                         {
1009                                 len = offsetof(PgStat_MsgFuncpurge, m_functionid[0])
1010                                         +f_msg.m_nentries * sizeof(Oid);
1011
1012                                 pgstat_send(&f_msg, len);
1013
1014                                 f_msg.m_nentries = 0;
1015                         }
1016                 }
1017
1018                 /*
1019                  * Send the rest
1020                  */
1021                 if (f_msg.m_nentries > 0)
1022                 {
1023                         len = offsetof(PgStat_MsgFuncpurge, m_functionid[0])
1024                                 +f_msg.m_nentries * sizeof(Oid);
1025
1026                         pgstat_send(&f_msg, len);
1027                 }
1028
1029                 hash_destroy(htab);
1030         }
1031 }
1032
1033
1034 /* ----------
1035  * pgstat_collect_oids() -
1036  *
1037  *      Collect the OIDs of all objects listed in the specified system catalog
1038  *      into a temporary hash table.  Caller should hash_destroy the result
1039  *      when done with it.  (However, we make the table in CurrentMemoryContext
1040  *      so that it will be freed properly in event of an error.)
1041  * ----------
1042  */
1043 static HTAB *
1044 pgstat_collect_oids(Oid catalogid)
1045 {
1046         HTAB       *htab;
1047         HASHCTL         hash_ctl;
1048         Relation        rel;
1049         HeapScanDesc scan;
1050         HeapTuple       tup;
1051
1052         memset(&hash_ctl, 0, sizeof(hash_ctl));
1053         hash_ctl.keysize = sizeof(Oid);
1054         hash_ctl.entrysize = sizeof(Oid);
1055         hash_ctl.hash = oid_hash;
1056         hash_ctl.hcxt = CurrentMemoryContext;
1057         htab = hash_create("Temporary table of OIDs",
1058                                            PGSTAT_TAB_HASH_SIZE,
1059                                            &hash_ctl,
1060                                            HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
1061
1062         rel = heap_open(catalogid, AccessShareLock);
1063         scan = heap_beginscan(rel, SnapshotNow, 0, NULL);
1064         while ((tup = heap_getnext(scan, ForwardScanDirection)) != NULL)
1065         {
1066                 Oid                     thisoid = HeapTupleGetOid(tup);
1067
1068                 CHECK_FOR_INTERRUPTS();
1069
1070                 (void) hash_search(htab, (void *) &thisoid, HASH_ENTER, NULL);
1071         }
1072         heap_endscan(scan);
1073         heap_close(rel, AccessShareLock);
1074
1075         return htab;
1076 }
1077
1078
1079 /* ----------
1080  * pgstat_drop_database() -
1081  *
1082  *      Tell the collector that we just dropped a database.
1083  *      (If the message gets lost, we will still clean the dead DB eventually
1084  *      via future invocations of pgstat_vacuum_stat().)
1085  * ----------
1086  */
1087 void
1088 pgstat_drop_database(Oid databaseid)
1089 {
1090         PgStat_MsgDropdb msg;
1091
1092         if (pgStatSock < 0)
1093                 return;
1094
1095         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DROPDB);
1096         msg.m_databaseid = databaseid;
1097         pgstat_send(&msg, sizeof(msg));
1098 }
1099
1100
1101 /* ----------
1102  * pgstat_drop_relation() -
1103  *
1104  *      Tell the collector that we just dropped a relation.
1105  *      (If the message gets lost, we will still clean the dead entry eventually
1106  *      via future invocations of pgstat_vacuum_stat().)
1107  *
1108  *      Currently not used for lack of any good place to call it; we rely
1109  *      entirely on pgstat_vacuum_stat() to clean out stats for dead rels.
1110  * ----------
1111  */
1112 #ifdef NOT_USED
1113 void
1114 pgstat_drop_relation(Oid relid)
1115 {
1116         PgStat_MsgTabpurge msg;
1117         int                     len;
1118
1119         if (pgStatSock < 0)
1120                 return;
1121
1122         msg.m_tableid[0] = relid;
1123         msg.m_nentries = 1;
1124
1125         len = offsetof(PgStat_MsgTabpurge, m_tableid[0]) +sizeof(Oid);
1126
1127         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_TABPURGE);
1128         msg.m_databaseid = MyDatabaseId;
1129         pgstat_send(&msg, len);
1130 }
1131 #endif   /* NOT_USED */
1132
1133
1134 /* ----------
1135  * pgstat_reset_counters() -
1136  *
1137  *      Tell the statistics collector to reset counters for our database.
1138  * ----------
1139  */
1140 void
1141 pgstat_reset_counters(void)
1142 {
1143         PgStat_MsgResetcounter msg;
1144
1145         if (pgStatSock < 0)
1146                 return;
1147
1148         if (!superuser())
1149                 ereport(ERROR,
1150                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1151                                  errmsg("must be superuser to reset statistics counters")));
1152
1153         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETCOUNTER);
1154         msg.m_databaseid = MyDatabaseId;
1155         pgstat_send(&msg, sizeof(msg));
1156 }
1157
1158 /* ----------
1159  * pgstat_reset_shared_counters() -
1160  *
1161  *      Tell the statistics collector to reset cluster-wide shared counters.
1162  * ----------
1163  */
1164 void
1165 pgstat_reset_shared_counters(const char *target)
1166 {
1167         PgStat_MsgResetsharedcounter msg;
1168
1169         if (pgStatSock < 0)
1170                 return;
1171
1172         if (!superuser())
1173                 ereport(ERROR,
1174                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1175                                  errmsg("must be superuser to reset statistics counters")));
1176
1177         if (strcmp(target, "bgwriter") == 0)
1178                 msg.m_resettarget = RESET_BGWRITER;
1179         else
1180         {
1181                 ereport(ERROR,
1182                                 (errcode(ERRCODE_SYNTAX_ERROR),
1183                                  errmsg("unrecognized reset target: '%s'", target),
1184                                  errhint("allowed targets are 'bgwriter'.")));
1185         }
1186
1187         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETSHAREDCOUNTER);
1188         pgstat_send(&msg, sizeof(msg));
1189 }
1190
1191 /* ----------
1192  * pgstat_reset_single_counter() -
1193  *
1194  *      Tell the statistics collector to reset a single counter.
1195  * ----------
1196  */
1197 void pgstat_reset_single_counter(Oid objoid, PgStat_Single_Reset_Type type)
1198 {
1199         PgStat_MsgResetsinglecounter msg;
1200
1201         if (pgStatSock < 0)
1202                 return;
1203
1204         if (!superuser())
1205                 ereport(ERROR,
1206                                 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
1207                                  errmsg("must be superuser to reset statistics counters")));
1208
1209         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_RESETSINGLECOUNTER);
1210         msg.m_databaseid = MyDatabaseId;
1211         msg.m_resettype = type;
1212         msg.m_objectid = objoid;
1213
1214         pgstat_send(&msg, sizeof(msg));
1215 }
1216
1217 /* ----------
1218  * pgstat_report_autovac() -
1219  *
1220  *      Called from autovacuum.c to report startup of an autovacuum process.
1221  *      We are called before InitPostgres is done, so can't rely on MyDatabaseId;
1222  *      the db OID must be passed in, instead.
1223  * ----------
1224  */
1225 void
1226 pgstat_report_autovac(Oid dboid)
1227 {
1228         PgStat_MsgAutovacStart msg;
1229
1230         if (pgStatSock < 0)
1231                 return;
1232
1233         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_AUTOVAC_START);
1234         msg.m_databaseid = dboid;
1235         msg.m_start_time = GetCurrentTimestamp();
1236
1237         pgstat_send(&msg, sizeof(msg));
1238 }
1239
1240
1241 /* ---------
1242  * pgstat_report_vacuum() -
1243  *
1244  *      Tell the collector about the table we just vacuumed.
1245  * ---------
1246  */
1247 void
1248 pgstat_report_vacuum(Oid tableoid, bool shared, bool adopt_counts,
1249                                          PgStat_Counter tuples)
1250 {
1251         PgStat_MsgVacuum msg;
1252
1253         if (pgStatSock < 0 || !pgstat_track_counts)
1254                 return;
1255
1256         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_VACUUM);
1257         msg.m_databaseid = shared ? InvalidOid : MyDatabaseId;
1258         msg.m_tableoid = tableoid;
1259         msg.m_adopt_counts = adopt_counts;
1260         msg.m_autovacuum = IsAutoVacuumWorkerProcess();
1261         msg.m_vacuumtime = GetCurrentTimestamp();
1262         msg.m_tuples = tuples;
1263         pgstat_send(&msg, sizeof(msg));
1264 }
1265
1266 /* --------
1267  * pgstat_report_analyze() -
1268  *
1269  *      Tell the collector about the table we just analyzed.
1270  * --------
1271  */
1272 void
1273 pgstat_report_analyze(Relation rel, bool adopt_counts,
1274                                           PgStat_Counter livetuples, PgStat_Counter deadtuples)
1275 {
1276         PgStat_MsgAnalyze msg;
1277
1278         if (pgStatSock < 0 || !pgstat_track_counts)
1279                 return;
1280
1281         /*
1282          * Unlike VACUUM, ANALYZE might be running inside a transaction that has
1283          * already inserted and/or deleted rows in the target table. ANALYZE will
1284          * have counted such rows as live or dead respectively. Because we will
1285          * report our counts of such rows at transaction end, we should subtract
1286          * off these counts from what we send to the collector now, else they'll
1287          * be double-counted after commit.      (This approach also ensures that the
1288          * collector ends up with the right numbers if we abort instead of
1289          * committing.)
1290          */
1291         if (rel->pgstat_info != NULL)
1292         {
1293                 PgStat_TableXactStatus *trans;
1294
1295                 for (trans = rel->pgstat_info->trans; trans; trans = trans->upper)
1296                 {
1297                         livetuples -= trans->tuples_inserted - trans->tuples_deleted;
1298                         deadtuples -= trans->tuples_updated + trans->tuples_deleted;
1299                 }
1300                 /* count stuff inserted by already-aborted subxacts, too */
1301                 deadtuples -= rel->pgstat_info->t_counts.t_delta_dead_tuples;
1302                 /* Since ANALYZE's counts are estimates, we could have underflowed */
1303                 livetuples = Max(livetuples, 0);
1304                 deadtuples = Max(deadtuples, 0);
1305         }
1306
1307         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_ANALYZE);
1308         msg.m_databaseid = rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId;
1309         msg.m_tableoid = RelationGetRelid(rel);
1310         msg.m_adopt_counts = adopt_counts;
1311         msg.m_autovacuum = IsAutoVacuumWorkerProcess();
1312         msg.m_analyzetime = GetCurrentTimestamp();
1313         msg.m_live_tuples = livetuples;
1314         msg.m_dead_tuples = deadtuples;
1315         pgstat_send(&msg, sizeof(msg));
1316 }
1317
1318
1319 /* ----------
1320  * pgstat_ping() -
1321  *
1322  *      Send some junk data to the collector to increase traffic.
1323  * ----------
1324  */
1325 void
1326 pgstat_ping(void)
1327 {
1328         PgStat_MsgDummy msg;
1329
1330         if (pgStatSock < 0)
1331                 return;
1332
1333         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_DUMMY);
1334         pgstat_send(&msg, sizeof(msg));
1335 }
1336
1337 /* ----------
1338  * pgstat_send_inquiry() -
1339  *
1340  *      Notify collector that we need fresh data.
1341  *      ts specifies the minimum acceptable timestamp for the stats file.
1342  * ----------
1343  */
1344 static void
1345 pgstat_send_inquiry(TimestampTz ts)
1346 {
1347         PgStat_MsgInquiry msg;
1348
1349         pgstat_setheader(&msg.m_hdr, PGSTAT_MTYPE_INQUIRY);
1350         msg.inquiry_time = ts;
1351         pgstat_send(&msg, sizeof(msg));
1352 }
1353
1354
1355 /*
1356  * Initialize function call usage data.
1357  * Called by the executor before invoking a function.
1358  */
1359 void
1360 pgstat_init_function_usage(FunctionCallInfoData *fcinfo,
1361                                                    PgStat_FunctionCallUsage *fcu)
1362 {
1363         PgStat_BackendFunctionEntry *htabent;
1364         bool            found;
1365
1366         if (pgstat_track_functions <= fcinfo->flinfo->fn_stats)
1367         {
1368                 /* stats not wanted */
1369                 fcu->fs = NULL;
1370                 return;
1371         }
1372
1373         if (!pgStatFunctions)
1374         {
1375                 /* First time through - initialize function stat table */
1376                 HASHCTL         hash_ctl;
1377
1378                 memset(&hash_ctl, 0, sizeof(hash_ctl));
1379                 hash_ctl.keysize = sizeof(Oid);
1380                 hash_ctl.entrysize = sizeof(PgStat_BackendFunctionEntry);
1381                 hash_ctl.hash = oid_hash;
1382                 pgStatFunctions = hash_create("Function stat entries",
1383                                                                           PGSTAT_FUNCTION_HASH_SIZE,
1384                                                                           &hash_ctl,
1385                                                                           HASH_ELEM | HASH_FUNCTION);
1386         }
1387
1388         /* Get the stats entry for this function, create if necessary */
1389         htabent = hash_search(pgStatFunctions, &fcinfo->flinfo->fn_oid,
1390                                                   HASH_ENTER, &found);
1391         if (!found)
1392                 MemSet(&htabent->f_counts, 0, sizeof(PgStat_FunctionCounts));
1393
1394         fcu->fs = &htabent->f_counts;
1395
1396         /* save stats for this function, later used to compensate for recursion */
1397         fcu->save_f_time = htabent->f_counts.f_time;
1398
1399         /* save current backend-wide total time */
1400         fcu->save_total = total_func_time;
1401
1402         /* get clock time as of function start */
1403         INSTR_TIME_SET_CURRENT(fcu->f_start);
1404 }
1405
1406 /*
1407  * Calculate function call usage and update stat counters.
1408  * Called by the executor after invoking a function.
1409  *
1410  * In the case of a set-returning function that runs in value-per-call mode,
1411  * we will see multiple pgstat_init_function_usage/pgstat_end_function_usage
1412  * calls for what the user considers a single call of the function.  The
1413  * finalize flag should be TRUE on the last call.
1414  */
1415 void
1416 pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, bool finalize)
1417 {
1418         PgStat_FunctionCounts *fs = fcu->fs;
1419         instr_time      f_total;
1420         instr_time      f_others;
1421         instr_time      f_self;
1422
1423         /* stats not wanted? */
1424         if (fs == NULL)
1425                 return;
1426
1427         /* total elapsed time in this function call */
1428         INSTR_TIME_SET_CURRENT(f_total);
1429         INSTR_TIME_SUBTRACT(f_total, fcu->f_start);
1430
1431         /* self usage: elapsed minus anything already charged to other calls */
1432         f_others = total_func_time;
1433         INSTR_TIME_SUBTRACT(f_others, fcu->save_total);
1434         f_self = f_total;
1435         INSTR_TIME_SUBTRACT(f_self, f_others);
1436
1437         /* update backend-wide total time */
1438         INSTR_TIME_ADD(total_func_time, f_self);
1439
1440         /*
1441          * Compute the new total f_time as the total elapsed time added to the
1442          * pre-call value of f_time.  This is necessary to avoid double-counting
1443          * any time taken by recursive calls of myself.  (We do not need any
1444          * similar kluge for self time, since that already excludes any recursive
1445          * calls.)
1446          */
1447         INSTR_TIME_ADD(f_total, fcu->save_f_time);
1448
1449         /* update counters in function stats table */
1450         if (finalize)
1451                 fs->f_numcalls++;
1452         fs->f_time = f_total;
1453         INSTR_TIME_ADD(fs->f_time_self, f_self);
1454
1455         /* indicate that we have something to send */
1456         have_function_stats = true;
1457 }
1458
1459
1460 /* ----------
1461  * pgstat_initstats() -
1462  *
1463  *      Initialize a relcache entry to count access statistics.
1464  *      Called whenever a relation is opened.
1465  *
1466  *      We assume that a relcache entry's pgstat_info field is zeroed by
1467  *      relcache.c when the relcache entry is made; thereafter it is long-lived
1468  *      data.  We can avoid repeated searches of the TabStatus arrays when the
1469  *      same relation is touched repeatedly within a transaction.
1470  * ----------
1471  */
1472 void
1473 pgstat_initstats(Relation rel)
1474 {
1475         Oid                     rel_id = rel->rd_id;
1476         char            relkind = rel->rd_rel->relkind;
1477
1478         /* We only count stats for things that have storage */
1479         if (!(relkind == RELKIND_RELATION ||
1480                   relkind == RELKIND_INDEX ||
1481                   relkind == RELKIND_TOASTVALUE ||
1482                   relkind == RELKIND_SEQUENCE))
1483         {
1484                 rel->pgstat_info = NULL;
1485                 return;
1486         }
1487
1488         if (pgStatSock < 0 || !pgstat_track_counts)
1489         {
1490                 /* We're not counting at all */
1491                 rel->pgstat_info = NULL;
1492                 return;
1493         }
1494
1495         /*
1496          * If we already set up this relation in the current transaction, nothing
1497          * to do.
1498          */
1499         if (rel->pgstat_info != NULL &&
1500                 rel->pgstat_info->t_id == rel_id)
1501                 return;
1502
1503         /* Else find or make the PgStat_TableStatus entry, and update link */
1504         rel->pgstat_info = get_tabstat_entry(rel_id, rel->rd_rel->relisshared);
1505 }
1506
1507 /*
1508  * get_tabstat_entry - find or create a PgStat_TableStatus entry for rel
1509  */
1510 static PgStat_TableStatus *
1511 get_tabstat_entry(Oid rel_id, bool isshared)
1512 {
1513         PgStat_TableStatus *entry;
1514         TabStatusArray *tsa;
1515         TabStatusArray *prev_tsa;
1516         int                     i;
1517
1518         /*
1519          * Search the already-used tabstat slots for this relation.
1520          */
1521         prev_tsa = NULL;
1522         for (tsa = pgStatTabList; tsa != NULL; prev_tsa = tsa, tsa = tsa->tsa_next)
1523         {
1524                 for (i = 0; i < tsa->tsa_used; i++)
1525                 {
1526                         entry = &tsa->tsa_entries[i];
1527                         if (entry->t_id == rel_id)
1528                                 return entry;
1529                 }
1530
1531                 if (tsa->tsa_used < TABSTAT_QUANTUM)
1532                 {
1533                         /*
1534                          * It must not be present, but we found a free slot instead. Fine,
1535                          * let's use this one.  We assume the entry was already zeroed,
1536                          * either at creation or after last use.
1537                          */
1538                         entry = &tsa->tsa_entries[tsa->tsa_used++];
1539                         entry->t_id = rel_id;
1540                         entry->t_shared = isshared;
1541                         return entry;
1542                 }
1543         }
1544
1545         /*
1546          * We ran out of tabstat slots, so allocate more.  Be sure they're zeroed.
1547          */
1548         tsa = (TabStatusArray *) MemoryContextAllocZero(TopMemoryContext,
1549                                                                                                         sizeof(TabStatusArray));
1550         if (prev_tsa)
1551                 prev_tsa->tsa_next = tsa;
1552         else
1553                 pgStatTabList = tsa;
1554
1555         /*
1556          * Use the first entry of the new TabStatusArray.
1557          */
1558         entry = &tsa->tsa_entries[tsa->tsa_used++];
1559         entry->t_id = rel_id;
1560         entry->t_shared = isshared;
1561         return entry;
1562 }
1563
1564 /*
1565  * get_tabstat_stack_level - add a new (sub)transaction stack entry if needed
1566  */
1567 static PgStat_SubXactStatus *
1568 get_tabstat_stack_level(int nest_level)
1569 {
1570         PgStat_SubXactStatus *xact_state;
1571
1572         xact_state = pgStatXactStack;
1573         if (xact_state == NULL || xact_state->nest_level != nest_level)
1574         {
1575                 xact_state = (PgStat_SubXactStatus *)
1576                         MemoryContextAlloc(TopTransactionContext,
1577                                                            sizeof(PgStat_SubXactStatus));
1578                 xact_state->nest_level = nest_level;
1579                 xact_state->prev = pgStatXactStack;
1580                 xact_state->first = NULL;
1581                 pgStatXactStack = xact_state;
1582         }
1583         return xact_state;
1584 }
1585
1586 /*
1587  * add_tabstat_xact_level - add a new (sub)transaction state record
1588  */
1589 static void
1590 add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level)
1591 {
1592         PgStat_SubXactStatus *xact_state;
1593         PgStat_TableXactStatus *trans;
1594
1595         /*
1596          * If this is the first rel to be modified at the current nest level, we
1597          * first have to push a transaction stack entry.
1598          */
1599         xact_state = get_tabstat_stack_level(nest_level);
1600
1601         /* Now make a per-table stack entry */
1602         trans = (PgStat_TableXactStatus *)
1603                 MemoryContextAllocZero(TopTransactionContext,
1604                                                            sizeof(PgStat_TableXactStatus));
1605         trans->nest_level = nest_level;
1606         trans->upper = pgstat_info->trans;
1607         trans->parent = pgstat_info;
1608         trans->next = xact_state->first;
1609         xact_state->first = trans;
1610         pgstat_info->trans = trans;
1611 }
1612
1613 /*
1614  * pgstat_count_heap_insert - count a tuple insertion
1615  */
1616 void
1617 pgstat_count_heap_insert(Relation rel)
1618 {
1619         PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1620
1621         if (pgstat_track_counts && pgstat_info != NULL)
1622         {
1623                 /* We have to log the effect at the proper transactional level */
1624                 int                     nest_level = GetCurrentTransactionNestLevel();
1625
1626                 if (pgstat_info->trans == NULL ||
1627                         pgstat_info->trans->nest_level != nest_level)
1628                         add_tabstat_xact_level(pgstat_info, nest_level);
1629
1630                 pgstat_info->trans->tuples_inserted++;
1631         }
1632 }
1633
1634 /*
1635  * pgstat_count_heap_update - count a tuple update
1636  */
1637 void
1638 pgstat_count_heap_update(Relation rel, bool hot)
1639 {
1640         PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1641
1642         if (pgstat_track_counts && pgstat_info != NULL)
1643         {
1644                 /* We have to log the effect at the proper transactional level */
1645                 int                     nest_level = GetCurrentTransactionNestLevel();
1646
1647                 if (pgstat_info->trans == NULL ||
1648                         pgstat_info->trans->nest_level != nest_level)
1649                         add_tabstat_xact_level(pgstat_info, nest_level);
1650
1651                 pgstat_info->trans->tuples_updated++;
1652
1653                 /* t_tuples_hot_updated is nontransactional, so just advance it */
1654                 if (hot)
1655                         pgstat_info->t_counts.t_tuples_hot_updated++;
1656         }
1657 }
1658
1659 /*
1660  * pgstat_count_heap_delete - count a tuple deletion
1661  */
1662 void
1663 pgstat_count_heap_delete(Relation rel)
1664 {
1665         PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1666
1667         if (pgstat_track_counts && pgstat_info != NULL)
1668         {
1669                 /* We have to log the effect at the proper transactional level */
1670                 int                     nest_level = GetCurrentTransactionNestLevel();
1671
1672                 if (pgstat_info->trans == NULL ||
1673                         pgstat_info->trans->nest_level != nest_level)
1674                         add_tabstat_xact_level(pgstat_info, nest_level);
1675
1676                 pgstat_info->trans->tuples_deleted++;
1677         }
1678 }
1679
1680 /*
1681  * pgstat_update_heap_dead_tuples - update dead-tuples count
1682  *
1683  * The semantics of this are that we are reporting the nontransactional
1684  * recovery of "delta" dead tuples; so t_delta_dead_tuples decreases
1685  * rather than increasing, and the change goes straight into the per-table
1686  * counter, not into transactional state.
1687  */
1688 void
1689 pgstat_update_heap_dead_tuples(Relation rel, int delta)
1690 {
1691         PgStat_TableStatus *pgstat_info = rel->pgstat_info;
1692
1693         if (pgstat_track_counts && pgstat_info != NULL)
1694                 pgstat_info->t_counts.t_delta_dead_tuples -= delta;
1695 }
1696
1697
1698 /* ----------
1699  * AtEOXact_PgStat
1700  *
1701  *      Called from access/transam/xact.c at top-level transaction commit/abort.
1702  * ----------
1703  */
1704 void
1705 AtEOXact_PgStat(bool isCommit)
1706 {
1707         PgStat_SubXactStatus *xact_state;
1708
1709         /*
1710          * Count transaction commit or abort.  (We use counters, not just bools,
1711          * in case the reporting message isn't sent right away.)
1712          */
1713         if (isCommit)
1714                 pgStatXactCommit++;
1715         else
1716                 pgStatXactRollback++;
1717
1718         /*
1719          * Transfer transactional insert/update counts into the base tabstat
1720          * entries.  We don't bother to free any of the transactional state, since
1721          * it's all in TopTransactionContext and will go away anyway.
1722          */
1723         xact_state = pgStatXactStack;
1724         if (xact_state != NULL)
1725         {
1726                 PgStat_TableXactStatus *trans;
1727
1728                 Assert(xact_state->nest_level == 1);
1729                 Assert(xact_state->prev == NULL);
1730                 for (trans = xact_state->first; trans != NULL; trans = trans->next)
1731                 {
1732                         PgStat_TableStatus *tabstat;
1733
1734                         Assert(trans->nest_level == 1);
1735                         Assert(trans->upper == NULL);
1736                         tabstat = trans->parent;
1737                         Assert(tabstat->trans == trans);
1738                         /* count attempted actions regardless of commit/abort */
1739                         tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
1740                         tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
1741                         tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
1742                         if (isCommit)
1743                         {
1744                                 /* insert adds a live tuple, delete removes one */
1745                                 tabstat->t_counts.t_delta_live_tuples +=
1746                                         trans->tuples_inserted - trans->tuples_deleted;
1747                                 /* update and delete each create a dead tuple */
1748                                 tabstat->t_counts.t_delta_dead_tuples +=
1749                                         trans->tuples_updated + trans->tuples_deleted;
1750                                 /* insert, update, delete each count as one change event */
1751                                 tabstat->t_counts.t_changed_tuples +=
1752                                         trans->tuples_inserted + trans->tuples_updated +
1753                                         trans->tuples_deleted;
1754                         }
1755                         else
1756                         {
1757                                 /* inserted tuples are dead, deleted tuples are unaffected */
1758                                 tabstat->t_counts.t_delta_dead_tuples +=
1759                                         trans->tuples_inserted + trans->tuples_updated;
1760                                 /* an aborted xact generates no changed_tuple events */
1761                         }
1762                         tabstat->trans = NULL;
1763                 }
1764         }
1765         pgStatXactStack = NULL;
1766
1767         /* Make sure any stats snapshot is thrown away */
1768         pgstat_clear_snapshot();
1769 }
1770
1771 /* ----------
1772  * AtEOSubXact_PgStat
1773  *
1774  *      Called from access/transam/xact.c at subtransaction commit/abort.
1775  * ----------
1776  */
1777 void
1778 AtEOSubXact_PgStat(bool isCommit, int nestDepth)
1779 {
1780         PgStat_SubXactStatus *xact_state;
1781
1782         /*
1783          * Transfer transactional insert/update counts into the next higher
1784          * subtransaction state.
1785          */
1786         xact_state = pgStatXactStack;
1787         if (xact_state != NULL &&
1788                 xact_state->nest_level >= nestDepth)
1789         {
1790                 PgStat_TableXactStatus *trans;
1791                 PgStat_TableXactStatus *next_trans;
1792
1793                 /* delink xact_state from stack immediately to simplify reuse case */
1794                 pgStatXactStack = xact_state->prev;
1795
1796                 for (trans = xact_state->first; trans != NULL; trans = next_trans)
1797                 {
1798                         PgStat_TableStatus *tabstat;
1799
1800                         next_trans = trans->next;
1801                         Assert(trans->nest_level == nestDepth);
1802                         tabstat = trans->parent;
1803                         Assert(tabstat->trans == trans);
1804                         if (isCommit)
1805                         {
1806                                 if (trans->upper && trans->upper->nest_level == nestDepth - 1)
1807                                 {
1808                                         trans->upper->tuples_inserted += trans->tuples_inserted;
1809                                         trans->upper->tuples_updated += trans->tuples_updated;
1810                                         trans->upper->tuples_deleted += trans->tuples_deleted;
1811                                         tabstat->trans = trans->upper;
1812                                         pfree(trans);
1813                                 }
1814                                 else
1815                                 {
1816                                         /*
1817                                          * When there isn't an immediate parent state, we can just
1818                                          * reuse the record instead of going through a
1819                                          * palloc/pfree pushup (this works since it's all in
1820                                          * TopTransactionContext anyway).  We have to re-link it
1821                                          * into the parent level, though, and that might mean
1822                                          * pushing a new entry into the pgStatXactStack.
1823                                          */
1824                                         PgStat_SubXactStatus *upper_xact_state;
1825
1826                                         upper_xact_state = get_tabstat_stack_level(nestDepth - 1);
1827                                         trans->next = upper_xact_state->first;
1828                                         upper_xact_state->first = trans;
1829                                         trans->nest_level = nestDepth - 1;
1830                                 }
1831                         }
1832                         else
1833                         {
1834                                 /*
1835                                  * On abort, update top-level tabstat counts, then forget
1836                                  * the subtransaction
1837                                  */
1838
1839                                 /* count attempted actions regardless of commit/abort */
1840                                 tabstat->t_counts.t_tuples_inserted += trans->tuples_inserted;
1841                                 tabstat->t_counts.t_tuples_updated += trans->tuples_updated;
1842                                 tabstat->t_counts.t_tuples_deleted += trans->tuples_deleted;
1843                                 /* inserted tuples are dead, deleted tuples are unaffected */
1844                                 tabstat->t_counts.t_delta_dead_tuples +=
1845                                         trans->tuples_inserted + trans->tuples_updated;
1846                                 tabstat->trans = trans->upper;
1847                                 pfree(trans);
1848                         }
1849                 }
1850                 pfree(xact_state);
1851         }
1852 }
1853
1854
1855 /*
1856  * AtPrepare_PgStat
1857  *              Save the transactional stats state at 2PC transaction prepare.
1858  *
1859  * In this phase we just generate 2PC records for all the pending
1860  * transaction-dependent stats work.
1861  */
1862 void
1863 AtPrepare_PgStat(void)
1864 {
1865         PgStat_SubXactStatus *xact_state;
1866
1867         xact_state = pgStatXactStack;
1868         if (xact_state != NULL)
1869         {
1870                 PgStat_TableXactStatus *trans;
1871
1872                 Assert(xact_state->nest_level == 1);
1873                 Assert(xact_state->prev == NULL);
1874                 for (trans = xact_state->first; trans != NULL; trans = trans->next)
1875                 {
1876                         PgStat_TableStatus *tabstat;
1877                         TwoPhasePgStatRecord record;
1878
1879                         Assert(trans->nest_level == 1);
1880                         Assert(trans->upper == NULL);
1881                         tabstat = trans->parent;
1882                         Assert(tabstat->trans == trans);
1883
1884                         record.tuples_inserted = trans->tuples_inserted;
1885                         record.tuples_updated = trans->tuples_updated;
1886                         record.tuples_deleted = trans->tuples_deleted;
1887                         record.t_id = tabstat->t_id;
1888                         record.t_shared = tabstat->t_shared;
1889
1890                         RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0,
1891                                                                    &record, sizeof(TwoPhasePgStatRecord));
1892                 }
1893         }
1894 }
1895
1896 /*
1897  * PostPrepare_PgStat
1898  *              Clean up after successful PREPARE.
1899  *
1900  * All we need do here is unlink the transaction stats state from the
1901  * nontransactional state.      The nontransactional action counts will be
1902  * reported to the stats collector immediately, while the effects on live
1903  * and dead tuple counts are preserved in the 2PC state file.
1904  *
1905  * Note: AtEOXact_PgStat is not called during PREPARE.
1906  */
1907 void
1908 PostPrepare_PgStat(void)
1909 {
1910         PgStat_SubXactStatus *xact_state;
1911
1912         /*
1913          * We don't bother to free any of the transactional state, since it's all
1914          * in TopTransactionContext and will go away anyway.
1915          */
1916         xact_state = pgStatXactStack;
1917         if (xact_state != NULL)
1918         {
1919                 PgStat_TableXactStatus *trans;
1920
1921                 for (trans = xact_state->first; trans != NULL; trans = trans->next)
1922                 {
1923                         PgStat_TableStatus *tabstat;
1924
1925                         tabstat = trans->parent;
1926                         tabstat->trans = NULL;
1927                 }
1928         }
1929         pgStatXactStack = NULL;
1930
1931         /* Make sure any stats snapshot is thrown away */
1932         pgstat_clear_snapshot();
1933 }
1934
1935 /*
1936  * 2PC processing routine for COMMIT PREPARED case.
1937  *
1938  * Load the saved counts into our local pgstats state.
1939  */
1940 void
1941 pgstat_twophase_postcommit(TransactionId xid, uint16 info,
1942                                                    void *recdata, uint32 len)
1943 {
1944         TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
1945         PgStat_TableStatus *pgstat_info;
1946
1947         /* Find or create a tabstat entry for the rel */
1948         pgstat_info = get_tabstat_entry(rec->t_id, rec->t_shared);
1949
1950         /* Same math as in AtEOXact_PgStat, commit case */
1951         pgstat_info->t_counts.t_tuples_inserted += rec->tuples_inserted;
1952         pgstat_info->t_counts.t_tuples_updated += rec->tuples_updated;
1953         pgstat_info->t_counts.t_tuples_deleted += rec->tuples_deleted;
1954         pgstat_info->t_counts.t_delta_live_tuples +=
1955                 rec->tuples_inserted - rec->tuples_deleted;
1956         pgstat_info->t_counts.t_delta_dead_tuples +=
1957                 rec->tuples_updated + rec->tuples_deleted;
1958         pgstat_info->t_counts.t_changed_tuples +=
1959                 rec->tuples_inserted + rec->tuples_updated +
1960                 rec->tuples_deleted;
1961 }
1962
1963 /*
1964  * 2PC processing routine for ROLLBACK PREPARED case.
1965  *
1966  * Load the saved counts into our local pgstats state, but treat them
1967  * as aborted.
1968  */
1969 void
1970 pgstat_twophase_postabort(TransactionId xid, uint16 info,
1971                                                   void *recdata, uint32 len)
1972 {
1973         TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata;
1974         PgStat_TableStatus *pgstat_info;
1975
1976         /* Find or create a tabstat entry for the rel */
1977         pgstat_info = get_tabstat_entry(rec->t_id, rec->t_shared);
1978
1979         /* Same math as in AtEOXact_PgStat, abort case */
1980         pgstat_info->t_counts.t_tuples_inserted += rec->tuples_inserted;
1981         pgstat_info->t_counts.t_tuples_updated += rec->tuples_updated;
1982         pgstat_info->t_counts.t_tuples_deleted += rec->tuples_deleted;
1983         pgstat_info->t_counts.t_delta_dead_tuples +=
1984                 rec->tuples_inserted + rec->tuples_updated;
1985 }
1986
1987
1988 /* ----------
1989  * pgstat_fetch_stat_dbentry() -
1990  *
1991  *      Support function for the SQL-callable pgstat* functions. Returns
1992  *      the collected statistics for one database or NULL. NULL doesn't mean
1993  *      that the database doesn't exist, it is just not yet known by the
1994  *      collector, so the caller is better off to report ZERO instead.
1995  * ----------
1996  */
1997 PgStat_StatDBEntry *
1998 pgstat_fetch_stat_dbentry(Oid dbid)
1999 {
2000         /*
2001          * If not done for this transaction, read the statistics collector stats
2002          * file into some hash tables.
2003          */
2004         backend_read_statsfile();
2005
2006         /*
2007          * Lookup the requested database; return NULL if not found
2008          */
2009         return (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
2010                                                                                           (void *) &dbid,
2011                                                                                           HASH_FIND, NULL);
2012 }
2013
2014
2015 /* ----------
2016  * pgstat_fetch_stat_tabentry() -
2017  *
2018  *      Support function for the SQL-callable pgstat* functions. Returns
2019  *      the collected statistics for one table or NULL. NULL doesn't mean
2020  *      that the table doesn't exist, it is just not yet known by the
2021  *      collector, so the caller is better off to report ZERO instead.
2022  * ----------
2023  */
2024 PgStat_StatTabEntry *
2025 pgstat_fetch_stat_tabentry(Oid relid)
2026 {
2027         Oid                     dbid;
2028         PgStat_StatDBEntry *dbentry;
2029         PgStat_StatTabEntry *tabentry;
2030
2031         /*
2032          * If not done for this transaction, read the statistics collector stats
2033          * file into some hash tables.
2034          */
2035         backend_read_statsfile();
2036
2037         /*
2038          * Lookup our database, then look in its table hash table.
2039          */
2040         dbid = MyDatabaseId;
2041         dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
2042                                                                                                  (void *) &dbid,
2043                                                                                                  HASH_FIND, NULL);
2044         if (dbentry != NULL && dbentry->tables != NULL)
2045         {
2046                 tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
2047                                                                                                            (void *) &relid,
2048                                                                                                            HASH_FIND, NULL);
2049                 if (tabentry)
2050                         return tabentry;
2051         }
2052
2053         /*
2054          * If we didn't find it, maybe it's a shared table.
2055          */
2056         dbid = InvalidOid;
2057         dbentry = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
2058                                                                                                  (void *) &dbid,
2059                                                                                                  HASH_FIND, NULL);
2060         if (dbentry != NULL && dbentry->tables != NULL)
2061         {
2062                 tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
2063                                                                                                            (void *) &relid,
2064                                                                                                            HASH_FIND, NULL);
2065                 if (tabentry)
2066                         return tabentry;
2067         }
2068
2069         return NULL;
2070 }
2071
2072
2073 /* ----------
2074  * pgstat_fetch_stat_funcentry() -
2075  *
2076  *      Support function for the SQL-callable pgstat* functions. Returns
2077  *      the collected statistics for one function or NULL.
2078  * ----------
2079  */
2080 PgStat_StatFuncEntry *
2081 pgstat_fetch_stat_funcentry(Oid func_id)
2082 {
2083         PgStat_StatDBEntry *dbentry;
2084         PgStat_StatFuncEntry *funcentry = NULL;
2085
2086         /* load the stats file if needed */
2087         backend_read_statsfile();
2088
2089         /* Lookup our database, then find the requested function.  */
2090         dbentry = pgstat_fetch_stat_dbentry(MyDatabaseId);
2091         if (dbentry != NULL && dbentry->functions != NULL)
2092         {
2093                 funcentry = (PgStat_StatFuncEntry *) hash_search(dbentry->functions,
2094                                                                                                                  (void *) &func_id,
2095                                                                                                                  HASH_FIND, NULL);
2096         }
2097
2098         return funcentry;
2099 }
2100
2101
2102 /* ----------
2103  * pgstat_fetch_stat_beentry() -
2104  *
2105  *      Support function for the SQL-callable pgstat* functions. Returns
2106  *      our local copy of the current-activity entry for one backend.
2107  *
2108  *      NB: caller is responsible for a check if the user is permitted to see
2109  *      this info (especially the querystring).
2110  * ----------
2111  */
2112 PgBackendStatus *
2113 pgstat_fetch_stat_beentry(int beid)
2114 {
2115         pgstat_read_current_status();
2116
2117         if (beid < 1 || beid > localNumBackends)
2118                 return NULL;
2119
2120         return &localBackendStatusTable[beid - 1];
2121 }
2122
2123
2124 /* ----------
2125  * pgstat_fetch_stat_numbackends() -
2126  *
2127  *      Support function for the SQL-callable pgstat* functions. Returns
2128  *      the maximum current backend id.
2129  * ----------
2130  */
2131 int
2132 pgstat_fetch_stat_numbackends(void)
2133 {
2134         pgstat_read_current_status();
2135
2136         return localNumBackends;
2137 }
2138
2139 /*
2140  * ---------
2141  * pgstat_fetch_global() -
2142  *
2143  *      Support function for the SQL-callable pgstat* functions. Returns
2144  *      a pointer to the global statistics struct.
2145  * ---------
2146  */
2147 PgStat_GlobalStats *
2148 pgstat_fetch_global(void)
2149 {
2150         backend_read_statsfile();
2151
2152         return &globalStats;
2153 }
2154
2155
2156 /* ------------------------------------------------------------
2157  * Functions for management of the shared-memory PgBackendStatus array
2158  * ------------------------------------------------------------
2159  */
2160
2161 static PgBackendStatus *BackendStatusArray = NULL;
2162 static PgBackendStatus *MyBEEntry = NULL;
2163 static char *BackendAppnameBuffer = NULL;
2164 static char *BackendActivityBuffer = NULL;
2165
2166
2167 /*
2168  * Report shared-memory space needed by CreateSharedBackendStatus.
2169  */
2170 Size
2171 BackendStatusShmemSize(void)
2172 {
2173         Size            size;
2174
2175         size = mul_size(sizeof(PgBackendStatus), MaxBackends);
2176         size = add_size(size,
2177                                         mul_size(NAMEDATALEN, MaxBackends));
2178         size = add_size(size,
2179                                         mul_size(pgstat_track_activity_query_size, MaxBackends));
2180         return size;
2181 }
2182
2183 /*
2184  * Initialize the shared status array and activity/appname string buffers
2185  * during postmaster startup.
2186  */
2187 void
2188 CreateSharedBackendStatus(void)
2189 {
2190         Size            size;
2191         bool            found;
2192         int                     i;
2193         char       *buffer;
2194
2195         /* Create or attach to the shared array */
2196         size = mul_size(sizeof(PgBackendStatus), MaxBackends);
2197         BackendStatusArray = (PgBackendStatus *)
2198                 ShmemInitStruct("Backend Status Array", size, &found);
2199
2200         if (!found)
2201         {
2202                 /*
2203                  * We're the first - initialize.
2204                  */
2205                 MemSet(BackendStatusArray, 0, size);
2206         }
2207
2208         /* Create or attach to the shared appname buffer */
2209         size = mul_size(NAMEDATALEN, MaxBackends);
2210         BackendAppnameBuffer = (char *)
2211                 ShmemInitStruct("Backend Application Name Buffer", size, &found);
2212
2213         if (!found)
2214         {
2215                 MemSet(BackendAppnameBuffer, 0, size);
2216
2217                 /* Initialize st_appname pointers. */
2218                 buffer = BackendAppnameBuffer;
2219                 for (i = 0; i < MaxBackends; i++)
2220                 {
2221                         BackendStatusArray[i].st_appname = buffer;
2222                         buffer += NAMEDATALEN;
2223                 }
2224         }
2225
2226         /* Create or attach to the shared activity buffer */
2227         size = mul_size(pgstat_track_activity_query_size, MaxBackends);
2228         BackendActivityBuffer = (char *)
2229                 ShmemInitStruct("Backend Activity Buffer", size, &found);
2230
2231         if (!found)
2232         {
2233                 MemSet(BackendActivityBuffer, 0, size);
2234
2235                 /* Initialize st_activity pointers. */
2236                 buffer = BackendActivityBuffer;
2237                 for (i = 0; i < MaxBackends; i++)
2238                 {
2239                         BackendStatusArray[i].st_activity = buffer;
2240                         buffer += pgstat_track_activity_query_size;
2241                 }
2242         }
2243 }
2244
2245
2246 /* ----------
2247  * pgstat_initialize() -
2248  *
2249  *      Initialize pgstats state, and set up our on-proc-exit hook.
2250  *      Called from InitPostgres.  MyBackendId must be set,
2251  *      but we must not have started any transaction yet (since the
2252  *      exit hook must run after the last transaction exit).
2253  *      NOTE: MyDatabaseId isn't set yet; so the shutdown hook has to be careful.
2254  * ----------
2255  */
2256 void
2257 pgstat_initialize(void)
2258 {
2259         /* Initialize MyBEEntry */
2260         Assert(MyBackendId >= 1 && MyBackendId <= MaxBackends);
2261         MyBEEntry = &BackendStatusArray[MyBackendId - 1];
2262
2263         /* Set up a process-exit hook to clean up */
2264         on_shmem_exit(pgstat_beshutdown_hook, 0);
2265 }
2266
2267 /* ----------
2268  * pgstat_bestart() -
2269  *
2270  *      Initialize this backend's entry in the PgBackendStatus array.
2271  *      Called from InitPostgres.
2272  *      MyDatabaseId, session userid, and application_name must be set
2273  *      (hence, this cannot be combined with pgstat_initialize).
2274  * ----------
2275  */
2276 void
2277 pgstat_bestart(void)
2278 {
2279         TimestampTz proc_start_timestamp;
2280         Oid                     userid;
2281         SockAddr        clientaddr;
2282         volatile PgBackendStatus *beentry;
2283
2284         /*
2285          * To minimize the time spent modifying the PgBackendStatus entry, fetch
2286          * all the needed data first.
2287          *
2288          * If we have a MyProcPort, use its session start time (for consistency,
2289          * and to save a kernel call).
2290          */
2291         if (MyProcPort)
2292                 proc_start_timestamp = MyProcPort->SessionStartTime;
2293         else
2294                 proc_start_timestamp = GetCurrentTimestamp();
2295         userid = GetSessionUserId();
2296
2297         /*
2298          * We may not have a MyProcPort (eg, if this is the autovacuum process).
2299          * If so, use all-zeroes client address, which is dealt with specially in
2300          * pg_stat_get_backend_client_addr and pg_stat_get_backend_client_port.
2301          */
2302         if (MyProcPort)
2303                 memcpy(&clientaddr, &MyProcPort->raddr, sizeof(clientaddr));
2304         else
2305                 MemSet(&clientaddr, 0, sizeof(clientaddr));
2306
2307         /*
2308          * Initialize my status entry, following the protocol of bumping
2309          * st_changecount before and after; and make sure it's even afterwards. We
2310          * use a volatile pointer here to ensure the compiler doesn't try to get
2311          * cute.
2312          */
2313         beentry = MyBEEntry;
2314         do
2315         {
2316                 beentry->st_changecount++;
2317         } while ((beentry->st_changecount & 1) == 0);
2318
2319         beentry->st_procpid = MyProcPid;
2320         beentry->st_proc_start_timestamp = proc_start_timestamp;
2321         beentry->st_activity_start_timestamp = 0;
2322         beentry->st_xact_start_timestamp = 0;
2323         beentry->st_databaseid = MyDatabaseId;
2324         beentry->st_userid = userid;
2325         beentry->st_clientaddr = clientaddr;
2326         beentry->st_waiting = false;
2327         beentry->st_appname[0] = '\0';
2328         beentry->st_activity[0] = '\0';
2329         /* Also make sure the last byte in each string area is always 0 */
2330         beentry->st_appname[NAMEDATALEN - 1] = '\0';
2331         beentry->st_activity[pgstat_track_activity_query_size - 1] = '\0';
2332
2333         beentry->st_changecount++;
2334         Assert((beentry->st_changecount & 1) == 0);
2335
2336         /* Update app name to current GUC setting */
2337         if (application_name)
2338                 pgstat_report_appname(application_name);
2339 }
2340
2341 /*
2342  * Shut down a single backend's statistics reporting at process exit.
2343  *
2344  * Flush any remaining statistics counts out to the collector.
2345  * Without this, operations triggered during backend exit (such as
2346  * temp table deletions) won't be counted.
2347  *
2348  * Lastly, clear out our entry in the PgBackendStatus array.
2349  */
2350 static void
2351 pgstat_beshutdown_hook(int code, Datum arg)
2352 {
2353         volatile PgBackendStatus *beentry = MyBEEntry;
2354
2355         /*
2356          * If we got as far as discovering our own database ID, we can report
2357          * what we did to the collector.  Otherwise, we'd be sending an invalid
2358          * database ID, so forget it.  (This means that accesses to pg_database
2359          * during failed backend starts might never get counted.)
2360          */
2361         if (OidIsValid(MyDatabaseId))
2362                 pgstat_report_stat(true);
2363
2364         /*
2365          * Clear my status entry, following the protocol of bumping st_changecount
2366          * before and after.  We use a volatile pointer here to ensure the
2367          * compiler doesn't try to get cute.
2368          */
2369         beentry->st_changecount++;
2370
2371         beentry->st_procpid = 0;        /* mark invalid */
2372
2373         beentry->st_changecount++;
2374         Assert((beentry->st_changecount & 1) == 0);
2375 }
2376
2377
2378 /* ----------
2379  * pgstat_report_activity() -
2380  *
2381  *      Called from tcop/postgres.c to report what the backend is actually doing
2382  *      (usually "<IDLE>" or the start of the query to be executed).
2383  * ----------
2384  */
2385 void
2386 pgstat_report_activity(const char *cmd_str)
2387 {
2388         volatile PgBackendStatus *beentry = MyBEEntry;
2389         TimestampTz start_timestamp;
2390         int                     len;
2391
2392         TRACE_POSTGRESQL_STATEMENT_STATUS(cmd_str);
2393
2394         if (!pgstat_track_activities || !beentry)
2395                 return;
2396
2397         /*
2398          * To minimize the time spent modifying the entry, fetch all the needed
2399          * data first.
2400          */
2401         start_timestamp = GetCurrentStatementStartTimestamp();
2402
2403         len = strlen(cmd_str);
2404         len = pg_mbcliplen(cmd_str, len, pgstat_track_activity_query_size - 1);
2405
2406         /*
2407          * Update my status entry, following the protocol of bumping
2408          * st_changecount before and after.  We use a volatile pointer here to
2409          * ensure the compiler doesn't try to get cute.
2410          */
2411         beentry->st_changecount++;
2412
2413         beentry->st_activity_start_timestamp = start_timestamp;
2414         memcpy((char *) beentry->st_activity, cmd_str, len);
2415         beentry->st_activity[len] = '\0';
2416
2417         beentry->st_changecount++;
2418         Assert((beentry->st_changecount & 1) == 0);
2419 }
2420
2421 /* ----------
2422  * pgstat_report_appname() -
2423  *
2424  *      Called to update our application name.
2425  * ----------
2426  */
2427 void
2428 pgstat_report_appname(const char *appname)
2429 {
2430         volatile PgBackendStatus *beentry = MyBEEntry;
2431         int                     len;
2432
2433         if (!beentry)
2434                 return;
2435
2436         /* This should be unnecessary if GUC did its job, but be safe */
2437         len = pg_mbcliplen(appname, strlen(appname), NAMEDATALEN - 1);
2438
2439         /*
2440          * Update my status entry, following the protocol of bumping
2441          * st_changecount before and after.  We use a volatile pointer here to
2442          * ensure the compiler doesn't try to get cute.
2443          */
2444         beentry->st_changecount++;
2445
2446         memcpy((char *) beentry->st_appname, appname, len);
2447         beentry->st_appname[len] = '\0';
2448
2449         beentry->st_changecount++;
2450         Assert((beentry->st_changecount & 1) == 0);
2451 }
2452
2453 /*
2454  * Report current transaction start timestamp as the specified value.
2455  * Zero means there is no active transaction.
2456  */
2457 void
2458 pgstat_report_xact_timestamp(TimestampTz tstamp)
2459 {
2460         volatile PgBackendStatus *beentry = MyBEEntry;
2461
2462         if (!pgstat_track_activities || !beentry)
2463                 return;
2464
2465         /*
2466          * Update my status entry, following the protocol of bumping
2467          * st_changecount before and after.  We use a volatile pointer here to
2468          * ensure the compiler doesn't try to get cute.
2469          */
2470         beentry->st_changecount++;
2471         beentry->st_xact_start_timestamp = tstamp;
2472         beentry->st_changecount++;
2473         Assert((beentry->st_changecount & 1) == 0);
2474 }
2475
2476 /* ----------
2477  * pgstat_report_waiting() -
2478  *
2479  *      Called from lock manager to report beginning or end of a lock wait.
2480  *
2481  * NB: this *must* be able to survive being called before MyBEEntry has been
2482  * initialized.
2483  * ----------
2484  */
2485 void
2486 pgstat_report_waiting(bool waiting)
2487 {
2488         volatile PgBackendStatus *beentry = MyBEEntry;
2489
2490         if (!pgstat_track_activities || !beentry)
2491                 return;
2492
2493         /*
2494          * Since this is a single-byte field in a struct that only this process
2495          * may modify, there seems no need to bother with the st_changecount
2496          * protocol.  The update must appear atomic in any case.
2497          */
2498         beentry->st_waiting = waiting;
2499 }
2500
2501
2502 /* ----------
2503  * pgstat_read_current_status() -
2504  *
2505  *      Copy the current contents of the PgBackendStatus array to local memory,
2506  *      if not already done in this transaction.
2507  * ----------
2508  */
2509 static void
2510 pgstat_read_current_status(void)
2511 {
2512         volatile PgBackendStatus *beentry;
2513         PgBackendStatus *localtable;
2514         PgBackendStatus *localentry;
2515         char       *localappname,
2516                            *localactivity;
2517         int                     i;
2518
2519         Assert(!pgStatRunningInCollector);
2520         if (localBackendStatusTable)
2521                 return;                                 /* already done */
2522
2523         pgstat_setup_memcxt();
2524
2525         localtable = (PgBackendStatus *)
2526                 MemoryContextAlloc(pgStatLocalContext,
2527                                                    sizeof(PgBackendStatus) * MaxBackends);
2528         localappname = (char *)
2529                 MemoryContextAlloc(pgStatLocalContext,
2530                                                    NAMEDATALEN * MaxBackends);
2531         localactivity = (char *)
2532                 MemoryContextAlloc(pgStatLocalContext,
2533                                                    pgstat_track_activity_query_size * MaxBackends);
2534         localNumBackends = 0;
2535
2536         beentry = BackendStatusArray;
2537         localentry = localtable;
2538         for (i = 1; i <= MaxBackends; i++)
2539         {
2540                 /*
2541                  * Follow the protocol of retrying if st_changecount changes while we
2542                  * copy the entry, or if it's odd.  (The check for odd is needed to
2543                  * cover the case where we are able to completely copy the entry while
2544                  * the source backend is between increment steps.)      We use a volatile
2545                  * pointer here to ensure the compiler doesn't try to get cute.
2546                  */
2547                 for (;;)
2548                 {
2549                         int                     save_changecount = beentry->st_changecount;
2550
2551                         localentry->st_procpid = beentry->st_procpid;
2552                         if (localentry->st_procpid > 0)
2553                         {
2554                                 memcpy(localentry, (char *) beentry, sizeof(PgBackendStatus));
2555
2556                                 /*
2557                                  * strcpy is safe even if the string is modified concurrently,
2558                                  * because there's always a \0 at the end of the buffer.
2559                                  */
2560                                 strcpy(localappname, (char *) beentry->st_appname);
2561                                 localentry->st_appname = localappname;
2562                                 strcpy(localactivity, (char *) beentry->st_activity);
2563                                 localentry->st_activity = localactivity;
2564                         }
2565
2566                         if (save_changecount == beentry->st_changecount &&
2567                                 (save_changecount & 1) == 0)
2568                                 break;
2569
2570                         /* Make sure we can break out of loop if stuck... */
2571                         CHECK_FOR_INTERRUPTS();
2572                 }
2573
2574                 beentry++;
2575                 /* Only valid entries get included into the local array */
2576                 if (localentry->st_procpid > 0)
2577                 {
2578                         localentry++;
2579                         localappname += NAMEDATALEN;
2580                         localactivity += pgstat_track_activity_query_size;
2581                         localNumBackends++;
2582                 }
2583         }
2584
2585         /* Set the pointer only after completion of a valid table */
2586         localBackendStatusTable = localtable;
2587 }
2588
2589
2590 /* ----------
2591  * pgstat_get_backend_current_activity() -
2592  *
2593  *      Return a string representing the current activity of the backend with
2594  *      the specified PID.      This looks directly at the BackendStatusArray,
2595  *      and so will provide current information regardless of the age of our
2596  *      transaction's snapshot of the status array.
2597  *
2598  *      It is the caller's responsibility to invoke this only for backends whose
2599  *      state is expected to remain stable while the result is in use.  The
2600  *      only current use is in deadlock reporting, where we can expect that
2601  *      the target backend is blocked on a lock.  (There are corner cases
2602  *      where the target's wait could get aborted while we are looking at it,
2603  *      but the very worst consequence is to return a pointer to a string
2604  *      that's been changed, so we won't worry too much.)
2605  *
2606  *      Note: return strings for special cases match pg_stat_get_backend_activity.
2607  * ----------
2608  */
2609 const char *
2610 pgstat_get_backend_current_activity(int pid, bool checkUser)
2611 {
2612         PgBackendStatus *beentry;
2613         int                     i;
2614
2615         beentry = BackendStatusArray;
2616         for (i = 1; i <= MaxBackends; i++)
2617         {
2618                 /*
2619                  * Although we expect the target backend's entry to be stable, that
2620                  * doesn't imply that anyone else's is.  To avoid identifying the
2621                  * wrong backend, while we check for a match to the desired PID we
2622                  * must follow the protocol of retrying if st_changecount changes
2623                  * while we examine the entry, or if it's odd.  (This might be
2624                  * unnecessary, since fetching or storing an int is almost certainly
2625                  * atomic, but let's play it safe.)  We use a volatile pointer here to
2626                  * ensure the compiler doesn't try to get cute.
2627                  */
2628                 volatile PgBackendStatus *vbeentry = beentry;
2629                 bool            found;
2630
2631                 for (;;)
2632                 {
2633                         int                     save_changecount = vbeentry->st_changecount;
2634
2635                         found = (vbeentry->st_procpid == pid);
2636
2637                         if (save_changecount == vbeentry->st_changecount &&
2638                                 (save_changecount & 1) == 0)
2639                                 break;
2640
2641                         /* Make sure we can break out of loop if stuck... */
2642                         CHECK_FOR_INTERRUPTS();
2643                 }
2644
2645                 if (found)
2646                 {
2647                         /* Now it is safe to use the non-volatile pointer */
2648                         if (checkUser && !superuser() && beentry->st_userid != GetUserId())
2649                                 return "<insufficient privilege>";
2650                         else if (*(beentry->st_activity) == '\0')
2651                                 return "<command string not enabled>";
2652                         else
2653                                 return beentry->st_activity;
2654                 }
2655
2656                 beentry++;
2657         }
2658
2659         /* If we get here, caller is in error ... */
2660         return "<backend information not available>";
2661 }
2662
2663
2664 /* ------------------------------------------------------------
2665  * Local support functions follow
2666  * ------------------------------------------------------------
2667  */
2668
2669
2670 /* ----------
2671  * pgstat_setheader() -
2672  *
2673  *              Set common header fields in a statistics message
2674  * ----------
2675  */
2676 static void
2677 pgstat_setheader(PgStat_MsgHdr *hdr, StatMsgType mtype)
2678 {
2679         hdr->m_type = mtype;
2680 }
2681
2682
2683 /* ----------
2684  * pgstat_send() -
2685  *
2686  *              Send out one statistics message to the collector
2687  * ----------
2688  */
2689 static void
2690 pgstat_send(void *msg, int len)
2691 {
2692         int                     rc;
2693
2694         if (pgStatSock < 0)
2695                 return;
2696
2697         ((PgStat_MsgHdr *) msg)->m_size = len;
2698
2699         /* We'll retry after EINTR, but ignore all other failures */
2700         do
2701         {
2702                 rc = send(pgStatSock, msg, len, 0);
2703         } while (rc < 0 && errno == EINTR);
2704
2705 #ifdef USE_ASSERT_CHECKING
2706         /* In debug builds, log send failures ... */
2707         if (rc < 0)
2708                 elog(LOG, "could not send to statistics collector: %m");
2709 #endif
2710 }
2711
2712 /* ----------
2713  * pgstat_send_bgwriter() -
2714  *
2715  *              Send bgwriter statistics to the collector
2716  * ----------
2717  */
2718 void
2719 pgstat_send_bgwriter(void)
2720 {
2721         /* We assume this initializes to zeroes */
2722         static const PgStat_MsgBgWriter all_zeroes;
2723
2724         /*
2725          * This function can be called even if nothing at all has happened. In
2726          * this case, avoid sending a completely empty message to the stats
2727          * collector.
2728          */
2729         if (memcmp(&BgWriterStats, &all_zeroes, sizeof(PgStat_MsgBgWriter)) == 0)
2730                 return;
2731
2732         /*
2733          * Prepare and send the message
2734          */
2735         pgstat_setheader(&BgWriterStats.m_hdr, PGSTAT_MTYPE_BGWRITER);
2736         pgstat_send(&BgWriterStats, sizeof(BgWriterStats));
2737
2738         /*
2739          * Clear out the statistics buffer, so it can be re-used.
2740          */
2741         MemSet(&BgWriterStats, 0, sizeof(BgWriterStats));
2742 }
2743
2744
2745 /* ----------
2746  * PgstatCollectorMain() -
2747  *
2748  *      Start up the statistics collector process.      This is the body of the
2749  *      postmaster child process.
2750  *
2751  *      The argc/argv parameters are valid only in EXEC_BACKEND case.
2752  * ----------
2753  */
2754 NON_EXEC_STATIC void
2755 PgstatCollectorMain(int argc, char *argv[])
2756 {
2757         int                     len;
2758         PgStat_Msg      msg;
2759
2760 #ifndef WIN32
2761 #ifdef HAVE_POLL
2762         struct pollfd input_fd;
2763 #else
2764         struct timeval sel_timeout;
2765         fd_set          rfds;
2766 #endif
2767 #endif
2768
2769         IsUnderPostmaster = true;       /* we are a postmaster subprocess now */
2770
2771         MyProcPid = getpid();           /* reset MyProcPid */
2772
2773         MyStartTime = time(NULL);       /* record Start Time for logging */
2774
2775         /*
2776          * If possible, make this process a group leader, so that the postmaster
2777          * can signal any child processes too.  (pgstat probably never has any
2778          * child processes, but for consistency we make all postmaster child
2779          * processes do this.)
2780          */
2781 #ifdef HAVE_SETSID
2782         if (setsid() < 0)
2783                 elog(FATAL, "setsid() failed: %m");
2784 #endif
2785
2786         /*
2787          * Ignore all signals usually bound to some action in the postmaster,
2788          * except SIGQUIT.
2789          */
2790         pqsignal(SIGHUP, pgstat_sighup_handler);
2791         pqsignal(SIGINT, SIG_IGN);
2792         pqsignal(SIGTERM, SIG_IGN);
2793         pqsignal(SIGQUIT, pgstat_exit);
2794         pqsignal(SIGALRM, SIG_IGN);
2795         pqsignal(SIGPIPE, SIG_IGN);
2796         pqsignal(SIGUSR1, SIG_IGN);
2797         pqsignal(SIGUSR2, SIG_IGN);
2798         pqsignal(SIGCHLD, SIG_DFL);
2799         pqsignal(SIGTTIN, SIG_DFL);
2800         pqsignal(SIGTTOU, SIG_DFL);
2801         pqsignal(SIGCONT, SIG_DFL);
2802         pqsignal(SIGWINCH, SIG_DFL);
2803         PG_SETMASK(&UnBlockSig);
2804
2805         /*
2806          * Identify myself via ps
2807          */
2808         init_ps_display("stats collector process", "", "", "");
2809
2810         /*
2811          * Arrange to write the initial status file right away
2812          */
2813         last_statrequest = GetCurrentTimestamp();
2814         last_statwrite = last_statrequest - 1;
2815
2816         /*
2817          * Read in an existing statistics stats file or initialize the stats to
2818          * zero.
2819          */
2820         pgStatRunningInCollector = true;
2821         pgStatDBHash = pgstat_read_statsfile(InvalidOid, true);
2822
2823         /*
2824          * Setup the descriptor set for select(2).      Since only one bit in the set
2825          * ever changes, we need not repeat FD_ZERO each time.
2826          */
2827 #if !defined(HAVE_POLL) && !defined(WIN32)
2828         FD_ZERO(&rfds);
2829 #endif
2830
2831         /*
2832          * Loop to process messages until we get SIGQUIT or detect ungraceful
2833          * death of our parent postmaster.
2834          *
2835          * For performance reasons, we don't want to do a PostmasterIsAlive() test
2836          * after every message; instead, do it only when select()/poll() is
2837          * interrupted by timeout.      In essence, we'll stay alive as long as
2838          * backends keep sending us stuff often, even if the postmaster is gone.
2839          */
2840         for (;;)
2841         {
2842                 int                     got_data;
2843
2844                 /*
2845                  * Quit if we get SIGQUIT from the postmaster.
2846                  */
2847                 if (need_exit)
2848                         break;
2849
2850                 /*
2851                  * Reload configuration if we got SIGHUP from the postmaster.
2852                  */
2853                 if (got_SIGHUP)
2854                 {
2855                         ProcessConfigFile(PGC_SIGHUP);
2856                         got_SIGHUP = false;
2857                 }
2858
2859                 /*
2860                  * Write the stats file if a new request has arrived that is not
2861                  * satisfied by existing file.
2862                  */
2863                 if (last_statwrite < last_statrequest)
2864                         pgstat_write_statsfile(false);
2865
2866                 /*
2867                  * Wait for a message to arrive; but not for more than
2868                  * PGSTAT_SELECT_TIMEOUT seconds. (This determines how quickly we will
2869                  * shut down after an ungraceful postmaster termination; so it needn't
2870                  * be very fast.  However, on some systems SIGQUIT won't interrupt the
2871                  * poll/select call, so this also limits speed of response to SIGQUIT,
2872                  * which is more important.)
2873                  *
2874                  * We use poll(2) if available, otherwise select(2). Win32 has its own
2875                  * implementation.
2876                  */
2877 #ifndef WIN32
2878 #ifdef HAVE_POLL
2879                 input_fd.fd = pgStatSock;
2880                 input_fd.events = POLLIN | POLLERR;
2881                 input_fd.revents = 0;
2882
2883                 if (poll(&input_fd, 1, PGSTAT_SELECT_TIMEOUT * 1000) < 0)
2884                 {
2885                         if (errno == EINTR)
2886                                 continue;
2887                         ereport(ERROR,
2888                                         (errcode_for_socket_access(),
2889                                          errmsg("poll() failed in statistics collector: %m")));
2890                 }
2891
2892                 got_data = (input_fd.revents != 0);
2893 #else                                                   /* !HAVE_POLL */
2894
2895                 FD_SET          (pgStatSock, &rfds);
2896
2897                 /*
2898                  * timeout struct is modified by select() on some operating systems,
2899                  * so re-fill it each time.
2900                  */
2901                 sel_timeout.tv_sec = PGSTAT_SELECT_TIMEOUT;
2902                 sel_timeout.tv_usec = 0;
2903
2904                 if (select(pgStatSock + 1, &rfds, NULL, NULL, &sel_timeout) < 0)
2905                 {
2906                         if (errno == EINTR)
2907                                 continue;
2908                         ereport(ERROR,
2909                                         (errcode_for_socket_access(),
2910                                          errmsg("select() failed in statistics collector: %m")));
2911                 }
2912
2913                 got_data = FD_ISSET(pgStatSock, &rfds);
2914 #endif   /* HAVE_POLL */
2915 #else                                                   /* WIN32 */
2916                 got_data = pgwin32_waitforsinglesocket(pgStatSock, FD_READ,
2917                                                                                            PGSTAT_SELECT_TIMEOUT * 1000);
2918 #endif
2919
2920                 /*
2921                  * If there is a message on the socket, read it and check for
2922                  * validity.
2923                  */
2924                 if (got_data)
2925                 {
2926                         len = recv(pgStatSock, (char *) &msg,
2927                                            sizeof(PgStat_Msg), 0);
2928                         if (len < 0)
2929                         {
2930                                 if (errno == EINTR)
2931                                         continue;
2932                                 ereport(ERROR,
2933                                                 (errcode_for_socket_access(),
2934                                                  errmsg("could not read statistics message: %m")));
2935                         }
2936
2937                         /*
2938                          * We ignore messages that are smaller than our common header
2939                          */
2940                         if (len < sizeof(PgStat_MsgHdr))
2941                                 continue;
2942
2943                         /*
2944                          * The received length must match the length in the header
2945                          */
2946                         if (msg.msg_hdr.m_size != len)
2947                                 continue;
2948
2949                         /*
2950                          * O.K. - we accept this message.  Process it.
2951                          */
2952                         switch (msg.msg_hdr.m_type)
2953                         {
2954                                 case PGSTAT_MTYPE_DUMMY:
2955                                         break;
2956
2957                                 case PGSTAT_MTYPE_INQUIRY:
2958                                         pgstat_recv_inquiry((PgStat_MsgInquiry *) &msg, len);
2959                                         break;
2960
2961                                 case PGSTAT_MTYPE_TABSTAT:
2962                                         pgstat_recv_tabstat((PgStat_MsgTabstat *) &msg, len);
2963                                         break;
2964
2965                                 case PGSTAT_MTYPE_TABPURGE:
2966                                         pgstat_recv_tabpurge((PgStat_MsgTabpurge *) &msg, len);
2967                                         break;
2968
2969                                 case PGSTAT_MTYPE_DROPDB:
2970                                         pgstat_recv_dropdb((PgStat_MsgDropdb *) &msg, len);
2971                                         break;
2972
2973                                 case PGSTAT_MTYPE_RESETCOUNTER:
2974                                         pgstat_recv_resetcounter((PgStat_MsgResetcounter *) &msg,
2975                                                                                          len);
2976                                         break;
2977
2978                                 case PGSTAT_MTYPE_RESETSHAREDCOUNTER:
2979                                         pgstat_recv_resetsharedcounter(
2980                                                                                          (PgStat_MsgResetsharedcounter *) &msg,
2981                                                                                          len);
2982                                         break;
2983
2984                                 case PGSTAT_MTYPE_RESETSINGLECOUNTER:
2985                                         pgstat_recv_resetsinglecounter(
2986                                                                                          (PgStat_MsgResetsinglecounter *) &msg,
2987                                                                                          len);
2988                                         break;
2989
2990                                 case PGSTAT_MTYPE_AUTOVAC_START:
2991                                         pgstat_recv_autovac((PgStat_MsgAutovacStart *) &msg, len);
2992                                         break;
2993
2994                                 case PGSTAT_MTYPE_VACUUM:
2995                                         pgstat_recv_vacuum((PgStat_MsgVacuum *) &msg, len);
2996                                         break;
2997
2998                                 case PGSTAT_MTYPE_ANALYZE:
2999                                         pgstat_recv_analyze((PgStat_MsgAnalyze *) &msg, len);
3000                                         break;
3001
3002                                 case PGSTAT_MTYPE_BGWRITER:
3003                                         pgstat_recv_bgwriter((PgStat_MsgBgWriter *) &msg, len);
3004                                         break;
3005
3006                                 case PGSTAT_MTYPE_FUNCSTAT:
3007                                         pgstat_recv_funcstat((PgStat_MsgFuncstat *) &msg, len);
3008                                         break;
3009
3010                                 case PGSTAT_MTYPE_FUNCPURGE:
3011                                         pgstat_recv_funcpurge((PgStat_MsgFuncpurge *) &msg, len);
3012                                         break;
3013
3014                                 default:
3015                                         break;
3016                         }
3017                 }
3018                 else
3019                 {
3020                         /*
3021                          * We can only get here if the select/poll timeout elapsed. Check
3022                          * for postmaster death.
3023                          */
3024                         if (!PostmasterIsAlive(true))
3025                                 break;
3026                 }
3027         }                                                       /* end of message-processing loop */
3028
3029         /*
3030          * Save the final stats to reuse at next startup.
3031          */
3032         pgstat_write_statsfile(true);
3033
3034         exit(0);
3035 }
3036
3037
3038 /* SIGQUIT signal handler for collector process */
3039 static void
3040 pgstat_exit(SIGNAL_ARGS)
3041 {
3042         need_exit = true;
3043 }
3044
3045 /* SIGHUP handler for collector process */
3046 static void
3047 pgstat_sighup_handler(SIGNAL_ARGS)
3048 {
3049         got_SIGHUP = true;
3050 }
3051
3052
3053 /*
3054  * Lookup the hash table entry for the specified database. If no hash
3055  * table entry exists, initialize it, if the create parameter is true.
3056  * Else, return NULL.
3057  */
3058 static PgStat_StatDBEntry *
3059 pgstat_get_db_entry(Oid databaseid, bool create)
3060 {
3061         PgStat_StatDBEntry *result;
3062         bool            found;
3063         HASHACTION      action = (create ? HASH_ENTER : HASH_FIND);
3064
3065         /* Lookup or create the hash table entry for this database */
3066         result = (PgStat_StatDBEntry *) hash_search(pgStatDBHash,
3067                                                                                                 &databaseid,
3068                                                                                                 action, &found);
3069
3070         if (!create && !found)
3071                 return NULL;
3072
3073         /* If not found, initialize the new one. */
3074         if (!found)
3075         {
3076                 HASHCTL         hash_ctl;
3077
3078                 result->tables = NULL;
3079                 result->functions = NULL;
3080                 result->n_xact_commit = 0;
3081                 result->n_xact_rollback = 0;
3082                 result->n_blocks_fetched = 0;
3083                 result->n_blocks_hit = 0;
3084                 result->n_tuples_returned = 0;
3085                 result->n_tuples_fetched = 0;
3086                 result->n_tuples_inserted = 0;
3087                 result->n_tuples_updated = 0;
3088                 result->n_tuples_deleted = 0;
3089                 result->last_autovac_time = 0;
3090
3091                 memset(&hash_ctl, 0, sizeof(hash_ctl));
3092                 hash_ctl.keysize = sizeof(Oid);
3093                 hash_ctl.entrysize = sizeof(PgStat_StatTabEntry);
3094                 hash_ctl.hash = oid_hash;
3095                 result->tables = hash_create("Per-database table",
3096                                                                          PGSTAT_TAB_HASH_SIZE,
3097                                                                          &hash_ctl,
3098                                                                          HASH_ELEM | HASH_FUNCTION);
3099
3100                 hash_ctl.keysize = sizeof(Oid);
3101                 hash_ctl.entrysize = sizeof(PgStat_StatFuncEntry);
3102                 hash_ctl.hash = oid_hash;
3103                 result->functions = hash_create("Per-database function",
3104                                                                                 PGSTAT_FUNCTION_HASH_SIZE,
3105                                                                                 &hash_ctl,
3106                                                                                 HASH_ELEM | HASH_FUNCTION);
3107         }
3108
3109         return result;
3110 }
3111
3112
3113 /*
3114  * Lookup the hash table entry for the specified table. If no hash
3115  * table entry exists, initialize it, if the create parameter is true.
3116  * Else, return NULL.
3117  */
3118 static PgStat_StatTabEntry *
3119 pgstat_get_tab_entry(PgStat_StatDBEntry *dbentry, Oid tableoid, bool create)
3120 {
3121         PgStat_StatTabEntry *result;
3122         bool            found;
3123         HASHACTION      action = (create ? HASH_ENTER : HASH_FIND);
3124
3125         /* Lookup or create the hash table entry for this table */
3126         result = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
3127                                                                                                  &tableoid,
3128                                                                                                  action, &found);
3129
3130         if (!create && !found)
3131                 return NULL;
3132
3133         /* If not found, initialize the new one. */
3134         if (!found)
3135         {
3136                 result->numscans = 0;
3137                 result->tuples_returned = 0;
3138                 result->tuples_fetched = 0;
3139                 result->tuples_inserted = 0;
3140                 result->tuples_updated = 0;
3141                 result->tuples_deleted = 0;
3142                 result->tuples_hot_updated = 0;
3143                 result->n_live_tuples = 0;
3144                 result->n_dead_tuples = 0;
3145                 result->changes_since_analyze = 0;
3146                 result->blocks_fetched = 0;
3147                 result->blocks_hit = 0;
3148
3149                 result->vacuum_timestamp = 0;
3150                 result->autovac_vacuum_timestamp = 0;
3151                 result->analyze_timestamp = 0;
3152                 result->autovac_analyze_timestamp = 0;
3153         }
3154
3155         return result;
3156 }
3157
3158
3159 /* ----------
3160  * pgstat_write_statsfile() -
3161  *
3162  *      Tell the news.
3163  *      If writing to the permanent file (happens when the collector is
3164  *      shutting down only), remove the temporary file so that backends
3165  *      starting up under a new postmaster can't read the old data before
3166  *      the new collector is ready.
3167  * ----------
3168  */
3169 static void
3170 pgstat_write_statsfile(bool permanent)
3171 {
3172         HASH_SEQ_STATUS hstat;
3173         HASH_SEQ_STATUS tstat;
3174         HASH_SEQ_STATUS fstat;
3175         PgStat_StatDBEntry *dbentry;
3176         PgStat_StatTabEntry *tabentry;
3177         PgStat_StatFuncEntry *funcentry;
3178         FILE       *fpout;
3179         int32           format_id;
3180         const char *tmpfile = permanent ? PGSTAT_STAT_PERMANENT_TMPFILE : pgstat_stat_tmpname;
3181         const char *statfile = permanent ? PGSTAT_STAT_PERMANENT_FILENAME : pgstat_stat_filename;
3182
3183         /*
3184          * Open the statistics temp file to write out the current values.
3185          */
3186         fpout = AllocateFile(tmpfile, PG_BINARY_W);
3187         if (fpout == NULL)
3188         {
3189                 ereport(LOG,
3190                                 (errcode_for_file_access(),
3191                                  errmsg("could not open temporary statistics file \"%s\": %m",
3192                                                 tmpfile)));
3193                 return;
3194         }
3195
3196         /*
3197          * Set the timestamp of the stats file.
3198          */
3199         globalStats.stats_timestamp = GetCurrentTimestamp();
3200
3201         /*
3202          * Write the file header --- currently just a format ID.
3203          */
3204         format_id = PGSTAT_FILE_FORMAT_ID;
3205         fwrite(&format_id, sizeof(format_id), 1, fpout);
3206
3207         /*
3208          * Write global stats struct
3209          */
3210         fwrite(&globalStats, sizeof(globalStats), 1, fpout);
3211
3212         /*
3213          * Walk through the database table.
3214          */
3215         hash_seq_init(&hstat, pgStatDBHash);
3216         while ((dbentry = (PgStat_StatDBEntry *) hash_seq_search(&hstat)) != NULL)
3217         {
3218                 /*
3219                  * Write out the DB entry including the number of live backends. We
3220                  * don't write the tables or functions pointers, since they're of no
3221                  * use to any other process.
3222                  */
3223                 fputc('D', fpout);
3224                 fwrite(dbentry, offsetof(PgStat_StatDBEntry, tables), 1, fpout);
3225
3226                 /*
3227                  * Walk through the database's access stats per table.
3228                  */
3229                 hash_seq_init(&tstat, dbentry->tables);
3230                 while ((tabentry = (PgStat_StatTabEntry *) hash_seq_search(&tstat)) != NULL)
3231                 {
3232                         fputc('T', fpout);
3233                         fwrite(tabentry, sizeof(PgStat_StatTabEntry), 1, fpout);
3234                 }
3235
3236                 /*
3237                  * Walk through the database's function stats table.
3238                  */
3239                 hash_seq_init(&fstat, dbentry->functions);
3240                 while ((funcentry = (PgStat_StatFuncEntry *) hash_seq_search(&fstat)) != NULL)
3241                 {
3242                         fputc('F', fpout);
3243                         fwrite(funcentry, sizeof(PgStat_StatFuncEntry), 1, fpout);
3244                 }
3245
3246                 /*
3247                  * Mark the end of this DB
3248                  */
3249                 fputc('d', fpout);
3250         }
3251
3252         /*
3253          * No more output to be done. Close the temp file and replace the old
3254          * pgstat.stat with it.  The ferror() check replaces testing for error
3255          * after each individual fputc or fwrite above.
3256          */
3257         fputc('E', fpout);
3258
3259         if (ferror(fpout))
3260         {
3261                 ereport(LOG,
3262                                 (errcode_for_file_access(),
3263                            errmsg("could not write temporary statistics file \"%s\": %m",
3264                                           tmpfile)));
3265                 FreeFile(fpout);
3266                 unlink(tmpfile);
3267         }
3268         else if (FreeFile(fpout) < 0)
3269         {
3270                 ereport(LOG,
3271                                 (errcode_for_file_access(),
3272                            errmsg("could not close temporary statistics file \"%s\": %m",
3273                                           tmpfile)));
3274                 unlink(tmpfile);
3275         }
3276         else if (rename(tmpfile, statfile) < 0)
3277         {
3278                 ereport(LOG,
3279                                 (errcode_for_file_access(),
3280                                  errmsg("could not rename temporary statistics file \"%s\" to \"%s\": %m",
3281                                                 tmpfile, statfile)));
3282                 unlink(tmpfile);
3283         }
3284         else
3285         {
3286                 /*
3287                  * Successful write, so update last_statwrite.
3288                  */
3289                 last_statwrite = globalStats.stats_timestamp;
3290
3291                 /*
3292                  * It's not entirely clear whether there could be clock skew between
3293                  * backends and the collector; but just in case someone manages to
3294                  * send us a stats request time that's far in the future, reset it.
3295                  * This ensures that no inquiry message can cause more than one stats
3296                  * file write to occur.
3297                  */
3298                 last_statrequest = last_statwrite;
3299         }
3300
3301         if (permanent)
3302                 unlink(pgstat_stat_filename);
3303 }
3304
3305
3306 /* ----------
3307  * pgstat_read_statsfile() -
3308  *
3309  *      Reads in an existing statistics collector file and initializes the
3310  *      databases' hash table (whose entries point to the tables' hash tables).
3311  * ----------
3312  */
3313 static HTAB *
3314 pgstat_read_statsfile(Oid onlydb, bool permanent)
3315 {
3316         PgStat_StatDBEntry *dbentry;
3317         PgStat_StatDBEntry dbbuf;
3318         PgStat_StatTabEntry *tabentry;
3319         PgStat_StatTabEntry tabbuf;
3320         PgStat_StatFuncEntry funcbuf;
3321         PgStat_StatFuncEntry *funcentry;
3322         HASHCTL         hash_ctl;
3323         HTAB       *dbhash;
3324         HTAB       *tabhash = NULL;
3325         HTAB       *funchash = NULL;
3326         FILE       *fpin;
3327         int32           format_id;
3328         bool            found;
3329         const char *statfile = permanent ? PGSTAT_STAT_PERMANENT_FILENAME : pgstat_stat_filename;
3330
3331         /*
3332          * The tables will live in pgStatLocalContext.
3333          */
3334         pgstat_setup_memcxt();
3335
3336         /*
3337          * Create the DB hashtable
3338          */
3339         memset(&hash_ctl, 0, sizeof(hash_ctl));
3340         hash_ctl.keysize = sizeof(Oid);
3341         hash_ctl.entrysize = sizeof(PgStat_StatDBEntry);
3342         hash_ctl.hash = oid_hash;
3343         hash_ctl.hcxt = pgStatLocalContext;
3344         dbhash = hash_create("Databases hash", PGSTAT_DB_HASH_SIZE, &hash_ctl,
3345                                                  HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
3346
3347         /*
3348          * Clear out global statistics so they start from zero in case we can't
3349          * load an existing statsfile.
3350          */
3351         memset(&globalStats, 0, sizeof(globalStats));
3352
3353         /*
3354          * Try to open the status file. If it doesn't exist, the backends simply
3355          * return zero for anything and the collector simply starts from scratch
3356          * with empty counters.
3357          */
3358         if ((fpin = AllocateFile(statfile, PG_BINARY_R)) == NULL)
3359                 return dbhash;
3360
3361         /*
3362          * Verify it's of the expected format.
3363          */
3364         if (fread(&format_id, 1, sizeof(format_id), fpin) != sizeof(format_id)
3365                 || format_id != PGSTAT_FILE_FORMAT_ID)
3366         {
3367                 ereport(pgStatRunningInCollector ? LOG : WARNING,
3368                                 (errmsg("corrupted pgstat.stat file")));
3369                 goto done;
3370         }
3371
3372         /*
3373          * Read global stats struct
3374          */
3375         if (fread(&globalStats, 1, sizeof(globalStats), fpin) != sizeof(globalStats))
3376         {
3377                 ereport(pgStatRunningInCollector ? LOG : WARNING,
3378                                 (errmsg("corrupted pgstat.stat file")));
3379                 goto done;
3380         }
3381
3382         /*
3383          * We found an existing collector stats file. Read it and put all the
3384          * hashtable entries into place.
3385          */
3386         for (;;)
3387         {
3388                 switch (fgetc(fpin))
3389                 {
3390                                 /*
3391                                  * 'D'  A PgStat_StatDBEntry struct describing a database
3392                                  * follows. Subsequently, zero to many 'T' and 'F' entries
3393                                  * will follow until a 'd' is encountered.
3394                                  */
3395                         case 'D':
3396                                 if (fread(&dbbuf, 1, offsetof(PgStat_StatDBEntry, tables),
3397                                                   fpin) != offsetof(PgStat_StatDBEntry, tables))
3398                                 {
3399                                         ereport(pgStatRunningInCollector ? LOG : WARNING,
3400                                                         (errmsg("corrupted pgstat.stat file")));
3401                                         goto done;
3402                                 }
3403
3404                                 /*
3405                                  * Add to the DB hash
3406                                  */
3407                                 dbentry = (PgStat_StatDBEntry *) hash_search(dbhash,
3408                                                                                                   (void *) &dbbuf.databaseid,
3409                                                                                                                          HASH_ENTER,
3410                                                                                                                          &found);
3411                                 if (found)
3412                                 {
3413                                         ereport(pgStatRunningInCollector ? LOG : WARNING,
3414                                                         (errmsg("corrupted pgstat.stat file")));
3415                                         goto done;
3416                                 }
3417
3418                                 memcpy(dbentry, &dbbuf, sizeof(PgStat_StatDBEntry));
3419                                 dbentry->tables = NULL;
3420                                 dbentry->functions = NULL;
3421
3422                                 /*
3423                                  * Don't collect tables if not the requested DB (or the
3424                                  * shared-table info)
3425                                  */
3426                                 if (onlydb != InvalidOid)
3427                                 {
3428                                         if (dbbuf.databaseid != onlydb &&
3429                                                 dbbuf.databaseid != InvalidOid)
3430                                                 break;
3431                                 }
3432
3433                                 memset(&hash_ctl, 0, sizeof(hash_ctl));
3434                                 hash_ctl.keysize = sizeof(Oid);
3435                                 hash_ctl.entrysize = sizeof(PgStat_StatTabEntry);
3436                                 hash_ctl.hash = oid_hash;
3437                                 hash_ctl.hcxt = pgStatLocalContext;
3438                                 dbentry->tables = hash_create("Per-database table",
3439                                                                                           PGSTAT_TAB_HASH_SIZE,
3440                                                                                           &hash_ctl,
3441                                                                    HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
3442
3443                                 hash_ctl.keysize = sizeof(Oid);
3444                                 hash_ctl.entrysize = sizeof(PgStat_StatFuncEntry);
3445                                 hash_ctl.hash = oid_hash;
3446                                 hash_ctl.hcxt = pgStatLocalContext;
3447                                 dbentry->functions = hash_create("Per-database function",
3448                                                                                                  PGSTAT_FUNCTION_HASH_SIZE,
3449                                                                                                  &hash_ctl,
3450                                                                    HASH_ELEM | HASH_FUNCTION | HASH_CONTEXT);
3451
3452                                 /*
3453                                  * Arrange that following records add entries to this
3454                                  * database's hash tables.
3455                                  */
3456                                 tabhash = dbentry->tables;
3457                                 funchash = dbentry->functions;
3458                                 break;
3459
3460                                 /*
3461                                  * 'd'  End of this database.
3462                                  */
3463                         case 'd':
3464                                 tabhash = NULL;
3465                                 funchash = NULL;
3466                                 break;
3467
3468                                 /*
3469                                  * 'T'  A PgStat_StatTabEntry follows.
3470                                  */
3471                         case 'T':
3472                                 if (fread(&tabbuf, 1, sizeof(PgStat_StatTabEntry),
3473                                                   fpin) != sizeof(PgStat_StatTabEntry))
3474                                 {
3475                                         ereport(pgStatRunningInCollector ? LOG : WARNING,
3476                                                         (errmsg("corrupted pgstat.stat file")));
3477                                         goto done;
3478                                 }
3479
3480                                 /*
3481                                  * Skip if table belongs to a not requested database.
3482                                  */
3483                                 if (tabhash == NULL)
3484                                         break;
3485
3486                                 tabentry = (PgStat_StatTabEntry *) hash_search(tabhash,
3487                                                                                                         (void *) &tabbuf.tableid,
3488                                                                                                                  HASH_ENTER, &found);
3489
3490                                 if (found)
3491                                 {
3492                                         ereport(pgStatRunningInCollector ? LOG : WARNING,
3493                                                         (errmsg("corrupted pgstat.stat file")));
3494                                         goto done;
3495                                 }
3496
3497                                 memcpy(tabentry, &tabbuf, sizeof(tabbuf));
3498                                 break;
3499
3500                                 /*
3501                                  * 'F'  A PgStat_StatFuncEntry follows.
3502                                  */
3503                         case 'F':
3504                                 if (fread(&funcbuf, 1, sizeof(PgStat_StatFuncEntry),
3505                                                   fpin) != sizeof(PgStat_StatFuncEntry))
3506                                 {
3507                                         ereport(pgStatRunningInCollector ? LOG : WARNING,
3508                                                         (errmsg("corrupted pgstat.stat file")));
3509                                         goto done;
3510                                 }
3511
3512                                 /*
3513                                  * Skip if function belongs to a not requested database.
3514                                  */
3515                                 if (funchash == NULL)
3516                                         break;
3517
3518                                 funcentry = (PgStat_StatFuncEntry *) hash_search(funchash,
3519                                                                                                 (void *) &funcbuf.functionid,
3520                                                                                                                  HASH_ENTER, &found);
3521
3522                                 if (found)
3523                                 {
3524                                         ereport(pgStatRunningInCollector ? LOG : WARNING,
3525                                                         (errmsg("corrupted pgstat.stat file")));
3526                                         goto done;
3527                                 }
3528
3529                                 memcpy(funcentry, &funcbuf, sizeof(funcbuf));
3530                                 break;
3531
3532                                 /*
3533                                  * 'E'  The EOF marker of a complete stats file.
3534                                  */
3535                         case 'E':
3536                                 goto done;
3537
3538                         default:
3539                                 ereport(pgStatRunningInCollector ? LOG : WARNING,
3540                                                 (errmsg("corrupted pgstat.stat file")));
3541                                 goto done;
3542                 }
3543         }
3544
3545 done:
3546         FreeFile(fpin);
3547
3548         if (permanent)
3549                 unlink(PGSTAT_STAT_PERMANENT_FILENAME);
3550
3551         return dbhash;
3552 }
3553
3554 /* ----------
3555  * pgstat_read_statsfile_timestamp() -
3556  *
3557  *      Attempt to fetch the timestamp of an existing stats file.
3558  *      Returns TRUE if successful (timestamp is stored at *ts).
3559  * ----------
3560  */
3561 static bool
3562 pgstat_read_statsfile_timestamp(bool permanent, TimestampTz *ts)
3563 {
3564         PgStat_GlobalStats myGlobalStats;
3565         FILE       *fpin;
3566         int32           format_id;
3567         const char *statfile = permanent ? PGSTAT_STAT_PERMANENT_FILENAME : pgstat_stat_filename;
3568
3569         /*
3570          * Try to open the status file.
3571          */
3572         if ((fpin = AllocateFile(statfile, PG_BINARY_R)) == NULL)
3573                 return false;
3574
3575         /*
3576          * Verify it's of the expected format.
3577          */
3578         if (fread(&format_id, 1, sizeof(format_id), fpin) != sizeof(format_id)
3579                 || format_id != PGSTAT_FILE_FORMAT_ID)
3580         {
3581                 FreeFile(fpin);
3582                 return false;
3583         }
3584
3585         /*
3586          * Read global stats struct
3587          */
3588         if (fread(&myGlobalStats, 1, sizeof(myGlobalStats), fpin) != sizeof(myGlobalStats))
3589         {
3590                 FreeFile(fpin);
3591                 return false;
3592         }
3593
3594         *ts = myGlobalStats.stats_timestamp;
3595
3596         FreeFile(fpin);
3597         return true;
3598 }
3599
3600 /*
3601  * If not already done, read the statistics collector stats file into
3602  * some hash tables.  The results will be kept until pgstat_clear_snapshot()
3603  * is called (typically, at end of transaction).
3604  */
3605 static void
3606 backend_read_statsfile(void)
3607 {
3608         TimestampTz min_ts;
3609         int                     count;
3610
3611         /* already read it? */
3612         if (pgStatDBHash)
3613                 return;
3614         Assert(!pgStatRunningInCollector);
3615
3616         /*
3617          * We set the minimum acceptable timestamp to PGSTAT_STAT_INTERVAL msec
3618          * before now.  This indirectly ensures that the collector needn't write
3619          * the file more often than PGSTAT_STAT_INTERVAL.  In an autovacuum
3620          * worker, however, we want a lower delay to avoid using stale data, so we
3621          * use PGSTAT_RETRY_DELAY (since the number of worker is low, this
3622          * shouldn't be a problem).
3623          *
3624          * Note that we don't recompute min_ts after sleeping; so we might end up
3625          * accepting a file a bit older than PGSTAT_STAT_INTERVAL.      In practice
3626          * that shouldn't happen, though, as long as the sleep time is less than
3627          * PGSTAT_STAT_INTERVAL; and we don't want to lie to the collector about
3628          * what our cutoff time really is.
3629          */
3630         if (IsAutoVacuumWorkerProcess())
3631                 min_ts = TimestampTzPlusMilliseconds(GetCurrentTimestamp(),
3632                                                                                          -PGSTAT_RETRY_DELAY);
3633         else
3634                 min_ts = TimestampTzPlusMilliseconds(GetCurrentTimestamp(),
3635                                                                                          -PGSTAT_STAT_INTERVAL);
3636
3637         /*
3638          * Loop until fresh enough stats file is available or we ran out of time.
3639          * The stats inquiry message is sent repeatedly in case collector drops
3640          * it.
3641          */
3642         for (count = 0; count < PGSTAT_POLL_LOOP_COUNT; count++)
3643         {
3644                 TimestampTz file_ts = 0;
3645
3646                 CHECK_FOR_INTERRUPTS();
3647
3648                 if (pgstat_read_statsfile_timestamp(false, &file_ts) &&
3649                         file_ts >= min_ts)
3650                         break;
3651
3652                 /* Not there or too old, so kick the collector and wait a bit */
3653                 pgstat_send_inquiry(min_ts);
3654                 pg_usleep(PGSTAT_RETRY_DELAY * 1000L);
3655         }
3656
3657         if (count >= PGSTAT_POLL_LOOP_COUNT)
3658                 elog(WARNING, "pgstat wait timeout");
3659
3660         /* Autovacuum launcher wants stats about all databases */
3661         if (IsAutoVacuumLauncherProcess())
3662                 pgStatDBHash = pgstat_read_statsfile(InvalidOid, false);
3663         else
3664                 pgStatDBHash = pgstat_read_statsfile(MyDatabaseId, false);
3665 }
3666
3667
3668 /* ----------
3669  * pgstat_setup_memcxt() -
3670  *
3671  *      Create pgStatLocalContext, if not already done.
3672  * ----------
3673  */
3674 static void
3675 pgstat_setup_memcxt(void)
3676 {
3677         if (!pgStatLocalContext)
3678                 pgStatLocalContext = AllocSetContextCreate(TopMemoryContext,
3679                                                                                                    "Statistics snapshot",
3680                                                                                                    ALLOCSET_SMALL_MINSIZE,
3681                                                                                                    ALLOCSET_SMALL_INITSIZE,
3682                                                                                                    ALLOCSET_SMALL_MAXSIZE);
3683 }
3684
3685
3686 /* ----------
3687  * pgstat_clear_snapshot() -
3688  *
3689  *      Discard any data collected in the current transaction.  Any subsequent
3690  *      request will cause new snapshots to be read.
3691  *
3692  *      This is also invoked during transaction commit or abort to discard
3693  *      the no-longer-wanted snapshot.
3694  * ----------
3695  */
3696 void
3697 pgstat_clear_snapshot(void)
3698 {
3699         /* Release memory, if any was allocated */
3700         if (pgStatLocalContext)
3701                 MemoryContextDelete(pgStatLocalContext);
3702
3703         /* Reset variables */
3704         pgStatLocalContext = NULL;
3705         pgStatDBHash = NULL;
3706         localBackendStatusTable = NULL;
3707         localNumBackends = 0;
3708 }
3709
3710
3711 /* ----------
3712  * pgstat_recv_inquiry() -
3713  *
3714  *      Process stat inquiry requests.
3715  * ----------
3716  */
3717 static void
3718 pgstat_recv_inquiry(PgStat_MsgInquiry *msg, int len)
3719 {
3720         if (msg->inquiry_time > last_statrequest)
3721                 last_statrequest = msg->inquiry_time;
3722 }
3723
3724
3725 /* ----------
3726  * pgstat_recv_tabstat() -
3727  *
3728  *      Count what the backend has done.
3729  * ----------
3730  */
3731 static void
3732 pgstat_recv_tabstat(PgStat_MsgTabstat *msg, int len)
3733 {
3734         PgStat_StatDBEntry *dbentry;
3735         PgStat_StatTabEntry *tabentry;
3736         int                     i;
3737         bool            found;
3738
3739         dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
3740
3741         /*
3742          * Update database-wide stats.
3743          */
3744         dbentry->n_xact_commit += (PgStat_Counter) (msg->m_xact_commit);
3745         dbentry->n_xact_rollback += (PgStat_Counter) (msg->m_xact_rollback);
3746
3747         /*
3748          * Process all table entries in the message.
3749          */
3750         for (i = 0; i < msg->m_nentries; i++)
3751         {
3752                 PgStat_TableEntry *tabmsg = &(msg->m_entry[i]);
3753
3754                 tabentry = (PgStat_StatTabEntry *) hash_search(dbentry->tables,
3755                                                                                                            (void *) &(tabmsg->t_id),
3756                                                                                                            HASH_ENTER, &found);
3757
3758                 if (!found)
3759                 {
3760                         /*
3761                          * If it's a new table entry, initialize counters to the values we
3762                          * just got.
3763                          */
3764                         tabentry->numscans = tabmsg->t_counts.t_numscans;
3765                         tabentry->tuples_returned = tabmsg->t_counts.t_tuples_returned;
3766                         tabentry->tuples_fetched = tabmsg->t_counts.t_tuples_fetched;
3767                         tabentry->tuples_inserted = tabmsg->t_counts.t_tuples_inserted;
3768                         tabentry->tuples_updated = tabmsg->t_counts.t_tuples_updated;
3769                         tabentry->tuples_deleted = tabmsg->t_counts.t_tuples_deleted;
3770                         tabentry->tuples_hot_updated = tabmsg->t_counts.t_tuples_hot_updated;
3771                         tabentry->n_live_tuples = tabmsg->t_counts.t_delta_live_tuples;
3772                         tabentry->n_dead_tuples = tabmsg->t_counts.t_delta_dead_tuples;
3773                         tabentry->changes_since_analyze = tabmsg->t_counts.t_changed_tuples;
3774                         tabentry->blocks_fetched = tabmsg->t_counts.t_blocks_fetched;
3775                         tabentry->blocks_hit = tabmsg->t_counts.t_blocks_hit;
3776
3777                         tabentry->vacuum_timestamp = 0;
3778                         tabentry->autovac_vacuum_timestamp = 0;
3779                         tabentry->analyze_timestamp = 0;
3780                         tabentry->autovac_analyze_timestamp = 0;
3781                 }
3782                 else
3783                 {
3784                         /*
3785                          * Otherwise add the values to the existing entry.
3786                          */
3787                         tabentry->numscans += tabmsg->t_counts.t_numscans;
3788                         tabentry->tuples_returned += tabmsg->t_counts.t_tuples_returned;
3789                         tabentry->tuples_fetched += tabmsg->t_counts.t_tuples_fetched;
3790                         tabentry->tuples_inserted += tabmsg->t_counts.t_tuples_inserted;
3791                         tabentry->tuples_updated += tabmsg->t_counts.t_tuples_updated;
3792                         tabentry->tuples_deleted += tabmsg->t_counts.t_tuples_deleted;
3793                         tabentry->tuples_hot_updated += tabmsg->t_counts.t_tuples_hot_updated;
3794                         tabentry->n_live_tuples += tabmsg->t_counts.t_delta_live_tuples;
3795                         tabentry->n_dead_tuples += tabmsg->t_counts.t_delta_dead_tuples;
3796                         tabentry->changes_since_analyze += tabmsg->t_counts.t_changed_tuples;
3797                         tabentry->blocks_fetched += tabmsg->t_counts.t_blocks_fetched;
3798                         tabentry->blocks_hit += tabmsg->t_counts.t_blocks_hit;
3799                 }
3800
3801                 /* Clamp n_live_tuples in case of negative delta_live_tuples */
3802                 tabentry->n_live_tuples = Max(tabentry->n_live_tuples, 0);
3803                 /* Likewise for n_dead_tuples */
3804                 tabentry->n_dead_tuples = Max(tabentry->n_dead_tuples, 0);
3805
3806                 /*
3807                  * Add per-table stats to the per-database entry, too.
3808                  */
3809                 dbentry->n_tuples_returned += tabmsg->t_counts.t_tuples_returned;
3810                 dbentry->n_tuples_fetched += tabmsg->t_counts.t_tuples_fetched;
3811                 dbentry->n_tuples_inserted += tabmsg->t_counts.t_tuples_inserted;
3812                 dbentry->n_tuples_updated += tabmsg->t_counts.t_tuples_updated;
3813                 dbentry->n_tuples_deleted += tabmsg->t_counts.t_tuples_deleted;
3814                 dbentry->n_blocks_fetched += tabmsg->t_counts.t_blocks_fetched;
3815                 dbentry->n_blocks_hit += tabmsg->t_counts.t_blocks_hit;
3816         }
3817 }
3818
3819
3820 /* ----------
3821  * pgstat_recv_tabpurge() -
3822  *
3823  *      Arrange for dead table removal.
3824  * ----------
3825  */
3826 static void
3827 pgstat_recv_tabpurge(PgStat_MsgTabpurge *msg, int len)
3828 {
3829         PgStat_StatDBEntry *dbentry;
3830         int                     i;
3831
3832         dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
3833
3834         /*
3835          * No need to purge if we don't even know the database.
3836          */
3837         if (!dbentry || !dbentry->tables)
3838                 return;
3839
3840         /*
3841          * Process all table entries in the message.
3842          */
3843         for (i = 0; i < msg->m_nentries; i++)
3844         {
3845                 /* Remove from hashtable if present; we don't care if it's not. */
3846                 (void) hash_search(dbentry->tables,
3847                                                    (void *) &(msg->m_tableid[i]),
3848                                                    HASH_REMOVE, NULL);
3849         }
3850 }
3851
3852
3853 /* ----------
3854  * pgstat_recv_dropdb() -
3855  *
3856  *      Arrange for dead database removal
3857  * ----------
3858  */
3859 static void
3860 pgstat_recv_dropdb(PgStat_MsgDropdb *msg, int len)
3861 {
3862         PgStat_StatDBEntry *dbentry;
3863
3864         /*
3865          * Lookup the database in the hashtable.
3866          */
3867         dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
3868
3869         /*
3870          * If found, remove it.
3871          */
3872         if (dbentry)
3873         {
3874                 if (dbentry->tables != NULL)
3875                         hash_destroy(dbentry->tables);
3876                 if (dbentry->functions != NULL)
3877                         hash_destroy(dbentry->functions);
3878
3879                 if (hash_search(pgStatDBHash,
3880                                                 (void *) &(dbentry->databaseid),
3881                                                 HASH_REMOVE, NULL) == NULL)
3882                         ereport(ERROR,
3883                                         (errmsg("database hash table corrupted "
3884                                                         "during cleanup --- abort")));
3885         }
3886 }
3887
3888
3889 /* ----------
3890  * pgstat_recv_resetcounter() -
3891  *
3892  *      Reset the statistics for the specified database.
3893  * ----------
3894  */
3895 static void
3896 pgstat_recv_resetcounter(PgStat_MsgResetcounter *msg, int len)
3897 {
3898         HASHCTL         hash_ctl;
3899         PgStat_StatDBEntry *dbentry;
3900
3901         /*
3902          * Lookup the database in the hashtable.  Nothing to do if not there.
3903          */
3904         dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
3905
3906         if (!dbentry)
3907                 return;
3908
3909         /*
3910          * We simply throw away all the database's table entries by recreating a
3911          * new hash table for them.
3912          */
3913         if (dbentry->tables != NULL)
3914                 hash_destroy(dbentry->tables);
3915         if (dbentry->functions != NULL)
3916                 hash_destroy(dbentry->functions);
3917
3918         dbentry->tables = NULL;
3919         dbentry->functions = NULL;
3920         dbentry->n_xact_commit = 0;
3921         dbentry->n_xact_rollback = 0;
3922         dbentry->n_blocks_fetched = 0;
3923         dbentry->n_blocks_hit = 0;
3924
3925         memset(&hash_ctl, 0, sizeof(hash_ctl));
3926         hash_ctl.keysize = sizeof(Oid);
3927         hash_ctl.entrysize = sizeof(PgStat_StatTabEntry);
3928         hash_ctl.hash = oid_hash;
3929         dbentry->tables = hash_create("Per-database table",
3930                                                                   PGSTAT_TAB_HASH_SIZE,
3931                                                                   &hash_ctl,
3932                                                                   HASH_ELEM | HASH_FUNCTION);
3933
3934         hash_ctl.keysize = sizeof(Oid);
3935         hash_ctl.entrysize = sizeof(PgStat_StatFuncEntry);
3936         hash_ctl.hash = oid_hash;
3937         dbentry->functions = hash_create("Per-database function",
3938                                                                          PGSTAT_FUNCTION_HASH_SIZE,
3939                                                                          &hash_ctl,
3940                                                                          HASH_ELEM | HASH_FUNCTION);
3941 }
3942
3943 /* ----------
3944  * pgstat_recv_resetshared() -
3945  *
3946  *      Reset some shared statistics of the cluster.
3947  * ----------
3948  */
3949 static void
3950 pgstat_recv_resetsharedcounter(PgStat_MsgResetsharedcounter *msg, int len)
3951 {
3952     if (msg->m_resettarget==RESET_BGWRITER)
3953         {
3954                 /* Reset the global background writer statistics for the cluster. */
3955                 memset(&globalStats, 0, sizeof(globalStats));
3956         }
3957
3958         /*
3959          * Presumably the sender of this message validated the target, don't
3960          * complain here if it's not valid
3961          */
3962 }
3963
3964 /* ----------
3965  * pgstat_recv_resetsinglecounter() -
3966  *
3967  *      Reset a statistics for a single object
3968  * ----------
3969  */
3970 static void
3971 pgstat_recv_resetsinglecounter(PgStat_MsgResetsinglecounter *msg, int len)
3972 {
3973         PgStat_StatDBEntry *dbentry;
3974
3975         dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
3976
3977         if (!dbentry)
3978                 return;
3979
3980
3981         /* Remove object if it exists, ignore it if not */
3982         if (msg->m_resettype == RESET_TABLE)
3983                 (void) hash_search(dbentry->tables, (void *) &(msg->m_objectid), HASH_REMOVE, NULL);
3984         else if (msg->m_resettype == RESET_FUNCTION)
3985                 (void) hash_search(dbentry->functions, (void *)&(msg->m_objectid), HASH_REMOVE, NULL);
3986 }
3987
3988 /* ----------
3989  * pgstat_recv_autovac() -
3990  *
3991  *      Process an autovacuum signalling message.
3992  * ----------
3993  */
3994 static void
3995 pgstat_recv_autovac(PgStat_MsgAutovacStart *msg, int len)
3996 {
3997         PgStat_StatDBEntry *dbentry;
3998
3999         /*
4000          * Store the last autovacuum time in the database's hashtable entry.
4001          */
4002         dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
4003
4004         dbentry->last_autovac_time = msg->m_start_time;
4005 }
4006
4007 /* ----------
4008  * pgstat_recv_vacuum() -
4009  *
4010  *      Process a VACUUM message.
4011  * ----------
4012  */
4013 static void
4014 pgstat_recv_vacuum(PgStat_MsgVacuum *msg, int len)
4015 {
4016         PgStat_StatDBEntry *dbentry;
4017         PgStat_StatTabEntry *tabentry;
4018
4019         /*
4020          * Store the data in the table's hashtable entry.
4021          */
4022         dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
4023
4024         tabentry = pgstat_get_tab_entry(dbentry, msg->m_tableoid, true);
4025
4026         if (msg->m_adopt_counts)
4027                 tabentry->n_live_tuples = msg->m_tuples;
4028         /* Resetting dead_tuples to 0 is an approximation ... */
4029         tabentry->n_dead_tuples = 0;
4030
4031         if (msg->m_autovacuum)
4032                 tabentry->autovac_vacuum_timestamp = msg->m_vacuumtime;
4033         else
4034                 tabentry->vacuum_timestamp = msg->m_vacuumtime;
4035 }
4036
4037 /* ----------
4038  * pgstat_recv_analyze() -
4039  *
4040  *      Process an ANALYZE message.
4041  * ----------
4042  */
4043 static void
4044 pgstat_recv_analyze(PgStat_MsgAnalyze *msg, int len)
4045 {
4046         PgStat_StatDBEntry *dbentry;
4047         PgStat_StatTabEntry *tabentry;
4048
4049         /*
4050          * Store the data in the table's hashtable entry.
4051          */
4052         dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
4053
4054         tabentry = pgstat_get_tab_entry(dbentry, msg->m_tableoid, true);
4055
4056         if (msg->m_adopt_counts)
4057         {
4058                 tabentry->n_live_tuples = msg->m_live_tuples;
4059                 tabentry->n_dead_tuples = msg->m_dead_tuples;
4060         }
4061
4062         /*
4063          * We reset changes_since_analyze to zero, forgetting any changes that
4064          * occurred while the ANALYZE was in progress.
4065          */
4066         tabentry->changes_since_analyze = 0;
4067
4068         if (msg->m_autovacuum)
4069                 tabentry->autovac_analyze_timestamp = msg->m_analyzetime;
4070         else
4071                 tabentry->analyze_timestamp = msg->m_analyzetime;
4072 }
4073
4074
4075 /* ----------
4076  * pgstat_recv_bgwriter() -
4077  *
4078  *      Process a BGWRITER message.
4079  * ----------
4080  */
4081 static void
4082 pgstat_recv_bgwriter(PgStat_MsgBgWriter *msg, int len)
4083 {
4084         globalStats.timed_checkpoints += msg->m_timed_checkpoints;
4085         globalStats.requested_checkpoints += msg->m_requested_checkpoints;
4086         globalStats.buf_written_checkpoints += msg->m_buf_written_checkpoints;
4087         globalStats.buf_written_clean += msg->m_buf_written_clean;
4088         globalStats.maxwritten_clean += msg->m_maxwritten_clean;
4089         globalStats.buf_written_backend += msg->m_buf_written_backend;
4090         globalStats.buf_alloc += msg->m_buf_alloc;
4091 }
4092
4093 /* ----------
4094  * pgstat_recv_funcstat() -
4095  *
4096  *      Count what the backend has done.
4097  * ----------
4098  */
4099 static void
4100 pgstat_recv_funcstat(PgStat_MsgFuncstat *msg, int len)
4101 {
4102         PgStat_FunctionEntry *funcmsg = &(msg->m_entry[0]);
4103         PgStat_StatDBEntry *dbentry;
4104         PgStat_StatFuncEntry *funcentry;
4105         int                     i;
4106         bool            found;
4107
4108         dbentry = pgstat_get_db_entry(msg->m_databaseid, true);
4109
4110         /*
4111          * Process all function entries in the message.
4112          */
4113         for (i = 0; i < msg->m_nentries; i++, funcmsg++)
4114         {
4115                 funcentry = (PgStat_StatFuncEntry *) hash_search(dbentry->functions,
4116                                                                                                    (void *) &(funcmsg->f_id),
4117                                                                                                                  HASH_ENTER, &found);
4118
4119                 if (!found)
4120                 {
4121                         /*
4122                          * If it's a new function entry, initialize counters to the values
4123                          * we just got.
4124                          */
4125                         funcentry->f_numcalls = funcmsg->f_numcalls;
4126                         funcentry->f_time = funcmsg->f_time;
4127                         funcentry->f_time_self = funcmsg->f_time_self;
4128                 }
4129                 else
4130                 {
4131                         /*
4132                          * Otherwise add the values to the existing entry.
4133                          */
4134                         funcentry->f_numcalls += funcmsg->f_numcalls;
4135                         funcentry->f_time += funcmsg->f_time;
4136                         funcentry->f_time_self += funcmsg->f_time_self;
4137                 }
4138         }
4139 }
4140
4141 /* ----------
4142  * pgstat_recv_funcpurge() -
4143  *
4144  *      Arrange for dead function removal.
4145  * ----------
4146  */
4147 static void
4148 pgstat_recv_funcpurge(PgStat_MsgFuncpurge *msg, int len)
4149 {
4150         PgStat_StatDBEntry *dbentry;
4151         int                     i;
4152
4153         dbentry = pgstat_get_db_entry(msg->m_databaseid, false);
4154
4155         /*
4156          * No need to purge if we don't even know the database.
4157          */
4158         if (!dbentry || !dbentry->functions)
4159                 return;
4160
4161         /*
4162          * Process all function entries in the message.
4163          */
4164         for (i = 0; i < msg->m_nentries; i++)
4165         {
4166                 /* Remove from hashtable if present; we don't care if it's not. */
4167                 (void) hash_search(dbentry->functions,
4168                                                    (void *) &(msg->m_functionid[i]),
4169                                                    HASH_REMOVE, NULL);
4170         }
4171 }