rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
postgresql/src/backend/postmaster/postmaster.c

1125 lines
29 KiB
C
Raw Blame History

/*-------------------------------------------------------------------------
*
* postmaster.c--
* This program acts as a clearing house for requests to the
* POSTGRES system. Frontend programs send a startup message
* to the Postmaster and the postmaster uses the info in the
* message to setup a backend process.
*
* Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
* $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.3 1996/07/23 02:23:47 scrappy Exp $
*
* NOTES
*
* Initialization:
* The Postmaster sets up a few shared memory data structures
* for the backends. It should at the very least initialize the
* lock manager.
*
* Synchronization:
* The Postmaster shares memory with the backends and will have to lock
* the shared memory it accesses. The Postmaster should never block
* on messages from clients.
*
* Garbage Collection:
* The Postmaster cleans up after backends if they have an emergency
* exit and/or core dump.
*
* Communication:
*
*-------------------------------------------------------------------------
*/
#include "libpq/pqsignal.h" /* substitute for <signal.h> */
#include <string.h>
#include <stdlib.h>
#ifndef WIN32
#include <unistd.h>
#endif /* WIN32 */
#include <ctype.h>
#include <sys/types.h> /* for fd_set stuff */
#include <sys/stat.h> /* for umask */
#include <sys/time.h>
#include <sys/param.h> /* for MAXHOSTNAMELEN on most */
#ifdef WIN32
#include <winsock.h>
#include <limits.h>
#define MAXINT INT_MAX
#else
#include <netdb.h> /* for MAXHOSTNAMELEN on some */
# if defined(PORTNAME_BSD44_derived) || \
defined(PORTNAME_bsdi) || \
defined(PORTNAME_bsdi_2_1)
# include <machine/limits.h>
# define MAXINT INT_MAX
# else
# include <values.h>
# endif /* !PORTNAME_BSD44_derived */
#include <sys/wait.h>
#endif /* WIN32 */
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#if defined(PORTNAME_aix)
#include <sys/select.h>
#endif /* PORTNAME_aix */
#include "storage/ipc.h"
#include "libpq/libpq.h"
#include "libpq/auth.h"
#include "libpq/pqcomm.h"
#include "miscadmin.h"
#include "lib/dllist.h"
#include "utils/mcxt.h"
#include "storage/proc.h"
#include "utils/elog.h"
#ifdef DBX_VERSION
#define FORK() (0)
#else
#if defined(PORTNAME_irix5)
/* IRIX 5 does not have vfork() */
#define FORK() fork()
#else
#define FORK() vfork()
#endif
#endif
/*
* Info for garbage collection. Whenever a process dies, the Postmaster
* cleans up after it. Currently, NO information is required for cleanup,
* but I left this structure around in case that changed.
*/
typedef struct bkend {
int pid; /* process id of backend */
} Backend;
/* list of active backends. For garbage collection only now. */
static Dllist* BackendList;
/* list of ports associated with still open, but incomplete connections */
static Dllist* PortList;
static short PostPortName = -1;
static short ActiveBackends = FALSE;
static int NextBackendId = MAXINT; /* XXX why? */
static char *progname = (char *) NULL;
char *DataDir = (char *) NULL;
/*
* Default Values
*/
static char Execfile[MAXPATHLEN] = "";
static int ServerSock = INVALID_SOCK; /* stream socket server */
/*
* Set by the -o option
*/
static char ExtraOptions[ARGV_SIZE] = "";
/*
* These globals control the behavior of the postmaster in case some
* backend dumps core. Normally, it kills all peers of the dead backend
* and reinitializes shared memory. By specifying -s or -n, we can have
* the postmaster stop (rather than kill) peers and not reinitialize
* shared data structures.
*/
static int Reinit = 1;
static int SendStop = 0;
static int MultiplexedBackends = 0;
static int MultiplexedBackendPort;
#ifdef HBA
static int useHostBasedAuth = 1;
#else
static int useHostBasedAuth = 0;
#endif
/*
* postmaster.c - function prototypes
*/
static void pmdaemonize(void);
static int ConnStartup(Port *port);
static int ConnCreate(int serverFd, int *newFdP);
static void reset_shared(short port);
#if defined(PORTNAME_linux)
static void pmdie(int);
static void reaper(int);
static void dumpstatus(int);
#else
static void pmdie(void);
static void reaper(void);
static void dumpstatus();
#endif
static void CleanupProc(int pid, int exitstatus);
static int DoExec(StartupInfo *packet, int portFd);
static void ExitPostmaster(int status);
static void usage();
static void checkDataDir();
int ServerLoop(void);
int BackendStartup(StartupInfo *packet, Port *port, int *pidPtr);
extern char *optarg;
extern int optind, opterr;
int
PostmasterMain(int argc, char *argv[])
{
extern int NBuffers; /* from buffer/bufmgr.c */
extern bool IsPostmaster; /* from smgr/mm.c */
int opt;
char *hostName;
int status;
int silentflag = 0;
char hostbuf[MAXHOSTNAMELEN];
#ifdef WIN32
WSADATA WSAData;
#endif /* WIN32 */
progname = argv[0];
/* for security, no dir or file created can be group or other accessible */
(void) umask((mode_t) 0077);
if (!(hostName = getenv("PGHOST"))) {
if (gethostname(hostbuf, MAXHOSTNAMELEN) < 0)
(void) strcpy(hostbuf, "localhost");
hostName = hostbuf;
}
opterr = 0;
while ((opt = getopt(argc, argv, "a:B:b:D:dmM:no:p:Ss")) != EOF) {
switch (opt) {
case 'a':
/* Set the authentication system. */
be_setauthsvc(optarg);
break;
case 'B':
/*
* The number of buffers to create. Setting this
* option means we have to start each backend with
* a -B # to make sure they know how many buffers
* were allocated.
*/
NBuffers = atol(optarg);
(void) strcat(ExtraOptions, " -B ");
(void) strcat(ExtraOptions, optarg);
break;
case 'b':
/* Set the backend executable file to use. */
if (!ValidateBackend(optarg))
strcpy(Execfile, optarg);
else {
fprintf(stderr, "%s: invalid backend \"%s\"\n",
progname, optarg);
exit(2);
}
break;
case 'D':
/* Set PGDATA from the command line. */
DataDir = optarg;
break;
case 'd':
/*
* Turn on debugging for the postmaster and the backend
* servers descended from it.
*/
if ((optind < argc) && *argv[optind] != '-') {
DebugLvl = atoi(argv[optind]);
optind++;
}
else
DebugLvl = 1;
break;
case 'm':
MultiplexedBackends = 1;
MultiplexedBackendPort = atoi(optarg);
break;
case 'M':
/* ignore this flag. This may be passed in because the
program was run as 'postgres -M' instead of 'postmaster' */
break;
case 'n':
/* Don't reinit shared mem after abnormal exit */
Reinit = 0;
break;
case 'o':
/*
* Other options to pass to the backend on the
* command line -- useful only for debugging.
*/
(void) strcat(ExtraOptions, " ");
(void) strcat(ExtraOptions, optarg);
break;
case 'p':
/* Set PGPORT by hand. */
PostPortName = (short) atoi(optarg);
break;
case 'S':
/*
* Start in 'S'ilent mode (disassociate from controlling tty).
* You may also think of this as 'S'ysV mode since it's most
* badly needed on SysV-derived systems like SVR4 and HP-UX.
*/
silentflag = 1;
break;
case 's':
/*
* In the event that some backend dumps core,
* send SIGSTOP, rather than SIGUSR1, to all
* its peers. This lets the wily post_hacker
* collect core dumps from everyone.
*/
SendStop = 1;
break;
default:
/* usage() never returns */
usage(progname);
break;
}
}
if (PostPortName == -1)
PostPortName = pq_getport();
IsPostmaster = true;
if (!DataDir)
DataDir = GetPGData();
/*
* check whether the data directory exists. Passing this test doesn't
* gaurantee we are accessing the right data base but is a first barrier
* to site administrators who starts up the postmaster without realizing
* it cannot access the data base.
*/
checkDataDir();
if (!Execfile[0] && FindBackend(Execfile, argv[0]) < 0) {
fprintf(stderr, "%s: could not find backend to execute...\n",
argv[0]);
exit(1);
}
#ifdef WIN32
if ((status = WSAStartup(MAKEWORD(1,1), &WSAData)) == 0)
(void) printf("%s\nInitializing WinSock: %s\n", WSAData.szDescription, WSAData.szSystemStatus);
else
{
fprintf(stderr, "Error initializing WinSock: %d is the err", status);
exit(1);
}
_nt_init();
_nt_attach();
#endif /* WIN32 */
status = StreamServerPort(hostName, PostPortName, &ServerSock);
if (status != STATUS_OK) {
fprintf(stderr, "%s: cannot create stream port\n",
progname);
exit(1);
}
/* set up shared memory and semaphores */
EnableMemoryContext(TRUE);
reset_shared(PostPortName);
/*
* Initialize the list of active backends. This list is only
* used for garbage collecting the backend processes.
*/
BackendList = DLNewList();
PortList = DLNewList();
if (silentflag)
pmdaemonize();
signal(SIGINT, pmdie);
#ifndef WIN32
signal(SIGCHLD, reaper);
signal(SIGTTIN, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGHUP, pmdie);
signal(SIGTERM, pmdie);
signal(SIGCONT, dumpstatus);
#endif /* WIN32 */
status = ServerLoop();
ExitPostmaster(status != STATUS_OK);
return 0; /* not reached */
}
static void
pmdaemonize()
{
int i;
if (fork())
exit(0);
if (setsid() < 0) {
fprintf(stderr, "%s: ", progname);
perror("cannot disassociate from controlling TTY");
exit(1);
}
i = open(NULL_DEV, O_RDWR);
(void) dup2(i, 0);
(void) dup2(i, 1);
(void) dup2(i, 2);
(void) close(i);
}
static void
usage(char *progname)
{
fprintf(stderr, "usage: %s [options..]\n", progname);
fprintf(stderr, "\t-a authsys\tdo/do not permit use of an authentication system\n");
fprintf(stderr, "\t-B nbufs\tset number of shared buffers\n");
fprintf(stderr, "\t-b backend\tuse a specific backend server executable\n");
fprintf(stderr, "\t-d [1|2|3]\tset debugging level\n");
fprintf(stderr, "\t-D datadir\tset data directory\n");
fprintf(stderr, "\t-m \tstart up multiplexing backends\n");
fprintf(stderr, "\t-n\t\tdon't reinitialize shared memory after abnormal exit\n");
fprintf(stderr, "\t-o option\tpass 'option' to each backend servers\n");
fprintf(stderr, "\t-p port\t\tspecify port for postmaster to listen on\n");
fprintf(stderr, "\t-S\t\tsilent mode (disassociate from tty)\n");
fprintf(stderr, "\t-s\t\tsend SIGSTOP to all backend servers if one dies\n");
exit(1);
}
int
ServerLoop()
{
int serverFd = ServerSock;
fd_set rmask, basemask;
int nSockets, nSelected, status, newFd;
Dlelem *prev, *curr;
/* int orgsigmask = sigblock(0); */
sigset_t oldsigmask, newsigmask;
nSockets = ServerSock + 1;
FD_ZERO(&basemask);
FD_SET(ServerSock, &basemask);
sigprocmask(0,0,&oldsigmask);
sigemptyset(&newsigmask);
sigaddset(&newsigmask,SIGCHLD);
for (;;) {
/* sigsetmask(orgsigmask); */
sigprocmask(SIG_SETMASK,&oldsigmask,0);
newFd = -1;
memmove((char *) &rmask, (char *) &basemask, sizeof(fd_set));
if ((nSelected = select(nSockets, &rmask,
(fd_set *) NULL,
(fd_set *) NULL,
(struct timeval *) NULL)) < 0) {
if (errno == EINTR)
continue;
fprintf(stderr, "%s: ServerLoop: select failed\n",
progname);
return(STATUS_ERROR);
/* [TRH]
* To avoid race conditions, block SIGCHLD signals while we are
* handling the request. (both reaper() and ConnCreate()
* manipulate the BackEnd list, and reaper() calls free() which is
* usually non-reentrant.)
*/
sigprocmask(SIG_BLOCK, &newsigmask, &oldsigmask);
/* sigblock(sigmask(SIGCHLD)); */ /* XXX[TRH] portability */
}
if (DebugLvl > 1) {
fprintf(stderr, "%s: ServerLoop: %d sockets pending\n",
progname, nSelected);
}
/* new connection pending on our well-known port's socket */
if (FD_ISSET(ServerSock, &rmask)) {
/*
* connect and make an addition to PortList. If
* the connection dies and we notice it, just forget
* about the whole thing.
*/
if (ConnCreate(serverFd, &newFd) == STATUS_OK) {
if (newFd >= nSockets)
nSockets = newFd + 1;
FD_SET(newFd, &rmask);
FD_SET(newFd, &basemask);
if (DebugLvl)
fprintf(stderr, "%s: ServerLoop: connect on %d\n",
progname, newFd);
}
--nSelected;
FD_CLR(ServerSock, &rmask);
}
if (DebugLvl > 1) {
fprintf(stderr, "%s: ServerLoop:\tnSelected=%d\n",
progname, nSelected);
curr = DLGetHead(PortList);
while (curr) {
Port *port = DLE_VAL(curr);
fprintf(stderr, "%s: ServerLoop:\t\tport %d%s pending\n",
progname, port->sock,
FD_ISSET(port->sock, &rmask)
? "" :
" not");
curr = DLGetSucc(curr);
}
}
curr = DLGetHead(PortList);
while (curr) {
Port *port = (Port*)DLE_VAL(curr);
int lastbytes = port->nBytes;
if (FD_ISSET(port->sock, &rmask) && port->sock != newFd) {
if (DebugLvl > 1)
fprintf(stderr, "%s: ServerLoop:\t\thandling %d\n",
progname, port->sock);
--nSelected;
/*
* Read the incoming packet into its packet buffer.
* Read the connection id out of the packet so we
* know who the packet is from.
*/
status = PacketReceive(port, &port->buf, NON_BLOCKING);
switch (status) {
case STATUS_OK:
ConnStartup(port);
ActiveBackends = TRUE;
/*FALLTHROUGH*/
case STATUS_INVALID:
if (DebugLvl)
fprintf(stderr, "%s: ServerLoop:\t\tdone with %d\n",
progname, port->sock);
break;
case STATUS_BAD_PACKET:
/*
* This is a bogus client, kill the connection
* and forget the whole thing.
*/
if (DebugLvl)
fprintf(stderr, "%s: ServerLoop:\t\tbad packet format (reported packet size of %d read on port %d\n", progname, port->nBytes, port->sock);
break;
case STATUS_NOT_DONE:
if (DebugLvl)
fprintf(stderr, "%s: ServerLoop:\t\tpartial packet (%d bytes actually read) on %d\n",
progname, port->nBytes, port->sock);
/*
* If we've received at least a PacketHdr's worth of data
* and we're still receiving data each time we read, we're
* ok. If the client gives us less than a PacketHdr at
* the beginning, just kill the connection and forget
* about the whole thing.
*/
if (lastbytes < port->nBytes) {
if (DebugLvl)
fprintf(stderr, "%s: ServerLoop:\t\tpartial packet on %d ok\n",
progname, port->sock);
curr = DLGetSucc(curr);
continue;
}
break;
case STATUS_ERROR: /* system call error - die */
fprintf(stderr, "%s: ServerLoop:\t\terror receiving packet\n",
progname);
return(STATUS_ERROR);
}
FD_CLR(port->sock, &basemask);
StreamClose(port->sock);
prev = DLGetPred(curr);
DLRemove(curr);
DLFreeElem(curr);
curr = 0;
}
curr = DLGetSucc(curr);
}
Assert(nSelected == 0);
}
}
static int
ConnStartup(Port *port) /* receiving port */
{
MsgType msgType;
char namebuf[NAMEDATALEN + 1];
/* StartupInfo *sp;*/
int pid;
PacketBuf *p;
/* sp = PacketBuf2StartupInfo(&port->buf);*/
StartupInfo sp;
char *tmp;
p = &port->buf;
sp.database[0]='\0';
sp.user[0]='\0';
sp.options[0]='\0';
sp.execFile[0]='\0';
sp.tty[0]='\0';
tmp= p->data;
strncpy(sp.database,tmp,sizeof(sp.database));
tmp += sizeof(sp.database);
strncpy(sp.user,tmp, sizeof(sp.user));
tmp += sizeof(sp.user);
strncpy(sp.options,tmp, sizeof(sp.options));
tmp += sizeof(sp.options);
strncpy(sp.execFile,tmp, sizeof(sp.execFile));
tmp += sizeof(sp.execFile);
strncpy(sp.tty,tmp, sizeof(sp.tty));
msgType = ntohl(port->buf.msgtype);
(void) strncpy(namebuf, sp.user, NAMEDATALEN);
namebuf[NAMEDATALEN] = '\0';
if (!namebuf[0]) {
fprintf(stderr, "%s: ConnStartup: no user name specified\n",
progname);
return(STATUS_ERROR);
}
if (msgType == STARTUP_MSG && useHostBasedAuth)
msgType = STARTUP_HBA_MSG;
if (be_recvauth(msgType, port, namebuf,&sp) != STATUS_OK) {
fprintf(stderr, "%s: ConnStartup: authentication failed\n",
progname);
return(STATUS_ERROR);
}
if (BackendStartup(&sp, port, &pid) != STATUS_OK) {
fprintf(stderr, "%s: ConnStartup: couldn't start backend\n",
progname);
return(STATUS_ERROR);
}
return(STATUS_OK);
}
/*
* ConnCreate -- create a local connection data structure
*/
static int
ConnCreate(int serverFd, int *newFdP)
{
int status;
Port *port;
if (!(port = (Port *) calloc(1, sizeof(Port)))) {
fprintf(stderr, "%s: ConnCreate: malloc failed\n",
progname);
ExitPostmaster(1);
}
if ((status = StreamConnection(serverFd, port)) != STATUS_OK) {
StreamClose(port->sock);
free(port);
}
else {
DLAddHead(PortList, DLNewElem(port));
*newFdP = port->sock;
}
return (status);
}
/*
* reset_shared -- reset shared memory and semaphores
*/
static void
reset_shared(short port)
{
IPCKey key;
key = SystemPortAddressCreateIPCKey((SystemPortAddress) port);
CreateSharedMemoryAndSemaphores(key);
ActiveBackends = FALSE;
}
/*
* pmdie -- signal handler for cleaning up after a kill signal.
*/
static void
#if defined(PORTNAME_linux)
pmdie(int i)
#else
pmdie()
#endif
{
exitpg(0);
}
/*
* Reaper -- signal handler to cleanup after a backend (child) dies.
*/
static void
#if defined(PORTNAME_linux)
reaper(int i)
#else
reaper()
#endif
{
int status; /* backend exit status */
int pid; /* process id of dead backend */
if (DebugLvl)
fprintf(stderr, "%s: reaping dead processes...\n",
progname);
#ifndef WIN32
while((pid = waitpid(-1, &status, WNOHANG)) > 0)
CleanupProc(pid, status);
#endif /* WIN32 */
}
/*
* CleanupProc -- cleanup after terminated backend.
*
* Remove all local state associated with backend.
*
* Dillon's note: should log child's exit status in the system log.
*/
static void
CleanupProc(int pid,
int exitstatus) /* child's exit status. */
{
Dlelem *prev, *curr;
Backend *bp;
int sig;
if (DebugLvl) {
fprintf(stderr, "%s: CleanupProc: pid %d exited with status %d\n",
progname, pid, exitstatus);
}
/*
* -------------------------
* If a backend dies in an ugly way (i.e. exit status not 0) then
* we must signal all other backends to quickdie. If exit status
* is zero we assume everything is hunky dory and simply remove the
* backend from the active backend list.
* -------------------------
*/
if (!exitstatus) {
curr = DLGetHead(BackendList);
while (curr) {
bp = (Backend*)DLE_VAL(curr);
if (bp->pid == pid) {
DLRemove(curr);
DLFreeElem(curr);
break;
}
curr = DLGetSucc(curr);
}
ProcRemove(pid);
return;
}
curr = DLGetHead(BackendList);
while (curr) {
bp = (Backend*)DLE_VAL(curr);
/*
* -----------------
* SIGUSR1 is the special signal that sez exit without exitpg
* and let the user know what's going on. ProcSemaphoreKill()
* cleans up the backends semaphore. If SendStop is set (-s on
* the command line), then we send a SIGSTOP so that we can
* collect core dumps from all backends by hand.
* -----------------
*/
#ifndef WIN32
sig = (SendStop) ? SIGSTOP : SIGUSR1;
if (bp->pid != pid) {
if (DebugLvl)
fprintf(stderr, "%s: CleanupProc: sending %s to process %d\n",
progname,
(sig == SIGUSR1)
? "SIGUSR1" : "SIGSTOP",
bp->pid);
(void) kill(bp->pid, sig);
}
#endif /* WIN32 */
ProcRemove(bp->pid);
prev = DLGetPred(curr);
DLRemove(curr);
DLFreeElem(curr);
if (!prev) { /* removed head */
curr = DLGetHead(BackendList);
continue;
}
curr = DLGetSucc(curr);
}
/*
* -------------
* Quasi_exit means run all of the on_exitpg routines but don't
* acutally call exit(). The on_exit list of routines to do is
* also truncated.
*
* Nothing up my sleeve here, ActiveBackends means that since the
* last time we recreated shared memory and sems another frontend
* has requested and received a connection and I have forked off
* another backend. This prevents me from reinitializing shared
* stuff more than once for the set of backends that caused the
* failure and were killed off.
* ----------------
*/
if (ActiveBackends == TRUE && Reinit) {
if (DebugLvl)
fprintf(stderr, "%s: CleanupProc: reinitializing shared memory and semaphores\n",
progname);
quasi_exitpg();
reset_shared(PostPortName);
}
}
/*
* BackendStartup -- start backend process
*
* returns: STATUS_ERROR if the fork/exec failed, STATUS_OK
* otherwise.
*
*/
int
BackendStartup(StartupInfo *packet, /* client's startup packet */
Port *port,
int *pidPtr)
{
Backend* bn; /* for backend cleanup */
int pid, i;
static char envEntry[4][2 * ARGV_SIZE];
for (i = 0; i < 4; ++i) {
memset(envEntry[i], 2*ARGV_SIZE,0);
}
/*
* Set up the necessary environment variables for the backend
* This should really be some sort of message....
*/
sprintf(envEntry[0], "POSTPORT=%d", PostPortName);
putenv(envEntry[0]);
sprintf(envEntry[1], "POSTID=%d", NextBackendId);
putenv(envEntry[1]);
sprintf(envEntry[2], "PG_USER=%s", packet->user);
putenv(envEntry[2]);
if (!getenv("PGDATA")) {
sprintf(envEntry[3], "PGDATA=%s", DataDir);
putenv(envEntry[3]);
}
if (DebugLvl > 2) {
char **p;
extern char **environ;
fprintf(stderr, "%s: BackendStartup: environ dump:\n",
progname);
fprintf(stderr, "-----------------------------------------\n");
for (p = environ; *p; ++p)
fprintf(stderr, "\t%s\n", *p);
fprintf(stderr, "-----------------------------------------\n");
}
#ifndef WIN32
if ((pid = FORK()) == 0) { /* child */
if (DoExec(packet, port->sock))
fprintf(stderr, "%s child[%d]: BackendStartup: execv failed\n",
progname, pid);
/* use _exit to keep from double-flushing stdio */
_exit(1);
}
/* in parent */
if (pid < 0) {
fprintf(stderr, "%s: BackendStartup: fork failed\n",
progname);
return(STATUS_ERROR);
}
#else
pid = DoExec(packet, port->sock);
if (pid == FALSE) {
fprintf(stderr, "%s: BackendStartup: CreateProcess failed\n",
progname);
return(STATUS_ERROR);
}
#endif /* WIN32 */
if (DebugLvl)
fprintf(stderr, "%s: BackendStartup: pid %d user %s db %s socket %d\n",
progname, pid, packet->user,
(packet->database[0] == '\0' ? packet->user : packet->database),
port->sock);
/* adjust backend counter */
/* XXX Don't know why this is done, but for now backend needs it */
NextBackendId -= 1;
/*
* Everything's been successful, it's safe to add this backend to our
* list of backends.
*/
if (!(bn = (Backend *) calloc(1, sizeof (Backend)))) {
fprintf(stderr, "%s: BackendStartup: malloc failed\n",
progname);
ExitPostmaster(1);
}
bn->pid = pid;
DLAddHead(BackendList,DLNewElem(bn));
if (MultiplexedBackends)
MultiplexedBackendPort++;
*pidPtr = pid;
return(STATUS_OK);
}
/*
* split_opts -- destructively load a string into an argv array
*
* Since no current POSTGRES arguments require any quoting characters,
* we can use the simple-minded tactic of assuming each set of space-
* delimited characters is a separate argv element.
*
* If you don't like that, well, we *used* to pass the whole option string
* as ONE argument to execl(), which was even less intelligent...
*/
void
split_opts(char **argv, int *argcp, char *s)
{
int i = *argcp;
while (s && *s) {
while (isspace(*s))
++s;
if (*s)
argv[i++] = s;
while (*s && !isspace(*s))
++s;
if (isspace(*s))
*s++ = '\0';
}
*argcp = i;
}
/*
* DoExec -- set up the argument list and perform an execv system call
*
* Tries fairly hard not to dork with anything that isn't automatically
* allocated so we don't do anything weird to the postmaster when it gets
* its thread back. (This is vfork() we're talking about. If we're using
* fork() because we don't have vfork(), then we don't really care.)
*
* returns:
* Shouldn't return at all.
* If execv() fails, return status.
*/
static int
DoExec(StartupInfo *packet, int portFd)
{
char execbuf[MAXPATHLEN];
char portbuf[ARGV_SIZE];
char mbbuf[ARGV_SIZE];
char debugbuf[ARGV_SIZE];
char ttybuf[ARGV_SIZE + 1];
char argbuf[(2 * ARGV_SIZE) + 1];
/*
* each argument takes at least three chars, so we can't
* have more than ARGV_SIZE arguments in (2 * ARGV_SIZE)
* chars (i.e., packet->options plus ExtraOptions)...
*/
char *av[ARGV_SIZE];
char dbbuf[ARGV_SIZE + 1];
int ac = 0;
int i;
#ifdef WIN32
char win32_args[(2 * ARGV_SIZE) + 1];
PROCESS_INFORMATION piProcInfo;
STARTUPINFO siStartInfo;
BOOL fSuccess;
#endif /* WIN32 */
(void) strncpy(execbuf, Execfile, MAXPATHLEN);
execbuf[MAXPATHLEN - 1] = '\0';
av[ac++] = execbuf;
/* Tell the backend it is being called from the postmaster */
av[ac++] = "-p";
/*
* Pass the requested debugging level along to the backend. We
* decrement by one; level one debugging in the postmaster traces
* postmaster connection activity, and levels two and higher
* are passed along to the backend. This allows us to watch only
* the postmaster or the postmaster and the backend.
*/
if (DebugLvl > 1) {
(void) sprintf(debugbuf, "-d%d", DebugLvl - 1);
av[ac++] = debugbuf;
}
else
av[ac++] = "-Q";
/* Pass the requested debugging output file */
if (packet->tty[0]) {
(void) strncpy(ttybuf, packet->tty, ARGV_SIZE);
av[ac++] = "-o";
#ifdef WIN32
/* BIG HACK - The front end is passing "/dev/null" here which
** causes new backends to fail. So, as a very special case,
** use a real NT filename.
*/
av[ac++] = "CON";
#else
av[ac++] = ttybuf;
#endif /* WIN32 */
}
/* tell the multiplexed backend to start on a certain port */
if (MultiplexedBackends) {
sprintf(mbbuf, "-m %d", MultiplexedBackendPort);
av[ac++] = mbbuf;
}
/* Tell the backend the descriptor of the fe/be socket */
(void) sprintf(portbuf, "-P%d", portFd);
av[ac++] = portbuf;
(void) strncpy(argbuf, packet->options, ARGV_SIZE);
argbuf[ARGV_SIZE] = '\0';
(void) strncat(argbuf, ExtraOptions, ARGV_SIZE);
argbuf[(2 * ARGV_SIZE) + 1] = '\0';
split_opts(av, &ac, argbuf);
if (packet->database[0])
(void) strncpy(dbbuf, packet->database, ARGV_SIZE);
else
(void) strncpy(dbbuf, packet->user, NAMEDATALEN);
dbbuf[ARGV_SIZE] = '\0';
av[ac++] = dbbuf;
av[ac] = (char *) NULL;
if (DebugLvl > 1) {
fprintf(stderr, "%s child[%d]: execv(",
progname, getpid());
for (i = 0; i < ac; ++i)
fprintf(stderr, "%s, ", av[i]);
fprintf(stderr, ")\n");
}
#ifndef WIN32
return(execv(av[0], av));
#else
/* Copy all the arguments into one char array */
win32_args[0] = '\0';
for (i = 0; i < ac; i++)
{
strcat(win32_args, av[i]);
strcat(win32_args, " ");
}
siStartInfo.cb = sizeof(STARTUPINFO);
siStartInfo.lpReserved = NULL;
siStartInfo.lpDesktop = NULL;
siStartInfo.lpTitle = NULL;
siStartInfo.lpReserved2 = NULL;
siStartInfo.cbReserved2 = 0;
siStartInfo.dwFlags = 0;
fSuccess = CreateProcess(progname, win32_args, NULL, NULL,
TRUE, 0, NULL, NULL, &siStartInfo, &piProcInfo);
if (fSuccess)
{
/* The parent process doesn't need the handles */
CloseHandle(piProcInfo.hThread);
CloseHandle(piProcInfo.hProcess);
return (piProcInfo.dwProcessId);
}
else
return (FALSE);
#endif /* WIN32 */
}
/*
* ExitPostmaster -- cleanup
*/
static void
ExitPostmaster(int status)
{
/* should cleanup shared memory and kill all backends */
/*
* Not sure of the semantics here. When the Postmaster dies,
* should the backends all be killed? probably not.
*/
if (ServerSock != INVALID_SOCK)
close(ServerSock);
exitpg(status);
}
static void
#if defined(PORTNAME_linux)
dumpstatus(int i)
#else
dumpstatus()
#endif
{
Dlelem *curr = DLGetHead(PortList);
while (curr) {
Port *port = DLE_VAL(curr);
fprintf(stderr, "%s: dumpstatus:\n", progname);
fprintf(stderr, "\tsock %d: nBytes=%d, laddr=0x%x, raddr=0x%x\n",
port->sock, port->nBytes,
port->laddr,
port->raddr);
curr = DLGetSucc(curr);
}
}
static void
checkDataDir()
{
char path[MAXPATHLEN];
FILE *fp;
sprintf(path, "%s%cbase%ctemplate1%cpg_class", DataDir, SEP_CHAR, SEP_CHAR,
SEP_CHAR);
if ((fp=fopen(path, "r")) == NULL) {
fprintf(stderr, "%s: data base not found in directory \"%s\"\n",
progname, DataDir);
exit(2);
}
fclose(fp);
#ifndef WIN32
if (!ValidPgVersion(DataDir)) {
fprintf(stderr, "%s: data base in \"%s\" is of a different version.\n",
progname, DataDir);
exit(2);
}
#endif /* WIN32 */
}
Reference in New Issue View Git Blame Copy Permalink