service-monitor.c revision 870bcf0d0c07f7d915f1f571f38968426ba575a1
/* Copyright (c) 2005-2011 Dovecot authors, see the included COPYING file */
#include "common.h"
#include "array.h"
#include "ioloop.h"
#include "fd-close-on-exec.h"
#include "hash.h"
#include "str.h"
#include "safe-mkstemp.h"
#include "service.h"
#include "service-process.h"
#include "service-process-notify.h"
#include "service-anvil.h"
#include "service-log.h"
#include "service-monitor.h"
#include <stdlib.h>
#include <unistd.h>
#include <syslog.h>
#include <signal.h>
#define SERVICE_STARTUP_FAILURE_THROTTLE_SECS 60
#define SERVICE_DROP_WARN_INTERVAL_SECS 60
#define MAX_DIE_WAIT_SECS 5
#define SERVICE_MAX_EXIT_FAILURES_IN_SEC 10
const struct master_status *status);
{
struct master_status status;
/* we don't have any extra idling processes anymore. */
/* assume this process is busy */
process->available_count = 0;
} else {
}
}
}
const struct master_status *status)
{
process->total_count +=
process->idle_start = 0;
if (status->available_count != 0)
return;
/* process used up all of its clients */
service->process_avail--;
service->process_avail == 0 &&
/* we may need to start more */
}
const struct master_status *status)
{
if (process->available_count == 0) {
/* process can accept more clients again */
if (service->process_avail++ == 0)
}
/* we have more processes than we really need.
add a bit of randomness so that we don't send the
signal to all of them at once */
process);
}
}
}
static void
const struct master_status *status)
{
struct service_process *process;
/* we've probably wait()ed it away already. ignore */
return;
}
/* a) Process was closed and another process was created with
the same PID, but we're still receiving status update from
the old process.
b) Some process is trying to corrupt our internal state by
trying to pretend to be someone else. We could use stronger
randomness here, but the worst they can do is DoS and there
are already more serious problems if someone is able to do
this.. */
return;
}
/* first status notification */
}
return;
/* process started servicing some more clients */
} else {
/* process finished servicing some clients */
}
}
{
unsigned int i, count;
if (ret <= 0) {
if (ret == 0)
else
return;
return;
}
if ((ret % sizeof(struct master_status)) != 0) {
"(%d bytes)", (int)ret);
return;
}
for (i = 0; i < count; i++)
}
{
return;
}
{
struct service_listener *const *lp;
int fd;
/* drop all pending connections */
}
}
{
}
static void service_drop_connections(struct service_listener *l)
{
unsigned int limit;
int fd;
if (service->last_drop_warning +
i_warning("service(%s): %s (%u) reached, "
"client connections are being dropped",
}
/* reached process limit, notify processes that they
need to start killing existing connections if they
reach connection limit */
} else if (!service->listen_pending) {
/* maybe this is a temporary peak, stop for a while and
see if it goes away */
} else {
/* this has been happening for a while now. just accept and
close the connection, so it's clear that this is happening
because of the limit, rather than because the service
processes aren't answering fast enough */
if (fd > 0)
}
}
static void service_accept(struct service_listener *l)
{
/* we've reached our limits, new clients will have to
wait until there are more processes available */
return;
}
/* create a child process and let it accept() this connection */
else
}
{
unsigned int i, count;
return;
for (i = 0; i < count; i++) {
break;
}
}
if (i > 0) {
/* we created some processes, they'll do the listening now */
}
}
{
struct service_listener *const *listeners;
struct service_listener *l = *listeners;
}
}
{
if (service->process_avail > 0 ||
return;
}
{
struct service_listener *const *listeners;
struct service_listener *l = *listeners;
}
}
{
int fd;
return 0;
T_BEGIN {
const char *path;
if (fd == -1) {
path);
} else {
}
} T_END;
}
{
i_error("pipe() failed: %m");
if (service_login_create_notify_fd(service) < 0)
continue;
}
/* we haven't yet created status pipe */
continue;
}
}
}
}
/* start up a process for startup-services */
}
}
}
{
int i;
for (i = 0; i < 2; i++) {
"close(status fd) failed: %m");
}
}
}
"close(login notify fd) failed: %m");
}
}
}
{
bool finished;
for (;;) {
if ((*servicep)->process_avail > 0)
}
break;
usleep(100000);
}
}
{
i_error("close(master dead pipe) failed: %m");
i_error("close(master dead pipe) failed: %m");
}
if (wait) {
/* we've notified all children that the master is dead.
now wait for the children to either die or to tell that
they're no longer listening for new connections */
}
}
static bool
{
bool throttle;
service->exit_failures_in_sec = 0;
}
return throttle;
}
void services_monitor_reap_children(void)
{
struct service_process *process;
int status;
bool service_stopped, throttle;
i_error("waitpid() returned unknown PID %s",
continue;
}
if (status == 0) {
/* success */
if (service->listen_pending &&
/* one success resets all failures */
service->exit_failures_in_sec = 0;
} else {
}
/* if we're reloading, we may get here with a service list
that's going to be destroyed after this process is
destroyed. keep the list referenced until we're done. */
if (throttle)
if (!service_stopped) {
}
}
}