pid_t wd_hb_receiver(int fork_wait_time, WdHbIf hb_if)
{
int sock;
pid_t pid = 0;
WdHbPacket pkt;
struct timeval tv;
char from[WD_MAX_HOST_NAMELEN];
char buf[(MD5_PASSWD_LEN+1)*2];
char pack_str[WD_MAX_PACKET_STRING];
int pack_str_len;
WdInfo * p;
pid = fork();
if (pid != 0)
{
if (pid == -1)
pool_error("wd_hb_receiver: fork() failed.");
return pid;
}
if (fork_wait_time > 0)
{
sleep(fork_wait_time);
}
myargv = save_ps_display_args(myargc, myargv);
POOL_SETMASK(&UnBlockSig);
signal(SIGTERM, hb_receiver_exit);
signal(SIGINT, hb_receiver_exit);
signal(SIGQUIT, hb_receiver_exit);
signal(SIGCHLD, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGALRM, SIG_IGN);
init_ps_display("", "", "", "");
if ( (sock = wd_create_hb_recv_socket(hb_if)) < 0)
{
pool_error("wd_hb_receiver: socket create failed");
hb_receiver_exit(SIGTERM);
}
set_ps_display("heartbeat receiver", false);
for(;;)
{
if (wd_hb_recv(sock, &pkt) == WD_OK)
{
/* authentication */
if (strlen(pool_config->wd_authkey))
{
/* calculate hash from packet */
pack_str_len = packet_to_string_hb(pkt, pack_str, sizeof(pack_str));
wd_calc_hash(pack_str, pack_str_len, buf);
if (strcmp(pkt.hash, buf))
{
pool_log("wd_hb_receiver: authentication failed");
continue;
}
}
/* get current time */
gettimeofday(&tv, NULL);
/* who send this packet? */
strlcpy(from, pkt.from, sizeof(from));
p = WD_List;
while (p->status != WD_END)
{
if (!strcmp(p->hostname, from))
{
/* this is the first packet or the latest packet */
if (!WD_TIME_ISSET(p->hb_send_time) ||
WD_TIME_BEFORE(p->hb_send_time, pkt.send_time))
{
pool_debug("wd_hb_receiver: received heartbeat signal from %s", from);
p->hb_send_time = pkt.send_time;
p->hb_last_recv_time = tv;
}
break;
}
p++;
}
}
}
return pid;
}
pid_t wd_hb_sender(int fork_wait_time, WdHbIf hb_if)
{
int sock;
pid_t pid = 0;
WdHbPacket pkt;
WdInfo * p = WD_List;
char pack_str[WD_MAX_PACKET_STRING];
int pack_str_len;
pid = fork();
if (pid != 0)
{
if (pid == -1)
pool_error("wd_hb_sender: fork() failed.");
return pid;
}
if (fork_wait_time > 0)
{
sleep(fork_wait_time);
}
myargv = save_ps_display_args(myargc, myargv);
POOL_SETMASK(&UnBlockSig);
signal(SIGTERM, hb_sender_exit);
signal(SIGINT, hb_sender_exit);
signal(SIGQUIT, hb_sender_exit);
signal(SIGCHLD, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGALRM, SIG_IGN);
init_ps_display("", "", "", "");
if ( (sock = wd_create_hb_send_socket(hb_if)) < 0)
{
pool_error("wd_hb_sender: socket create failed");
hb_sender_exit(SIGTERM);
}
set_ps_display("heartbeat sender", false);
for(;;)
{
gettimeofday(&pkt.send_time, NULL);
strlcpy(pkt.from, pool_config->wd_hostname, sizeof(pkt.from));
pkt.status = p->status;
if (strlen(pool_config->wd_authkey))
{
/* calculate hash from packet */
pack_str_len = packet_to_string_hb(pkt, pack_str, sizeof(pack_str));
wd_calc_hash(pack_str, pack_str_len, pkt.hash);
}
wd_hb_send(sock, &pkt, sizeof(pkt), hb_if.addr);
pool_debug("wd_hb_sender: send heartbeat signal to %s", hb_if.addr);
sleep(pool_config->wd_heartbeat_keepalive);
}
return pid;
}
/*
* Main entry point for syslogger process
* argc/argv parameters are valid only in EXEC_BACKEND case.
*/
NON_EXEC_STATIC void
SysLoggerMain(int argc, char *argv[])
{
#ifndef WIN32
char logbuffer[READ_BUF_SIZE];
int bytes_in_logbuffer = 0;
#endif
char *currentLogDir;
char *currentLogFilename;
int currentLogRotationAge;
pg_time_t now;
now = MyStartTime;
#ifdef EXEC_BACKEND
syslogger_parseArgs(argc, argv);
#endif /* EXEC_BACKEND */
am_syslogger = true;
init_ps_display("logger process", "", "", "");
/*
* If we restarted, our stderr is already redirected into our own input
* pipe. This is of course pretty useless, not to mention that it
* interferes with detecting pipe EOF. Point stderr to /dev/null. This
* assumes that all interesting messages generated in the syslogger will
* come through elog.c and will be sent to write_syslogger_file.
*/
if (redirection_done)
{
int fd = open(DEVNULL, O_WRONLY, 0);
/*
* The closes might look redundant, but they are not: we want to be
* darn sure the pipe gets closed even if the open failed. We can
* survive running with stderr pointing nowhere, but we can't afford
* to have extra pipe input descriptors hanging around.
*
* As we're just trying to reset these to go to DEVNULL, there's not
* much point in checking for failure from the close/dup2 calls here,
* if they fail then presumably the file descriptors are closed and
* any writes will go into the bitbucket anyway.
*/
close(fileno(stdout));
close(fileno(stderr));
if (fd != -1)
{
(void) dup2(fd, fileno(stdout));
(void) dup2(fd, fileno(stderr));
close(fd);
}
}
/*
* Syslogger's own stderr can't be the syslogPipe, so set it back to text
* mode if we didn't just close it. (It was set to binary in
* SubPostmasterMain).
*/
#ifdef WIN32
else
_setmode(_fileno(stderr), _O_TEXT);
#endif
/*
* Also close our copy of the write end of the pipe. This is needed to
* ensure we can detect pipe EOF correctly. (But note that in the restart
* case, the postmaster already did this.)
*/
#ifndef WIN32
if (syslogPipe[1] >= 0)
close(syslogPipe[1]);
syslogPipe[1] = -1;
#else
if (syslogPipe[1])
CloseHandle(syslogPipe[1]);
syslogPipe[1] = 0;
#endif
/*
* Properly accept or ignore signals the postmaster might send us
*
* Note: we ignore all termination signals, and instead exit only when all
* upstream processes are gone, to ensure we don't miss any dying gasps of
* broken backends...
*/
pqsignal(SIGHUP, sigHupHandler); /* set flag to read config file */
pqsignal(SIGINT, SIG_IGN);
pqsignal(SIGTERM, SIG_IGN);
pqsignal(SIGQUIT, SIG_IGN);
pqsignal(SIGALRM, SIG_IGN);
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, sigUsr1Handler); /* request log rotation */
pqsignal(SIGUSR2, SIG_IGN);
/*
* Reset some signals that are accepted by postmaster but not here
*/
pqsignal(SIGCHLD, SIG_DFL);
pqsignal(SIGTTIN, SIG_DFL);
pqsignal(SIGTTOU, SIG_DFL);
pqsignal(SIGCONT, SIG_DFL);
pqsignal(SIGWINCH, SIG_DFL);
PG_SETMASK(&UnBlockSig);
#ifdef WIN32
/* Fire up separate data transfer thread */
InitializeCriticalSection(&sysloggerSection);
EnterCriticalSection(&sysloggerSection);
threadHandle = (HANDLE) _beginthreadex(NULL, 0, pipeThread, NULL, 0, NULL);
if (threadHandle == 0)
elog(FATAL, "could not create syslogger data transfer thread: %m");
#endif /* WIN32 */
/*
* Remember active logfile's name. We recompute this from the reference
* time because passing down just the pg_time_t is a lot cheaper than
* passing a whole file path in the EXEC_BACKEND case.
*/
last_file_name = logfile_getname(first_syslogger_file_time, NULL);
/* remember active logfile parameters */
currentLogDir = pstrdup(Log_directory);
currentLogFilename = pstrdup(Log_filename);
currentLogRotationAge = Log_RotationAge;
/* set next planned rotation time */
set_next_rotation_time();
/* main worker loop */
for (;;)
{
bool time_based_rotation = false;
int size_rotation_for = 0;
long cur_timeout;
int cur_flags;
#ifndef WIN32
int rc;
#endif
/* Clear any already-pending wakeups */
ResetLatch(MyLatch);
/*
* Process any requests or signals received recently.
*/
if (got_SIGHUP)
{
got_SIGHUP = false;
ProcessConfigFile(PGC_SIGHUP);
/*
* Check if the log directory or filename pattern changed in
* postgresql.conf. If so, force rotation to make sure we're
* writing the logfiles in the right place.
*/
if (strcmp(Log_directory, currentLogDir) != 0)
{
pfree(currentLogDir);
currentLogDir = pstrdup(Log_directory);
rotation_requested = true;
/*
* Also, create new directory if not present; ignore errors
*/
mkdir(Log_directory, S_IRWXU);
}
if (strcmp(Log_filename, currentLogFilename) != 0)
{
pfree(currentLogFilename);
currentLogFilename = pstrdup(Log_filename);
rotation_requested = true;
}
/*
* If rotation time parameter changed, reset next rotation time,
* but don't immediately force a rotation.
*/
if (currentLogRotationAge != Log_RotationAge)
{
currentLogRotationAge = Log_RotationAge;
set_next_rotation_time();
}
/*
* If we had a rotation-disabling failure, re-enable rotation
* attempts after SIGHUP, and force one immediately.
*/
if (rotation_disabled)
{
rotation_disabled = false;
rotation_requested = true;
}
}
if (Log_RotationAge > 0 && !rotation_disabled)
{
/* Do a logfile rotation if it's time */
now = (pg_time_t) time(NULL);
if (now >= next_rotation_time)
rotation_requested = time_based_rotation = true;
}
if (!rotation_requested && Log_RotationSize > 0 && !rotation_disabled)
{
/* Do a rotation if file is too big */
if (ftell(syslogFile) >= Log_RotationSize * 1024L)
{
rotation_requested = true;
size_rotation_for |= LOG_DESTINATION_STDERR;
}
if (csvlogFile != NULL &&
ftell(csvlogFile) >= Log_RotationSize * 1024L)
{
rotation_requested = true;
size_rotation_for |= LOG_DESTINATION_CSVLOG;
}
}
if (rotation_requested)
{
/*
* Force rotation when both values are zero. It means the request
* was sent by pg_rotate_logfile.
*/
if (!time_based_rotation && size_rotation_for == 0)
size_rotation_for = LOG_DESTINATION_STDERR | LOG_DESTINATION_CSVLOG;
logfile_rotate(time_based_rotation, size_rotation_for);
}
/*
* Calculate time till next time-based rotation, so that we don't
* sleep longer than that. We assume the value of "now" obtained
* above is still close enough. Note we can't make this calculation
* until after calling logfile_rotate(), since it will advance
* next_rotation_time.
*
* Also note that we need to beware of overflow in calculation of the
* timeout: with large settings of Log_RotationAge, next_rotation_time
* could be more than INT_MAX msec in the future. In that case we'll
* wait no more than INT_MAX msec, and try again.
*/
if (Log_RotationAge > 0 && !rotation_disabled)
{
pg_time_t delay;
delay = next_rotation_time - now;
if (delay > 0)
{
if (delay > INT_MAX / 1000)
delay = INT_MAX / 1000;
cur_timeout = delay * 1000L; /* msec */
}
else
cur_timeout = 0;
cur_flags = WL_TIMEOUT;
}
else
{
cur_timeout = -1L;
cur_flags = 0;
}
/*
* Sleep until there's something to do
*/
#ifndef WIN32
rc = WaitLatchOrSocket(MyLatch,
WL_LATCH_SET | WL_SOCKET_READABLE | cur_flags,
syslogPipe[0],
cur_timeout,
WAIT_EVENT_SYSLOGGER_MAIN);
if (rc & WL_SOCKET_READABLE)
{
int bytesRead;
bytesRead = read(syslogPipe[0],
logbuffer + bytes_in_logbuffer,
sizeof(logbuffer) - bytes_in_logbuffer);
if (bytesRead < 0)
{
if (errno != EINTR)
ereport(LOG,
(errcode_for_socket_access(),
errmsg("could not read from logger pipe: %m")));
}
else if (bytesRead > 0)
{
bytes_in_logbuffer += bytesRead;
process_pipe_input(logbuffer, &bytes_in_logbuffer);
continue;
}
else
{
/*
* Zero bytes read when select() is saying read-ready means
* EOF on the pipe: that is, there are no longer any processes
* with the pipe write end open. Therefore, the postmaster
* and all backends are shut down, and we are done.
*/
pipe_eof_seen = true;
/* if there's any data left then force it out now */
flush_pipe_input(logbuffer, &bytes_in_logbuffer);
}
}
#else /* WIN32 */
/*
* On Windows we leave it to a separate thread to transfer data and
* detect pipe EOF. The main thread just wakes up to handle SIGHUP
* and rotation conditions.
*
* Server code isn't generally thread-safe, so we ensure that only one
* of the threads is active at a time by entering the critical section
* whenever we're not sleeping.
*/
LeaveCriticalSection(&sysloggerSection);
(void) WaitLatch(MyLatch,
WL_LATCH_SET | cur_flags,
cur_timeout,
WAIT_EVENT_SYSLOGGER_MAIN);
EnterCriticalSection(&sysloggerSection);
#endif /* WIN32 */
if (pipe_eof_seen)
{
/*
* seeing this message on the real stderr is annoying - so we make
* it DEBUG1 to suppress in normal use.
*/
ereport(DEBUG1,
(errmsg("logger shutting down")));
/*
* Normal exit from the syslogger is here. Note that we
* deliberately do not close syslogFile before exiting; this is to
* allow for the possibility of elog messages being generated
* inside proc_exit. Regular exit() will take care of flushing
* and closing stdio channels.
*/
proc_exit(0);
}
}
}
/**
* This method is called after fork of the sweeper process. It sets up signal
* handlers and does initialization that is required by a postgres backend.
*/
NON_EXEC_STATIC void
BackoffSweeperMain(int argc, char *argv[])
{
sigjmp_buf local_sigjmp_buf;
IsUnderPostmaster = true;
isSweeperProcess = true;
/* Stay away from PMChildSlot */
MyPMChildSlot = -1;
/* reset MyProcPid */
MyProcPid = getpid();
/* Lose the postmaster's on-exit routines */
on_exit_reset();
/* Identify myself via ps */
init_ps_display("sweeper process", "", "", "");
SetProcessingMode(InitProcessing);
/*
* Set up signal handlers. We operate on databases much like a regular
* backend, so we use the same signal handling. See equivalent code in
* tcop/postgres.c.
*/
pqsignal(SIGHUP, SIG_IGN);
pqsignal(SIGINT, SIG_IGN);
pqsignal(SIGALRM, SIG_IGN);
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, SIG_IGN);
pqsignal(SIGTERM, die);
pqsignal(SIGQUIT, quickdie);
pqsignal(SIGUSR2, BackoffRequestShutdown);
pqsignal(SIGFPE, FloatExceptionHandler);
pqsignal(SIGCHLD, SIG_DFL);
/*
* Copied from bgwriter
*/
CurrentResourceOwner = ResourceOwnerCreate(NULL, "Sweeper process");
/* Early initialization */
BaseInit();
/* See InitPostgres()... */
InitProcess();
SetProcessingMode(NormalProcessing);
/*
* If an exception is encountered, processing resumes here.
*
* See notes in postgres.c about the design of this coding.
*/
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/* Prevents interrupts while cleaning up */
HOLD_INTERRUPTS();
/* Report the error to the server log */
EmitErrorReport();
/*
* We can now go away. Note that because we'll call InitProcess, a
* callback will be registered to do ProcKill, which will clean up
* necessary state.
*/
proc_exit(0);
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
PG_SETMASK(&UnBlockSig);
MyBackendId = InvalidBackendId;
/* main loop */
BackoffSweeperLoop();
/* One iteration done, go away */
proc_exit(0);
}
/*
* AutoVacMain
*/
NON_EXEC_STATIC void
AutoVacMain(int argc, char *argv[])
{
ListCell *cell;
List *dblist;
autovac_dbase *db;
TransactionId xidForceLimit;
bool for_xid_wrap;
sigjmp_buf local_sigjmp_buf;
/* we are a postmaster subprocess now */
IsUnderPostmaster = true;
am_autovacuum = true;
/* MPP-4990: Autovacuum always runs as utility-mode */
Gp_role = GP_ROLE_UTILITY;
/* reset MyProcPid */
MyProcPid = getpid();
/* record Start Time for logging */
MyStartTime = time(NULL);
/* Identify myself via ps */
init_ps_display("autovacuum process", "", "", "");
SetProcessingMode(InitProcessing);
/*
* If possible, make this process a group leader, so that the postmaster
* can signal any child processes too. (autovacuum probably never has
* any child processes, but for consistency we make all postmaster
* child processes do this.)
*/
#ifdef HAVE_SETSID
if (setsid() < 0)
elog(FATAL, "setsid() failed: %m");
#endif
/*
* Set up signal handlers. We operate on databases much like a regular
* backend, so we use the same signal handling. See equivalent code in
* tcop/postgres.c.
*
* Currently, we don't pay attention to postgresql.conf changes that
* happen during a single daemon iteration, so we can ignore SIGHUP.
*/
pqsignal(SIGHUP, SIG_IGN);
/*
* SIGINT is used to signal cancelling the current table's vacuum; SIGTERM
* means abort and exit cleanly, and SIGQUIT means abandon ship.
*/
pqsignal(SIGINT, StatementCancelHandler);
pqsignal(SIGTERM, die);
pqsignal(SIGQUIT, quickdie);
pqsignal(SIGALRM, handle_sig_alarm);
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, procsignal_sigusr1_handler);
/* We don't listen for async notifies */
pqsignal(SIGUSR2, SIG_IGN);
pqsignal(SIGFPE, FloatExceptionHandler);
pqsignal(SIGCHLD, SIG_DFL);
/* Early initialization */
BaseInit();
/*
* Create a per-backend PGPROC struct in shared memory, except in the
* EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
* this before we can use LWLocks (and in the EXEC_BACKEND case we already
* had to do some stuff with LWLocks).
*/
#ifndef EXEC_BACKEND
InitProcess();
#endif
/*
* If an exception is encountered, processing resumes here.
*
* See notes in postgres.c about the design of this coding.
*/
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/* Prevents interrupts while cleaning up */
HOLD_INTERRUPTS();
/* Report the error to the server log */
EmitErrorReport();
/*
* We can now go away. Note that because we called InitProcess, a
* callback was registered to do ProcKill, which will clean up
* necessary state.
*/
proc_exit(0);
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
PG_SETMASK(&UnBlockSig);
/*
* Force zero_damaged_pages OFF in the autovac process, even if it is set
* in postgresql.conf. We don't really want such a dangerous option being
* applied non-interactively.
*/
SetConfigOption("zero_damaged_pages", "false", PGC_SUSET, PGC_S_OVERRIDE);
/* Get a list of databases */
dblist = autovac_get_database_list();
/*
* Determine the oldest datfrozenxid/relfrozenxid that we will allow
* to pass without forcing a vacuum. (This limit can be tightened for
* particular tables, but not loosened.)
*/
recentXid = ReadNewTransactionId();
xidForceLimit = recentXid - autovacuum_freeze_max_age;
/* ensure it's a "normal" XID, else TransactionIdPrecedes misbehaves */
if (xidForceLimit < FirstNormalTransactionId)
xidForceLimit -= FirstNormalTransactionId;
/*
* Choose a database to connect to. We pick the database that was least
* recently auto-vacuumed, or one that needs vacuuming to prevent Xid
* wraparound-related data loss. If any db at risk of wraparound is
* found, we pick the one with oldest datfrozenxid,
* independently of autovacuum times.
*
* Note that a database with no stats entry is not considered, except for
* Xid wraparound purposes. The theory is that if no one has ever
* connected to it since the stats were last initialized, it doesn't need
* vacuuming.
*
* XXX This could be improved if we had more info about whether it needs
* vacuuming before connecting to it. Perhaps look through the pgstats
* data for the database's tables? One idea is to keep track of the
* number of new and dead tuples per database in pgstats. However it
* isn't clear how to construct a metric that measures that and not cause
* starvation for less busy databases.
*/
db = NULL;
for_xid_wrap = false;
foreach(cell, dblist)
{
autovac_dbase *tmp = lfirst(cell);
/* Find pgstat entry if any */
tmp->entry = pgstat_fetch_stat_dbentry(tmp->oid);
/* Check to see if this one is at risk of wraparound */
if (TransactionIdPrecedes(tmp->frozenxid, xidForceLimit))
{
if (db == NULL ||
TransactionIdPrecedes(tmp->frozenxid, db->frozenxid))
db = tmp;
for_xid_wrap = true;
continue;
}
else if (for_xid_wrap)
continue; /* ignore not-at-risk DBs */
/*
* Otherwise, skip a database with no pgstat entry; it means it
* hasn't seen any activity.
*/
if (!tmp->entry)
continue;
/*
* Remember the db with oldest autovac time. (If we are here,
* both tmp->entry and db->entry must be non-null.)
*/
if (db == NULL ||
tmp->entry->last_autovac_time < db->entry->last_autovac_time)
db = tmp;
}
/*
* main entry pont of pcp worker child process
*/
void
pcp_worker_main(int port)
{
sigjmp_buf local_sigjmp_buf;
MemoryContext PCPMemoryContext;
int authenticated = 0;
char salt[4];
int random_salt = 0;
struct timeval uptime;
char tos;
int rsize;
char *buf = NULL;
ereport(DEBUG1,
(errmsg("I am PCP worker child with pid:%d",getpid())));
/* Identify myself via ps */
init_ps_display("", "", "", "");
gettimeofday(&uptime, NULL);
srandom((unsigned int) (getpid() ^ uptime.tv_usec));
/* set up signal handlers */
signal(SIGTERM, die);
signal(SIGINT, die);
signal(SIGQUIT, die);
signal(SIGCHLD, SIG_DFL);
signal(SIGUSR2, wakeup_handler_child);
signal(SIGUSR1, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGALRM, SIG_IGN);
/* Create per loop iteration memory context */
PCPMemoryContext = AllocSetContextCreate(TopMemoryContext,
"PCP_worker_main_loop",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
MemoryContextSwitchTo(TopMemoryContext);
/*
* install the call back for preparation of pcp worker child exit
*/
on_system_exit(pcp_worker_will_go_down, (Datum)NULL);
/* Initialize my backend status */
pool_initialize_private_backend_status();
/* Initialize process context */
pool_init_process_context();
pcp_frontend = pcp_open(port);
unset_nonblock(pcp_frontend->fd);
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
error_context_stack = NULL;
EmitErrorReport();
MemoryContextSwitchTo(TopMemoryContext);
FlushErrorState();
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
for(;;)
{
MemoryContextSwitchTo(PCPMemoryContext);
MemoryContextResetAndDeleteChildren(PCPMemoryContext);
errno = 0;
/* read a PCP packet */
do_pcp_read(pcp_frontend, &tos, 1);
do_pcp_read(pcp_frontend, &rsize, sizeof(int));
rsize = ntohl(rsize);
if ((rsize - sizeof(int)) > 0)
{
buf = (char *)palloc(rsize - sizeof(int));
do_pcp_read(pcp_frontend, buf, rsize - sizeof(int));
}
ereport(DEBUG1,
(errmsg("received PCP packet"),
errdetail("PCP packet type of service '%c'", tos)));
if (tos == 'R') /* authentication */
{
set_ps_display("PCP: processing authentication", false);
process_authentication(pcp_frontend, buf,salt, &random_salt);
authenticated = 1;
continue;
}
if (tos == 'M') /* md5 salt */
{
set_ps_display("PCP: processing authentication", false);
send_md5salt(pcp_frontend, salt);
random_salt = 1;
continue;
}
/* is this connection authenticated? if not disconnect immediately*/
if (!authenticated)
ereport(FATAL,
(errmsg("authentication failed for new PCP connection"),
errdetail("connection not authorized")));
/* process a request */
pcp_process_command(tos, buf, rsize);
}
exit(0);
}
/*
* child main loop
*/
void do_child(int unix_fd, int inet_fd)
{
POOL_CONNECTION *frontend;
POOL_CONNECTION_POOL *backend;
struct timeval now;
struct timezone tz;
struct timeval timeout;
static int connected; /* non 0 if has been accepted connections from frontend */
int connections_count = 0; /* used if child_max_connections > 0 */
int found;
char psbuf[NI_MAXHOST + 128];
pool_debug("I am %d", getpid());
/* Identify myself via ps */
init_ps_display("", "", "", "");
/* set up signal handlers */
signal(SIGALRM, SIG_DFL);
signal(SIGTERM, die);
signal(SIGINT, die);
signal(SIGHUP, reload_config_handler);
signal(SIGQUIT, die);
signal(SIGCHLD, SIG_DFL);
signal(SIGUSR1, close_idle_connection);
signal(SIGUSR2, wakeup_handler);
signal(SIGPIPE, SIG_IGN);
#ifdef NONE_BLOCK
/* set listen fds to none-blocking */
pool_set_nonblock(unix_fd);
if (inet_fd)
{
pool_set_nonblock(inet_fd);
}
#endif
/* Initialize my backend status */
pool_initialize_private_backend_status();
/* Initialize per process context */
pool_init_process_context();
/* initialize random seed */
gettimeofday(&now, &tz);
#if defined(sun) || defined(__sun)
srand((unsigned int) now.tv_usec);
#else
srandom((unsigned int) now.tv_usec);
#endif
/* initialize system db connection */
init_system_db_connection();
/* initialize connection pool */
if (pool_init_cp())
{
child_exit(1);
}
/*
* Open pool_passwd in child process. This is necessary to avoid the
* file descriptor race condition reported in [pgpool-general: 1141].
*/
if (strcmp("", pool_config->pool_passwd))
{
pool_reopen_passwd_file();
}
timeout.tv_sec = pool_config->child_life_time;
timeout.tv_usec = 0;
for (;;)
{
StartupPacket *sp;
idle = 1;
/* pgpool stop request already sent? */
check_stop_request();
/* Check if restart request is set because of failback event
* happend. If so, exit myself with exit code 1 to be
* restarted by pgpool parent.
*/
if (pool_get_my_process_info()->need_to_restart)
{
pool_log("do_child: failback event found. restart myself.");
pool_get_my_process_info()->need_to_restart = 0;
child_exit(1);
}
accepted = 0;
/* perform accept() */
frontend = do_accept(unix_fd, inet_fd, &timeout);
if (frontend == NULL) /* connection request from frontend timed out */
{
/* check select() timeout */
if (connected && pool_config->child_life_time > 0 &&
timeout.tv_sec == 0 && timeout.tv_usec == 0)
{
pool_debug("child life %d seconds expired", pool_config->child_life_time);
/*
* Doesn't need to call this. child_exit() calls it.
* send_frontend_exits();
*/
child_exit(2);
}
continue;
}
/* set frontend fd to blocking */
pool_unset_nonblock(frontend->fd);
/* reset busy flag */
idle = 0;
/* check backend timer is expired */
if (backend_timer_expired)
{
pool_backend_timer();
backend_timer_expired = 0;
}
/* read the startup packet */
retry_startup:
sp = read_startup_packet(frontend);
if (sp == NULL)
{
/* failed to read the startup packet. return to the accept() loop */
pool_close(frontend);
connection_count_down();
continue;
}
/* cancel request? */
if (sp->major == 1234 && sp->minor == 5678)
{
cancel_request((CancelPacket *)sp->startup_packet);
pool_close(frontend);
pool_free_startup_packet(sp);
connection_count_down();
continue;
}
/* SSL? */
if (sp->major == 1234 && sp->minor == 5679 && !frontend->ssl_active)
{
pool_debug("SSLRequest from client");
pool_ssl_negotiate_serverclient(frontend);
pool_free_startup_packet(sp);
goto retry_startup;
}
/* this should run before ClientAuthentication */
pool_prestogres_set_defaults(sp);
if (pool_config->enable_pool_hba)
{
/*
* do client authentication.
* Note that ClientAuthentication does not return if frontend
* was rejected; it simply terminates this process.
*/
frontend->protoVersion = sp->major;
frontend->database = strdup(sp->database);
if (frontend->database == NULL)
{
pool_error("do_child: strdup failed: %s\n", strerror(errno));
child_exit(1);
}
frontend->username = strdup(sp->user);
if (frontend->username == NULL)
{
pool_error("do_child: strdup failed: %s\n", strerror(errno));
child_exit(1);
}
ClientAuthentication(frontend);
/* ClientAuthentication can overwrite database and user */
if (strcmp(sp->database, frontend->database) || strcmp(sp->user, frontend->username)) {
free(sp->database);
sp->database = strdup(frontend->database);
free(sp->user);
sp->user = strdup(frontend->username);
if (frontend->username == NULL)
{
pool_error("do_child: strdup failed: %s\n", strerror(errno));
child_exit(1);
}
rebuild_startup_packet(sp);
}
}
/*
* Ok, negotiation with frontend has been done. Let's go to the
* next step. Connect to backend if there's no existing
* connection which can be reused by this frontend.
* Authentication is also done in this step.
*/
/* Check if restart request is set because of failback event
* happend. If so, close idle connections to backend and make
* a new copy of backend status.
*/
if (pool_get_my_process_info()->need_to_restart)
{
pool_log("do_child: failback event found. discard existing connections");
pool_get_my_process_info()->need_to_restart = 0;
close_idle_connection(0);
pool_initialize_private_backend_status();
}
/*
* if there's no connection associated with user and database,
* we need to connect to the backend and send the startup packet.
*/
/* look for existing connection */
found = 0;
backend = pool_get_cp(sp->user, sp->database, sp->major, 1);
if (backend != NULL)
{
found = 1;
/* existing connection associated with same user/database/major found.
* however we should make sure that the startup packet contents are identical.
* OPTION data and others might be different.
*/
if (sp->len != MASTER_CONNECTION(backend)->sp->len)
{
pool_debug("do_child: connection exists but startup packet length is not identical");
found = 0;
}
else if(memcmp(sp->startup_packet, MASTER_CONNECTION(backend)->sp->startup_packet, sp->len) != 0)
{
pool_debug("do_child: connection exists but startup packet contents is not identical");
found = 0;
}
if (found == 0)
{
/* we need to discard existing connection since startup packet is different */
pool_discard_cp(sp->user, sp->database, sp->major);
backend = NULL;
}
}
if (backend == NULL)
{
/* create a new connection to backend */
if ((backend = connect_backend(sp, frontend)) == NULL)
{
connection_count_down();
continue;
}
}
else
{
/* reuse existing connection */
if (!connect_using_existing_connection(frontend, backend, sp))
continue;
}
connected = 1;
/* show ps status */
sp = MASTER_CONNECTION(backend)->sp;
snprintf(psbuf, sizeof(psbuf), "%s %s %s idle",
sp->user, sp->database, remote_ps_data);
set_ps_display(psbuf, false);
/*
* Initialize per session context
*/
pool_init_session_context(frontend, backend);
/* Mark this connection pool is connected from frontend */
pool_coninfo_set_frontend_connected(pool_get_process_context()->proc_id, pool_pool_index());
/* query process loop */
for (;;)
{
POOL_STATUS status;
status = pool_process_query(frontend, backend, 0);
sp = MASTER_CONNECTION(backend)->sp;
switch (status)
{
/* client exits */
case POOL_END:
/*
* do not cache connection if:
* pool_config->connection_cahe == 0 or
* database name is template0, template1, postgres or regression
*/
if (pool_config->connection_cache == 0 ||
!strcmp(sp->database, "template0") ||
!strcmp(sp->database, "template1") ||
!strcmp(sp->database, "postgres") ||
!strcmp(sp->database, "regression"))
{
reset_connection();
pool_close(frontend);
pool_send_frontend_exits(backend);
pool_discard_cp(sp->user, sp->database, sp->major);
}
else
{
POOL_STATUS status1;
/* send reset request to backend */
status1 = pool_process_query(frontend, backend, 1);
pool_close(frontend);
/* if we detect errors on resetting connection, we need to discard
* this connection since it might be in unknown status
*/
if (status1 != POOL_CONTINUE)
{
pool_debug("error in resetting connections. discarding connection pools...");
pool_send_frontend_exits(backend);
pool_discard_cp(sp->user, sp->database, sp->major);
}
else
pool_connection_pool_timer(backend);
}
break;
/* error occurred. discard backend connection pool
and disconnect connection to the frontend */
case POOL_ERROR:
pool_log("do_child: exits with status 1 due to error");
child_exit(1);
break;
/* fatal error occurred. just exit myself... */
case POOL_FATAL:
notice_backend_error(1);
child_exit(1);
break;
/* not implemented yet */
case POOL_IDLE:
do_accept(unix_fd, inet_fd, &timeout);
pool_debug("accept while idle");
break;
default:
break;
}
if (status != POOL_CONTINUE)
break;
}
/* Destroy session context */
pool_session_context_destroy();
/* Mark this connection pool is not connected from frontend */
pool_coninfo_unset_frontend_connected(pool_get_process_context()->proc_id, pool_pool_index());
accepted = 0;
connection_count_down();
timeout.tv_sec = pool_config->child_life_time;
timeout.tv_usec = 0;
/* increment queries counter if necessary */
if ( pool_config->child_max_connections > 0 )
connections_count++;
/* check if maximum connections count for this child reached */
if ( ( pool_config->child_max_connections > 0 ) &&
( connections_count >= pool_config->child_max_connections ) )
{
pool_log("child exiting, %d connections reached", pool_config->child_max_connections);
send_frontend_exits();
child_exit(2);
}
}
child_exit(0);
}
/*
* Common service main.
*/
void
ServiceMain(ServiceCtrl *serviceCtrl)
{
ServiceConfig *serviceConfig;
sigjmp_buf local_sigjmp_buf;
Assert(serviceCtrl != NULL);
serviceConfig = (ServiceConfig*)serviceCtrl->serviceConfig;
Assert(serviceConfig != NULL);
IsUnderPostmaster = true;
/* reset MyProcPid */
MyProcPid = getpid();
/* Lose the postmaster's on-exit routines */
on_exit_reset();
/* Identify myself via ps */
init_ps_display(serviceConfig->psTitle, "", "", "");
if (serviceConfig->ServiceEarlyInit != NULL)
{
serviceConfig->ServiceEarlyInit();
}
else
{
SetProcessingMode(InitProcessing);
}
/*
* Set up signal handlers. We operate on databases much like a regular
* backend, so we use the same signal handling. See equivalent code in
* tcop/postgres.c.
*
* Currently, we don't pay attention to postgresql.conf changes that
* happen during a single daemon iteration, so we can ignore SIGHUP.
*/
pqsignal(SIGHUP, SIG_IGN);
/*
* Presently, SIGINT will lead to autovacuum shutdown, because that's how
* we handle ereport(ERROR). It could be improved however.
*/
pqsignal(SIGINT, StatementCancelHandler);
pqsignal(SIGTERM, ServiceDie);
pqsignal(SIGQUIT, ServiceQuickDie);
pqsignal(SIGALRM, handle_sig_alarm);
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, procsignal_sigusr1_handler);
/* We don't listen for async notifies */
pqsignal(SIGUSR2, serviceConfig->ServiceRequestShutdown);
pqsignal(SIGFPE, FloatExceptionHandler);
pqsignal(SIGCHLD, SIG_DFL);
#ifdef SIGBUS
pqsignal(SIGBUS, HandleCrash);
#endif
#ifdef SIGILL
pqsignal(SIGILL, HandleCrash);
#endif
#ifdef SIGSEGV
pqsignal(SIGSEGV, HandleCrash);
#endif
/* Early initialization */
BaseInit();
if (serviceConfig->ServicePostgresInit != NULL)
{
serviceConfig->ServicePostgresInit();
}
SetProcessingMode(NormalProcessing);
/*
* If an exception is encountered, processing resumes here.
*
* See notes in postgres.c about the design of this coding.
*/
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/* Prevents interrupts while cleaning up */
HOLD_INTERRUPTS();
/* Report the error to the server log */
EmitErrorReport();
/*
* We can now go away. Note that because we'll call InitProcess, a
* callback will be registered to do ProcKill, which will clean up
* necessary state.
*/
proc_exit(0);
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
PG_SETMASK(&UnBlockSig);
/* set up a listener port and put it in shmem*/
serviceCtrl->listenerPort = ServiceListenerSetup(serviceCtrl);
if (serviceConfig->ServiceInit != NULL)
{
serviceConfig->ServiceInit(serviceCtrl->listenerPort);
}
/* listen loop */
ServiceListenLoop(serviceCtrl);
proc_exit(0);
}
void
ContQuerySchedulerMain(int argc, char *argv[])
{
sigjmp_buf local_sigjmp_buf;
List *dbs = NIL;
/* we are a postmaster subprocess now */
IsUnderPostmaster = true;
am_cont_scheduler = true;
/* reset MyProcPid */
MyProcPid = getpid();
MyPMChildSlot = AssignPostmasterChildSlot();
/* record Start Time for logging */
MyStartTime = time(NULL);
/* Identify myself via ps */
init_ps_display("continuous query scheduler process", "", "", "");
ereport(LOG, (errmsg("continuous query scheduler started")));
if (PostAuthDelay)
pg_usleep(PostAuthDelay * 1000000L);
SetProcessingMode(InitProcessing);
/*
* If possible, make this process a group leader, so that the postmaster
* can signal any child processes too. This is only for consistency sake, we
* never fork the scheduler process. Instead dynamic bgworkers are used.
*/
#ifdef HAVE_SETSID
if (setsid() < 0)
elog(FATAL, "setsid() failed: %m");
#endif
/*
* Set up signal handlers. We operate on databases much like a regular
* backend, so we use the same signal handling. See equivalent code in
* tcop/postgres.c.
*/
pqsignal(SIGHUP, sighup_handler);
pqsignal(SIGINT, sigint_handler);
pqsignal(SIGTERM, sigterm_handler);
pqsignal(SIGQUIT, quickdie);
InitializeTimeouts(); /* establishes SIGALRM handler */
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, procsignal_sigusr1_handler);
pqsignal(SIGUSR2, sigusr2_handler);
pqsignal(SIGFPE, FloatExceptionHandler);
pqsignal(SIGCHLD, SIG_DFL);
#define BACKTRACE_SEGFAULTS
#ifdef BACKTRACE_SEGFAULTS
pqsignal(SIGSEGV, debug_segfault);
#endif
/* Early initialization */
BaseInit();
/*
* Create a per-backend PGPROC struct in shared memory, except in the
* EXEC_BACKEND case where this was done in SubPostmasterMain. We must do
* this before we can use LWLocks (and in the EXEC_BACKEND case we already
* had to do some stuff with LWLocks).
*/
#ifndef EXEC_BACKEND
InitProcess();
#endif
InitPostgres(NULL, InvalidOid, NULL, NULL);
SetProcessingMode(NormalProcessing);
/*
* Create a memory context that we will do all our work in. We do this so
* that we can reset the context during error recovery and thereby avoid
* possible memory leaks.
*/
ContQuerySchedulerMemCxt = AllocSetContextCreate(TopMemoryContext,
"ContQuerySchedulerCtx",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
MemoryContextSwitchTo(ContQuerySchedulerMemCxt);
/*
* If an exception is encountered, processing resumes here.
*
* This code is a stripped down version of PostgresMain error recovery.
*/
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/* since not using PG_TRY, must reset error stack by hand */
error_context_stack = NULL;
/* Prevents interrupts while cleaning up */
HOLD_INTERRUPTS();
/* Forget any pending QueryCancel or timeout request */
disable_all_timeouts(false);
QueryCancelPending = false; /* second to avoid race condition */
/* Report the error to the server log */
EmitErrorReport();
/* Abort the current transaction in order to recover */
AbortCurrentTransaction();
/*
* Now return to normal top-level context and clear ErrorContext for
* next time.
*/
MemoryContextSwitchTo(ContQuerySchedulerMemCxt);
FlushErrorState();
/* Flush any leaked data in the top-level context */
MemoryContextResetAndDeleteChildren(ContQuerySchedulerMemCxt);
/* Now we can allow interrupts again */
RESUME_INTERRUPTS();
/*
* Sleep at least 1 second after any error. We don't want to be
* filling the error logs as fast as we can.
*/
pg_usleep(1000000L);
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
/* must unblock signals before calling rebuild_database_list */
PG_SETMASK(&UnBlockSig);
ContQuerySchedulerShmem->scheduler_pid = MyProcPid;
dbs = get_database_list();
/* Loop forever */
for (;;)
{
ListCell *lc;
int rc;
foreach(lc, dbs)
{
DatabaseEntry *db_entry = lfirst(lc);
bool found;
ContQueryProcGroup *grp = hash_search(ContQuerySchedulerShmem->proc_table, &db_entry->oid, HASH_ENTER, &found);
/* If we don't have an entry for this dboid, initialize a new one and fire off bg procs */
if (!found)
{
grp->db_oid = db_entry->oid;
namestrcpy(&grp->db_name, NameStr(db_entry->name));
start_group(grp);
}
}
/* Allow sinval catchup interrupts while sleeping */
EnableCatchupInterrupt();
/*
* Wait until naptime expires or we get some type of signal (all the
* signal handlers will wake us by calling SetLatch).
*/
rc = WaitLatch(&MyProc->procLatch, WL_LATCH_SET | WL_POSTMASTER_DEATH, 0);
ResetLatch(&MyProc->procLatch);
DisableCatchupInterrupt();
/*
* Emergency bailout if postmaster has died. This is to avoid the
* necessity for manual cleanup of all postmaster children.
*/
if (rc & WL_POSTMASTER_DEATH)
proc_exit(1);
/* the normal shutdown case */
if (got_SIGTERM)
break;
/* update config? */
if (got_SIGHUP)
{
got_SIGHUP = false;
ProcessConfigFile(PGC_SIGHUP);
/* update tuning parameters, so that they can be read downstream by background processes */
update_tuning_params();
}
/* terminate a proc group? */
if (got_SIGUSR2)
{
HASH_SEQ_STATUS status;
ContQueryProcGroup *grp;
got_SIGUSR2 = false;
hash_seq_init(&status, ContQuerySchedulerShmem->proc_table);
while ((grp = (ContQueryProcGroup *) hash_seq_search(&status)) != NULL)
{
ListCell *lc;
if (!grp->terminate)
continue;
foreach(lc, dbs)
{
DatabaseEntry *entry = lfirst(lc);
if (entry->oid == grp->db_oid)
{
dbs = list_delete(dbs, entry);
break;
}
}
terminate_group(grp);
}
}
pid_t
wd_child(int fork_wait_time)
{
int sock;
volatile int fd;
int rtn;
pid_t pid = 0;
sigjmp_buf local_sigjmp_buf;
pid = fork();
if (pid != 0)
{
if (pid == -1)
ereport(PANIC,
(errmsg("failed to fork a watchdog process")));
return pid;
}
on_exit_reset();
processType = PT_WATCHDOG;
if (fork_wait_time > 0)
{
sleep(fork_wait_time);
}
POOL_SETMASK(&UnBlockSig);
signal(SIGTERM, wd_child_exit);
signal(SIGINT, wd_child_exit);
signal(SIGQUIT, wd_child_exit);
signal(SIGCHLD, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGALRM, SIG_IGN);
init_ps_display("", "", "", "");
if (WD_List == NULL)
{
/* memory allocate is not ready */
wd_child_exit(15);
}
/* Create per loop iteration memory context */
ProcessLoopContext = AllocSetContextCreate(TopMemoryContext,
"wd_child_main_loop",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
MemoryContextSwitchTo(TopMemoryContext);
sock = wd_create_recv_socket(WD_MYSELF->wd_port);
if (sock < 0)
{
/* socket create failed */
wd_child_exit(15);
}
set_ps_display("watchdog", false);
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/* Since not using PG_TRY, must reset error stack by hand */
if(fd > 0)
close(fd);
error_context_stack = NULL;
EmitErrorReport();
MemoryContextSwitchTo(TopMemoryContext);
FlushErrorState();
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
/* child loop */
for(;;)
{
MemoryContextSwitchTo(ProcessLoopContext);
MemoryContextResetAndDeleteChildren(ProcessLoopContext);
fd = -1;
WdPacket buf;
fd = wd_accept(sock);
if (fd < 0)
{
continue;
}
rtn = wd_recv_packet(fd, &buf);
if (rtn == WD_OK)
{
wd_send_response(fd, &buf);
}
close(fd);
}
return pid;
}
/* fork heartbeat sender child */
pid_t
wd_hb_sender(int fork_wait_time, WdHbIf *hb_if)
{
int sock;
pid_t pid = 0;
WdHbPacket pkt;
WdInfo * p = WD_List;
char pack_str[WD_MAX_PACKET_STRING];
int pack_str_len;
sigjmp_buf local_sigjmp_buf;
pid = fork();
if (pid != 0)
{
if (pid == -1)
ereport(PANIC,
(errmsg("failed to fork a heartbeat sender child")));
return pid;
}
on_exit_reset();
processType = PT_HB_SENDER;
if (fork_wait_time > 0)
{
sleep(fork_wait_time);
}
POOL_SETMASK(&UnBlockSig);
signal(SIGTERM, hb_sender_exit);
signal(SIGINT, hb_sender_exit);
signal(SIGQUIT, hb_sender_exit);
signal(SIGCHLD, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGALRM, SIG_IGN);
init_ps_display("", "", "", "");
/* Create per loop iteration memory context */
ProcessLoopContext = AllocSetContextCreate(TopMemoryContext,
"wdhb_sender",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
MemoryContextSwitchTo(TopMemoryContext);
sock = wd_create_hb_send_socket(hb_if);
set_ps_display("heartbeat sender", false);
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/* Since not using PG_TRY, must reset error stack by hand */
error_context_stack = NULL;
EmitErrorReport();
MemoryContextSwitchTo(TopMemoryContext);
FlushErrorState();
sleep(pool_config->wd_heartbeat_keepalive);
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
for(;;)
{
MemoryContextSwitchTo(ProcessLoopContext);
MemoryContextResetAndDeleteChildren(ProcessLoopContext);
/* contents of packet */
gettimeofday(&pkt.send_time, NULL);
strlcpy(pkt.from, pool_config->wd_hostname, sizeof(pkt.from));
pkt.from_pgpool_port = pool_config->port;
pkt.status = p->status;
/* authentication key */
if (strlen(pool_config->wd_authkey))
{
/* calculate hash from packet */
pack_str_len = packet_to_string_hb(&pkt, pack_str, sizeof(pack_str));
wd_calc_hash(pack_str, pack_str_len, pkt.hash);
}
/* send heartbeat signal */
wd_hb_send(sock, &pkt, sizeof(pkt), hb_if->addr, hb_if->dest_port);
ereport(DEBUG1,
(errmsg("watchdog heartbeat: send heartbeat signal to %s:%d", hb_if->addr, hb_if->dest_port)));
sleep(pool_config->wd_heartbeat_keepalive);
}
return pid;
}
/* fork heartbeat receiver child */
pid_t
wd_hb_receiver(int fork_wait_time, WdHbIf *hb_if)
{
int sock;
pid_t pid = 0;
WdHbPacket pkt;
struct timeval tv;
char from[WD_MAX_HOST_NAMELEN];
int from_pgpool_port;
char buf[(MD5_PASSWD_LEN+1)*2];
char pack_str[WD_MAX_PACKET_STRING];
int pack_str_len;
sigjmp_buf local_sigjmp_buf;
WdInfo * p;
pid = fork();
if (pid != 0)
{
if (pid == -1)
ereport(PANIC,
(errmsg("failed to fork a heartbeat receiver child")));
return pid;
}
on_exit_reset();
processType = PT_HB_RECEIVER;
if (fork_wait_time > 0)
{
sleep(fork_wait_time);
}
POOL_SETMASK(&UnBlockSig);
signal(SIGTERM, hb_receiver_exit);
signal(SIGINT, hb_receiver_exit);
signal(SIGQUIT, hb_receiver_exit);
signal(SIGCHLD, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGALRM, SIG_IGN);
init_ps_display("", "", "", "");
/* Create per loop iteration memory context */
ProcessLoopContext = AllocSetContextCreate(TopMemoryContext,
"wdhb_hb_receiver",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
MemoryContextSwitchTo(TopMemoryContext);
sock = wd_create_hb_recv_socket(hb_if);
set_ps_display("heartbeat receiver", false);
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/* Since not using PG_TRY, must reset error stack by hand */
error_context_stack = NULL;
EmitErrorReport();
MemoryContextSwitchTo(TopMemoryContext);
FlushErrorState();
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
for(;;)
{
MemoryContextSwitchTo(ProcessLoopContext);
MemoryContextResetAndDeleteChildren(ProcessLoopContext);
/* receive heartbeat signal */
wd_hb_recv(sock, &pkt);
/* authentication */
if (strlen(pool_config->wd_authkey))
{
/* calculate hash from packet */
pack_str_len = packet_to_string_hb(&pkt, pack_str, sizeof(pack_str));
wd_calc_hash(pack_str, pack_str_len, buf);
if (strcmp(pkt.hash, buf))
ereport(ERROR,
(errmsg("watchdog heartbeat receive"),
errdetail("authentication failed")));
}
/* get current time */
gettimeofday(&tv, NULL);
/* who send this packet? */
strlcpy(from, pkt.from, sizeof(from));
from_pgpool_port = pkt.from_pgpool_port;
p = WD_List;
while (p->status != WD_END)
{
if (!strcmp(p->hostname, from) && p->pgpool_port == from_pgpool_port)
{
/* ignore the packet from down pgpool */
if (pkt.status == WD_DOWN)
{
ereport(DEBUG1,
(errmsg("watchdog heartbeat: received heartbeat signal from \"%s:%d\" whose status is down. ignored",
from, from_pgpool_port)));
break;
}
/* this is the first packet or the latest packet */
if (!WD_TIME_ISSET(p->hb_send_time) ||
WD_TIME_BEFORE(p->hb_send_time, pkt.send_time))
{
ereport(DEBUG1,
(errmsg("watchdog heartbeat: received heartbeat signal from \"%s:%d\"",
from, from_pgpool_port)));
p->hb_send_time = pkt.send_time;
p->hb_last_recv_time = tv;
}
else
{
ereport(DEBUG1,
(errmsg("watchdog heartbeat: received heartbeat signal is older than the latest, ignored")));
}
break;
}
p++;
}
}
return pid;
}
pid_t
wd_child(int fork_wait_time)
{
int sock;
int fd;
int rtn;
pid_t pid = 0;
pid = fork();
if (pid != 0)
{
if (pid == -1)
pool_error("wd_child: fork() failed.");
return pid;
}
if (fork_wait_time > 0)
{
sleep(fork_wait_time);
}
myargv = save_ps_display_args(myargc, myargv);
POOL_SETMASK(&UnBlockSig);
signal(SIGTERM, wd_child_exit);
signal(SIGINT, wd_child_exit);
signal(SIGQUIT, wd_child_exit);
signal(SIGCHLD, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
signal(SIGALRM, SIG_IGN);
init_ps_display("", "", "", "");
if (WD_List == NULL)
{
/* memory allocate is not ready */
wd_child_exit(15);
}
sock = wd_create_recv_socket(WD_MYSELF->wd_port);
if (sock < 0)
{
/* socket create failed */
wd_child_exit(15);
}
set_ps_display("watchdog", false);
/* child loop */
for(;;)
{
WdPacket buf;
fd = wd_accept(sock);
if (fd < 0)
{
continue;
}
rtn = wd_recv_packet(fd, &buf);
if (rtn == WD_OK)
{
wd_send_response(fd, &buf);
}
close(fd);
}
return pid;
}
/*
* Main entry point for syslogger process
* argc/argv parameters are valid only in EXEC_BACKEND case.
*/
NON_EXEC_STATIC void
SysLoggerMain(int argc, char *argv[])
{
#ifndef WIN32
char logbuffer[READ_BUF_SIZE];
int bytes_in_logbuffer = 0;
#endif
char *currentLogDir;
char *currentLogFilename;
int currentLogRotationAge;
IsUnderPostmaster = true; /* we are a postmaster subprocess now */
MyProcPid = getpid(); /* reset MyProcPid */
MyStartTime = time(NULL); /* set our start time in case we call elog */
#ifdef EXEC_BACKEND
syslogger_parseArgs(argc, argv);
#endif /* EXEC_BACKEND */
am_syslogger = true;
init_ps_display("logger process", "", "", "");
/*
* If we restarted, our stderr is already redirected into our own input
* pipe. This is of course pretty useless, not to mention that it
* interferes with detecting pipe EOF. Point stderr to /dev/null. This
* assumes that all interesting messages generated in the syslogger will
* come through elog.c and will be sent to write_syslogger_file.
*/
if (redirection_done)
{
int fd = open(DEVNULL, O_WRONLY, 0);
/*
* The closes might look redundant, but they are not: we want to be
* darn sure the pipe gets closed even if the open failed. We can
* survive running with stderr pointing nowhere, but we can't afford
* to have extra pipe input descriptors hanging around.
*/
close(fileno(stdout));
close(fileno(stderr));
if (fd != -1)
{
dup2(fd, fileno(stdout));
dup2(fd, fileno(stderr));
close(fd);
}
}
/*
* Syslogger's own stderr can't be the syslogPipe, so set it back to text
* mode if we didn't just close it. (It was set to binary in
* SubPostmasterMain).
*/
#ifdef WIN32
else
_setmode(_fileno(stderr), _O_TEXT);
#endif
/*
* Also close our copy of the write end of the pipe. This is needed to
* ensure we can detect pipe EOF correctly. (But note that in the restart
* case, the postmaster already did this.)
*/
#ifndef WIN32
if (syslogPipe[1] >= 0)
close(syslogPipe[1]);
syslogPipe[1] = -1;
#else
if (syslogPipe[1])
CloseHandle(syslogPipe[1]);
syslogPipe[1] = 0;
#endif
/*
* If possible, make this process a group leader, so that the postmaster
* can signal any child processes too. (syslogger probably never has any
* child processes, but for consistency we make all postmaster child
* processes do this.)
*/
#ifdef HAVE_SETSID
if (setsid() < 0)
elog(FATAL, "setsid() failed: %m");
#endif
/*
* Properly accept or ignore signals the postmaster might send us
*
* Note: we ignore all termination signals, and instead exit only when all
* upstream processes are gone, to ensure we don't miss any dying gasps of
* broken backends...
*/
pqsignal(SIGHUP, sigHupHandler); /* set flag to read config file */
pqsignal(SIGINT, SIG_IGN);
pqsignal(SIGTERM, SIG_IGN);
pqsignal(SIGQUIT, SIG_IGN);
pqsignal(SIGALRM, SIG_IGN);
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, sigUsr1Handler); /* request log rotation */
pqsignal(SIGUSR2, SIG_IGN);
/*
* Reset some signals that are accepted by postmaster but not here
*/
pqsignal(SIGCHLD, SIG_DFL);
pqsignal(SIGTTIN, SIG_DFL);
pqsignal(SIGTTOU, SIG_DFL);
pqsignal(SIGCONT, SIG_DFL);
pqsignal(SIGWINCH, SIG_DFL);
PG_SETMASK(&UnBlockSig);
#ifdef WIN32
/* Fire up separate data transfer thread */
InitializeCriticalSection(&sysloggerSection);
EnterCriticalSection(&sysloggerSection);
threadHandle = (HANDLE) _beginthreadex(NULL, 0, pipeThread, NULL, 0, NULL);
if (threadHandle == 0)
elog(FATAL, "could not create syslogger data transfer thread: %m");
#endif /* WIN32 */
/*
* Remember active logfile's name. We recompute this from the reference
* time because passing down just the pg_time_t is a lot cheaper than
* passing a whole file path in the EXEC_BACKEND case.
*/
last_file_name = logfile_getname(first_syslogger_file_time, NULL);
/* remember active logfile parameters */
currentLogDir = pstrdup(Log_directory);
currentLogFilename = pstrdup(Log_filename);
currentLogRotationAge = Log_RotationAge;
/* set next planned rotation time */
set_next_rotation_time();
/* main worker loop */
for (;;)
{
bool time_based_rotation = false;
int size_rotation_for = 0;
#ifndef WIN32
int bytesRead;
int rc;
fd_set rfds;
struct timeval timeout;
#endif
if (got_SIGHUP)
{
got_SIGHUP = false;
ProcessConfigFile(PGC_SIGHUP);
/*
* Check if the log directory or filename pattern changed in
* postgresql.conf. If so, force rotation to make sure we're
* writing the logfiles in the right place.
*/
if (strcmp(Log_directory, currentLogDir) != 0)
{
pfree(currentLogDir);
currentLogDir = pstrdup(Log_directory);
rotation_requested = true;
/*
* Also, create new directory if not present; ignore errors
*/
mkdir(Log_directory, S_IRWXU);
}
if (strcmp(Log_filename, currentLogFilename) != 0)
{
pfree(currentLogFilename);
currentLogFilename = pstrdup(Log_filename);
rotation_requested = true;
}
/*
* If rotation time parameter changed, reset next rotation time,
* but don't immediately force a rotation.
*/
if (currentLogRotationAge != Log_RotationAge)
{
currentLogRotationAge = Log_RotationAge;
set_next_rotation_time();
}
/*
* If we had a rotation-disabling failure, re-enable rotation
* attempts after SIGHUP, and force one immediately.
*/
if (rotation_disabled)
{
rotation_disabled = false;
rotation_requested = true;
}
}
if (!rotation_requested && Log_RotationAge > 0 && !rotation_disabled)
{
/* Do a logfile rotation if it's time */
pg_time_t now = (pg_time_t) time(NULL);
if (now >= next_rotation_time)
rotation_requested = time_based_rotation = true;
}
if (!rotation_requested && Log_RotationSize > 0 && !rotation_disabled)
{
/* Do a rotation if file is too big */
if (ftell(syslogFile) >= Log_RotationSize * 1024L)
{
rotation_requested = true;
size_rotation_for |= LOG_DESTINATION_STDERR;
}
if (csvlogFile != NULL &&
ftell(csvlogFile) >= Log_RotationSize * 1024L)
{
rotation_requested = true;
size_rotation_for |= LOG_DESTINATION_CSVLOG;
}
}
if (rotation_requested)
{
/*
* Force rotation when both values are zero. It means the request
* was sent by pg_rotate_logfile.
*/
if (!time_based_rotation && size_rotation_for == 0)
size_rotation_for = LOG_DESTINATION_STDERR | LOG_DESTINATION_CSVLOG;
logfile_rotate(time_based_rotation, size_rotation_for);
}
#ifndef WIN32
/*
* Wait for some data, timing out after 1 second
*/
FD_ZERO(&rfds);
FD_SET(syslogPipe[0], &rfds);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
rc = select(syslogPipe[0] + 1, &rfds, NULL, NULL, &timeout);
if (rc < 0)
{
if (errno != EINTR)
ereport(LOG,
(errcode_for_socket_access(),
errmsg("select() failed in logger process: %m")));
}
else if (rc > 0 && FD_ISSET(syslogPipe[0], &rfds))
{
bytesRead = piperead(syslogPipe[0],
logbuffer + bytes_in_logbuffer,
sizeof(logbuffer) - bytes_in_logbuffer);
if (bytesRead < 0)
{
if (errno != EINTR)
ereport(LOG,
(errcode_for_socket_access(),
errmsg("could not read from logger pipe: %m")));
}
else if (bytesRead > 0)
{
bytes_in_logbuffer += bytesRead;
process_pipe_input(logbuffer, &bytes_in_logbuffer);
continue;
}
else
{
/*
* Zero bytes read when select() is saying read-ready means
* EOF on the pipe: that is, there are no longer any processes
* with the pipe write end open. Therefore, the postmaster
* and all backends are shut down, and we are done.
*/
pipe_eof_seen = true;
/* if there's any data left then force it out now */
flush_pipe_input(logbuffer, &bytes_in_logbuffer);
}
}
#else /* WIN32 */
/*
* On Windows we leave it to a separate thread to transfer data and
* detect pipe EOF. The main thread just wakes up once a second to
* check for SIGHUP and rotation conditions.
*
* Server code isn't generally thread-safe, so we ensure that only one
* of the threads is active at a time by entering the critical section
* whenever we're not sleeping.
*/
LeaveCriticalSection(&sysloggerSection);
pg_usleep(1000000L);
EnterCriticalSection(&sysloggerSection);
#endif /* WIN32 */
if (pipe_eof_seen)
{
/*
* seeing this message on the real stderr is annoying - so we make
* it DEBUG1 to suppress in normal use.
*/
ereport(DEBUG1,
(errmsg("logger shutting down")));
/*
* Normal exit from the syslogger is here. Note that we
* deliberately do not close syslogFile before exiting; this is to
* allow for the possibility of elog messages being generated
* inside proc_exit. Regular exit() will take care of flushing
* and closing stdio channels.
*/
proc_exit(0);
}
}
}
/*
* Main entry point for syslogger process
* argc/argv parameters are valid only in EXEC_BACKEND case.
*/
NON_EXEC_STATIC void
SysLoggerMain(int argc, char *argv[])
{
char *currentLogDir;
char *currentLogFilename;
int currentLogRotationAge;
IsUnderPostmaster = true; /* we are a postmaster subprocess now */
MyProcPid = getpid(); /* reset MyProcPid */
/* Lose the postmaster's on-exit routines */
on_exit_reset();
#ifdef EXEC_BACKEND
syslogger_parseArgs(argc, argv);
#endif /* EXEC_BACKEND */
am_syslogger = true;
init_ps_display("logger process", "", "");
set_ps_display("");
/*
* If we restarted, our stderr is already redirected into our own
* input pipe. This is of course pretty useless, not to mention that
* it interferes with detecting pipe EOF. Point stderr to /dev/null.
* This assumes that all interesting messages generated in the
* syslogger will come through elog.c and will be sent to
* write_syslogger_file.
*/
if (redirection_done)
{
int fd = open(NULL_DEV, O_WRONLY);
/*
* The closes might look redundant, but they are not: we want to
* be darn sure the pipe gets closed even if the open failed. We
* can survive running with stderr pointing nowhere, but we can't
* afford to have extra pipe input descriptors hanging around.
*/
close(fileno(stdout));
close(fileno(stderr));
dup2(fd, fileno(stdout));
dup2(fd, fileno(stderr));
close(fd);
}
/*
* Also close our copy of the write end of the pipe. This is needed
* to ensure we can detect pipe EOF correctly. (But note that in the
* restart case, the postmaster already did this.)
*/
#ifndef WIN32
if (syslogPipe[1] >= 0)
close(syslogPipe[1]);
syslogPipe[1] = -1;
#else
if (syslogPipe[1])
CloseHandle(syslogPipe[1]);
syslogPipe[1] = 0;
#endif
/*
* Properly accept or ignore signals the postmaster might send us
*
* Note: we ignore all termination signals, and instead exit only when
* all upstream processes are gone, to ensure we don't miss any dying
* gasps of broken backends...
*/
pqsignal(SIGHUP, sigHupHandler); /* set flag to read config file */
pqsignal(SIGINT, SIG_IGN);
pqsignal(SIGTERM, SIG_IGN);
pqsignal(SIGQUIT, SIG_IGN);
pqsignal(SIGALRM, SIG_IGN);
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, SIG_IGN);
pqsignal(SIGUSR2, SIG_IGN);
/*
* Reset some signals that are accepted by postmaster but not here
*/
pqsignal(SIGCHLD, SIG_DFL);
pqsignal(SIGTTIN, SIG_DFL);
pqsignal(SIGTTOU, SIG_DFL);
pqsignal(SIGCONT, SIG_DFL);
pqsignal(SIGWINCH, SIG_DFL);
PG_SETMASK(&UnBlockSig);
#ifdef WIN32
/* Fire up separate data transfer thread */
InitializeCriticalSection(&sysfileSection);
{
unsigned int tid;
threadHandle = (HANDLE) _beginthreadex(0, 0, pipeThread, 0, 0, &tid);
}
#endif /* WIN32 */
/* remember active logfile parameters */
currentLogDir = pstrdup(Log_directory);
currentLogFilename = pstrdup(Log_filename);
currentLogRotationAge = Log_RotationAge;
/* set next planned rotation time */
set_next_rotation_time();
/* main worker loop */
for (;;)
{
bool rotation_requested = false;
bool time_based_rotation = false;
#ifndef WIN32
char logbuffer[1024];
int bytesRead;
int rc;
fd_set rfds;
struct timeval timeout;
#endif
if (got_SIGHUP)
{
got_SIGHUP = false;
ProcessConfigFile(PGC_SIGHUP);
/*
* Check if the log directory or filename pattern changed in
* postgresql.conf. If so, force rotation to make sure we're
* writing the logfiles in the right place.
*/
if (strcmp(Log_directory, currentLogDir) != 0)
{
pfree(currentLogDir);
currentLogDir = pstrdup(Log_directory);
rotation_requested = true;
}
if (strcmp(Log_filename, currentLogFilename) != 0)
{
pfree(currentLogFilename);
currentLogFilename = pstrdup(Log_filename);
rotation_requested = true;
}
/*
* If rotation time parameter changed, reset next rotation time,
* but don't immediately force a rotation.
*/
if (currentLogRotationAge != Log_RotationAge)
{
currentLogRotationAge = Log_RotationAge;
set_next_rotation_time();
}
}
if (!rotation_requested && Log_RotationAge > 0)
{
/* Do a logfile rotation if it's time */
pg_time_t now = time(NULL);
if (now >= next_rotation_time)
rotation_requested = time_based_rotation = true;
}
if (!rotation_requested && Log_RotationSize > 0)
{
/* Do a rotation if file is too big */
if (ftell(syslogFile) >= Log_RotationSize * 1024L)
rotation_requested = true;
}
if (rotation_requested)
logfile_rotate(time_based_rotation);
#ifndef WIN32
/*
* Wait for some data, timing out after 1 second
*/
FD_ZERO(&rfds);
FD_SET(syslogPipe[0], &rfds);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
rc = select(syslogPipe[0] + 1, &rfds, NULL, NULL, &timeout);
if (rc < 0)
{
if (errno != EINTR)
ereport(LOG,
(errcode_for_socket_access(),
errmsg("select() failed in logger process: %m")));
}
else if (rc > 0 && FD_ISSET(syslogPipe[0], &rfds))
{
bytesRead = piperead(syslogPipe[0],
logbuffer, sizeof(logbuffer));
if (bytesRead < 0)
{
if (errno != EINTR)
ereport(LOG,
(errcode_for_socket_access(),
errmsg("could not read from logger pipe: %m")));
}
else if (bytesRead > 0)
{
write_syslogger_file_binary(logbuffer, bytesRead);
continue;
}
else
{
/*
* Zero bytes read when select() is saying read-ready
* means EOF on the pipe: that is, there are no longer any
* processes with the pipe write end open. Therefore, the
* postmaster and all backends are shut down, and we are
* done.
*/
pipe_eof_seen = true;
}
}
#else /* WIN32 */
/*
* On Windows we leave it to a separate thread to transfer data
* and detect pipe EOF. The main thread just wakes up once a
* second to check for SIGHUP and rotation conditions.
*/
pgwin32_backend_usleep(1000000);
#endif /* WIN32 */
if (pipe_eof_seen)
{
ereport(LOG,
(errmsg("logger shutting down")));
/*
* Normal exit from the syslogger is here. Note that we
* deliberately do not close syslogFile before exiting; this
* is to allow for the possibility of elog messages being
* generated inside proc_exit. Regular exit() will take care
* of flushing and closing stdio channels.
*/
proc_exit(0);
}
}
}
/* fork lifecheck process*/
static pid_t
fork_a_lifecheck(int fork_wait_time)
{
pid_t pid;
sigjmp_buf local_sigjmp_buf;
pid = fork();
if (pid != 0)
{
if (pid == -1)
ereport(ERROR,
(errmsg("failed to fork a lifecheck process")));
return pid;
}
on_exit_reset();
processType = PT_LIFECHECK;
if (fork_wait_time > 0) {
sleep(fork_wait_time);
}
POOL_SETMASK(&UnBlockSig);
init_ps_display("", "", "", "");
signal(SIGTERM, wd_exit);
signal(SIGINT, wd_exit);
signal(SIGQUIT, wd_exit);
signal(SIGCHLD, SIG_DFL);
signal(SIGHUP, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
/* Create per loop iteration memory context */
ProcessLoopContext = AllocSetContextCreate(TopMemoryContext,
"wd_lifecheck_main_loop",
ALLOCSET_DEFAULT_MINSIZE,
ALLOCSET_DEFAULT_INITSIZE,
ALLOCSET_DEFAULT_MAXSIZE);
MemoryContextSwitchTo(TopMemoryContext);
set_ps_display("lifecheck",false);
/* wait until ready to go */
while (WD_OK != is_wd_lifecheck_ready())
{
sleep(pool_config->wd_interval * 10);
}
ereport(LOG,
(errmsg("watchdog: lifecheck started")));
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/* Since not using PG_TRY, must reset error stack by hand */
error_context_stack = NULL;
EmitErrorReport();
MemoryContextSwitchTo(TopMemoryContext);
FlushErrorState();
sleep(pool_config->wd_heartbeat_keepalive);
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
/* watchdog loop */
for (;;)
{
MemoryContextSwitchTo(ProcessLoopContext);
MemoryContextResetAndDeleteChildren(ProcessLoopContext);
/* pgpool life check */
wd_lifecheck();
sleep(pool_config->wd_interval);
}
return pid;
}
/*
* FtsProbeMain
*/
NON_EXEC_STATIC void
ftsMain(int argc, char *argv[])
{
sigjmp_buf local_sigjmp_buf;
char *fullpath;
IsUnderPostmaster = true;
am_ftsprobe = true;
/* Stay away from PMChildSlot */
MyPMChildSlot = -1;
/* reset MyProcPid */
MyProcPid = getpid();
/* Lose the postmaster's on-exit routines */
on_exit_reset();
/* Identify myself via ps */
init_ps_display("ftsprobe process", "", "", "");
SetProcessingMode(InitProcessing);
/*
* reread postgresql.conf if requested
*/
pqsignal(SIGHUP, sigHupHandler);
/*
* Presently, SIGINT will lead to autovacuum shutdown, because that's how
* we handle ereport(ERROR). It could be improved however.
*/
pqsignal(SIGINT, ReqFtsFullScan); /* request full-scan */
pqsignal(SIGTERM, die);
pqsignal(SIGQUIT, quickdie); /* we don't do any ftsprobe specific cleanup, just use the standard. */
pqsignal(SIGALRM, handle_sig_alarm);
pqsignal(SIGPIPE, SIG_IGN);
pqsignal(SIGUSR1, procsignal_sigusr1_handler);
/* We don't listen for async notifies */
pqsignal(SIGUSR2, RequestShutdown);
pqsignal(SIGFPE, FloatExceptionHandler);
pqsignal(SIGCHLD, SIG_DFL);
/*
* Copied from bgwriter
*/
CurrentResourceOwner = ResourceOwnerCreate(NULL, "FTS Probe");
/* Early initialization */
BaseInit();
/* See InitPostgres()... */
InitProcess();
InitBufferPoolBackend();
InitXLOGAccess();
SetProcessingMode(NormalProcessing);
/*
* If an exception is encountered, processing resumes here.
*
* See notes in postgres.c about the design of this coding.
*/
if (sigsetjmp(local_sigjmp_buf, 1) != 0)
{
/* Prevents interrupts while cleaning up */
HOLD_INTERRUPTS();
/* Report the error to the server log */
EmitErrorReport();
/*
* We can now go away. Note that because we'll call InitProcess, a
* callback will be registered to do ProcKill, which will clean up
* necessary state.
*/
proc_exit(0);
}
/* We can now handle ereport(ERROR) */
PG_exception_stack = &local_sigjmp_buf;
PG_SETMASK(&UnBlockSig);
/*
* Add my PGPROC struct to the ProcArray.
*
* Once I have done this, I am visible to other backends!
*/
InitProcessPhase2();
/*
* Initialize my entry in the shared-invalidation manager's array of
* per-backend data.
*
* Sets up MyBackendId, a unique backend identifier.
*/
MyBackendId = InvalidBackendId;
SharedInvalBackendInit(false);
if (MyBackendId > MaxBackends || MyBackendId <= 0)
elog(FATAL, "bad backend id: %d", MyBackendId);
/*
* bufmgr needs another initialization call too
*/
InitBufferPoolBackend();
/* heap access requires the rel-cache */
RelationCacheInitialize();
InitCatalogCache();
/*
* It's now possible to do real access to the system catalogs.
*
* Load relcache entries for the system catalogs. This must create at
* least the minimum set of "nailed-in" cache entries.
*/
RelationCacheInitializePhase2();
/*
* In order to access the catalog, we need a database, and a
* tablespace; our access to the heap is going to be slightly
* limited, so we'll just use some defaults.
*/
if (!FindMyDatabase(probeDatabase, &MyDatabaseId, &MyDatabaseTableSpace))
ereport(FATAL,
(errcode(ERRCODE_UNDEFINED_DATABASE),
errmsg("database \"%s\" does not exit", probeDatabase)));
/* Now we can mark our PGPROC entry with the database ID */
/* (We assume this is an atomic store so no lock is needed) */
MyProc->databaseId = MyDatabaseId;
fullpath = GetDatabasePath(MyDatabaseId, MyDatabaseTableSpace);
SetDatabasePath(fullpath);
RelationCacheInitializePhase3();
/* shmem: publish probe pid */
ftsProbeInfo->fts_probePid = MyProcPid;
/* main loop */
FtsLoop();
/* One iteration done, go away */
proc_exit(0);
}
