Instance.cc
Go to the documentation of this file.
1/*
2 * Copyright (C) 1996-2022 The Squid Software Foundation and contributors
3 *
4 * Squid software is distributed under GPLv2+ license and includes
5 * contributions from numerous individuals and organizations.
6 * Please see the COPYING and CONTRIBUTORS files for details.
7 */
8
9#include "squid.h"
10#include "base/File.h"
11#include "debug/Messages.h"
12#include "fs_io.h"
13#include "Instance.h"
14#include "parser/Tokenizer.h"
15#include "sbuf/Stream.h"
16#include "SquidConfig.h"
17#include "tools.h"
18
19#include <cerrno>
20
21/* To support concurrent PID files, convert local statics into PidFile class */
22
26
29static SBuf
31{
32 if (!Config.pidFilename || strcmp(Config.pidFilename, "none") == 0)
33 return SBuf();
34
35 // If chroot has been requested, then we first read the PID file before
36 // chroot() and then create/update it inside a chrooted environment.
37 // TODO: Consider removing half-baked chroot support from Squid.
38 extern bool Chrooted;
39 if (!Config.chroot_dir || Chrooted) // no need to compensate
40 return SBuf(Config.pidFilename);
41
42 SBuf filename;
43 filename.append(Config.chroot_dir);
44 filename.append("/");
45 filename.append(Config.pidFilename);
46 debugs(50, 3, "outside chroot: " << filename);
47 return filename;
48}
49
51static SBuf
52PidFileDescription(const SBuf &filename)
53{
54 return ToSBuf("PID file (", filename, ')');
55}
56
59static SBuf
61{
62 const auto name = PidFilenameCalc();
64 return name;
65}
66
68static pid_t
70{
71 const auto input = pidFile.readSmall(1, 32);
72 int64_t rawPid = -1;
73
75 if (!(tok.int64(rawPid, 10, false) && // PID digits
76 (tok.skipOne(CharacterSet::CR)||true) && // optional CR (Windows/etc.)
77 tok.skipOne(CharacterSet::LF) && // required end of line
78 tok.atEnd())) { // no trailing garbage
79 throw TexcHere(ToSBuf("Malformed ", TheFile));
80 }
81
82 debugs(50, 7, "found PID " << rawPid << " in " << TheFile);
83
84 if (rawPid < 1)
85 throw TexcHere(ToSBuf("Bad ", TheFile, " contains unreasonably small PID value: ", rawPid));
86 const auto finalPid = static_cast<pid_t>(rawPid);
87 if (static_cast<int64_t>(finalPid) != rawPid)
88 throw TexcHere(ToSBuf("Bad ", TheFile, " contains unreasonably large PID value: ", rawPid));
89
90 return finalPid;
91}
92
94static bool
96{
97 const auto result = kill(pid, 0);
98 const auto savedErrno = errno;
99 if (result != 0)
100 debugs(50, 3, "kill(" << pid << ", 0) failed: " << xstrerr(savedErrno));
101 // if we do not have permissions to signal the process, then it is running
102 return (result == 0 || savedErrno == EPERM);
103}
104
106static void
108{
109 bool running = false;
110 SBuf description;
111 try {
112 const auto pid = GetOtherPid(pidFile);
113 description = ToSBuf(TheFile, " with PID ", pid);
114 running = ProcessIsRunning(pid);
115 }
116 catch (const std::exception &ex) {
117 debugs(50, 5, "assuming no other Squid instance: " << ex.what());
118 return;
119 }
120
121 if (running)
122 throw TexcHere(ToSBuf("Squid is already running: Found fresh instance ", description));
123
124 debugs(50, 5, "assuming stale instance " << description);
125}
126
127pid_t
129{
130 const auto filename = PidFilename();
131 if (filename.isEmpty())
132 throw TexcHere("no pid_filename configured");
133
134 File pidFile(filename, File::Be::ReadOnly().locked());
135 return GetOtherPid(pidFile);
136}
137
138void
140{
141 const auto filename = PidFilename();
142 if (filename.isEmpty())
143 return; // the check is impossible
144
145 if (const auto filePtr = File::Optional(filename, File::Be::ReadOnly().locked())) {
146 const std::unique_ptr<File> pidFile(filePtr);
148 } else {
149 // It is best to assume then to check because checking without a lock
150 // might lead to false positives that lead to no Squid starting at all!
151 debugs(50, 5, "cannot lock " << TheFile << "; assuming no other Squid is running");
152 // If our assumption is false, we will fail to _create_ the PID file,
153 // and, hence, will not start, allowing that other Squid to run.
154 }
155}
156
159
161static void
163{
164 if (ThePidFileToRemove.isEmpty()) // not the PidFilename()!
165 return; // nothing to do
166
167 debugs(50, Important(22), "Removing " << PidFileDescription(ThePidFileToRemove));
168
169 // Do not write to cache_log after our PID file is removed because another
170 // instance may already be logging there. Stop logging now because, if we
171 // wait until safeunlink(), some debugs() may slip through into the now
172 // "unlocked" cache_log, especially if we avoid the sensitive suid() area.
173 // Use stderr to capture late debugs() that did not make it into cache_log.
175
176 const char *filename = ThePidFileToRemove.c_str(); // avoid complex operations inside enter_suid()
177 enter_suid();
178 safeunlink(filename, 0);
179 leave_suid();
180
182}
183
185void
187{
188 // Instance code assumes that we do not support PID filename reconfiguration
189 static bool called = false;
190 Must(!called);
191 called = true;
192
193 const auto filename = PidFilename();
194 if (filename.isEmpty())
195 return; // nothing to do
196
197 File pidFile(filename, File::Be::ReadWrite().locked().createdIfMissing().openedByRoot());
198
199 // another instance may have started after the caller checked (if it did)
201
202 /* now we know that we own the PID file created and/or locked above */
203
204 // Cleanup is scheduled through atexit() to ensure both:
205 // - cleanup upon fatal() and similar "unplanned" exits and
206 // - enter_suid() existence and proper logging support during cleanup.
207 // Even without PID filename reconfiguration support, we have to remember
208 // the file name we have used because Config.pidFilename may change!
209 (void)std::atexit(&RemoveInstance); // failures leave the PID file on disk
210 ThePidFileToRemove = filename;
211
212 /* write our PID to the locked file */
213 SBuf pidBuf;
214 pidBuf.Printf("%d\n", static_cast<int>(getpid()));
215 pidFile.truncate();
216 pidFile.writeAll(pidBuf);
217
218 // We must fsync before releasing the lock or other Squid processes may not see
219 // our written PID (and decide that they are dealing with a corrupted PID file).
220 pidFile.synchronize();
221
222 debugs(50, Important(23), "Created " << TheFile);
223}
224
static pid_t pid
Definition: IcmpSquid.cc:34
static bool ProcessIsRunning(const pid_t pid)
determines whether a given process is running at the time of the call
Definition: Instance.cc:95
static SBuf PidFilenameCalc()
Definition: Instance.cc:30
static pid_t GetOtherPid(File &pidFile)
Definition: Instance.cc:69
static void ThrowIfAlreadyRunningWith(File &pidFile)
quits if another Squid instance (that owns the given PID file) is running
Definition: Instance.cc:107
static void RemoveInstance()
atexit() handler; removes the PID file created with Instance::WriteOurPid()
Definition: Instance.cc:162
static SBuf PidFilename()
Definition: Instance.cc:60
static SBuf ThePidFileToRemove
ties Instance::WriteOurPid() scheduler and RemoveInstance(void) handler
Definition: Instance.cc:158
static SBuf TheFile
Definition: Instance.cc:25
static SBuf PidFileDescription(const SBuf &filename)
Definition: Instance.cc:52
class SquidConfig Config
Definition: SquidConfig.cc:12
#define TexcHere(msg)
legacy convenience macro; it is not difficult to type Here() now
Definition: TextException.h:59
#define Must(condition)
Definition: TextException.h:71
static const CharacterSet LF
Definition: CharacterSet.h:92
static const CharacterSet CR
Definition: CharacterSet.h:80
static void StopCacheLogUse()
Definition: debug.cc:1127
static FileOpeningConfig ReadWrite()
Definition: File.cc:56
static FileOpeningConfig ReadOnly()
Definition: File.cc:31
a portable locking-aware exception-friendly file (with RAII API)
Definition: File.h:67
void writeAll(const SBuf &data)
write(2) with a "wrote everything" check
Definition: File.cc:279
static File * Optional(const SBuf &aName, const FileOpeningConfig &cfg)
Definition: File.cc:123
void truncate()
makes the file size (and the current I/O offset) zero
Definition: File.cc:214
void synchronize()
fsync(2)
Definition: File.cc:303
SBuf readSmall(SBuf::size_type minBytes, SBuf::size_type maxBytes)
read(2) for small files
Definition: File.cc:240
Definition: SBuf.h:94
const char * c_str()
Definition: SBuf.cc:516
bool isEmpty() const
Definition: SBuf.h:431
SBuf & append(const SBuf &S)
Definition: SBuf.cc:185
SBuf & Printf(const char *fmt,...)
Definition: SBuf.cc:214
void clear()
Definition: SBuf.cc:175
char * chroot_dir
Definition: SquidConfig.h:481
char * pidFilename
Definition: SquidConfig.h:222
#define Important(id)
Definition: Messages.h:91
#define debugs(SECTION, LEVEL, CONTENT)
Definition: Stream.h:196
void safeunlink(const char *s, int quiet)
Definition: fs_io.cc:469
bool Chrooted
Definition: main.cc:1088
void WriteOurPid()
creates a PID file; throws on error
Definition: Instance.cc:186
void ThrowIfAlreadyRunning()
Definition: Instance.cc:139
pid_t Other()
Definition: Instance.cc:128
SBuf ToSBuf(Args &&... args)
slowly stream-prints all arguments into a freshly allocated SBuf
Definition: Stream.h:63
Definition: parse.c:160
void leave_suid(void)
Definition: tools.cc:556
void enter_suid(void)
Definition: tools.cc:620
const char * xstrerr(int error)
Definition: xstrerror.cc:83

 

Introduction

Documentation

Support

Miscellaneous

Web Site Translations

Mirrors