Skip site navigation (1) Skip section navigation (2)

Re: pg_ctl.c

From: "Thomas Hallgren" <thhal(at)mailblocks(dot)com>
To: pgsql-patches(at)postgresql(dot)org
Subject: Re: pg_ctl.c
Date: 2004-05-27 08:53:12
Message-ID: c94ah1$304s$1@news.hub.org (view raw or flat)
Thread:
Lists: pgsql-patches
Neither the version in CVS head nor the version you attached here links on
win32 (msys/mingw). I get the following:

gcc -O2 -fno-strict-aliasing -Wall -Wmissing-prototypes -Wmissing-declaratio
ns pg_ctl.o
ec.o -L../../../src/interfaces/libpq -lpq -L../../../src/port   -lz -lreadli
ne -lwsock32 -lm  -lpgport -lws2_32 -o pg_ctl.exe
pg_ctl.o(.text+0xa3c):pg_ctl.c: undefined reference to `kill'
pg_ctl.o(.text+0xc4c):pg_ctl.c: undefined reference to `kill'
pg_ctl.o(.text+0xe5a):pg_ctl.c: undefined reference to `kill'
pg_ctl.o(.text+0x1058):pg_ctl.c: undefined reference to `kill'

Regards,

Thomas Hallgren

"Bruce Momjian" <pgman(at)candle(dot)pha(dot)pa(dot)us> wrote in message
news:200405261459(dot)i4QExWT28671(at)candle(dot)pha(dot)pa(dot)us(dot)(dot)(dot)
> OK, here is a new version with lots of fixes.
>
> -- 
>   Bruce Momjian                        |  http://candle.pha.pa.us
>   pgman(at)candle(dot)pha(dot)pa(dot)us               |  (610) 359-1001
>   +  If your life is a hard drive,     |  13 Roberts Road
>   +  Christ can be your backup.        |  Newtown Square, Pennsylvania
19073
>


----------------------------------------------------------------------------
----


>
/*-------------------------------------------------------------------------
>  *
>  * pg_ctl --- start/stops/restarts the PostgreSQL server
>  *
>  * Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
>  *
>  * $PostgreSQL: pgsql-server/src/bin/initdb/initdb.c,v 1.32 2004/05/18
03:36:36 momjian Exp $
>  *
>
*-------------------------------------------------------------------------
>  */
>
> #include "postgres_fe.h"
> #include "libpq-fe.h"
>
> #include <signal.h>
> #include <errno.h>
> #include <sys/types.h>
> #include <sys/stat.h>
>
> #include "libpq/pqsignal.h"
> #include "getopt_long.h"
>
> #ifndef HAVE_OPTRESET
> int optreset;
> #endif
>
>
> #define _(x) gettext((x))
>
> #define WHITESPACE "\f\n\r\t\v" /* as defined by isspace() */
>
> /* postmaster version ident string */
> #define PM_VERSIONSTR "postmaster (PostgreSQL) " PG_VERSION "\n"
>
>
> typedef enum
> {
> SMART_MODE,
> FAST_MODE,
> IMMEDIATE_MODE
> } ShutdownMode;
>
>
> typedef enum
> {
> NO_COMMAND = 0,
> START_COMMAND,
> STOP_COMMAND,
> RESTART_COMMAND,
> RELOAD_COMMAND,
> STATUS_COMMAND,
> KILL_COMMAND
> } CtlCommand;
>
>
> static bool do_wait = false;
> static bool wait_set = false;
> static int wait_seconds = 60;
> static bool silence_echo = false;
> static ShutdownMode shutdown_mode = SMART_MODE;
> static int sig = SIGTERM; /* default */
> static int killproc;
> static CtlCommand ctl_command = NO_COMMAND;
> static char *pg_data_opts = NULL;
> static char *pg_data = NULL;
> static char *post_opts = NULL;
> static const char *progname;
> static char *log_file = NULL;
> static char *postgres_path = NULL;
> static char *argv0 = NULL;
>
> static void *xmalloc(size_t size);
> static char *xstrdup(const char *s);
> static void do_advice(void);
> static void do_help(void);
> static void set_mode(char *modeopt);
> static void set_sig(char *signame);
> static void do_start();
> static void do_stop(void);
> static void do_restart(void);
> static void do_reload(void);
> static void do_status(void);
> static void do_kill(void);
> static long get_pgpid(void);
> static char **readfile(char *path);
> static int start_postmaster(void);
> static bool test_postmaster_connection(void);
>
> static char def_postopts_file[MAXPGPATH];
> static char postopts_file[MAXPGPATH];
> static char pid_file[MAXPGPATH];
> static char conf_file[MAXPGPATH];
>
> /*
>  * routines to check memory allocations and fail noisily.
>  */
>
> static void *
> xmalloc(size_t size)
> {
> void    *result;
>
> result = malloc(size);
> if (!result)
> {
> fprintf(stderr, _("%s: out of memory\n"), progname);
> exit(1);
> }
> return result;
> }
>
>
>
> static char *
> xstrdup(const char *s)
> {
> char    *result;
>
> result = strdup(s);
> if (!result)
> {
> fprintf(stderr, _("%s: out of memory\n"), progname);
> exit(1);
> }
> return result;
> }
>
>
>
> static long
> get_pgpid(void)
> {
> FILE    *pidf;
> long pid;
>
> pidf = fopen(pid_file, "r");
> if (pidf == NULL)
> {
> /* No pid file, not an error on startup */
> if (errno == ENOENT)
> return 0;
> else
> {
> perror("openning pid file");
> exit(1);
> }
> }
> fscanf(pidf, "%ld", &pid);
> fclose(pidf);
> return pid;
> }
>
>
> /*
>  * get the lines from a text file - return NULL if file can't be opened
>  */
> static char **
> readfile(char *path)
> {
> FILE    *infile;
> int maxlength = 0,
> linelen = 0;
> int nlines = 0;
> char   **result;
> char    *buffer;
> int c;
>
> if ((infile = fopen(path, "r")) == NULL)
> return NULL;
>
> /* pass over the file twice - the first time to size the result */
>
> while ((c = fgetc(infile)) != EOF)
> {
> linelen++;
> if (c == '\n')
> {
> nlines++;
> if (linelen > maxlength)
> maxlength = linelen;
> linelen = 0;
> }
> }
>
> /* handle last line without a terminating newline (yuck) */
> if (linelen)
> nlines++;
> if (linelen > maxlength)
> maxlength = linelen;
>
> /* set up the result and the line buffer */
>
> result = (char **) xmalloc((nlines + 1) * sizeof(char *));
> buffer = (char *) xmalloc(maxlength + 1);
>
> /* now reprocess the file and store the lines */
> rewind(infile);
> nlines = 0;
> while (fgets(buffer, maxlength + 1, infile) != NULL)
> result[nlines++] = xstrdup(buffer);
>
> fclose(infile);
> result[nlines] = NULL;
>
> return result;
> }
>
>
>
> /*
>  * start/test/stop routines
>  */
>
> static int
> start_postmaster(void)
> {
> /*
> * Since there might be quotes to handle here, it is easier simply
> * to pass everything to a shell to process them.
> */
> char cmd[MAXPGPATH];
>
> /* Does '&' work on Win32? */
> if (log_file != NULL)
> snprintf(cmd, MAXPGPATH, "\"%s\" %s < %s >>\"%s\" 2>&1 &",
> postgres_path, post_opts, DEVNULL, log_file);
> else
> snprintf(cmd, MAXPGPATH, "\"%s\" %s < %s 2>&1 &",
> postgres_path, post_opts, DEVNULL);
> return system(cmd);
> }
>
>
>
> /* Find the pgport and try a connection */
> static bool
> test_postmaster_connection(void)
> {
> PGconn    *conn;
> bool success = false;
> int i;
> char portstr[32];
> char *p;
>
>
> *portstr = '\0';
>
> /* post_opts */
> for (p = post_opts; *p;)
> {
> /* advance past whitespace/quoting */
> while (isspace(*p) || *p == '\'' || *p == '"')
> p++;
>
> if (strncmp(p, "-p", strlen("-p")) == 0)
> {
> p += strlen("-p");
> /* advance past whitespace/quoting */
> while (isspace(*p) || *p == '\'' || *p == '"')
> p++;
> StrNCpy(portstr, p, Min(strcspn(p, "\"'"WHITESPACE) + 1,
> sizeof(portstr)));
> /* keep looking, maybe there is another -p */
> }
> /* Advance to next whitespace */
> while (!isspace(*p))
> p++;
> }
>
> /* config file */
> if (!*portstr)
> {
> char   **optlines;
>
> optlines = readfile(conf_file);
> if (optlines != NULL)
> {
> for (;*optlines != NULL; optlines++)
> {
> p = *optlines;
>
> while (isspace(*p))
> p++;
> if (strncmp(p, "port", strlen("port")) != 0)
> continue;
> p += strlen("port");
> while (isspace(*p))
> p++;
> if (*p != '=')
> continue;
> p++;
> while (isspace(*p))
> p++;
> StrNCpy(portstr, p, Min(strcspn(p, "#"WHITESPACE) + 1,
> sizeof(portstr)));
> /* keep looking, maybe there is another */
> }
> }
> }
>
> /* environment */
> if (!*portstr && getenv("PGPORT") != NULL)
> StrNCpy(portstr, getenv("PGPORT"), sizeof(portstr));
>
> /* default */
> if (!*portstr)
> snprintf(portstr, sizeof(portstr), "%d", DEF_PGPORT);
>
> for (i = 0; i < wait_seconds; i++)
> {
> if ((conn = PQsetdbLogin(NULL, portstr, NULL, NULL, "template1", NULL,
NULL)) != NULL)
> {
> PQfinish(conn);
> success = true;
> break;
> }
> }
>
> return success;
> }
>
>
>
> static void
> do_start(void)
> {
> long pid;
> long old_pid = 0;
> char    *optline = NULL;
>
> if (ctl_command != RESTART_COMMAND)
> {
> old_pid = get_pgpid();
> if (old_pid != 0)
> fprintf(stderr,
> _("%s: Another postmaster may be running. "
> "Trying to start postmaster anyway.\n"),
> progname);
> }
>
> if (post_opts == NULL)
> {
> char   **optlines;
> int len;
>
> optlines = readfile(ctl_command == RESTART_COMMAND ?
> postopts_file : def_postopts_file);
> if (optlines == NULL)
> {
> if (ctl_command == START_COMMAND)
> post_opts = "";
> else
> {
> fprintf(stderr, _("%s: cannot read %s\n"), progname, postopts_file);
> exit(1);
> }
> }
> else if (optlines[0] == NULL || optlines[1] != NULL)
> {
> fprintf(stderr, _("%s: option file %s must have exactly 1 line\n"),
> progname, ctl_command == RESTART_COMMAND ?
> postopts_file : def_postopts_file);
> exit(1);
> }
> else
> {
> optline = optlines[0];
> len = strcspn(optline, "\r\n");
> optline[len] = '\0';
>
> if (ctl_command == RESTART_COMMAND)
> {
> char    *arg1;
>
> arg1 = strchr(optline, '\'');
> if (arg1 == NULL || arg1 == optline)
> post_opts = "";
> else
> {
> *(arg1 - 1) = '\0'; /* this should be a space */
> post_opts = arg1;
> }
> if (postgres_path != NULL)
> postgres_path = optline;
> }
> else
> post_opts = optline;
> }
> }
>
> if (postgres_path == NULL)
> {
> char    *postmaster_path;
> int ret;
>
> postmaster_path = xmalloc(MAXPGPATH);
>
> if ((ret = find_other_exec(argv0, "postmaster", PM_VERSIONSTR,
>    postmaster_path)) < 0)
> {
> if (ret == -1)
> fprintf(stderr,
> _("The program \"postmaster\" is needed by %s "
>    "but was not found in the same directory as \"%s\".\n"
>   "Check your installation.\n"),
> progname, progname);
> else
> fprintf(stderr,
> _("The program \"postmaster\" was found by %s "
>   "but was not the same version as \"%s\".\n"
>   "Check your installation.\n"),
> progname, progname);
> exit(1);
> }
> postgres_path = postmaster_path;
> }
>
> if (start_postmaster() != 0)
> {
> fprintf(stderr, _("Unable to run the postmaster binary\n"));
> exit(1);
> }
>
> if (old_pid != 0)
> {
> pg_usleep(1000000);
> pid = get_pgpid();
> if (pid == old_pid)
> {
> fprintf(stderr,
> _("%s: cannot start postmaster\n"
> "Examine the log output\n"),
> progname);
> exit(1);
> }
> }
>
> if (do_wait)
> {
> if (!silence_echo)
> {
> printf(_("waiting for postmaster to start..."));
> fflush(stdout);
> }
>
> if (test_postmaster_connection() == false)
> printf(_("could not start postmaster\n"));
> else if (!silence_echo)
> printf(_("done\npostmaster started\n"));
> }
> else if (!silence_echo)
> printf(_("postmaster starting\n"));
> }
>
>
>
> static void
> do_stop(void)
> {
> int cnt;
> long pid;
>
> pid = get_pgpid();
>
> if (pid == 0) /* no pid file */
> {
> fprintf(stderr, _("%s: could not find %s\n"), progname, pid_file);
> fprintf(stderr, _("Is postmaster running?\n"));
> exit(1);
> }
> else if (pid < 0) /* standalone backend, not postmaster */
> {
> pid = -pid;
> fprintf(stderr,
> _("%s: cannot stop postmaster; "
> "postgres is running (PID: %ld)\n"),
> progname, pid);
> exit(1);
> }
>
> if (kill((pid_t) pid, sig) != 0)
> {
> fprintf(stderr, _("stop signal failed\n"));
> exit(1);
> }
>
> if (!do_wait)
> {
> if (!silence_echo)
> printf(_("postmaster shutting down\n"));
> return;
> }
> else
> {
> if (!silence_echo)
> {
> printf(_("waiting for postmaster to shut down..."));
> fflush(stdout);
> }
>
> for (cnt = 0; cnt < wait_seconds; cnt++)
> {
> if ((pid = get_pgpid()) != 0)
> {
> if (!silence_echo)
> {
> printf(".");
> fflush(stdout);
> }
> pg_usleep(1000000); /* 1 sec */
> }
> else
> break;
> }
>
> if (pid != 0) /* pid file still exists */
> {
> if (!silence_echo)
> printf(_(" failed\n"));
>
> fprintf(stderr, _("%s: postmaster does not shut down\n"), progname);
> exit(1);
> }
> printf(_("done\npostmaster stopped\n"));
> }
> }
>
>
> /*
>  * restart/reload routines
>  */
>
> static void
> do_restart(void)
> {
> int cnt;
> long pid;
>
> pid = get_pgpid();
>
> if (pid == 0) /* no pid file */
> {
> fprintf(stderr, _("%s: could not find %s\n"), progname, pid_file);
> fprintf(stderr, _("Is postmaster running?\nstarting postmaster
anyway\n"));
> do_start();
> return;
> }
> else if (pid < 0) /* standalone backend, not postmaster */
> {
> pid = -pid;
> fprintf(stderr,
> _("%s: cannot restart postmaster; "
> "postgres is running (PID: %ld)\n"),
> progname, pid);
> fprintf(stderr, _("Please terminate postgres and try again.\n"));
> exit(1);
> }
>
> if (kill((pid_t) pid, sig) != 0)
> {
> fprintf(stderr, _("stop signal failed\n"));
> exit(1);
> }
>
> if (!silence_echo)
> {
> printf(_("waiting for postmaster to shut down..."));
> fflush(stdout);
> }
>
> /* always wait for restart */
>
> for (cnt = 0; cnt < wait_seconds; cnt++)
> {
> if ((pid = get_pgpid()) != 0)
> {
> if (!silence_echo)
> {
> printf(".");
> fflush(stdout);
> }
> pg_usleep(1000000); /* 1 sec */
> }
> else
> break;
> }
>
> if (pid != 0) /* pid file still exists */
> {
> if (!silence_echo)
> printf(_(" failed\n"));
>
> fprintf(stderr, _("%s: postmaster does not shut down\n"), progname);
> exit(1);
> }
>
> printf(_("done\npostmaster stopped\n"));
> do_start();
> }
>
>
> static void
> do_reload(void)
> {
> long pid;
>
> pid = get_pgpid();
> if (pid == 0) /* no pid file */
> {
> fprintf(stderr, _("%s: could not find %s\n"), progname, pid_file);
> fprintf(stderr, _("Is postmaster running?\n"));
> exit(1);
> }
> else if (pid < 0) /* standalone backend, not postmaster */
> {
> pid = -pid;
> fprintf(stderr,
> _("%s: cannot reload postmaster; "
> "postgres is running (PID: %ld)\n"),
> progname, pid);
> fprintf(stderr, _("Please terminate postgres and try again.\n"));
> exit(1);
> }
>
> if (kill((pid_t) pid, sig) != 0)
> {
> fprintf(stderr, _("reload signal failed\n"));
> exit(1);
> }
>
> if (!silence_echo)
> fprintf(stdout, _("postmaster signaled\n"));
> }
>
> /*
>  * utility routines
>  */
>
> static void
> do_status(void)
> {
> long pid;
>
> pid = get_pgpid();
> if (pid == 0) /* no pid file */
> {
> fprintf(stderr, _("%s: postmaster or postgres not running\n"), progname);
> exit(1);
> }
> else if (pid < 0) /* standalone backend */
> {
> pid = -pid;
> fprintf(stdout, _("%s: a standalone backend \"postgres\" is running (PID:
%ld)\n"), progname, pid);
> }
> else /* postmaster */
> {
> char   **optlines;
>
> fprintf(stdout, _("%s: postmaster is running (PID: %ld)\n"), progname,
pid);
>
> optlines = readfile(postopts_file);
> if (optlines != NULL)
> for (; *optlines != NULL; optlines++)
> fputs(*optlines, stdout);
> }
> }
>
>
>
> static void
> do_kill(void)
> {
> if (kill(killproc, sig) != 0)
> {
> fprintf(stderr, _("signal %d failed\n"), sig);
> exit(1);
> }
> }
>
>
>
> static void
> do_advice(void)
> {
> fprintf(stderr, _("\nTry \"%s --help\" for more information.\n"),
progname);
> }
>
>
>
> static void
> do_help(void)
> {
> printf(_("%s is a utility to start, stop, restart, reload configuration
files,\n"), progname);
> printf(_("report the status of a PostgreSQL server, or kill a PostgreSQL
process\n\n"));
> printf(_("Usage:\n"));
> printf(_("  %s start   [-w] [-D DATADIR] [-s] [-l FILENAME] [-o
\"OPTIONS\"]\n"), progname);
> printf(_("  %s stop    [-W] [-D DATADIR] [-s] [-m SHUTDOWN-MODE]\n"),
progname);
> printf(_("  %s restart [-w] [-D DATADIR] [-s] [-m SHUTDOWN-MODE] [-o
\"OPTIONS\"]\n"), progname);
> printf(_("  %s reload  [-D DATADIR] [-s]\n"), progname);
> printf(_("  %s status  [-D DATADIR]\n"), progname);
> printf(_("  %s kill    SIGNALNAME PROCESSID\n"), progname);
> printf(_("Common options:\n"));
> printf(_("  -D, --pgdata DATADIR   location of the database storage
area\n"));
> printf(_("  -s, --silent only print errors, no informational
messages\n"));
> printf(_("  -w           wait until operation completes\n"));
> printf(_("  -W           do not wait until operation completes\n"));
> printf(_("  --help       show this help, then exit\n"));
> printf(_("  --version    output version information, then exit\n"));
> printf(_("(The default is to wait for shutdown, but not for start or
restart.)\n\n"));
> printf(_("If the -D option is omitted, the environment variable PGDATA is
used.\n\n"));
> printf(_("Options for start or restart:\n"));
> printf(_("  -l, --log FILENAME      write (or append) server log to
FILENAME.  The\n"));
> printf(_("                          use of this option is highly
recommended.\n"));
> printf(_("  -o OPTIONS              command line options to pass to the
postmaster\n"));
> printf(_("                          (PostgreSQL server executable)\n"));
> printf(_("  -p PATH-TO-POSTMASTER   normally not necessary\n\n"));
> printf(_("Options for stop or restart:\n"));
> printf(_("  -m SHUTDOWN-MODE   may be 'smart', 'fast', or
'immediate'\n\n"));
> printf(_("Allowed signal names for kill:\n"));
> printf(_("  -HUP -INT -QUIT -ABRT -TERM -USR1 -USR2\n\n"));
> printf(_("Shutdown modes are:\n"));
> printf(_("  smart       quit after all clients have disconnected\n"));
> printf(_("  fast        quit directly, with proper shutdown\n"));
> printf(_("  immediate   quit without complete shutdown; will lead to
recovery on restart\n\n"));
> printf(_("Report bugs to <pgsql-bugs(at)postgresql(dot)org>.\n"));
> }
>
>
>
> static void
> set_mode(char *modeopt)
> {
> if (strcmp(modeopt, "s") == 0 || strcmp(modeopt, "smart") == 0)
> {
> shutdown_mode = SMART_MODE;
> sig = SIGTERM;
> }
> else if (strcmp(modeopt, "f") == 0 || strcmp(modeopt, "fast") == 0)
> {
> shutdown_mode = FAST_MODE;
> sig = SIGINT;
> }
> else if (strcmp(modeopt, "i") == 0 || strcmp(modeopt, "immediate") == 0)
> {
> shutdown_mode = IMMEDIATE_MODE;
> sig = SIGQUIT;
> }
> else
> {
> fprintf(stderr, _("%s: invalid shutdown mode %s\n"), progname, modeopt);
> do_advice();
> exit(1);
> }
> }
>
>
>
> static void
> set_sig(char *signame)
> {
> if (!strcmp(signame, "-HUP"))
> sig = SIGHUP;
> else if (!strcmp(signame, "-INT"))
> sig = SIGINT;
> else if (!strcmp(signame, "-QUIT"))
> sig = SIGQUIT;
> else if (!strcmp(signame, "-ABRT"))
> sig = SIGABRT;
>
> /*
> * probably should NOT provide SIGKILL
> *
> * else if (!strcmp(signame,"-KILL")) sig = SIGKILL;
> */
> else if (!strcmp(signame, "-TERM"))
> sig = SIGTERM;
> else if (!strcmp(signame, "-USR1"))
> sig = SIGUSR1;
> else if (!strcmp(signame, "-USR2"))
> sig = SIGUSR2;
> else
> {
> fprintf(stderr, _("%s: invalid signal \"%s\"\n"), progname, signame);
> do_advice();
> exit(1);
> }
>
> }
>
>
>
> int
> main(int argc, char **argv)
> {
> static struct option long_options[] = {
> {"help", no_argument, NULL, '?'},
> {"version", no_argument, NULL, 'V'},
> {"log", required_argument, NULL, 'l'},
> {"mode", required_argument, NULL, 'm'},
> {"pgdata", required_argument, NULL, 'D'},
> {"silent", no_argument, NULL, 's'},
> {0, 0, 0, 0}
> };
>
> int option_index;
> int c;
>
> #ifdef WIN32
> setvbuf(stderr, NULL, _IONBF, 0);
> #endif
>
> progname = get_progname(argv[0]);
>
> /*
> * save argv[0] so do_start() can look for the postmaster if
> * necessary. we don't look for postmaster here because in many cases
> * we won't need it.
> */
> argv0 = argv[0];
>
> umask(077);
>
>     if (argc > 1)
>     {
> if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0 ||
> strcmp(argv[1], "-?") == 0)
> {
> do_help();
> exit(0);
> }
> else if (strcmp(argv[1], "-V") == 0 || strcmp(argv[1], "--version") == 0)
> {
> printf("%s (PostgreSQL) %s\n", progname, PG_VERSION);
> exit(0);
> }
> }
>
> /* process command-line options */
>
> while ((c = getopt_long(argc, argv, "D:l:m:o:p:swW", long_options,
&option_index)) != -1)
> {
> switch (c)
> {
> case 'D':
> {
> int len = strlen(optarg) + 4;
> char    *env_var;
>
> pg_data_opts = xmalloc(len);
> snprintf(pg_data_opts, len, "-D %s", optarg);
> env_var = xmalloc(len + sizeof("PGDATA="));
> snprintf(env_var, len + sizeof("PGDATA="), "PGDATA=%s", optarg);
> putenv(env_var);
> break;
> }
> case 'l':
> log_file = xstrdup(optarg);
> break;
> case 'm':
> set_mode(optarg);
> break;
> case 'o':
> post_opts = xstrdup(optarg);
> break;
> case 'p':
> postgres_path = xstrdup(optarg);
> break;
> case 's':
> silence_echo = true;
> break;
> case 'w':
> do_wait = true;
> wait_set = true;
> break;
> case 'W':
> do_wait = false;
> wait_set = true;
> break;
> default:
> fprintf(stderr, _("%s: invalid option %s\n"), progname, optarg);
> do_advice();
> exit(1);
> }
> }
>
> for (; optind < argc; optind++)
> {
> if (ctl_command != NO_COMMAND)
> {
> fprintf(stderr, _("%s: extra operation mode %s\n"), progname,
argv[optind]);
> do_advice();
> exit(1);
> }
>
> if (strcmp(argv[optind], "start") == 0)
> ctl_command = START_COMMAND;
> else if (strcmp(argv[optind], "stop") == 0)
> ctl_command = STOP_COMMAND;
> else if (strcmp(argv[optind], "restart") == 0)
> ctl_command = RESTART_COMMAND;
> else if (strcmp(argv[optind], "reload") == 0)
> ctl_command = RELOAD_COMMAND;
> else if (strcmp(argv[optind], "status") == 0)
> ctl_command = STATUS_COMMAND;
> else if (strcmp(argv[optind], "kill") == 0)
> {
> if (argc - optind < 3)
> {
> fprintf(stderr, _("%s: invalid kill syntax\n"), progname);
> do_advice();
> exit(1);
> }
> ctl_command = KILL_COMMAND;
> set_sig(argv[optind + 1]);
> killproc = atol(argv[optind + 2]);
> }
> else
> {
> fprintf(stderr, _("%s: invalid operation mode %s\n"), progname,
argv[optind]);
> do_advice();
> exit(1);
> }
> }
>
> if (ctl_command == NO_COMMAND)
> {
> fprintf(stderr, _("%s: no operation specified\n"), progname);
> do_advice();
> exit(1);
> }
>
> pg_data = getenv("PGDATA");
> canonicalize_path(pg_data);
>
> if (pg_data == NULL && ctl_command != KILL_COMMAND)
> {
> fprintf(stderr,
> _("%s: no database directory specified "
> "and environment variable PGDATA unset\n"),
> progname);
> do_advice();
> exit(1);
> }
>
> if (!wait_set)
> {
> switch (ctl_command)
> {
> case RESTART_COMMAND:
> case START_COMMAND:
> do_wait = false;
> break;
> case STOP_COMMAND:
> do_wait = true;
> break;
> default:
> break;
> }
> }
>
> if (ctl_command == RELOAD_COMMAND)
> {
> sig = SIGHUP;
> do_wait = false;
> }
>
> snprintf(def_postopts_file, MAXPGPATH, "%s/postmaster.opts.default",
pg_data);
> snprintf(postopts_file, MAXPGPATH, "%s/postmaster.opts", pg_data);
> snprintf(pid_file, MAXPGPATH, "%s/postmaster.pid", pg_data);
> snprintf(conf_file, MAXPGPATH, "%s/postgresql.conf", pg_data);
>
> switch (ctl_command)
> {
> case STATUS_COMMAND:
> do_status();
> break;
> case START_COMMAND:
> do_start();
> break;
> case STOP_COMMAND:
> do_stop();
> break;
> case RESTART_COMMAND:
> do_restart();
> break;
> case RELOAD_COMMAND:
> do_reload();
> break;
> case KILL_COMMAND:
> do_kill();
> break;
> default:
> break;
> }
>
> exit(0);
> }
>


----------------------------------------------------------------------------
----


> #-------------------------------------------------------------------------
> #
> # Makefile for src/bin/pg_ctl
> #
> # Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
> # Portions Copyright (c) 1994, Regents of the University of California
> #
> # $PostgreSQL: pgsql-server/src/bin/pg_ctl/Makefile,v 1.41 2004/05/24
01:01:37 momjian Exp $
> #
> #-------------------------------------------------------------------------
>
> subdir = src/bin/pg_ctl
> top_builddir = ../../..
> include $(top_builddir)/src/Makefile.global
>
> override CPPFLAGS
:= -DFRONTEND -DDEF_PGPORT=$(DEF_PGPORT) -I$(libpq_srcdir) $(CPPFLAGS)
>
> OBJS= pg_ctl.o exec.o
>
> all: submake-libpq submake-libpgport pg_ctl
>
> pg_ctl: $(OBJS) $(libpq_builddir)/libpq.a
> $(CC) $(CFLAGS) $(OBJS) $(libpq) $(LDFLAGS) $(LIBS) -o $(at)$(X)
>
> exec.c: % : $(top_srcdir)/src/port/%
> rm -f $@ && $(LN_S) $< .
>
> install: all installdirs
> $(INSTALL_PROGRAM) pg_ctl$(X) $(DESTDIR)$(bindir)/pg_ctl$(X)
>
> installdirs:
> $(mkinstalldirs) $(DESTDIR)$(bindir)
>
> uninstall:
> rm -f $(DESTDIR)$(bindir)/pg_ctl$(X)
>
> clean distclean maintainer-clean:
> rm -f pg_ctl$(X) $(OBJS) exec.c
>
>
> # ensure that changes in DEF_PGPORT propagate into object file
> pg_ctl.o: pg_ctl.c $(top_builddir)/src/Makefile.global
>


----------------------------------------------------------------------------
----


>
> ---------------------------(end of broadcast)---------------------------
> TIP 1: subscribe and unsubscribe commands go to majordomo(at)postgresql(dot)org
>


In response to

pgsql-patches by date

Next:From: Magnus HaganderDate: 2004-05-27 10:47:36
Subject: Re: pg_ctl.c
Previous:From: Neil ConwayDate: 2004-05-27 07:58:50
Subject: Re: Tablespaces

Privacy Policy | About PostgreSQL
Copyright © 1996-2014 The PostgreSQL Global Development Group