diff --git a/src/backend/main/main.c b/src/backend/main/main.c index d71885d..66e68e5 100644 --- a/src/backend/main/main.c +++ b/src/backend/main/main.c @@ -188,6 +188,8 @@ main(int argc, char *argv[]) AuxiliaryProcessMain(argc, argv); /* does not return */ else if (argc > 1 && strcmp(argv[1], "--describe-config") == 0) GucInfoMain(); /* does not return */ + else if (argc > 1 && strncmp(argv[1], "--child=", 8) == 0) + ChildPostgresMain(argc, argv, get_current_username(progname)); /* does not return */ else if (argc > 1 && strcmp(argv[1], "--single") == 0) PostgresMain(argc, argv, NULL, /* no dbname */ diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c index d294a5a..e319825 100644 --- a/src/backend/postmaster/postmaster.c +++ b/src/backend/postmaster/postmaster.c @@ -501,6 +501,7 @@ typedef struct static void read_backend_variables(char *id, Port *port); static void restore_backend_variables(BackendParameters *param, Port *port); +static void read_standalone_child_variables(char *id, pgsocket *psock); #ifndef WIN32 static bool save_backend_variables(BackendParameters *param, Port *port); @@ -4710,6 +4711,97 @@ ExitPostmaster(int status) proc_exit(status); } + +/* + * ChildPostgresMain - start a new-style standalone postgres process + * + * This may not belong here, but it does share a lot of code with ConnCreate + * and BackendInitialize. Basically what it has to do is set up a + * MyProcPort structure and then hand off control to PostgresMain. + * Beware that not very much stuff is initialized yet. + * + * In the future it might be interesting to support a "standalone + * multiprocess" mode in which we have a postmaster process that doesn't + * listen for connections, but does supervise autovacuum, bgwriter, etc + * auxiliary processes. So that's another reason why postmaster.c might be + * the right place for this. + */ +void +ChildPostgresMain(int argc, char *argv[], const char *username) +{ + Port *port; +#ifdef WIN32 + char paramHandleStr[32]; +#endif + + /* + * Fire up essential subsystems: error and memory management + */ + MemoryContextInit(); + + /* + * Build a Port structure for the client connection + */ + if (!(port = (Port *) calloc(1, sizeof(Port)))) + ereport(FATAL, + (errcode(ERRCODE_OUT_OF_MEMORY), + errmsg("out of memory"))); + + /* + * GSSAPI specific state struct must exist even though we won't use it + */ +#if defined(ENABLE_GSS) || defined(ENABLE_SSPI) + port->gss = (pg_gssinfo *) calloc(1, sizeof(pg_gssinfo)); + if (!port->gss) + ereport(FATAL, + (errcode(ERRCODE_OUT_OF_MEMORY), + errmsg("out of memory"))); +#endif + +#ifndef WIN32 + /* The file descriptor of the client socket is the argument of --child */ + if (sscanf(argv[1], "--child=%d", &port->sock) != 1) + ereport(FATAL, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("invalid argument for --child: \"%s\"", argv[1]))); +#else +/* The file descriptor of the client socket is the argument of --child */ + if (sscanf(argv[1], "--child=%s", paramHandleStr) != 1) + ereport(FATAL, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("invalid argument for --child: \"%s\"", argv[1]))); + + read_standalone_child_variables(paramHandleStr, &port->sock); + +#endif + + /* Default assumption about protocol to use */ + FrontendProtocol = port->proto = PG_PROTOCOL_LATEST; + + /* save process start time */ + port->SessionStartTime = GetCurrentTimestamp(); + MyStartTime = timestamptz_to_time_t(port->SessionStartTime); + + /* set these to empty in case they are needed */ + port->remote_host = ""; + port->remote_port = ""; + + MyProcPort = port; + + /* + * We can now initialize libpq and then enable reporting of ereport errors + * to the client. + */ + pq_init(); /* initialize libpq to talk to client */ + whereToSendOutput = DestRemote; /* now safe to ereport to client */ + + /* And pass off control to PostgresMain */ + PostgresMain(argc, argv, NULL, username); + + abort(); /* not reached */ +} + + /* * sigusr1_handler - handle signal conditions from child processes */ @@ -5891,6 +5983,47 @@ restore_backend_variables(BackendParameters *param, Port *port) } +#ifdef WIN32 +static void +read_standalone_child_variables(char *id, pgsocket *psock) +{ + HANDLE paramHandle; + InheritableSocket param; + InheritableSocket *paramp; + +/* Win32 version uses mapped file */ +#ifdef _WIN64 + paramHandle = (HANDLE) _atoi64(id); +#else + paramHandle = (HANDLE) atol(id); +#endif + paramp = MapViewOfFile(paramHandle, FILE_MAP_READ, 0, 0, 0); + if (!paramp) + { + write_stderr("could not map view of standalone child variables: error code %lu\n", + GetLastError()); + exit(1); + } + + memcpy(¶m, paramp, sizeof(InheritableSocket)); + + if (!UnmapViewOfFile(paramp)) + { + write_stderr("could not unmap view of standalone child variables: error code %lu\n", + GetLastError()); + exit(1); + } + + if (!CloseHandle(paramHandle)) + { + write_stderr("could not close handle to standalone child parameter variables: error code %lu\n", + GetLastError()); + exit(1); + } + + read_inheritable_socket(psock, ¶m); +} +#endif Size ShmemBackendArraySize(void) { diff --git a/src/backend/tcop/postgres.c b/src/backend/tcop/postgres.c index 181e3fe..f5a09c8 100644 --- a/src/backend/tcop/postgres.c +++ b/src/backend/tcop/postgres.c @@ -3271,8 +3271,10 @@ process_postgres_switches(int argc, char *argv[], GucContext ctx, { gucsource = PGC_S_ARGV; /* switches came from command line */ - /* Ignore the initial --single argument, if present */ - if (argc > 1 && strcmp(argv[1], "--single") == 0) + /* Ignore the initial --single or --child argument, if present */ + if (argc > 1 && + (strcmp(argv[1], "--single") == 0 || + strncmp(argv[1], "--child=", 8) == 0)) { argv++; argc--; @@ -3536,18 +3538,18 @@ PostgresMain(int argc, char *argv[], * standalone). */ if (!IsUnderPostmaster) - { MyProcPid = getpid(); + if (MyProcPort == NULL) MyStartTime = time(NULL); - } /* * Fire up essential subsystems: error and memory management * - * If we are running under the postmaster, this is done already. + * If we are running under the postmaster, this is done already; likewise + * in child-postgres mode. */ - if (!IsUnderPostmaster) + if (MyProcPort == NULL) MemoryContextInit(); SetProcessingMode(InitProcessing); diff --git a/src/include/postmaster/postmaster.h b/src/include/postmaster/postmaster.h index 5dc6dc5..35099d8 100644 --- a/src/include/postmaster/postmaster.h +++ b/src/include/postmaster/postmaster.h @@ -47,6 +47,9 @@ extern int postmaster_alive_fds[2]; extern const char *progname; extern void PostmasterMain(int argc, char *argv[]) __attribute__((noreturn)); + +extern void ChildPostgresMain(int argc, char *argv[], const char *username) __attribute__((noreturn)); + extern void ClosePostmasterPorts(bool am_syslogger); extern int MaxLivePostmasterChildren(void); diff --git a/src/interfaces/libpq/fe-connect.c b/src/interfaces/libpq/fe-connect.c index 18fcb0c..1da022c 100644 --- a/src/interfaces/libpq/fe-connect.c +++ b/src/interfaces/libpq/fe-connect.c @@ -17,6 +17,7 @@ #include #include +#include #include #include #include @@ -300,6 +301,14 @@ static const internalPQconninfoOption PQconninfoOptions[] = { "Replication", "D", 5, offsetof(struct pg_conn, replication)}, + {"standalone_datadir", NULL, NULL, NULL, + "Standalone-Data-Directory", "D", 64, + offsetof(struct pg_conn, standalone_datadir)}, + + {"standalone_backend", NULL, NULL, NULL, + "Standalone-Backend", "D", 64, + offsetof(struct pg_conn, standalone_backend)}, + /* Terminating entry --- MUST BE LAST */ {NULL, NULL, NULL, NULL, NULL, NULL, 0} @@ -401,6 +410,27 @@ pqDropConnection(PGconn *conn) if (conn->sock >= 0) closesocket(conn->sock); conn->sock = -1; + /* If we forked a child postgres process, wait for it to exit */ + if (conn->postgres_pid > 0) + { +#ifdef WIN32 + while (WaitForSingleObject(conn->proc_handle, INFINITE) != WAIT_OBJECT_0) + { + _dosmaperr(GetLastError()); + /* If interrupted by signal, keep waiting */ + if (errno != EINTR) + break; + } +#else + while (waitpid(conn->postgres_pid, NULL, 0) < 0) + { + /* If interrupted by signal, keep waiting */ + if (errno != EINTR) + break; + } +#endif + } + conn->postgres_pid = -1; /* Discard any unread/unsent data */ conn->inStart = conn->inCursor = conn->inEnd = 0; conn->outCount = 0; @@ -1299,6 +1329,340 @@ setKeepalivesWin32(PGconn *conn) #endif /* SIO_KEEPALIVE_VALS */ #endif /* WIN32 */ +#ifdef WIN32 +int +pgsockpair(int handles[2], PGconn *conn) +{ + SOCKET s; + struct sockaddr_in serv_addr; + int len = sizeof(serv_addr); + + handles[0] = handles[1] = INVALID_SOCKET; + + if ((s = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("pgsockpair could not create socket: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + + return -1; + } + + memset((void *) &serv_addr, 0, sizeof(serv_addr)); + serv_addr.sin_family = AF_INET; + serv_addr.sin_port = htons(0); + serv_addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + if (bind(s, (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("pgsockpair could not bind: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + + closesocket(s); + return -1; + } + if (listen(s, 1) == SOCKET_ERROR) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("pgsockpair could not listen: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + closesocket(s); + return -1; + } + if (getsockname(s, (SOCKADDR *) & serv_addr, &len) == SOCKET_ERROR) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("pgsockpair could not getsockname: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + closesocket(s); + return -1; + } + if ((handles[1] = socket(PF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("pgsockpair could not create socket 2: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + + closesocket(s); + return -1; + } + + if (connect(handles[1], (SOCKADDR *) & serv_addr, len) == SOCKET_ERROR) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("pgsockpair could not connect socket: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + closesocket(s); + return -1; + } + if ((handles[0] = accept(s, (SOCKADDR *) & serv_addr, &len)) == INVALID_SOCKET) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("pgsockpair could not accept socket: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + closesocket(handles[1]); + handles[1] = INVALID_SOCKET; + closesocket(s); + return -1; + } + closesocket(s); + return 0; +} + +/* + * Fork and exec a command, connecting up a pair of anonymous sockets for + * communication. argv[fdarg] is modified by appending the child-side + * socket's file descriptor number. The parent-side socket's FD is returned + * in *psock, and the function result is the child's PID. + */ +static pid_t +fork_backend_child(char **argv, int fdarg, PGconn *conn) +{ + int socks[2]; + char newfdarg[32]; + STARTUPINFO si; + PROCESS_INFORMATION pi; + int i; + int j; + char cmdLine[MAXPGPATH * 2]; + typedef struct + { + SOCKET origsocket; /* Original socket value, or PGINVALID_SOCKET + * if not a socket */ + WSAPROTOCOL_INFO wsainfo; + } InheritableSocket; + InheritableSocket *param; + HANDLE paramHandle; + SECURITY_ATTRIBUTES sa; + char paramHandleStr[32]; + + + if (pgsockpair(socks, conn) < 0) + return -1; + + /* Set up shared memory for parameter passing */ + ZeroMemory(&sa, sizeof(sa)); + sa.nLength = sizeof(sa); + sa.bInheritHandle = TRUE; + paramHandle = CreateFileMapping(INVALID_HANDLE_VALUE, + &sa, + PAGE_READWRITE, + 0, + sizeof(InheritableSocket), + NULL); + if (paramHandle == INVALID_HANDLE_VALUE) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("could not create standalone backend parameter file mapping: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + return -1; + } + + param = MapViewOfFile(paramHandle, FILE_MAP_WRITE, 0, 0, sizeof(InheritableSocket)); + if (!param) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("could not map backend parameter memory: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + + CloseHandle(paramHandle); + return -1; + } + + /* Insert temp file name instead of sockid incase of windows */ +#ifdef _WIN64 + sprintf(paramHandleStr, "%llu", (LONG_PTR) paramHandle); +#else + sprintf(paramHandleStr, "%lu", (DWORD) paramHandle); +#endif + + snprintf(newfdarg, sizeof(newfdarg), "%s%s", argv[fdarg], paramHandleStr); + argv[fdarg] = newfdarg; + + /* Format the cmd line */ + cmdLine[sizeof(cmdLine) - 1] = '\0'; + cmdLine[sizeof(cmdLine) - 2] = '\0'; + snprintf(cmdLine, sizeof(cmdLine) - 1, "\"%s\"", argv[0]); + + i = 0; + while (argv[++i] != NULL) + { + j = strlen(cmdLine); + snprintf(cmdLine + j, sizeof(cmdLine) - 1 - j, " \"%s\"", argv[i]); + } + if (cmdLine[sizeof(cmdLine) - 2] != '\0') + { + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("subprocess command line too long: %s\n")); + + return -1; + } + + memset(&pi, 0, sizeof(pi)); + memset(&si, 0, sizeof(si)); + si.cb = sizeof(si); + + if (!CreateProcess(NULL, cmdLine, NULL, NULL, TRUE, CREATE_SUSPENDED, + NULL, NULL, &si, &pi)) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("CreateProcess call failed: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + + return -1; + } + + + param->origsocket = socks[0]; + if (socks[0] != 0 && socks[0] != PGINVALID_SOCKET) + { + /* Actual socket */ + if (WSADuplicateSocket(socks[0], pi.dwProcessId, ¶m->wsainfo) != 0) + { + char sebuf[256]; + + if (!TerminateProcess(pi.hProcess, 255)) + { + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("could not terminate unstarted process: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + return -1; + } + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("could not duplicate the socket: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + return -1; + } + } + + /* + * Drop the parameter shared memory that is now inherited to the + * standalone chile + */ + if (!UnmapViewOfFile(param)) + { + char sebuf[256]; + + fprintf(stderr, + libpq_gettext("WARNING: could not unmap view of standalone child variables: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + } + + if (!CloseHandle(paramHandle)) + { + char sebuf[256]; + + fprintf(stderr, + libpq_gettext("WARNING: could not close handle of standalone child variables: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + } + + /* + * Now that the socket information is shared, we start the child thread + */ + if (ResumeThread(pi.hThread) == -1) + { + char sebuf[256]; + + if (!TerminateProcess(pi.hProcess, 255)) + { + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("could not terminate unstarted process: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + return -1; + } + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("could not resume thread of unstarted process: %s\n"), + SOCK_STRERROR(SOCK_ERRNO, sebuf, sizeof(sebuf))); + CloseHandle(pi.hProcess); + CloseHandle(pi.hThread); + return -1; + } + /* Don't close pi.hProcess here - the wait thread needs access to it */ + CloseHandle(pi.hThread); + + conn->sock = socks[1]; + conn->proc_handle = pi.hProcess; + return pi.dwProcessId; +} +#else + +/* + * Fork and exec a command, connecting up a pair of anonymous sockets for + * communication. argv[fdarg] is modified by appending the child-side + * socket's file descriptor number. The parent-side socket's FD is returned + * in *psock, and the function result is the child's PID. + */ +static pid_t +fork_backend_child(char **argv, int fdarg, int *psock) +{ + pid_t pid; + int socks[2]; + char newfdarg[32]; + + if (socketpair(AF_UNIX, SOCK_STREAM, 0, socks) < 0) + return -1; + + pid = fork(); + + if (pid < 0) + { + /* fork failed */ + close(socks[0]); + close(socks[1]); + return pid; + } + else if (pid == 0) + { + /* successful, in child process */ + close(socks[1]); + snprintf(newfdarg, sizeof(newfdarg), "%s%d", argv[fdarg], socks[0]); + argv[fdarg] = newfdarg; + execv(argv[0], argv); + perror(argv[0]); + exit(1); + } + else + { + /* successful, in parent process */ + close(socks[0]); + *psock = socks[1]; + } + + return pid; +} +#endif + /* ---------- * connectDBStart - * Begin the process of making a connection to the backend. @@ -1327,6 +1691,61 @@ connectDBStart(PGconn *conn) conn->outCount = 0; /* + * If the standalone_datadir option was specified, ignore any host or + * port specifications and just try to fork a standalone backend. + */ + if (conn->standalone_datadir && conn->standalone_datadir[0]) + { + char *be_argv[10]; + + /* + * We set up the backend's command line in execv(3) style, so that + * we don't need to cope with shell quoting rules. + */ + if (conn->standalone_backend && conn->standalone_backend[0]) + be_argv[0] = conn->standalone_backend; + else /* assume we should use hard-wired path */ + be_argv[0] = PGBINDIR "/postgres"; + + be_argv[1] = "--child="; + be_argv[2] = "-D"; + be_argv[3] = conn->standalone_datadir; + be_argv[4] = (conn->dbName && conn->dbName[0]) ? conn->dbName : NULL; + be_argv[5] = NULL; + +#ifdef WIN32 + conn->postgres_pid = fork_backend_child(be_argv, 1, conn); + if (conn->postgres_pid < 0) + goto connect_errReturn; +#else + conn->postgres_pid = fork_backend_child(be_argv, 1, &conn->sock); + if (conn->postgres_pid < 0) + { + char sebuf[256]; + + appendPQExpBuffer(&conn->errorMessage, + libpq_gettext("could not fork standalone backend: %s\n"), + pqStrerror(errno, sebuf, sizeof(sebuf))); + goto connect_errReturn; + } +#endif + + /* + * Go directly to CONNECTION_AUTH_OK state, since the standalone + * backend is not going to issue any authentication challenge to us. + * We're just waiting for startup to conclude. + */ +#ifdef USE_SSL + conn->allow_ssl_try = false; +#endif + conn->pversion = PG_PROTOCOL(3, 0); + conn->status = CONNECTION_AUTH_OK; + conn->asyncStatus = PGASYNC_BUSY; + + return 1; + } + + /* * Determine the parameters to pass to pg_getaddrinfo_all. */ @@ -2706,6 +3125,7 @@ makeEmptyPGconn(void) conn->auth_req_received = false; conn->password_needed = false; conn->dot_pgpass_used = false; + conn->postgres_pid = -1; #ifdef USE_SSL conn->allow_ssl_try = true; conn->wait_ssl_try = false; @@ -2782,6 +3202,10 @@ freePGconn(PGconn *conn) free(conn->pgport); if (conn->pgunixsocket) free(conn->pgunixsocket); + if (conn->standalone_datadir) + free(conn->standalone_datadir); + if (conn->standalone_backend) + free(conn->standalone_backend); if (conn->pgtty) free(conn->pgtty); if (conn->connect_timeout) diff --git a/src/interfaces/libpq/libpq-int.h b/src/interfaces/libpq/libpq-int.h index 408aeb1..1ac3088 100644 --- a/src/interfaces/libpq/libpq-int.h +++ b/src/interfaces/libpq/libpq-int.h @@ -306,6 +306,8 @@ struct pg_conn char *pgunixsocket; /* the Unix-domain socket that the server is * listening on; if NULL, uses a default * constructed from pgport */ + char *standalone_datadir; /* data directory for standalone backend */ + char *standalone_backend; /* executable for standalone backend */ char *pgtty; /* tty on which the backend messages is * displayed (OBSOLETE, NOT USED) */ char *connect_timeout; /* connection timeout (numeric string) */ @@ -376,6 +378,9 @@ struct pg_conn bool sigpipe_so; /* have we masked SIGPIPE via SO_NOSIGPIPE? */ bool sigpipe_flag; /* can we mask SIGPIPE via MSG_NOSIGNAL? */ + /* If we forked a child postgres process, its PID is kept here */ + pid_t postgres_pid; /* PID, or -1 if none */ + /* Transient state needed while establishing connection */ struct addrinfo *addrlist; /* list of possible backend addresses */ struct addrinfo *addr_cur; /* the one currently being tried */ @@ -418,6 +423,10 @@ struct pg_conn /* Status for asynchronous result construction */ PGresult *result; /* result being constructed */ PGresult *next_result; /* next result (used in single-row mode) */ +#ifdef WIN32 + /* If we forked a child postgres process, process handle */ + HANDLE proc_handle; +#endif /* Assorted state for SSL, GSS, etc */