/*
* find connection by user and database
*/
POOL_CONNECTION_POOL *pool_get_cp(char *user, char *database, int protoMajor, int check_socket)
{
#ifdef HAVE_SIGPROCMASK
sigset_t oldmask;
#else
int oldmask;
#endif
int i;
POOL_CONNECTION_POOL *p = pool_connection_pool;
if (p == NULL)
{
pool_error("pool_get_cp: pool_connection_pool is not initialized");
return NULL;
}
POOL_SETMASK2(&BlockSig, &oldmask);
for (i=0;i<pool_config.max_pool;i++)
{
if (MASTER_CONNECTION(p) &&
MASTER_CONNECTION(p)->sp->major == protoMajor &&
MASTER_CONNECTION(p)->sp->user != NULL &&
strcmp(MASTER_CONNECTION(p)->sp->user, user) == 0 &&
strcmp(MASTER_CONNECTION(p)->sp->database, database) == 0)
{
/* mark this connection is under use */
MASTER_CONNECTION(p)->closetime = 0;
POOL_SETMASK(&oldmask);
if (check_socket &&
(check_socket_status(MASTER(p)->fd) < 0 ||
(DUAL_MODE && check_socket_status(MASTER(p)->fd) < 0)))
{
pool_log("connection closed. retry to create new connection pool.");
pool_free_startup_packet(MASTER_CONNECTION(p)->sp);
pool_close(MASTER_CONNECTION(p)->con);
free(MASTER_CONNECTION(p));
if (DUAL_MODE)
{
pool_close(SECONDARY_CONNECTION(p)->con);
free(SECONDARY_CONNECTION(p));
}
memset(p, 0, sizeof(POOL_CONNECTION_POOL));
return NULL;
}
return p;
}
p++;
}
POOL_SETMASK(&oldmask);
return NULL;
}
static POOL_CONNECTION_POOL *connect_backend(StartupPacket *sp, POOL_CONNECTION *frontend)
{
POOL_CONNECTION_POOL *backend;
int i;
/* connect to the backend */
backend = pool_create_cp();
if (backend == NULL)
{
pool_send_error_message(frontend, sp->major, "XX000", "connection cache is full", "",
"increase max_pool", __FILE__, __LINE__);
pool_close(frontend);
pool_free_startup_packet(sp);
return NULL;
}
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i))
{
/* set DB node id */
CONNECTION(backend, i)->db_node_id = i;
/* mark this is a backend connection */
CONNECTION(backend, i)->isbackend = 1;
pool_ssl_negotiate_clientserver(CONNECTION(backend, i));
/*
* save startup packet info
*/
CONNECTION_SLOT(backend, i)->sp = sp;
/* send startup packet */
if (send_startup_packet(CONNECTION_SLOT(backend, i)) < 0)
{
pool_error("do_child: fails to send startup packet to the %d th backend", i);
pool_discard_cp(sp->user, sp->database, sp->major);
pool_close(frontend);
return NULL;
}
}
}
/*
* do authentication stuff
*/
if (pool_do_auth(frontend, backend))
{
pool_close(frontend);
pool_discard_cp(sp->user, sp->database, sp->major);
return NULL;
}
return backend;
}
/*
* Do house keeping works when pgpool child process exits
*/
void child_exit(int code)
{
if (getpid() == mypid)
{
pool_log("child_exit: called from pgpool main. ignored.");
return;
}
/* count down global connection counter */
if (accepted)
connection_count_down();
/* prepare to shutdown connections to system db */
if(pool_config->parallel_mode || pool_config->enable_query_cache)
{
if (system_db_info->pgconn)
pool_close_libpq_connection();
if (pool_system_db_connection())
pool_close(pool_system_db_connection()->con);
}
if (pool_config->memory_cache_enabled && !pool_is_shmem_cache())
{
memcached_disconnect();
}
/* let backend know now we are exiting */
if (pool_connection_pool)
send_frontend_exits();
exit(code);
}
/*
* Discard connection and memory allocated by
* make_persistent_db_connection().
*/
void discard_persistent_db_connection(POOL_CONNECTION_POOL_SLOT *cp)
{
int len;
if(cp == NULL)
return;
pool_write(cp->con, "X", 1);
len = htonl(4);
pool_write(cp->con, &len, sizeof(len));
/*
* XXX we cannot call pool_flush() here since backend may already
* close the socket and pool_flush() automatically invokes fail
* over handler. This could happen in copy command (remember the
* famous "lost synchronization with server, resetting
* connection" message)
*/
pool_set_nonblock(cp->con->fd);
pool_flush_it(cp->con);
pool_unset_nonblock(cp->con->fd);
pool_close(cp->con);
free(cp->sp->startup_packet);
free(cp->sp->database);
free(cp->sp->user);
free(cp->sp);
free(cp);
}
/*
* strhash_close: close hash array.
*
* i) sh STRHASH structure
*/
void
strhash_close(STRHASH *sh)
{
pool_close(sh->pool);
free(sh->htab);
free(sh);
}
/*
* disconnect and release a connection to the database
*/
void pool_discard_cp(char *user, char *database, int protoMajor)
{
POOL_CONNECTION_POOL *p = pool_get_cp(user, database, protoMajor, 0);
ConnectionInfo *info;
int i, freed = 0;
if (p == NULL)
{
pool_error("pool_discard_cp: cannot get connection pool for user %s datbase %s", user, database);
return;
}
for (i=0;i<NUM_BACKENDS;i++)
{
if (!VALID_BACKEND(i))
continue;
if (!freed)
{
pool_free_startup_packet(CONNECTION_SLOT(p, i)->sp);
freed = 1;
}
pool_close(CONNECTION(p, i));
free(CONNECTION_SLOT(p, i));
}
info = p->info;
memset(p, 0, sizeof(POOL_CONNECTION_POOL));
p->info = info;
memset(p->info, 0, sizeof(ConnectionInfo) * MAX_NUM_BACKENDS);
}
/**
* gfind_close: close iterator.
*/
void
gfind_close(GFIND *gfind)
{
dbop_close(gfind->dbop);
if (gfind->flags & GPATH_NEARSORT) {
pool_close(gfind->pool);
varray_close(gfind->path_array);
}
free((void *)gfind->prefix);
free(gfind);
}
/**
* Command redis
*/
static redisReply* redisCli(server_rec *s, const char *format, ...) {
redisContext* ctx = pool_open(s);
void *reply = NULL;
if (ctx) {
va_list ap;
va_start(ap,format);
reply = redisvCommand(ctx,format,ap);
va_end(ap);
pool_close(s, ctx);
}
return reply;
}
/*
* disconnect and release a connection to the database
*/
void pool_discard_cp(char *user, char *database, int protoMajor)
{
POOL_CONNECTION_POOL *p = pool_get_cp(user, database, protoMajor, 0);
if (p == NULL)
{
pool_error("pool_discard_cp: cannot get connection pool for user %s datbase %s", user, database);
return;
}
pool_free_startup_packet(MASTER_CONNECTION(p)->sp);
pool_close(MASTER_CONNECTION(p)->con);
free(MASTER_CONNECTION(p));
if (DUAL_MODE)
{
/* do not free memory! we did not allocate them */
pool_close(SECONDARY_CONNECTION(p)->con);
free(SECONDARY_CONNECTION(p));
}
memset(p, 0, sizeof(POOL_CONNECTION_POOL));
}
/*
* signal handler for SIGUSR1
* close all idle connections
*/
static RETSIGTYPE close_idle_connection(int sig)
{
int i, j;
POOL_CONNECTION_POOL *p = pool_connection_pool;
ConnectionInfo *info;
pool_debug("child receives close connection request");
for (j=0;j<pool_config->max_pool;j++, p++)
{
if (!MASTER_CONNECTION(p))
continue;
if (!MASTER_CONNECTION(p)->sp)
continue;
if (MASTER_CONNECTION(p)->sp->user == NULL)
continue;
if (MASTER_CONNECTION(p)->closetime > 0) /* idle connection? */
{
pool_debug("close_idle_connection: close idle connection: user %s database %s", MASTER_CONNECTION(p)->sp->user, MASTER_CONNECTION(p)->sp->database);
pool_send_frontend_exits(p);
for (i=0;i<NUM_BACKENDS;i++)
{
if (!VALID_BACKEND(i))
continue;
if (i == 0)
{
/* only first backend allocated the memory for the start up packet */
pool_free_startup_packet(CONNECTION_SLOT(p, i)->sp);
}
pool_close(CONNECTION(p, i));
}
info = p->info;
memset(p, 0, sizeof(POOL_CONNECTION_POOL));
p->info = info;
memset(p->info, 0, sizeof(ConnectionInfo));
}
}
}
/**
* gtags_close: close tag file
*
* @param[in] gtop #GTOP structure
*/
void
gtags_close(GTOP *gtop)
{
if (gtop->format & GTAGS_COMPRESS)
abbrev_close();
if (gtop->segment_pool)
pool_close(gtop->segment_pool);
if (gtop->path_array)
free(gtop->path_array);
if (gtop->sb)
strbuf_close(gtop->sb);
if (gtop->vb)
varray_close(gtop->vb);
if (gtop->path_hash)
strhash_close(gtop->path_hash);
gpath_close();
dbop_close(gtop->dbop);
if (gtop->gtags)
dbop_close(gtop->gtags);
free(gtop);
}
/*
* create a persistent connection
*/
POOL_CONNECTION_POOL_SLOT *make_persistent_db_connection(
char *hostname, int port, char *dbname, char *user, char *password, bool retry)
{
POOL_CONNECTION_POOL_SLOT *cp;
int fd;
#define MAX_USER_AND_DATABASE 1024
/* V3 startup packet */
typedef struct {
int protoVersion;
char data[MAX_USER_AND_DATABASE];
} StartupPacket_v3;
static StartupPacket_v3 *startup_packet;
int len, len1;
int status;
cp = malloc(sizeof(POOL_CONNECTION_POOL_SLOT));
if (cp == NULL)
{
pool_error("make_persistent_db_connection: could not allocate memory");
return NULL;
}
memset(cp, 0, sizeof(POOL_CONNECTION_POOL_SLOT));
startup_packet = malloc(sizeof(*startup_packet));
if (startup_packet == NULL)
{
pool_error("make_persistent_db_connection: could not allocate memory");
free_persisten_db_connection_memory(cp);
return NULL;
}
memset(startup_packet, 0, sizeof(*startup_packet));
startup_packet->protoVersion = htonl(0x00030000); /* set V3 proto major/minor */
/*
* create socket
*/
if (*hostname == '/')
{
fd = connect_unix_domain_socket_by_port(port, hostname, retry);
}
else
{
fd = connect_inet_domain_socket_by_port(hostname, port, retry);
}
if (fd < 0)
{
pool_error("make_persistent_db_connection: connection to %s(%d) failed", hostname, port);
free_persisten_db_connection_memory(cp);
free(startup_packet);
return NULL;
}
cp->con = pool_open(fd);
cp->closetime = 0;
cp->con->isbackend = 1;
pool_ssl_negotiate_clientserver(cp->con);
/*
* build V3 startup packet
*/
len = snprintf(startup_packet->data, sizeof(startup_packet->data), "user") + 1;
len1 = snprintf(&startup_packet->data[len], sizeof(startup_packet->data)-len, "%s", user) + 1;
if (len1 >= (sizeof(startup_packet->data)-len))
{
pool_error("make_persistent_db_connection: too long user name");
pool_close(cp->con);
free_persisten_db_connection_memory(cp);
free(startup_packet);
return NULL;
}
len += len1;
len1 = snprintf(&startup_packet->data[len], sizeof(startup_packet->data)-len, "database") + 1;
if (len1 >= (sizeof(startup_packet->data)-len))
{
pool_error("make_persistent_db_connection: too long user name");
pool_close(cp->con);
free_persisten_db_connection_memory(cp);
free(startup_packet);
return NULL;
}
len += len1;
len1 = snprintf(&startup_packet->data[len], sizeof(startup_packet->data)-len, "%s", dbname) + 1;
if (len1 >= (sizeof(startup_packet->data)-len))
{
pool_error("make_persistent_db_connection: too long database name");
pool_close(cp->con);
free_persisten_db_connection_memory(cp);
free(startup_packet);
return NULL;
}
len += len1;
startup_packet->data[len++] = '\0';
cp->sp = malloc(sizeof(StartupPacket));
if (cp->sp == NULL)
{
pool_error("make_persistent_db_connection: could not allocate memory");
pool_close(cp->con);
free_persisten_db_connection_memory(cp);
free(startup_packet);
return NULL;
}
cp->sp->startup_packet = (char *)startup_packet;
cp->sp->len = len + 4;
cp->sp->major = 3;
cp->sp->minor = 0;
cp->sp->database = strdup(dbname);
if (cp->sp->database == NULL)
{
pool_error("make_persistent_db_connection: could not allocate memory");
pool_close(cp->con);
free_persisten_db_connection_memory(cp);
return NULL;
}
cp->sp->user = strdup(user);
if (cp->sp->user == NULL)
{
pool_error("make_persistent_db_connection: could not allocate memory");
pool_close(cp->con);
free_persisten_db_connection_memory(cp);
return NULL;
}
/*
* send startup packet
*/
status = send_startup_packet(cp);
if (status)
{
pool_error("make_persistent_db_connection: send_startup_packet failed");
pool_close(cp->con);
free_persisten_db_connection_memory(cp);
return NULL;
}
/*
* do authentication
*/
if (s_do_auth(cp, password))
{
pool_error("make_persistent_db_connection: s_do_auth failed");
pool_close(cp->con);
free_persisten_db_connection_memory(cp);
return NULL;
}
return cp;
}
/*
* find connection by user and database
*/
POOL_CONNECTION_POOL *pool_get_cp(char *user, char *database, int protoMajor, int check_socket)
{
#ifdef HAVE_SIGPROCMASK
sigset_t oldmask;
#else
int oldmask;
#endif
int i, freed = 0;
ConnectionInfo *info;
POOL_CONNECTION_POOL *p = pool_connection_pool;
if (p == NULL)
{
pool_error("pool_get_cp: pool_connection_pool is not initialized");
return NULL;
}
POOL_SETMASK2(&BlockSig, &oldmask);
for (i=0;i<pool_config->max_pool;i++)
{
if (MASTER_CONNECTION(p) &&
MASTER_CONNECTION(p)->sp &&
MASTER_CONNECTION(p)->sp->major == protoMajor &&
MASTER_CONNECTION(p)->sp->user != NULL &&
strcmp(MASTER_CONNECTION(p)->sp->user, user) == 0 &&
strcmp(MASTER_CONNECTION(p)->sp->database, database) == 0)
{
int sock_broken = 0;
int j;
/* mark this connection is under use */
MASTER_CONNECTION(p)->closetime = 0;
for (j=0;j<NUM_BACKENDS;j++)
{
p->info[j].counter++;
}
POOL_SETMASK(&oldmask);
if (check_socket)
{
for (j=0;j<NUM_BACKENDS;j++)
{
if (!VALID_BACKEND(j))
continue;
if (CONNECTION_SLOT(p, j))
{
sock_broken = check_socket_status(CONNECTION(p, j)->fd);
if (sock_broken < 0)
break;
}
else
{
sock_broken = -1;
break;
}
}
if (sock_broken < 0)
{
pool_log("connection closed. retry to create new connection pool.");
for (j=0;j<NUM_BACKENDS;j++)
{
if (!VALID_BACKEND(j) || (CONNECTION_SLOT(p, j) == NULL))
continue;
if (!freed)
{
pool_free_startup_packet(CONNECTION_SLOT(p, j)->sp);
freed = 1;
}
pool_close(CONNECTION(p, j));
free(CONNECTION_SLOT(p, j));
}
info = p->info;
memset(p, 0, sizeof(POOL_CONNECTION_POOL_SLOT));
p->info = info;
memset(p->info, 0, sizeof(ConnectionInfo) * MAX_NUM_BACKENDS);
POOL_SETMASK(&oldmask);
return NULL;
}
}
POOL_SETMASK(&oldmask);
pool_index = i;
return p;
}
p++;
}
POOL_SETMASK(&oldmask);
return NULL;
}
void pool_backend_timer(void)
{
#define TMINTMAX 0x7fffffff
POOL_CONNECTION_POOL *p = pool_connection_pool;
int i, j;
time_t now;
time_t nearest = TMINTMAX;
ConnectionInfo *info;
POOL_SETMASK(&BlockSig);
now = time(NULL);
pool_debug("pool_backend_timer_handler called at %ld", now);
for (i=0;i<pool_config->max_pool;i++, p++)
{
if (!MASTER_CONNECTION(p))
continue;
if (!MASTER_CONNECTION(p)->sp)
continue;
if (MASTER_CONNECTION(p)->sp->user == NULL)
continue;
/* timer expire? */
if (MASTER_CONNECTION(p)->closetime)
{
int freed = 0;
pool_debug("pool_backend_timer_handler: expire time: %ld",
MASTER_CONNECTION(p)->closetime+pool_config->connection_life_time);
if (now >= (MASTER_CONNECTION(p)->closetime+pool_config->connection_life_time))
{
/* discard expired connection */
pool_debug("pool_backend_timer_handler: expires user %s database %s",
MASTER_CONNECTION(p)->sp->user, MASTER_CONNECTION(p)->sp->database);
pool_send_frontend_exits(p);
for (j=0;j<NUM_BACKENDS;j++)
{
if (!VALID_BACKEND(j))
continue;
if (!freed)
{
pool_free_startup_packet(CONNECTION_SLOT(p, j)->sp);
freed = 1;
}
pool_close(CONNECTION(p, j));
free(CONNECTION_SLOT(p, j));
}
info = p->info;
memset(p, 0, sizeof(POOL_CONNECTION_POOL));
p->info = info;
memset(p->info, 0, sizeof(ConnectionInfo) * MAX_NUM_BACKENDS);
/* prepare to shutdown connections to system db */
if(pool_config->system_db_dynamic_connection && (pool_config->parallel_mode || pool_config->enable_query_cache))
{
if (system_db_info->pgconn)
pool_close_libpq_connection();
if (pool_system_db_connection() && pool_system_db_connection()->con)
{
pool_send_frontend_exit(pool_system_db_connection()->con);
pool_close(pool_system_db_connection()->con);
}
if( system_db_info->connection )
{
free( system_db_info->connection );
memset(system_db_info->connection, 0, sizeof(POOL_CONNECTION_POOL_SLOT));
system_db_info->connection = NULL;
}
}
}
else
{
/* look for nearest timer */
if (MASTER_CONNECTION(p)->closetime < nearest)
nearest = MASTER_CONNECTION(p)->closetime;
}
}
}
/* any remaining timer */
if (nearest != TMINTMAX)
{
nearest = pool_config->connection_life_time - (now - nearest);
if (nearest <= 0)
nearest = 1;
pool_signal(SIGALRM, pool_backend_timer_handler);
alarm(nearest);
}
POOL_SETMASK(&UnBlockSig);
}
/*
* create a connection pool by user and database
*/
POOL_CONNECTION_POOL *pool_create_cp(void)
{
int i, freed = 0;
time_t closetime;
POOL_CONNECTION_POOL *oldestp;
POOL_CONNECTION_POOL *ret;
ConnectionInfo *info;
POOL_CONNECTION_POOL *p = pool_connection_pool;
if (p == NULL)
{
pool_error("pool_create_cp: pool_connection_pool is not initialized");
return NULL;
}
for (i=0;i<pool_config->max_pool;i++)
{
if (MASTER_CONNECTION(p) == NULL)
{
ret = new_connection(p);
if (ret)
pool_index = i;
return ret;
}
p++;
}
pool_debug("no empty connection slot was found");
/*
* no empty connection slot was found. look for the oldest connection and discard it.
*/
oldestp = p = pool_connection_pool;
closetime = MASTER_CONNECTION(p)->closetime;
pool_index = 0;
for (i=0;i<pool_config->max_pool;i++)
{
pool_debug("user: %s database: %s closetime: %ld",
MASTER_CONNECTION(p)->sp->user,
MASTER_CONNECTION(p)->sp->database,
MASTER_CONNECTION(p)->closetime);
if (MASTER_CONNECTION(p)->closetime < closetime)
{
closetime = MASTER_CONNECTION(p)->closetime;
oldestp = p;
pool_index = i;
}
p++;
}
p = oldestp;
pool_send_frontend_exits(p);
pool_debug("discarding old %zd th connection. user: %s database: %s",
oldestp - pool_connection_pool,
MASTER_CONNECTION(p)->sp->user,
MASTER_CONNECTION(p)->sp->database);
for (i=0;i<NUM_BACKENDS;i++)
{
if (!VALID_BACKEND(i))
continue;
if (!freed)
{
pool_free_startup_packet(CONNECTION_SLOT(p, i)->sp);
freed = 1;
}
pool_close(CONNECTION(p, i));
free(CONNECTION_SLOT(p, i));
}
info = p->info;
memset(p, 0, sizeof(POOL_CONNECTION_POOL));
p->info = info;
memset(p->info, 0, sizeof(ConnectionInfo) * MAX_NUM_BACKENDS);
ret = new_connection(p);
return ret;
}
/*
* create a connection pool by user and database
*/
POOL_CONNECTION_POOL *pool_create_cp(void)
{
int i;
time_t closetime;
POOL_CONNECTION_POOL *oldestp;
POOL_CONNECTION_POOL *p = pool_connection_pool;
if (p == NULL)
{
pool_error("pool_create_cp: pool_connection_pool is not initialized");
return NULL;
}
for (i=0;i<pool_config.max_pool;i++)
{
if (MASTER_CONNECTION(p) == NULL)
return new_connection(p);
p++;
}
pool_debug("no empty connection slot was found");
/*
* no empty connection slot was found. look for the oldest connection and discard it.
*/
oldestp = p = pool_connection_pool;
closetime = MASTER_CONNECTION(p)->closetime;
for (i=0;i<pool_config.max_pool;i++)
{
pool_debug("user: %s database: %s closetime: %d",
MASTER_CONNECTION(p)->sp->user,
MASTER_CONNECTION(p)->sp->database,
MASTER_CONNECTION(p)->closetime);
if (MASTER_CONNECTION(p)->closetime < closetime)
{
closetime = MASTER_CONNECTION(p)->closetime;
oldestp = p;
}
p++;
}
p = oldestp;
pool_send_frontend_exits(p);
pool_debug("discarding old %d th connection. user: %s database: %s",
oldestp - pool_connection_pool,
MASTER_CONNECTION(p)->sp->user,
MASTER_CONNECTION(p)->sp->database);
pool_free_startup_packet(MASTER_CONNECTION(p)->sp);
pool_close(MASTER_CONNECTION(p)->con);
free(MASTER_CONNECTION(p));
if (DUAL_MODE)
{
/* do not free memory! we did not allocate them */
pool_close(SECONDARY_CONNECTION(p)->con);
free(SECONDARY_CONNECTION(p));
}
memset(p, 0, sizeof(POOL_CONNECTION_POOL));
return new_connection(p);
}
void pool_backend_timer(void)
{
#define TMINTMAX 0x7fffffff
POOL_CONNECTION_POOL *p = pool_connection_pool;
int i;
time_t now;
time_t nearest = TMINTMAX;
POOL_SETMASK(&BlockSig);
now = time(NULL);
pool_debug("pool_backend_timer_handler called at %d", now);
for (i=0;i<pool_config.max_pool;i++, p++)
{
if (!MASTER_CONNECTION(p))
continue;
if (MASTER_CONNECTION(p)->sp->user == NULL)
continue;
/* timer expire? */
if (MASTER_CONNECTION(p)->closetime)
{
pool_debug("pool_backend_timer_handler: expire time: %d",
MASTER_CONNECTION(p)->closetime+pool_config.connection_life_time);
if (now >= (MASTER_CONNECTION(p)->closetime+pool_config.connection_life_time))
{
/* discard expired connection */
pool_debug("pool_backend_timer_handler: expires user %s database %s", MASTER_CONNECTION(p)->sp->user, MASTER_CONNECTION(p)->sp->database);
pool_send_frontend_exits(p);
pool_free_startup_packet(MASTER_CONNECTION(p)->sp);
pool_close(MASTER_CONNECTION(p)->con);
free(MASTER_CONNECTION(p));
if (DUAL_MODE)
{
pool_close(SECONDARY_CONNECTION(p)->con);
free(SECONDARY_CONNECTION(p));
}
memset(p, 0, sizeof(POOL_CONNECTION_POOL));
}
else
{
/* look for nearest timer */
if (MASTER_CONNECTION(p)->closetime < nearest)
nearest = MASTER_CONNECTION(p)->closetime;
}
}
}
/* any remaining timer */
if (nearest != TMINTMAX)
{
nearest = pool_config.connection_life_time - (now - nearest);
if (nearest <= 0)
nearest = 1;
pool_signal(SIGALRM, pool_backend_timer_handler);
alarm(nearest);
}
POOL_SETMASK(&UnBlockSig);
}
/*
* 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);
goto retry_startup;
}
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);
}
/*
* 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);
}
/*
* perform accept() and return new fd
*/
static POOL_CONNECTION *do_accept(int unix_fd, int inet_fd, struct timeval *timeout)
{
fd_set readmask;
int fds;
int save_errno;
SockAddr saddr;
int fd = 0;
int afd;
int inet = 0;
POOL_CONNECTION *cp;
#ifdef ACCEPT_PERFORMANCE
struct timeval now1, now2;
static long atime;
static int cnt;
#endif
struct timeval *timeoutval;
struct timeval tv1, tv2, tmback = {0, 0};
set_ps_display("wait for connection request", false);
/* Destroy session context for just in case... */
pool_session_context_destroy();
FD_ZERO(&readmask);
FD_SET(unix_fd, &readmask);
if (inet_fd)
FD_SET(inet_fd, &readmask);
if (timeout->tv_sec == 0 && timeout->tv_usec == 0)
timeoutval = NULL;
else
{
timeoutval = timeout;
tmback.tv_sec = timeout->tv_sec;
tmback.tv_usec = timeout->tv_usec;
gettimeofday(&tv1, NULL);
#ifdef DEBUG
pool_log("before select = {%d, %d}", timeoutval->tv_sec, timeoutval->tv_usec);
pool_log("g:before select = {%d, %d}", tv1.tv_sec, tv1.tv_usec);
#endif
}
fds = select(Max(unix_fd, inet_fd)+1, &readmask, NULL, NULL, timeoutval);
save_errno = errno;
/* check backend timer is expired */
if (backend_timer_expired)
{
pool_backend_timer();
backend_timer_expired = 0;
}
/*
* following code fragment computes remaining timeout val in a
* portable way. Linux does this automatically but other platforms do not.
*/
if (timeoutval)
{
gettimeofday(&tv2, NULL);
tmback.tv_usec -= tv2.tv_usec - tv1.tv_usec;
tmback.tv_sec -= tv2.tv_sec - tv1.tv_sec;
if (tmback.tv_usec < 0)
{
tmback.tv_sec--;
if (tmback.tv_sec < 0)
{
timeout->tv_sec = 0;
timeout->tv_usec = 0;
}
else
{
tmback.tv_usec += 1000000;
timeout->tv_sec = tmback.tv_sec;
timeout->tv_usec = tmback.tv_usec;
}
}
#ifdef DEBUG
pool_log("g:after select = {%d, %d}", tv2.tv_sec, tv2.tv_usec);
pool_log("after select = {%d, %d}", timeout->tv_sec, timeout->tv_usec);
#endif
}
errno = save_errno;
if (fds == -1)
{
if (errno == EAGAIN || errno == EINTR)
return NULL;
pool_error("select() failed. reason %s", strerror(errno));
return NULL;
}
/* timeout */
if (fds == 0)
{
return NULL;
}
if (FD_ISSET(unix_fd, &readmask))
{
fd = unix_fd;
}
if (FD_ISSET(inet_fd, &readmask))
{
fd = inet_fd;
inet++;
}
/*
* Note that some SysV systems do not work here. For those
* systems, we need some locking mechanism for the fd.
*/
memset(&saddr, 0, sizeof(saddr));
saddr.salen = sizeof(saddr.addr);
#ifdef ACCEPT_PERFORMANCE
gettimeofday(&now1,0);
#endif
retry_accept:
/* wait if recovery is started */
while (*InRecovery == 1)
{
pause();
}
afd = accept(fd, (struct sockaddr *)&saddr.addr, &saddr.salen);
save_errno = errno;
/* check backend timer is expired */
if (backend_timer_expired)
{
pool_backend_timer();
backend_timer_expired = 0;
}
errno = save_errno;
if (afd < 0)
{
if (errno == EINTR && *InRecovery)
goto retry_accept;
/*
* "Resource temporarily unavailable" (EAGAIN or EWOULDBLOCK)
* can be silently ignored. And EINTR can be ignored.
*/
if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
pool_error("accept() failed. reason: %s", strerror(errno));
return NULL;
}
#ifdef ACCEPT_PERFORMANCE
gettimeofday(&now2,0);
atime += (now2.tv_sec - now1.tv_sec)*1000000 + (now2.tv_usec - now1.tv_usec);
cnt++;
if (cnt % 100 == 0)
{
pool_log("cnt: %d atime: %ld", cnt, atime);
}
#endif
/* reload config file */
if (got_sighup)
{
pool_get_config(get_config_file_name(), RELOAD_CONFIG);
if (pool_config->enable_pool_hba)
{
load_hba(get_hba_file_name());
if (strcmp("", pool_config->pool_passwd))
pool_reopen_passwd_file();
}
if (pool_config->parallel_mode)
pool_memset_system_db_info(system_db_info->info);
got_sighup = 0;
}
connection_count_up();
accepted = 1;
if (pool_config->parallel_mode)
{
/*
* do not accept new connection if any of DB node or SystemDB is down when operating in
* parallel mode
*/
int i;
for (i=0;i<NUM_BACKENDS;i++)
{
if (BACKEND_INFO(i).backend_status == CON_DOWN || SYSDB_STATUS == CON_DOWN)
{
StartupPacket *sp;
char *msg = "pgpool is not available in parallel query mode";
if (SYSDB_STATUS == CON_DOWN)
pool_log("Cannot accept() new connection. SystemDB is down");
else
pool_log("Cannot accept() new connection. %d th backend is down", i);
if ((cp = pool_open(afd)) == NULL)
{
close(afd);
child_exit(1);
}
sp = read_startup_packet(cp);
if (sp == NULL)
{
/* failed to read the startup packet. return to the accept() loop */
pool_close(cp);
child_exit(1);
}
pool_debug("do_accept: send error message to frontend");
if (sp->major == PROTO_MAJOR_V3)
{
char buf[256];
if (SYSDB_STATUS == CON_DOWN)
snprintf(buf, sizeof(buf), "SystemDB is down");
else
snprintf(buf, sizeof(buf), "%d th backend is down", i);
pool_send_error_message(cp, sp->major, "08S01",
msg,
buf,
((SYSDB_STATUS == CON_DOWN) ? "repair the SystemDB and restart pgpool"
: "repair the backend and restart pgpool"),
__FILE__,
__LINE__);
}
else
{
pool_send_error_message(cp, sp->major,
0,
msg,
"",
"",
"",
0);
}
pool_close(cp);
child_exit(1);
}
}
}
else
{
/*
* do not accept new connection if all DB nodes are down when operating in
* non parallel mode
*/
int i;
int found = 0;
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i))
{
found = 1;
}
}
if (found == 0)
{
pool_log("Cannot accept() new connection. all backends are down");
child_exit(1);
}
}
pool_debug("I am %d accept fd %d", getpid(), afd);
pool_getnameinfo_all(&saddr, remote_host, remote_port);
snprintf(remote_ps_data, sizeof(remote_ps_data),
remote_port[0] == '\0' ? "%s" : "%s(%s)",
remote_host, remote_port);
set_ps_display("accept connection", false);
/* log who is connecting */
if (pool_config->log_connections)
{
pool_log("connection received: host=%s%s%s",
remote_host, remote_port[0] ? " port=" : "", remote_port);
}
/* set NODELAY and KEEPALIVE options if INET connection */
if (inet)
{
int on = 1;
if (setsockopt(afd, IPPROTO_TCP, TCP_NODELAY,
(char *) &on,
sizeof(on)) < 0)
{
pool_error("do_accept: setsockopt() failed: %s", strerror(errno));
close(afd);
return NULL;
}
if (setsockopt(afd, SOL_SOCKET, SO_KEEPALIVE,
(char *) &on,
sizeof(on)) < 0)
{
pool_error("do_accept: setsockopt() failed: %s", strerror(errno));
close(afd);
return NULL;
}
}
if ((cp = pool_open(afd)) == NULL)
{
close(afd);
return NULL;
}
/* save ip address for hba */
memcpy(&cp->raddr, &saddr, sizeof(SockAddr));
if (cp->raddr.addr.ss_family == 0)
cp->raddr.addr.ss_family = AF_UNIX;
return cp;
}
/*
* Reuse existing connection
*/
static bool connect_using_existing_connection(POOL_CONNECTION *frontend,
POOL_CONNECTION_POOL *backend,
StartupPacket *sp)
{
int i, freed = 0;
/*
* Save startup packet info
*/
for (i = 0; i < NUM_BACKENDS; i++)
{
if (VALID_BACKEND(i))
{
if (!freed)
{
pool_free_startup_packet(backend->slots[i]->sp);
freed = 1;
}
backend->slots[i]->sp = sp;
}
}
/* Reuse existing connection to backend */
if (pool_do_reauth(frontend, backend))
{
pool_close(frontend);
connection_count_down();
return false;
}
if (MAJOR(backend) == 3)
{
char command_buf[1024];
/* If we have received application_name in the start up
* packet, we send SET command to backend. Also we add or
* replace existing application_name data.
*/
if (sp->application_name)
{
snprintf(command_buf, sizeof(command_buf), "SET application_name TO '%s'", sp->application_name);
for (i=0;i<NUM_BACKENDS;i++)
{
if (VALID_BACKEND(i))
if (do_command(frontend, CONNECTION(backend, i),
command_buf, MAJOR(backend),
MASTER_CONNECTION(backend)->pid,
MASTER_CONNECTION(backend)->key, 0) != POOL_CONTINUE)
{
pool_error("connect_using_existing_connection: do_command failed. command: %s", command_buf);
return false;
}
}
pool_add_param(&MASTER(backend)->params, "application_name", sp->application_name);
}
if (send_params(frontend, backend))
{
pool_close(frontend);
connection_count_down();
return false;
}
}
/* Send ReadyForQuery to frontend */
pool_write(frontend, "Z", 1);
if (MAJOR(backend) == 3)
{
int len;
char tstate;
len = htonl(5);
pool_write(frontend, &len, sizeof(len));
tstate = TSTATE(backend, MASTER_NODE_ID);
pool_write(frontend, &tstate, 1);
}
if (pool_flush(frontend) < 0)
{
pool_close(frontend);
connection_count_down();
return false;
}
return true;
}
/*
* process cancel request
*/
void cancel_request(CancelPacket *sp)
{
int len;
int fd;
POOL_CONNECTION *con;
int i,j,k;
ConnectionInfo *c = NULL;
CancelPacket cp;
bool found = false;
pool_debug("Cancel request received");
/* look for cancel key from shmem info */
for (i=0;i<pool_config->num_init_children;i++)
{
for (j=0;j<pool_config->max_pool;j++)
{
for (k=0;k<NUM_BACKENDS;k++)
{
c = pool_coninfo(i, j, k);
pool_debug("con_info: address:%p database:%s user:%s pid:%d key:%d i:%d",
c, c->database, c->user, ntohl(c->pid), ntohl(c->key),i);
if (c->pid == sp->pid && c->key == sp->key)
{
pool_debug("found pid:%d key:%d i:%d",ntohl(c->pid), ntohl(c->key),i);
c = pool_coninfo(i, j, 0);
found = true;
goto found;
}
}
}
}
found:
if (!found)
{
pool_error("cancel_request: invalid cancel key: pid:%d key:%d",ntohl(sp->pid), ntohl(sp->key));
return; /* invalid key */
}
for (i=0;i<NUM_BACKENDS;i++,c++)
{
if (!VALID_BACKEND(i))
continue;
if (*(BACKEND_INFO(i).backend_hostname) == '/')
fd = connect_unix_domain_socket(i, TRUE);
else
fd = connect_inet_domain_socket(i, TRUE);
if (fd < 0)
{
pool_error("Could not create socket for sending cancel request for backend %d", i);
return;
}
con = pool_open(fd);
if (con == NULL)
return;
len = htonl(sizeof(len) + sizeof(CancelPacket));
pool_write(con, &len, sizeof(len));
cp.protoVersion = sp->protoVersion;
cp.pid = c->pid;
cp.key = c->key;
pool_log("cancel_request: canceling backend pid:%d key: %d", ntohl(cp.pid),ntohl(cp.key));
if (pool_write_and_flush(con, &cp, sizeof(CancelPacket)) < 0)
pool_error("Could not send cancel request packet for backend %d", i);
pool_close(con);
/*
* this is needed to ensure that the next DB node executes the
* query supposed to be canceled.
*/
sleep(1);
}
}
