/*
- * $Id$
- *
- * DEBUG: section 54 Interprocess Communication
+ * Copyright (C) 1996-2015 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.
*/
-#include "config.h"
+/* DEBUG: section 54 Interprocess Communication */
+
+#include "squid.h"
#include "base/TextException.h"
#include "compat/shm.h"
+#include "Debug.h"
+#include "fatal.h"
#include "ipc/mem/Segment.h"
-#include "protos.h"
+#include "SBuf.h"
+#include "tools.h"
+#if HAVE_FCNTL_H
#include <fcntl.h>
+#endif
+#if HAVE_SYS_MMAN_H
#include <sys/mman.h>
+#endif
+#if HAVE_SYS_STAT_H
#include <sys/stat.h>
+#endif
+#if HAVE_UNISTD_H
#include <unistd.h>
+#endif
+
+// test cases change this
+const char *Ipc::Mem::Segment::BasePath = DEFAULT_STATEDIR;
+
+void *
+Ipc::Mem::Segment::reserve(size_t chunkSize)
+{
+ Must(theMem);
+ // check for overflows
+ // chunkSize >= 0 may result in warnings on systems where off_t is unsigned
+ assert(!chunkSize || static_cast<off_t>(chunkSize) > 0);
+ assert(static_cast<off_t>(chunkSize) <= theSize);
+ assert(theReserved <= theSize - static_cast<off_t>(chunkSize));
+ void *result = reinterpret_cast<char*>(theMem) + theReserved;
+ theReserved += chunkSize;
+ return result;
+}
+
+SBuf
+Ipc::Mem::Segment::Name(const SBuf &prefix, const char *suffix)
+{
+ SBuf result = prefix;
+ result.append("_");
+ result.append(suffix);
+ return result;
+}
+
+#if HAVE_SHM
Ipc::Mem::Segment::Segment(const char *const id):
- theName(GenerateName(id)), theFD(-1), theMem(NULL),
- theSize(0), theReserved(0), doUnlink(false)
+ theFD(-1), theName(GenerateName(id)), theMem(NULL),
+ theSize(0), theReserved(0), doUnlink(false)
{
}
unlink();
}
+// fake Ipc::Mem::Segment::Enabled (!HAVE_SHM) is more selective
bool
Ipc::Mem::Segment::Enabled()
{
-#if HAVE_SHM
return true;
-#else
- return false;
-#endif
}
void
S_IRUSR | S_IWUSR);
if (theFD < 0) {
debugs(54, 5, HERE << "shm_open " << theName << ": " << xstrerror());
- fatal("Ipc::Mem::Segment::create failed to shm_open");
+ fatalf("Ipc::Mem::Segment::create failed to shm_open(%s): %s\n",
+ theName.termedBuf(), xstrerror());
}
if (ftruncate(theFD, aSize)) {
debugs(54, 5, HERE << "ftruncate " << theName << ": " << xstrerror());
- fatal("Ipc::Mem::Segment::create failed to ftruncate");
+ fatalf("Ipc::Mem::Segment::create failed to ftruncate(%s): %s\n",
+ theName.termedBuf(), xstrerror());
}
assert(statSize("Ipc::Mem::Segment::create") == aSize); // paranoid
theFD = shm_open(theName.termedBuf(), O_RDWR, 0);
if (theFD < 0) {
debugs(54, 5, HERE << "shm_open " << theName << ": " << xstrerror());
- String s = "Ipc::Mem::Segment::open failed to shm_open ";
- s.append(theName);
- fatal(s.termedBuf());
+ fatalf("Ipc::Mem::Segment::open failed to shm_open(%s): %s\n",
+ theName.termedBuf(), xstrerror());
}
theSize = statSize("Ipc::Mem::Segment::open");
mmap(NULL, theSize, PROT_READ | PROT_WRITE, MAP_SHARED, theFD, 0);
if (p == MAP_FAILED) {
debugs(54, 5, HERE << "mmap " << theName << ": " << xstrerror());
- fatal("Ipc::Mem::Segment::attach failed to mmap");
+ fatalf("Ipc::Mem::Segment::attach failed to mmap(%s): %s\n",
+ theName.termedBuf(), xstrerror());
}
theMem = p;
}
if (munmap(theMem, theSize)) {
debugs(54, 5, HERE << "munmap " << theName << ": " << xstrerror());
- fatal("Ipc::Mem::Segment::detach failed to munmap");
+ fatalf("Ipc::Mem::Segment::detach failed to munmap(%s): %s\n",
+ theName.termedBuf(), xstrerror());
}
theMem = 0;
}
debugs(54, 3, HERE << "unlinked " << theName << " segment");
}
-void *
-Ipc::Mem::Segment::reserve(size_t chunkSize)
-{
- Must(theMem);
- // check for overflows
- // chunkSize >= 0 may result in warnings on systems where off_t is unsigned
- assert(!chunkSize || static_cast<off_t>(chunkSize) > 0);
- assert(static_cast<off_t>(chunkSize) <= theSize);
- assert(theReserved <= theSize - static_cast<off_t>(chunkSize));
- void *result = reinterpret_cast<char*>(theMem) + theReserved;
- theReserved += chunkSize;
- return result;
-}
-
/// determines the size of the underlying "file"
off_t
Ipc::Mem::Segment::statSize(const char *context) const
memset(&s, 0, sizeof(s));
if (fstat(theFD, &s) != 0) {
- debugs(54, 5, HERE << "fstat " << theName << ": " << xstrerror());
- String s = context;
- s.append("failed to fstat(2) ");
- s.append(theName);
- fatal(s.termedBuf());
+ debugs(54, 5, HERE << context << " fstat " << theName << ": " << xstrerror());
+ fatalf("Ipc::Mem::Segment::statSize: %s failed to fstat(%s): %s\n",
+ context, theName.termedBuf(), xstrerror());
}
return s.st_size;
}
-/// Generate name for shared memory segment. Replaces all slashes with dots.
+/// Generate name for shared memory segment. Starts with a prefix required
+/// for cross-platform portability and replaces all slashes in ID with dots.
String
Ipc::Mem::Segment::GenerateName(const char *id)
{
- String name("/squid-");
+ assert(BasePath && *BasePath);
+ static const bool nameIsPath = shm_portable_segment_name_is_path();
+ String name;
+ if (nameIsPath) {
+ name.append(BasePath);
+ if (name[name.size()-1] != '/')
+ name.append('/');
+ } else
+ name.append("/squid-");
+
+ // append id, replacing slashes with dots
for (const char *slash = strchr(id, '/'); slash; slash = strchr(id, '/')) {
if (id != slash) {
name.append(id, slash - id);
id = slash + 1;
}
name.append(id);
+
+ name.append(".shm"); // to distinguish from non-segments when nameIsPath
return name;
}
+
+#else // HAVE_SHM
+
+#include <map>
+
+typedef std::map<String, Ipc::Mem::Segment *> SegmentMap;
+static SegmentMap Segments;
+
+Ipc::Mem::Segment::Segment(const char *const id):
+ theName(id), theMem(NULL), theSize(0), theReserved(0), doUnlink(false)
+{
+}
+
+Ipc::Mem::Segment::~Segment()
+{
+ if (doUnlink) {
+ delete [] static_cast<char *>(theMem);
+ theMem = NULL;
+ Segments.erase(theName);
+ debugs(54, 3, HERE << "unlinked " << theName << " fake segment");
+ }
+}
+
+bool
+Ipc::Mem::Segment::Enabled()
+{
+ return !UsingSmp() && IamWorkerProcess();
+}
+
+void
+Ipc::Mem::Segment::create(const off_t aSize)
+{
+ assert(aSize > 0);
+ assert(!theMem);
+ checkSupport("Fake segment creation");
+
+ const bool inserted = Segments.insert(std::make_pair(theName, this)).second;
+ if (!inserted)
+ fatalf("Duplicate fake segment creation: %s", theName.termedBuf());
+
+ theMem = new char[aSize];
+ theSize = aSize;
+ doUnlink = true;
+
+ debugs(54, 3, HERE << "created " << theName << " fake segment: " << theSize);
+}
+
+void
+Ipc::Mem::Segment::open()
+{
+ assert(!theMem);
+ checkSupport("Fake segment open");
+
+ const SegmentMap::const_iterator i = Segments.find(theName);
+ if (i == Segments.end())
+ fatalf("Fake segment not found: %s", theName.termedBuf());
+
+ const Segment &segment = *i->second;
+ theMem = segment.theMem;
+ theSize = segment.theSize;
+
+ debugs(54, 3, HERE << "opened " << theName << " fake segment: " << theSize);
+}
+
+void
+Ipc::Mem::Segment::checkSupport(const char *const context)
+{
+ if (!Enabled()) {
+ debugs(54, 5, HERE << context <<
+ ": True shared memory segments are not supported. "
+ "Cannot fake shared segments in SMP config.");
+ fatalf("Ipc::Mem::Segment: Cannot fake shared segments in SMP config (%s)\n",
+ context);
+ }
+}
+
+#endif // HAVE_SHM
+
+void
+Ipc::Mem::RegisteredRunner::useConfig()
+{
+ // If Squid is built with real segments, we create() real segments
+ // in the master process only. Otherwise, we create() fake
+ // segments in each worker process. We assume that only workers
+ // need and can work with fake segments.
+#if HAVE_SHM
+ if (IamMasterProcess())
+#else
+ if (IamWorkerProcess())
+#endif
+ create();
+
+ // we assume that master process does not need shared segments
+ // unless it is also a worker
+ if (!InDaemonMode() || !IamMasterProcess())
+ open();
+}
+
projects / thirdparty / squid.git / blobdiff