]> git.ipfire.org Git - thirdparty/postgresql.git/commitdiff
Add SET statement_timeout capability. Timeout is in ms. A value of
authorBruce Momjian <bruce@momjian.us>
Sat, 13 Jul 2002 01:02:14 +0000 (01:02 +0000)
committerBruce Momjian <bruce@momjian.us>
Sat, 13 Jul 2002 01:02:14 +0000 (01:02 +0000)
zero turns off the timer.

doc/src/sgml/runtime.sgml
src/backend/postmaster/postmaster.c
src/backend/storage/lmgr/proc.c
src/backend/tcop/postgres.c
src/backend/utils/misc/guc.c
src/backend/utils/misc/postgresql.conf.sample
src/bin/psql/tab-complete.c
src/include/storage/proc.h

index 07e0575b36831dab66829ab86ca6ed3b75828427..15f2e6e56af4105a2ca2f51fe01c2fd4e040e99c 100644 (file)
@@ -1,5 +1,5 @@
 <!--
-$Header: /cvsroot/pgsql/doc/src/sgml/runtime.sgml,v 1.120 2002/07/05 01:17:20 momjian Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/runtime.sgml,v 1.121 2002/07/13 01:02:14 momjian Exp $
 -->
 
 <Chapter Id="runtime">
@@ -1584,6 +1584,16 @@ dynamic_library_path = '/usr/local/lib/postgresql:/home/my_project/lib:$libdir'
       </listitem>
      </varlistentry>
 
+     <varlistentry>
+      <term><varname>STATEMENT_TIMEOUT</varname> (<type>integer</type>)</term>
+      <listitem>
+       <para>
+        Aborts any statement that takes over the specified number of
+        microseconds.  A value of zero turns off the timer.
+       </para>
+      </listitem>
+     </varlistentry>
+
      <varlistentry>
       <term><varname>SHARED_BUFFERS</varname> (<type>integer</type>)</term>
       <listitem>
index 349fe155c09a78e43dfb2e695d960417f236fb1f..f84bf27e92ba2778bfd206c6f92a09432371d8ca 100644 (file)
@@ -37,7 +37,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.280 2002/06/20 20:29:33 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/postmaster/postmaster.c,v 1.281 2002/07/13 01:02:14 momjian Exp $
  *
  * NOTES
  *
@@ -2105,7 +2105,7 @@ DoBackend(Port *port)
         * after a time delay, so that a broken client can't hog a connection
         * indefinitely.  PreAuthDelay doesn't count against the time limit.
         */
-       if (!enable_sigalrm_interrupt(AuthenticationTimeout * 1000))
+       if (!enable_sig_alarm(AuthenticationTimeout * 1000, false))
                elog(FATAL, "DoBackend: Unable to set timer for auth timeout");
 
        /*
@@ -2134,7 +2134,7 @@ DoBackend(Port *port)
         * Done with authentication.  Disable timeout, and prevent
         * SIGTERM/SIGQUIT again until backend startup is complete.
         */
-       if (!disable_sigalrm_interrupt())
+       if (!disable_sig_alarm(false))
                elog(FATAL, "DoBackend: Unable to disable timer for auth timeout");
        PG_SETMASK(&BlockSig);
 
index 012278ab4027ac1645a00c49542baf914895ca26..53dffec64237ebf33217e36818ddcabce09afc6b 100644 (file)
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.121 2002/06/20 20:29:35 momjian Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/storage/lmgr/proc.c,v 1.122 2002/07/13 01:02:14 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
 #include "storage/sinval.h"
 #include "storage/spin.h"
 
-
 int                    DeadlockTimeout = 1000;
+int                    StatementTimeout = 0;
+int                    RemainingStatementTimeout = 0;
+bool           alarm_is_statement_timeout = false;
 
 PGPROC    *MyProc = NULL;
 
@@ -319,7 +321,7 @@ LockWaitCancel(void)
        waitingForLock = false;
 
        /* Turn off the deadlock timer, if it's still running (see ProcSleep) */
-       disable_sigalrm_interrupt();
+       disable_sig_alarm(false);
 
        /* Unlink myself from the wait queue, if on it (might not be anymore!) */
        LWLockAcquire(LockMgrLock, LW_EXCLUSIVE);
@@ -600,7 +602,7 @@ ProcSleep(LOCKMETHODTABLE *lockMethodTable,
 
        /*
         * If we detected deadlock, give up without waiting.  This must agree
-        * with HandleDeadLock's recovery code, except that we shouldn't
+        * with CheckDeadLock's recovery code, except that we shouldn't
         * release the semaphore since we haven't tried to lock it yet.
         */
        if (early_deadlock)
@@ -632,13 +634,13 @@ ProcSleep(LOCKMETHODTABLE *lockMethodTable,
         * By delaying the check until we've waited for a bit, we can avoid
         * running the rather expensive deadlock-check code in most cases.
         */
-       if (!enable_sigalrm_interrupt(DeadlockTimeout))
+       if (!enable_sig_alarm(DeadlockTimeout, false))
                elog(FATAL, "ProcSleep: Unable to set timer for process wakeup");
 
        /*
         * If someone wakes us between LWLockRelease and PGSemaphoreLock,
         * PGSemaphoreLock will not block.  The wakeup is "saved" by the
-        * semaphore implementation.  Note also that if HandleDeadLock is
+        * semaphore implementation.  Note also that if CheckDeadLock is
         * invoked but does not detect a deadlock, PGSemaphoreLock() will
         * continue to wait.  There used to be a loop here, but it was useless
         * code...
@@ -654,7 +656,7 @@ ProcSleep(LOCKMETHODTABLE *lockMethodTable,
        /*
         * Disable the timer, if it's still running
         */
-       if (!disable_sigalrm_interrupt())
+       if (!disable_sig_alarm(false))
                elog(FATAL, "ProcSleep: Unable to disable timer for process wakeup");
 
        /*
@@ -785,7 +787,7 @@ ProcLockWakeup(LOCKMETHODTABLE *lockMethodTable, LOCK *lock)
  * --------------------
  */
 void
-HandleDeadLock(SIGNAL_ARGS)
+CheckDeadLock(void)
 {
        int                     save_errno = errno;
 
@@ -921,52 +923,180 @@ ProcSendSignal(BackendId procId)
  * Delay is given in milliseconds.     Caller should be sure a SIGALRM
  * signal handler is installed before this is called.
  *
+ * This code properly handles multiple alarms when the statement_timeout
+ * alarm is specified first.
+ *
  * Returns TRUE if okay, FALSE on failure.
  */
 bool
-enable_sigalrm_interrupt(int delayms)
+enable_sig_alarm(int delayms, bool is_statement_timeout)
 {
 #ifndef __BEOS__
-       struct itimerval timeval,
-                               dummy;
+       struct itimerval timeval, remaining;
+#else
+       bigtime_t       time_interval, remaining;
+#endif
 
+       /* Don't set timer if the statement timeout scheduled before next alarm. */
+       if (alarm_is_statement_timeout &&
+               !is_statement_timeout &&
+               RemainingStatementTimeout <= delayms)
+               return true;
+
+#ifndef __BEOS__
        MemSet(&timeval, 0, sizeof(struct itimerval));
        timeval.it_value.tv_sec = delayms / 1000;
        timeval.it_value.tv_usec = (delayms % 1000) * 1000;
-       if (setitimer(ITIMER_REAL, &timeval, &dummy))
+       if (setitimer(ITIMER_REAL, &timeval, &remaining))
                return false;
 #else
        /* BeOS doesn't have setitimer, but has set_alarm */
-       bigtime_t       time_interval;
-
        time_interval = delayms * 1000;         /* usecs */
-       if (set_alarm(time_interval, B_ONE_SHOT_RELATIVE_ALARM) < 0)
+       if ((remaining = set_alarm(time_interval, B_ONE_SHOT_RELATIVE_ALARM)) < 0)
                return false;
 #endif
 
+       if (is_statement_timeout)
+               RemainingStatementTimeout = StatementTimeout;
+       else
+       {
+               /* Switching to non-statement-timeout alarm, get remaining time */
+               if (alarm_is_statement_timeout)
+               {
+#ifndef __BEOS__
+                       /* We lose precision here because we convert to milliseconds */
+                       RemainingStatementTimeout = remaining.it_value.tv_sec * 1000 +
+                                                                               remaining.it_value.tv_usec / 1000;
+#else
+                       RemainingStatementTimeout = remaining / 1000;
+#endif
+                       /* Rounding could cause a zero */
+                       if (RemainingStatementTimeout == 0)
+                               RemainingStatementTimeout = 1;
+               }
+
+               if (RemainingStatementTimeout)
+               {
+                       /* Remaining timeout alarm < delayms? */
+                       if (RemainingStatementTimeout <= delayms)
+                       {
+                               /* reinstall statement timeout alarm */
+                               alarm_is_statement_timeout = true;
+#ifndef __BEOS__
+                               remaining.it_value.tv_sec = RemainingStatementTimeout / 1000;
+                               remaining.it_value.tv_usec = (RemainingStatementTimeout % 1000) * 1000;
+                               if (setitimer(ITIMER_REAL, &remaining, &timeval))
+                                       return false;
+                               else
+                                       return true;
+#else
+                               remaining = RemainingStatementTimeout * 1000;
+                               if ((timeval = set_alarm(remaining, B_ONE_SHOT_RELATIVE_ALARM)) < 0)
+                                       return false;
+                               else
+                                       return true;
+#endif
+                       }
+                       else
+                               RemainingStatementTimeout -= delayms;
+               }
+       }
+
+       if (is_statement_timeout)
+               alarm_is_statement_timeout = true;
+       else
+               alarm_is_statement_timeout = false;
+
        return true;
 }
 
 /*
- * Disable the SIGALRM interrupt, if it has not yet fired
+ * Cancel the SIGALRM timer.
+ *
+ * This is also called if the timer has fired to reschedule
+ * the statement_timeout timer.
  *
  * Returns TRUE if okay, FALSE on failure.
  */
 bool
-disable_sigalrm_interrupt(void)
+disable_sig_alarm(bool is_statement_timeout)
 {
 #ifndef __BEOS__
-       struct itimerval timeval,
-                               dummy;
-
+       struct itimerval timeval, remaining;
        MemSet(&timeval, 0, sizeof(struct itimerval));
-       if (setitimer(ITIMER_REAL, &timeval, &dummy))
-               return false;
 #else
-       /* BeOS doesn't have setitimer, but has set_alarm */
-       if (set_alarm(B_INFINITE_TIMEOUT, B_PERIODIC_ALARM) < 0)
-               return false;
+       bigtime_t time_interval = 0;
 #endif
 
+       if (!is_statement_timeout && RemainingStatementTimeout)
+       {
+#ifndef __BEOS__
+               /* turn off timer and get remaining time, if any */
+               if (setitimer(ITIMER_REAL, &timeval, &remaining))
+                       return false;
+               /* Add remaining time back because the timer didn't complete */
+               RemainingStatementTimeout += remaining.it_value.tv_sec * 1000 +
+                                                                        remaining.it_value.tv_usec / 1000;
+               /* Prepare to set timer */
+               timeval.it_value.tv_sec = RemainingStatementTimeout / 1000;
+               timeval.it_value.tv_usec = (RemainingStatementTimeout % 1000) * 1000;
+#else
+               /* BeOS doesn't have setitimer, but has set_alarm */
+               if ((time_interval = set_alarm(B_INFINITE_TIMEOUT, B_PERIODIC_ALARM)) < 0)
+                       return false;
+               RemainingStatementTimeout += time_interval / 1000;
+               time_interval = RemainingStatementTimeout * 1000;
+#endif
+               /* Restore remaining statement timeout value */
+               alarm_is_statement_timeout = true;
+       }
+       /*
+        *      Optimization: is_statement_timeout && RemainingStatementTimeout == 0
+        *  does nothing.  This is for cases where no timeout was set.
+        */
+       if (!is_statement_timeout || RemainingStatementTimeout)
+       {
+#ifndef __BEOS__
+               if (setitimer(ITIMER_REAL, &timeval, &remaining))
+                       return false;
+#else
+               if (time_interval)
+               {
+                       if (set_alarm(time_interval, B_ONE_SHOT_RELATIVE_ALARM) < 0)
+                               return false;
+               }
+               else
+               {
+                       if (set_alarm(B_INFINITE_TIMEOUT, B_PERIODIC_ALARM) < 0)
+                               return false;
+               }
+#endif
+       }
+
+       if (is_statement_timeout)
+               RemainingStatementTimeout = 0;
+
        return true;
 }
+
+
+/*
+ * Call alarm handler, either StatementCancel or Deadlock checker.
+ */
+void
+handle_sig_alarm(SIGNAL_ARGS)
+{
+       if (alarm_is_statement_timeout)
+       {
+               RemainingStatementTimeout = 0;
+               alarm_is_statement_timeout = false;
+               kill(MyProcPid, SIGINT);
+       }
+       else
+       {
+               CheckDeadLock();
+               /* Reactivate any statement_timeout alarm. */
+               disable_sig_alarm(false);
+       }
+}
+
index c6b8fcfafd6c0394a39d21b1e141a92c25691c50..154e478687b673a28be8d6085f67e45ab6610879 100644 (file)
@@ -8,7 +8,7 @@
  *
  *
  * IDENTIFICATION
- *       $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.269 2002/07/11 07:39:26 ishii Exp $
+ *       $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.270 2002/07/13 01:02:14 momjian Exp $
  *
  * NOTES
  *       this is the "main" module of the postgres backend and
@@ -78,6 +78,8 @@ char     *debug_query_string; /* used by pgmonitor */
 /* Note: whereToSendOutput is initialized for the bootstrap/standalone case */
 CommandDest whereToSendOutput = Debug;
 
+extern int StatementTimeout;
+
 static bool dontExecute = false;
 
 /* note: these declarations had better match tcopprot.h */
@@ -717,6 +719,9 @@ pg_exec_query_string(StringInfo query_string,               /* string to execute */
                                xact_started = true;
                        }
 
+                       if (StatementTimeout)
+                               enable_sig_alarm(StatementTimeout, true);
+
                        /*
                         * If we got a cancel signal in analysis or prior command,
                         * quit
@@ -791,6 +796,8 @@ pg_exec_query_string(StringInfo query_string,               /* string to execute */
                                        ShowUsage("EXECUTOR STATISTICS");
                        }
 
+                       disable_sig_alarm(true);
+
                        /*
                         * In a query block, we want to increment the command counter
                         * between queries so that the effects of early queries are
@@ -821,9 +828,7 @@ pg_exec_query_string(StringInfo query_string,               /* string to execute */
                                finish_xact_command();
                                xact_started = false;
                        }
-
-               }                                               /* end loop over queries generated from a
-                                                                * parsetree */
+               } /* end loop over queries generated from a parsetree */
 
                /*
                 * If this is the last parsetree of the query string, close down
@@ -996,7 +1001,7 @@ authdie(SIGNAL_ARGS)
  * at soonest convenient time
  */
 static void
-QueryCancelHandler(SIGNAL_ARGS)
+StatementCancelHandler(SIGNAL_ARGS)
 {
        int                     save_errno = errno;
 
@@ -1551,10 +1556,10 @@ PostgresMain(int argc, char *argv[], const char *username)
         */
 
        pqsignal(SIGHUP, SigHupHandler);        /* set flag to read config file */
-       pqsignal(SIGINT, QueryCancelHandler);           /* cancel current query */
+       pqsignal(SIGINT, StatementCancelHandler);               /* cancel current query */
        pqsignal(SIGTERM, die);         /* cancel current query and exit */
        pqsignal(SIGQUIT, quickdie);    /* hard crash time */
-       pqsignal(SIGALRM, HandleDeadLock);      /* check for deadlock after
+       pqsignal(SIGALRM, handle_sig_alarm);    /* check for deadlock after
                                                                                 * timeout */
 
        /*
@@ -1688,7 +1693,7 @@ PostgresMain(int argc, char *argv[], const char *username)
        if (!IsUnderPostmaster)
        {
                puts("\nPOSTGRES backend interactive interface ");
-               puts("$Revision: 1.269 $ $Date: 2002/07/11 07:39:26 $\n");
+               puts("$Revision: 1.270 $ $Date: 2002/07/13 01:02:14 $\n");
        }
 
        /*
@@ -1820,6 +1825,9 @@ PostgresMain(int argc, char *argv[], const char *username)
                QueryCancelPending = false;             /* forget any earlier CANCEL
                                                                                 * signal */
 
+               /* Stop any statement timer */
+               disable_sig_alarm(true);
+
                EnableNotifyInterrupt();
 
                /* Allow "die" interrupt to be processed while waiting */
index 53503f4b413c708248010641376454ec0dcbfb23..5162509b26190e5173b0e3fe587f416256b42168 100644 (file)
@@ -5,7 +5,7 @@
  * command, configuration file, and command line options.
  * See src/backend/utils/misc/README for more information.
  *
- * $Header: /cvsroot/pgsql/src/backend/utils/misc/guc.c,v 1.70 2002/06/16 00:09:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/misc/guc.c,v 1.71 2002/07/13 01:02:14 momjian Exp $
  *
  * Copyright 2000 by PostgreSQL Global Development Group
  * Written by Peter Eisentraut <peter_e@gmx.net>.
@@ -51,6 +51,7 @@
 extern bool Log_connections;
 extern int     PreAuthDelay;
 extern int     AuthenticationTimeout;
+extern int     StatementTimeout;
 extern int     CheckPointTimeout;
 extern int     CommitDelay;
 extern int     CommitSiblings;
@@ -575,6 +576,11 @@ static struct config_int
                DEFAULT_MAX_EXPR_DEPTH, 10, INT_MAX, NULL, NULL
        },
 
+       {
+               { "statement_timeout", PGC_USERSET }, &StatementTimeout,
+               0, 0, INT_MAX, NULL, NULL
+       },
+
        {
                { "max_fsm_relations", PGC_POSTMASTER }, &MaxFSMRelations,
                100, 10, INT_MAX, NULL, NULL
index 00dced8d394ae3fa91bcb3eb52057df22197b09b..bf141249ae043ffb2fbc66862ed1d25188c02255 100644 (file)
 #password_encryption = true
 #sql_inheritance = true
 #transform_null_equals = false
+#statement_timeout = 0                         # 0 is disabled
index 521742ea1dd22fb4952802c99a8948963da0adaa..24767172451baa7ed90f64c732e6878e95c6ca15 100644 (file)
@@ -3,7 +3,7 @@
  *
  * Copyright 2000 by PostgreSQL Global Development Group
  *
- * $Header: /cvsroot/pgsql/src/bin/psql/tab-complete.c,v 1.50 2002/06/16 00:09:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/tab-complete.c,v 1.51 2002/07/13 01:02:14 momjian Exp $
  */
 
 /*----------------------------------------------------------------------
@@ -267,6 +267,7 @@ psql_completion(char *text, int start, int end)
 
                "default_transaction_isolation",
                "search_path",
+               "statement_timeout",
 
                NULL
        };
index 71b86cc8b3624992a6c31f879ce997f8f8e9cd3e..b31b0bfe002cf3c236cc837cc049e890009e4802 100644 (file)
@@ -7,7 +7,7 @@
  * Portions Copyright (c) 1996-2002, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
- * $Id: proc.h,v 1.57 2002/06/20 20:29:52 momjian Exp $
+ * $Id: proc.h,v 1.58 2002/07/13 01:02:14 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -105,13 +105,14 @@ extern int ProcSleep(LOCKMETHODTABLE *lockMethodTable, LOCKMODE lockmode,
 extern PGPROC *ProcWakeup(PGPROC *proc, int errType);
 extern void ProcLockWakeup(LOCKMETHODTABLE *lockMethodTable, LOCK *lock);
 extern bool LockWaitCancel(void);
-extern void HandleDeadLock(SIGNAL_ARGS);
+extern void CheckDeadLock(void);
 
 extern void ProcWaitForSignal(void);
 extern void ProcCancelWaitForSignal(void);
 extern void ProcSendSignal(BackendId procId);
 
-extern bool enable_sigalrm_interrupt(int delayms);
-extern bool disable_sigalrm_interrupt(void);
+extern bool enable_sig_alarm(int delayms, bool is_statement_timeout);
+extern bool disable_sig_alarm(bool is_statement_timeout);
+extern void handle_sig_alarm(SIGNAL_ARGS);
 
 #endif   /* PROC_H */