Kid.cc

Go to the documentation of this file.

/*
 * Copyright (C) 1996-2023 The Squid Software Foundation and contributors
 *
 * Squid software is distributed under GPLv2+ license and includes
 * contributions from numerous individuals and organizations.
 * Please see the COPYING and CONTRIBUTORS files for details.
 */
 
/* DEBUG: section 54    Interprocess Communication */
 
#include "squid.h"
#include "globals.h"
#include "ipc/Kid.h"
#include "SquidConfig.h"
 
#include <ctime>
#if HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
 
int TheProcessKind = pkOther;
 
Kid::Kid()
{
}
 
Kid::Kid(const char *aRole, const int anId):
    processRole(aRole),
    processId(anId)
{
}
 
void Kid::start(pid_t cpid)
{
    assert(!running());
    assert(cpid > 0);
 
    isRunning = true;
    stopTime = 0;
    pid = cpid;
    startTime = squid_curtime;
}
 
void
Kid::stop(PidStatus const theExitStatus)
{
    assert(running());
    assert(startTime != 0);
 
    isRunning = false;
    stopTime = squid_curtime;
    status = theExitStatus;
 
    if ((stopTime - startTime) < fastFailureTimeLimit)
        ++badFailures;
    else
        badFailures = 0; // the failures are not "frequent" [any more]
 
    reportStopped(); // after all state changes
}
 
void
Kid::reportStopped() const
{
    if (calledExit()) {
        syslog(LOG_NOTICE,
               "Squid Parent: %s process %d exited with status %d",
               gist().c_str(), pid, exitStatus());
    } else if (signaled()) {
        syslog(LOG_NOTICE,
               "Squid Parent: %s process %d exited due to signal %d with status %d",
               gist().c_str(), pid, termSignal(), exitStatus());
    } else {
        syslog(LOG_NOTICE, "Squid Parent: %s process %d exited",
               gist().c_str(), pid);
    }
 
    if (hopeless() && Config.hopelessKidRevivalDelay) {
        syslog(LOG_NOTICE, "Squid Parent: %s process %d will not be restarted for %ld "
               "seconds due to repeated, frequent failures",
               gist().c_str(),
               pid,
               static_cast<long int>(Config.hopelessKidRevivalDelay));
    }
}
 
bool Kid::running() const
{
    return isRunning;
}
 
bool Kid::shouldRestart() const
{
    return !(running() ||
             exitedHappy() ||
             hopeless() ||
             shutting_down ||
             signaled(SIGINT) || // unexpected forced shutdown
             signaled(SIGTERM)); // unexpected forced shutdown
}
 
pid_t Kid::getPid() const
{
    assert(pid > 0);
    return pid;
}
 
bool Kid::hopeless() const
{
    return badFailures > badFailureLimit;
}
 
bool Kid::calledExit() const
{
    return (pid > 0) && !running() && WIFEXITED(status);
}
 
int Kid::exitStatus() const
{
    return WEXITSTATUS(status);
}
 
bool Kid::calledExit(int code) const
{
    return calledExit() && (exitStatus() == code);
}
 
bool Kid::exitedHappy() const
{
    return calledExit(0);
}
 
bool Kid::signaled() const
{
    return (pid > 0) && !running() && WIFSIGNALED(status);
}
 
int Kid::termSignal() const
{
    return WTERMSIG(status);
}
 
bool Kid::signaled(int sgnl) const
{
    return signaled() && (termSignal() == sgnl);
}
 
SBuf Kid::processName() const
{
    SBuf name("(");
    name.append(gist());
    name.append(")");
    return name;
}
 
SBuf Kid::gist() const
{
    SBuf name(processRole);
    name.appendf("-%d", processId);
    return name;
}
 
time_t
Kid::deathDuration() const
{
    return squid_curtime > stopTime ? squid_curtime - stopTime : 0;
}