*/
void ast_unregister_atexit(void (*func)(void));
+/*!
+ * \brief Cancel an existing shutdown and return to normal operation.
+ *
+ * \note Shutdown can be cancelled while the server is waiting for
+ * any existing channels to be destroyed before shutdown becomes
+ * irreversible.
+ *
+ * \return non-zero if shutdown cancelled.
+ */
+int ast_cancel_shutdown(void);
+
+/*!
+ * \details
+ * The server is preventing new channel creation in preparation for
+ * shutdown and may actively be releasing resources. The shutdown
+ * process may be canceled by ast_cancel_shutdown() if it is not too
+ * late.
+ *
+ * \note The preparation to shutdown phase can be quite lengthy
+ * if we are gracefully shutting down. How long existing calls will
+ * last is not up to us.
+ *
+ * \return non-zero if the server is preparing to or actively shutting down.
+ */
+int ast_shutting_down(void);
+
+/*!
+ * \return non-zero if the server is actively shutting down.
+ * \since 13.3.0
+ *
+ * \details
+ * The server is releasing resources and unloading modules.
+ * It won't be long now.
+ */
+int ast_shutdown_final(void);
+
#if !defined(LOW_MEMORY)
/*!
* \brief Register the version of a source code file with the core.
void ast_hangup(struct ast_channel *chan);
/*!
+ * \brief Soft hangup all active channels.
+ * \since 13.3.0
+ *
+ * \return Nothing
+ */
+void ast_softhangup_all(void);
+
+/*!
* \brief Softly hangup up a channel
*
* \param chan channel to be soft-hung-up
/*! Undo defer. ast_read will return any DTMF characters that were queued */
void ast_channel_undefer_dtmf(struct ast_channel *chan);
-/*! Initiate system shutdown -- prevents new channels from being allocated.
- * \param hangup If "hangup" is non-zero, all existing channels will receive soft
- * hangups */
-void ast_begin_shutdown(int hangup);
-
-/*! Cancels an existing shutdown and returns to normal operation */
-void ast_cancel_shutdown(void);
-
/*! \return number of channels available for lookup */
int ast_active_channels(void);
/*! \return the number of channels not yet destroyed */
int ast_undestroyed_channels(void);
-/*! \return non-zero if Asterisk is being shut down */
-int ast_shutting_down(void);
-
/*! Activate a given generator */
int ast_activate_generator(struct ast_channel *chan, struct ast_generator *gen, void *params);
extern unsigned int ast_FD_SETSIZE;
static char *_argv[256];
+
typedef enum {
- NOT_SHUTTING_DOWN = -2,
- SHUTTING_DOWN = -1,
- /* Valid values for quit_handler niceness below: */
+ /*! Normal operation */
+ NOT_SHUTTING_DOWN,
+ /*! Committed to shutting down. Final phase */
+ SHUTTING_DOWN_FINAL,
+ /*! Committed to shutting down. Initial phase */
+ SHUTTING_DOWN,
+ /*!
+ * Valid values for quit_handler() niceness below.
+ * These shutdown/restart levels can be cancelled.
+ *
+ * Remote console exit right now
+ */
SHUTDOWN_FAST,
+ /*! core stop/restart now */
SHUTDOWN_NORMAL,
+ /*! core stop/restart gracefully */
SHUTDOWN_NICE,
+ /*! core stop/restart when convenient */
SHUTDOWN_REALLY_NICE
} shutdown_nice_t;
+
static shutdown_nice_t shuttingdown = NOT_SHUTTING_DOWN;
+
+/*! Prevent new channel allocation for shutdown. */
+static int shutdown_pending;
+
static int restartnow;
static pthread_t consolethread = AST_PTHREADT_NULL;
static pthread_t mon_sig_flags;
return 0;
}
+int ast_shutdown_final(void)
+{
+ return shuttingdown == SHUTTING_DOWN_FINAL;
+}
+
+int ast_shutting_down(void)
+{
+ return shutdown_pending;
+}
+
+int ast_cancel_shutdown(void)
+{
+ int shutdown_aborted = 0;
+
+ ast_mutex_lock(&safe_system_lock);
+ if (shuttingdown >= SHUTDOWN_FAST) {
+ shuttingdown = NOT_SHUTTING_DOWN;
+ shutdown_pending = 0;
+ shutdown_aborted = 1;
+ }
+ ast_mutex_unlock(&safe_system_lock);
+ return shutdown_aborted;
+}
+
+/*!
+ * \internal
+ * \brief Initiate system shutdown -- prevents new channels from being allocated.
+ */
+static void ast_begin_shutdown(void)
+{
+ ast_mutex_lock(&safe_system_lock);
+ if (shuttingdown != NOT_SHUTTING_DOWN) {
+ shutdown_pending = 1;
+ }
+ ast_mutex_unlock(&safe_system_lock);
+}
+
static int can_safely_quit(shutdown_nice_t niceness, int restart);
static void really_quit(int num, shutdown_nice_t niceness, int restart);
/* It wasn't our time. */
}
+#define SHUTDOWN_TIMEOUT 15 /* Seconds */
+
+/*!
+ * \internal
+ * \brief Wait for all channels to die, a timeout, or shutdown cancelled.
+ * \since 13.3.0
+ *
+ * \param niceness Shutdown niceness in effect
+ * \param seconds Number of seconds to wait or less than zero if indefinitely.
+ *
+ * \retval zero if waiting wasn't necessary. We were idle.
+ * \retval non-zero if we had to wait.
+ */
+static int wait_for_channels_to_die(shutdown_nice_t niceness, int seconds)
+{
+ time_t start;
+ time_t now;
+ int waited = 0;
+
+ time(&start);
+ for (;;) {
+ if (!ast_undestroyed_channels() || shuttingdown != niceness) {
+ break;
+ }
+ if (seconds < 0) {
+ /* No timeout so just poll every second */
+ sleep(1);
+ } else {
+ time(&now);
+
+ /* Wait up to the given seconds for all channels to go away */
+ if (seconds < (now - start)) {
+ break;
+ }
+
+ /* Sleep 1/10 of a second */
+ usleep(100000);
+ }
+ waited = 1;
+ }
+ return waited;
+}
+
static int can_safely_quit(shutdown_nice_t niceness, int restart)
{
+ int waited = 0;
+
/* Check if someone else isn't already doing this. */
ast_mutex_lock(&safe_system_lock);
if (shuttingdown != NOT_SHUTTING_DOWN && niceness >= shuttingdown) {
* the atexit handlers, otherwise this would be a bit early. */
ast_cdr_engine_term();
- /* Shutdown the message queue for the technology agnostic message channel.
- * This has to occur before we pause shutdown pending ast_undestroyed_channels. */
+ /*
+ * Shutdown the message queue for the technology agnostic message channel.
+ * This has to occur before we pause shutdown pending ast_undestroyed_channels.
+ *
+ * XXX This is not reversed on shutdown cancel.
+ */
ast_msg_shutdown();
if (niceness == SHUTDOWN_NORMAL) {
- time_t s, e;
/* Begin shutdown routine, hanging up active channels */
- ast_begin_shutdown(1);
+ ast_begin_shutdown();
if (ast_opt_console) {
ast_verb(0, "Beginning asterisk %s....\n", restart ? "restart" : "shutdown");
}
- time(&s);
- for (;;) {
- time(&e);
- /* Wait up to 15 seconds for all channels to go away */
- if ((e - s) > 15 || !ast_undestroyed_channels() || shuttingdown != niceness) {
- break;
- }
- /* Sleep 1/10 of a second */
- usleep(100000);
- }
+ ast_softhangup_all();
+ waited |= wait_for_channels_to_die(niceness, SHUTDOWN_TIMEOUT);
} else if (niceness >= SHUTDOWN_NICE) {
if (niceness != SHUTDOWN_REALLY_NICE) {
- ast_begin_shutdown(0);
+ ast_begin_shutdown();
}
if (ast_opt_console) {
ast_verb(0, "Waiting for inactivity to perform %s...\n", restart ? "restart" : "halt");
}
- for (;;) {
- if (!ast_undestroyed_channels() || shuttingdown != niceness) {
- break;
- }
- sleep(1);
- }
+ waited |= wait_for_channels_to_die(niceness, -1);
}
/* Re-acquire lock and check if someone changed the niceness, in which
ast_mutex_unlock(&safe_system_lock);
return 0;
}
- shuttingdown = SHUTTING_DOWN;
+
+ if (niceness >= SHUTDOWN_REALLY_NICE) {
+ shuttingdown = SHUTTING_DOWN;
+ ast_mutex_unlock(&safe_system_lock);
+
+ /* No more Mr. Nice guy. We are committed to shutting down now. */
+ ast_begin_shutdown();
+ ast_softhangup_all();
+ waited |= wait_for_channels_to_die(SHUTTING_DOWN, SHUTDOWN_TIMEOUT);
+
+ ast_mutex_lock(&safe_system_lock);
+ }
+ shuttingdown = SHUTTING_DOWN_FINAL;
ast_mutex_unlock(&safe_system_lock);
+ if (niceness >= SHUTDOWN_NORMAL && waited) {
+ /*
+ * We were not idle. Give things in progress a chance to
+ * recognize the final shutdown phase.
+ */
+ sleep(1);
+ }
return 1;
}
static char *handle_abort_shutdown(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
- int aborting_shutdown = 0;
-
switch (cmd) {
case CLI_INIT:
e->command = "core abort shutdown";
if (a->argc != e->args)
return CLI_SHOWUSAGE;
- ast_mutex_lock(&safe_system_lock);
- if (shuttingdown >= SHUTDOWN_FAST) {
- aborting_shutdown = 1;
- shuttingdown = NOT_SHUTTING_DOWN;
- }
- ast_mutex_unlock(&safe_system_lock);
+ ast_cancel_shutdown();
- if (aborting_shutdown) {
- ast_cancel_shutdown();
- }
return CLI_SUCCESS;
}
#define MONITOR_DELAY 150 * 8 /*!< 150 ms of MONITORING DELAY */
#endif
-/*! \brief Prevent new channel allocation if shutting down. */
-static int shutting_down;
-
static int chancount;
unsigned long global_fin, global_fout;
return 0;
}
-void ast_begin_shutdown(int hangup)
+void ast_softhangup_all(void)
{
- shutting_down = 1;
-
- if (hangup) {
- ao2_callback(channels, OBJ_NODATA | OBJ_MULTIPLE, ast_channel_softhangup_cb, NULL);
- }
+ ao2_callback(channels, OBJ_NODATA | OBJ_MULTIPLE, ast_channel_softhangup_cb, NULL);
}
/*! \brief returns number of active/allocated channels */
return ast_atomic_fetchadd_int(&chancount, 0);
}
-/*! \brief Cancel a shutdown in progress */
-void ast_cancel_shutdown(void)
-{
- shutting_down = 0;
-}
-
-/*! \brief Returns non-zero if Asterisk is being shut down */
-int ast_shutting_down(void)
-{
- return shutting_down;
-}
-
/*! \brief Set when to hangup channel */
void ast_channel_setwhentohangup_tv(struct ast_channel *chan, struct timeval offset)
{
projects / asterisk/asterisk.git / commitdiff